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