drivers/char/tty_ioctl.c

   1 /*
   2  *  linux/drivers/char/tty_ioctl.c
   3  *
   4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
   5  *
   6  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
   7  * which can be dynamically activated and de-activated by the line
   8  * discipline handling modules (like SLIP).
   9  */
  10
  11 #include <linux/types.h>
  12 #include <linux/termios.h>
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/kernel.h>
  16 #include <linux/major.h>
  17 #include <linux/tty.h>
  18 #include <linux/fcntl.h>
  19 #include <linux/string.h>
  20 #include <linux/mm.h>
  21 #include <linux/module.h>
  22
  23 #include <asm/io.h>
  24 #include <asm/bitops.h>
  25 #include <asm/uaccess.h>
  26 #include <asm/system.h>
  27
  28 #undef TTY_DEBUG_WAIT_UNTIL_SENT
  29
  30 #undef  DEBUG
  31
  32 /*
  33  * Internal flag options for termios setting behavior
  34  */
  35 #define TERMIOS_FLUSH   1
  36 #define TERMIOS_WAIT    2
  37 #define TERMIOS_TERMIO  4
  38
  39 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
  40 {
  41         DECLARE_WAITQUEUE(wait, current);
  42
  43 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  44         char buf[64];
  45
  46         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
  47 #endif
  48         if (!tty->driver.chars_in_buffer)
  49                 return;
  50         add_wait_queue(&tty->write_wait, &wait);
  51         if (!timeout)
  52                 timeout = MAX_SCHEDULE_TIMEOUT;
  53         do {
  54 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  55                 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
  56                        tty->driver.chars_in_buffer(tty));
  57 #endif
  58                 set_current_state(TASK_INTERRUPTIBLE);
  59                 if (signal_pending(current))
  60                         goto stop_waiting;
  61                 if (!tty->driver.chars_in_buffer(tty))
  62                         break;
  63                 timeout = schedule_timeout(timeout);
  64         } while (timeout);
  65         if (tty->driver.wait_until_sent)
  66                 tty->driver.wait_until_sent(tty, timeout);
  67 stop_waiting:
  68         current->state = TASK_RUNNING;
  69         remove_wait_queue(&tty->write_wait, &wait);
  70 }
  71
  72 static void unset_locked_termios(struct termios *termios,
  73                                  struct termios *old,
  74                                  struct termios *locked)
  75 {
  76         int     i;
  77
  78 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
  79
  80         if (!locked) {
  81                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
  82                 return;
  83         }
  84
  85         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
  86         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
  87         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
  88         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
  89         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
  90         for (i=0; i < NCCS; i++)
  91                 termios->c_cc[i] = locked->c_cc[i] ?
  92                         old->c_cc[i] : termios->c_cc[i];
  93 }
  94
  95 static void change_termios(struct tty_struct * tty, struct termios * new_termios)
  96 {
  97         int canon_change;
  98         struct termios old_termios = *tty->termios;
  99
 100         cli();
 101         *tty->termios = *new_termios;
 102         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
 103         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
 104         if (canon_change) {
 105                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
 106                 tty->canon_head = tty->read_tail;
 107                 tty->canon_data = 0;
 108                 tty->erasing = 0;
 109         }
 110         sti();
 111         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
 112                 /* Get characters left over from canonical mode. */
 113                 wake_up_interruptible(&tty->read_wait);
 114
 115         /* see if packet mode change of state */
 116
 117         if (tty->link && tty->link->packet) {
 118                 int old_flow = ((old_termios.c_iflag & IXON) &&
 119                                 (old_termios.c_cc[VSTOP] == '\023') &&
 120                                 (old_termios.c_cc[VSTART] == '\021'));
 121                 int new_flow = (I_IXON(tty) &&
 122                                 STOP_CHAR(tty) == '\023' &&
 123                                 START_CHAR(tty) == '\021');
 124                 if (old_flow != new_flow) {
 125                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 126                         if (new_flow)
 127                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
 128                         else
 129                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
 130                         wake_up_interruptible(&tty->link->read_wait);
 131                 }
 132         }
 133
 134         if (tty->driver.set_termios)
 135                 (*tty->driver.set_termios)(tty, &old_termios);
 136
 137         if (tty->ldisc.set_termios)
 138                 (*tty->ldisc.set_termios)(tty, &old_termios);
 139 }
 140
 141 static int set_termios(struct tty_struct * tty, unsigned long arg, int opt)
 142 {
 143         struct termios tmp_termios;
 144         int retval = tty_check_change(tty);
 145
 146         if (retval)
 147                 return retval;
 148
 149         if (opt & TERMIOS_TERMIO) {
 150                 memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
 151                 if (user_termio_to_kernel_termios(&tmp_termios,
 152                                                   (struct termio *) arg))
 153                         return -EFAULT;
 154         } else {
 155                 if (user_termios_to_kernel_termios(&tmp_termios,
 156                                                    (struct termios *) arg))
 157                         return -EFAULT;
 158         }
 159
 160         if ((opt & TERMIOS_FLUSH) && tty->ldisc.flush_buffer)
 161                 tty->ldisc.flush_buffer(tty);
 162
 163         if (opt & TERMIOS_WAIT) {
 164                 tty_wait_until_sent(tty, 0);
 165                 if (signal_pending(current))
 166                         return -EINTR;
 167         }
 168
 169         change_termios(tty, &tmp_termios);
 170         return 0;
 171 }
 172
 173 static int get_termio(struct tty_struct * tty, struct termio * termio)
 174 {
 175         if (kernel_termios_to_user_termio(termio, tty->termios))
 176                 return -EFAULT;
 177         return 0;
 178 }
 179
 180 static unsigned long inq_canon(struct tty_struct * tty)
 181 {
 182         int nr, head, tail;
 183
 184         if (!tty->canon_data || !tty->read_buf)
 185                 return 0;
 186         head = tty->canon_head;
 187         tail = tty->read_tail;
 188         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
 189         /* Skip EOF-chars.. */
 190         while (head != tail) {
 191                 if (test_bit(tail, &tty->read_flags) &&
 192                     tty->read_buf[tail] == __DISABLED_CHAR)
 193                         nr--;
 194                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
 195         }
 196         return nr;
 197 }
 198
 199 #ifdef TIOCGETP
 200 /*
 201  * These are deprecated, but there is limited support..
 202  *
 203  * The "sg_flags" translation is a joke..
 204  */
 205 static int get_sgflags(struct tty_struct * tty)
 206 {
 207         int flags = 0;
 208
 209         if (!(tty->termios->c_lflag & ICANON)) {
 210                 if (tty->termios->c_lflag & ISIG)
 211                         flags |= 0x02;          /* cbreak */
 212                 else
 213                         flags |= 0x20;          /* raw */
 214         }
 215         if (tty->termios->c_lflag & ECHO)
 216                 flags |= 0x08;                  /* echo */
 217         if (tty->termios->c_oflag & OPOST)
 218                 if (tty->termios->c_oflag & ONLCR)
 219                         flags |= 0x10;          /* crmod */
 220         return flags;
 221 }
 222
 223 static int get_sgttyb(struct tty_struct * tty, struct sgttyb * sgttyb)
 224 {
 225         struct sgttyb tmp;
 226
 227         tmp.sg_ispeed = 0;
 228         tmp.sg_ospeed = 0;
 229         tmp.sg_erase = tty->termios->c_cc[VERASE];
 230         tmp.sg_kill = tty->termios->c_cc[VKILL];
 231         tmp.sg_flags = get_sgflags(tty);
 232         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 233 }
 234
 235 static void set_sgflags(struct termios * termios, int flags)
 236 {
 237         termios->c_iflag = ICRNL | IXON;
 238         termios->c_oflag = 0;
 239         termios->c_lflag = ISIG | ICANON;
 240         if (flags & 0x02) {     /* cbreak */
 241                 termios->c_iflag = 0;
 242                 termios->c_lflag &= ~ICANON;
 243         }
 244         if (flags & 0x08) {             /* echo */
 245                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 246                                     ECHOCTL | ECHOKE | IEXTEN;
 247         }
 248         if (flags & 0x10) {             /* crmod */
 249                 termios->c_oflag |= OPOST | ONLCR;
 250         }
 251         if (flags & 0x20) {     /* raw */
 252                 termios->c_iflag = 0;
 253                 termios->c_lflag &= ~(ISIG | ICANON);
 254         }
 255         if (!(termios->c_lflag & ICANON)) {
 256                 termios->c_cc[VMIN] = 1;
 257                 termios->c_cc[VTIME] = 0;
 258         }
 259 }
 260
 261 static int set_sgttyb(struct tty_struct * tty, struct sgttyb * sgttyb)
 262 {
 263         int retval;
 264         struct sgttyb tmp;
 265         struct termios termios;
 266
 267         retval = tty_check_change(tty);
 268         if (retval)
 269                 return retval;
 270         termios =  *tty->termios;
 271         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 272                 return -EFAULT;
 273         termios.c_cc[VERASE] = tmp.sg_erase;
 274         termios.c_cc[VKILL] = tmp.sg_kill;
 275         set_sgflags(&termios, tmp.sg_flags);
 276         change_termios(tty, &termios);
 277         return 0;
 278 }
 279 #endif
 280
 281 #ifdef TIOCGETC
 282 static int get_tchars(struct tty_struct * tty, struct tchars * tchars)
 283 {
 284         struct tchars tmp;
 285
 286         tmp.t_intrc = tty->termios->c_cc[VINTR];
 287         tmp.t_quitc = tty->termios->c_cc[VQUIT];
 288         tmp.t_startc = tty->termios->c_cc[VSTART];
 289         tmp.t_stopc = tty->termios->c_cc[VSTOP];
 290         tmp.t_eofc = tty->termios->c_cc[VEOF];
 291         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
 292         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 293 }
 294
 295 static int set_tchars(struct tty_struct * tty, struct tchars * tchars)
 296 {
 297         struct tchars tmp;
 298
 299         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 300                 return -EFAULT;
 301         tty->termios->c_cc[VINTR] = tmp.t_intrc;
 302         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
 303         tty->termios->c_cc[VSTART] = tmp.t_startc;
 304         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
 305         tty->termios->c_cc[VEOF] = tmp.t_eofc;
 306         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
 307         return 0;
 308 }
 309 #endif
 310
 311 #ifdef TIOCGLTC
 312 static int get_ltchars(struct tty_struct * tty, struct ltchars * ltchars)
 313 {
 314         struct ltchars tmp;
 315
 316         tmp.t_suspc = tty->termios->c_cc[VSUSP];
 317         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];       /* what is dsuspc anyway? */
 318         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
 319         tmp.t_flushc = tty->termios->c_cc[VEOL2];       /* what is flushc anyway? */
 320         tmp.t_werasc = tty->termios->c_cc[VWERASE];
 321         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
 322         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 323 }
 324
 325 static int set_ltchars(struct tty_struct * tty, struct ltchars * ltchars)
 326 {
 327         struct ltchars tmp;
 328
 329         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 330                 return -EFAULT;
 331
 332         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
 333         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;       /* what is dsuspc anyway? */
 334         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
 335         tty->termios->c_cc[VEOL2] = tmp.t_flushc;       /* what is flushc anyway? */
 336         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
 337         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
 338         return 0;
 339 }
 340 #endif
 341
 342 /*
 343  * Send a high priority character to the tty.
 344  */
 345 void send_prio_char(struct tty_struct *tty, char ch)
 346 {
 347         int     was_stopped = tty->stopped;
 348
 349         if (tty->driver.send_xchar) {
 350                 tty->driver.send_xchar(tty, ch);
 351                 return;
 352         }
 353         if (was_stopped)
 354                 start_tty(tty);
 355         tty->driver.write(tty, 0, &ch, 1);
 356         if (was_stopped)
 357                 stop_tty(tty);
 358 }
 359
 360 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
 361                        unsigned int cmd, unsigned long arg)
 362 {
 363         struct tty_struct * real_tty;
 364         int retval;
 365
 366         if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
 367             tty->driver.subtype == PTY_TYPE_MASTER)
 368                 real_tty = tty->link;
 369         else
 370                 real_tty = tty;
 371
 372         switch (cmd) {
 373 #ifdef TIOCGETP
 374                 case TIOCGETP:
 375                         return get_sgttyb(real_tty, (struct sgttyb *) arg);
 376                 case TIOCSETP:
 377                 case TIOCSETN:
 378                         return set_sgttyb(real_tty, (struct sgttyb *) arg);
 379 #endif
 380 #ifdef TIOCGETC
 381                 case TIOCGETC:
 382                         return get_tchars(real_tty, (struct tchars *) arg);
 383                 case TIOCSETC:
 384                         return set_tchars(real_tty, (struct tchars *) arg);
 385 #endif
 386 #ifdef TIOCGLTC
 387                 case TIOCGLTC:
 388                         return get_ltchars(real_tty, (struct ltchars *) arg);
 389                 case TIOCSLTC:
 390                         return set_ltchars(real_tty, (struct ltchars *) arg);
 391 #endif
 392                 case TCGETS:
 393                         if (kernel_termios_to_user_termios((struct termios *)arg, real_tty->termios))
 394                                 return -EFAULT;
 395                         return 0;
 396                 case TCSETSF:
 397                         return set_termios(real_tty, arg,  TERMIOS_FLUSH | TERMIOS_WAIT);
 398                 case TCSETSW:
 399                         return set_termios(real_tty, arg, TERMIOS_WAIT);
 400                 case TCSETS:
 401                         return set_termios(real_tty, arg, 0);
 402                 case TCGETA:
 403                         return get_termio(real_tty,(struct termio *) arg);
 404                 case TCSETAF:
 405                         return set_termios(real_tty, arg, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
 406                 case TCSETAW:
 407                         return set_termios(real_tty, arg, TERMIOS_WAIT | TERMIOS_TERMIO);
 408                 case TCSETA:
 409                         return set_termios(real_tty, arg, TERMIOS_TERMIO);
 410                 case TCXONC:
 411                         retval = tty_check_change(tty);
 412                         if (retval)
 413                                 return retval;
 414                         switch (arg) {
 415                         case TCOOFF:
 416                                 if (!tty->flow_stopped) {
 417                                         tty->flow_stopped = 1;
 418                                         stop_tty(tty);
 419                                 }
 420                                 break;
 421                         case TCOON:
 422                                 if (tty->flow_stopped) {
 423                                         tty->flow_stopped = 0;
 424                                         start_tty(tty);
 425                                 }
 426                                 break;
 427                         case TCIOFF:
 428                                 if (STOP_CHAR(tty) != __DISABLED_CHAR)
 429                                         send_prio_char(tty, STOP_CHAR(tty));
 430                                 break;
 431                         case TCION:
 432                                 if (START_CHAR(tty) != __DISABLED_CHAR)
 433                                         send_prio_char(tty, START_CHAR(tty));
 434                                 break;
 435                         default:
 436                                 return -EINVAL;
 437                         }
 438                         return 0;
 439                 case TCFLSH:
 440                         retval = tty_check_change(tty);
 441                         if (retval)
 442                                 return retval;
 443                         switch (arg) {
 444                         case TCIFLUSH:
 445                                 if (tty->ldisc.flush_buffer)
 446                                         tty->ldisc.flush_buffer(tty);
 447                                 break;
 448                         case TCIOFLUSH:
 449                                 if (tty->ldisc.flush_buffer)
 450                                         tty->ldisc.flush_buffer(tty);
 451                                 /* fall through */
 452                         case TCOFLUSH:
 453                                 if (tty->driver.flush_buffer)
 454                                         tty->driver.flush_buffer(tty);
 455                                 break;
 456                         default:
 457                                 return -EINVAL;
 458                         }
 459                         return 0;
 460                 case TIOCOUTQ:
 461                         return put_user(tty->driver.chars_in_buffer ?
 462                                         tty->driver.chars_in_buffer(tty) : 0,
 463                                         (int *) arg);
 464                 case TIOCINQ:
 465                         retval = tty->read_cnt;
 466                         if (L_ICANON(tty))
 467                                 retval = inq_canon(tty);
 468                         return put_user(retval, (unsigned int *) arg);
 469                 case TIOCGLCKTRMIOS:
 470                         if (kernel_termios_to_user_termios((struct termios *)arg, real_tty->termios_locked))
 471                                 return -EFAULT;
 472                         return 0;
 473
 474                 case TIOCSLCKTRMIOS:
 475                         if (!capable(CAP_SYS_ADMIN))
 476                                 return -EPERM;
 477                         if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios *) arg))
 478                                 return -EFAULT;
 479                         return 0;
 480
 481                 case TIOCPKT:
 482                 {
 483                         int pktmode;
 484
 485                         if (tty->driver.type != TTY_DRIVER_TYPE_PTY ||
 486                             tty->driver.subtype != PTY_TYPE_MASTER)
 487                                 return -ENOTTY;
 488                         if (get_user(pktmode, (int *) arg))
 489                                 return -EFAULT;
 490                         if (pktmode) {
 491                                 if (!tty->packet) {
 492                                         tty->packet = 1;
 493                                         tty->link->ctrl_status = 0;
 494                                 }
 495                         } else
 496                                 tty->packet = 0;
 497                         return 0;
 498                 }
 499                 case TIOCGSOFTCAR:
 500                         return put_user(C_CLOCAL(tty) ? 1 : 0, (int *) arg);
 501                 case TIOCSSOFTCAR:
 502                         if (get_user(arg, (unsigned int *) arg))
 503                                 return -EFAULT;
 504                         tty->termios->c_cflag =
 505                                 ((tty->termios->c_cflag & ~CLOCAL) |
 506                                  (arg ? CLOCAL : 0));
 507                         return 0;
 508                 default:
 509                         return -ENOIOCTLCMD;
 510                 }
 511 }
 512
 513 EXPORT_SYMBOL(n_tty_ioctl);