git.oblomov.eu Git - linux-2.6/blob - 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 #include <linux/bitops.h>
  23
  24 #include <asm/io.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
  40 /**
  41  *      tty_wait_until_sent     -       wait for I/O to finish
  42  *      @tty: tty we are waiting for
  43  *      @timeout: how long we will wait
  44  *
  45  *      Wait for characters pending in a tty driver to hit the wire, or
  46  *      for a timeout to occur (eg due to flow control)
  47  *
  48  *      Locking: none
  49  */
  50
  51 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
  52 {
  53         DECLARE_WAITQUEUE(wait, current);
  54
  55 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  56         char buf[64];
  57
  58         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
  59 #endif
  60         if (!tty->driver->chars_in_buffer)
  61                 return;
  62         add_wait_queue(&tty->write_wait, &wait);
  63         if (!timeout)
  64                 timeout = MAX_SCHEDULE_TIMEOUT;
  65         do {
  66 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  67                 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
  68                        tty->driver->chars_in_buffer(tty));
  69 #endif
  70                 set_current_state(TASK_INTERRUPTIBLE);
  71                 if (signal_pending(current))
  72                         goto stop_waiting;
  73                 if (!tty->driver->chars_in_buffer(tty))
  74                         break;
  75                 timeout = schedule_timeout(timeout);
  76         } while (timeout);
  77         if (tty->driver->wait_until_sent)
  78                 tty->driver->wait_until_sent(tty, timeout);
  79 stop_waiting:
  80         set_current_state(TASK_RUNNING);
  81         remove_wait_queue(&tty->write_wait, &wait);
  82 }
  83
  84 EXPORT_SYMBOL(tty_wait_until_sent);
  85
  86 static void unset_locked_termios(struct termios *termios,
  87                                  struct termios *old,
  88                                  struct termios *locked)
  89 {
  90         int     i;
  91
  92 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
  93
  94         if (!locked) {
  95                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
  96                 return;
  97         }
  98
  99         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
 100         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
 101         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
 102         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
 103         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
 104         for (i=0; i < NCCS; i++)
 105                 termios->c_cc[i] = locked->c_cc[i] ?
 106                         old->c_cc[i] : termios->c_cc[i];
 107 }
 108
 109 /**
 110  *      change_termios          -       update termios values
 111  *      @tty: tty to update
 112  *      @new_termios: desired new value
 113  *
 114  *      Perform updates to the termios values set on this terminal. There
 115  *      is a bit of layering violation here with n_tty in terms of the
 116  *      internal knowledge of this function.
 117  *
 118  *      Locking: termios_sem
 119  */
 120
 121 static void change_termios(struct tty_struct * tty, struct termios * new_termios)
 122 {
 123         int canon_change;
 124         struct termios old_termios = *tty->termios;
 125         struct tty_ldisc *ld;
 126
 127         /*
 128          *      Perform the actual termios internal changes under lock.
 129          */
 130
 131
 132         /* FIXME: we need to decide on some locking/ordering semantics
 133            for the set_termios notification eventually */
 134         down(&tty->termios_sem);
 135
 136         *tty->termios = *new_termios;
 137         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
 138         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
 139         if (canon_change) {
 140                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
 141                 tty->canon_head = tty->read_tail;
 142                 tty->canon_data = 0;
 143                 tty->erasing = 0;
 144         }
 145
 146
 147         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
 148                 /* Get characters left over from canonical mode. */
 149                 wake_up_interruptible(&tty->read_wait);
 150
 151         /* See if packet mode change of state. */
 152
 153         if (tty->link && tty->link->packet) {
 154                 int old_flow = ((old_termios.c_iflag & IXON) &&
 155                                 (old_termios.c_cc[VSTOP] == '\023') &&
 156                                 (old_termios.c_cc[VSTART] == '\021'));
 157                 int new_flow = (I_IXON(tty) &&
 158                                 STOP_CHAR(tty) == '\023' &&
 159                                 START_CHAR(tty) == '\021');
 160                 if (old_flow != new_flow) {
 161                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 162                         if (new_flow)
 163                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
 164                         else
 165                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
 166                         wake_up_interruptible(&tty->link->read_wait);
 167                 }
 168         }
 169
 170         if (tty->driver->set_termios)
 171                 (*tty->driver->set_termios)(tty, &old_termios);
 172
 173         ld = tty_ldisc_ref(tty);
 174         if (ld != NULL) {
 175                 if (ld->set_termios)
 176                         (ld->set_termios)(tty, &old_termios);
 177                 tty_ldisc_deref(ld);
 178         }
 179         up(&tty->termios_sem);
 180 }
 181
 182 /**
 183  *      set_termios             -       set termios values for a tty
 184  *      @tty: terminal device
 185  *      @arg: user data
 186  *      @opt: option information
 187  *
 188  *      Helper function to prepare termios data and run neccessary other
 189  *      functions before using change_termios to do the actual changes.
 190  *
 191  *      Locking:
 192  *              Called functions take ldisc and termios_sem locks
 193  */
 194
 195 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
 196 {
 197         struct termios tmp_termios;
 198         struct tty_ldisc *ld;
 199         int retval = tty_check_change(tty);
 200
 201         if (retval)
 202                 return retval;
 203
 204         if (opt & TERMIOS_TERMIO) {
 205                 memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
 206                 if (user_termio_to_kernel_termios(&tmp_termios,
 207                                                 (struct termio __user *)arg))
 208                         return -EFAULT;
 209         } else {
 210                 if (user_termios_to_kernel_termios(&tmp_termios,
 211                                                 (struct termios __user *)arg))
 212                         return -EFAULT;
 213         }
 214
 215         ld = tty_ldisc_ref(tty);
 216
 217         if (ld != NULL) {
 218                 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
 219                         ld->flush_buffer(tty);
 220                 tty_ldisc_deref(ld);
 221         }
 222
 223         if (opt & TERMIOS_WAIT) {
 224                 tty_wait_until_sent(tty, 0);
 225                 if (signal_pending(current))
 226                         return -EINTR;
 227         }
 228
 229         change_termios(tty, &tmp_termios);
 230         return 0;
 231 }
 232
 233 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
 234 {
 235         if (kernel_termios_to_user_termio(termio, tty->termios))
 236                 return -EFAULT;
 237         return 0;
 238 }
 239
 240 static unsigned long inq_canon(struct tty_struct * tty)
 241 {
 242         int nr, head, tail;
 243
 244         if (!tty->canon_data || !tty->read_buf)
 245                 return 0;
 246         head = tty->canon_head;
 247         tail = tty->read_tail;
 248         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
 249         /* Skip EOF-chars.. */
 250         while (head != tail) {
 251                 if (test_bit(tail, tty->read_flags) &&
 252                     tty->read_buf[tail] == __DISABLED_CHAR)
 253                         nr--;
 254                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
 255         }
 256         return nr;
 257 }
 258
 259 #ifdef TIOCGETP
 260 /*
 261  * These are deprecated, but there is limited support..
 262  *
 263  * The "sg_flags" translation is a joke..
 264  */
 265 static int get_sgflags(struct tty_struct * tty)
 266 {
 267         int flags = 0;
 268
 269         if (!(tty->termios->c_lflag & ICANON)) {
 270                 if (tty->termios->c_lflag & ISIG)
 271                         flags |= 0x02;          /* cbreak */
 272                 else
 273                         flags |= 0x20;          /* raw */
 274         }
 275         if (tty->termios->c_lflag & ECHO)
 276                 flags |= 0x08;                  /* echo */
 277         if (tty->termios->c_oflag & OPOST)
 278                 if (tty->termios->c_oflag & ONLCR)
 279                         flags |= 0x10;          /* crmod */
 280         return flags;
 281 }
 282
 283 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 284 {
 285         struct sgttyb tmp;
 286
 287         down(&tty->termios_sem);
 288         tmp.sg_ispeed = 0;
 289         tmp.sg_ospeed = 0;
 290         tmp.sg_erase = tty->termios->c_cc[VERASE];
 291         tmp.sg_kill = tty->termios->c_cc[VKILL];
 292         tmp.sg_flags = get_sgflags(tty);
 293         up(&tty->termios_sem);
 294
 295         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 296 }
 297
 298 static void set_sgflags(struct termios * termios, int flags)
 299 {
 300         termios->c_iflag = ICRNL | IXON;
 301         termios->c_oflag = 0;
 302         termios->c_lflag = ISIG | ICANON;
 303         if (flags & 0x02) {     /* cbreak */
 304                 termios->c_iflag = 0;
 305                 termios->c_lflag &= ~ICANON;
 306         }
 307         if (flags & 0x08) {             /* echo */
 308                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
 309                                     ECHOCTL | ECHOKE | IEXTEN;
 310         }
 311         if (flags & 0x10) {             /* crmod */
 312                 termios->c_oflag |= OPOST | ONLCR;
 313         }
 314         if (flags & 0x20) {     /* raw */
 315                 termios->c_iflag = 0;
 316                 termios->c_lflag &= ~(ISIG | ICANON);
 317         }
 318         if (!(termios->c_lflag & ICANON)) {
 319                 termios->c_cc[VMIN] = 1;
 320                 termios->c_cc[VTIME] = 0;
 321         }
 322 }
 323
 324 /**
 325  *      set_sgttyb              -       set legacy terminal values
 326  *      @tty: tty structure
 327  *      @sgttyb: pointer to old style terminal structure
 328  *
 329  *      Updates a terminal from the legacy BSD style terminal information
 330  *      structure.
 331  *
 332  *      Locking: termios_sem
 333  */
 334
 335 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
 336 {
 337         int retval;
 338         struct sgttyb tmp;
 339         struct termios termios;
 340
 341         retval = tty_check_change(tty);
 342         if (retval)
 343                 return retval;
 344
 345         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
 346                 return -EFAULT;
 347
 348         down(&tty->termios_sem);
 349         termios =  *tty->termios;
 350         termios.c_cc[VERASE] = tmp.sg_erase;
 351         termios.c_cc[VKILL] = tmp.sg_kill;
 352         set_sgflags(&termios, tmp.sg_flags);
 353         up(&tty->termios_sem);
 354         change_termios(tty, &termios);
 355         return 0;
 356 }
 357 #endif
 358
 359 #ifdef TIOCGETC
 360 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
 361 {
 362         struct tchars tmp;
 363
 364         tmp.t_intrc = tty->termios->c_cc[VINTR];
 365         tmp.t_quitc = tty->termios->c_cc[VQUIT];
 366         tmp.t_startc = tty->termios->c_cc[VSTART];
 367         tmp.t_stopc = tty->termios->c_cc[VSTOP];
 368         tmp.t_eofc = tty->termios->c_cc[VEOF];
 369         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
 370         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 371 }
 372
 373 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
 374 {
 375         struct tchars tmp;
 376
 377         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
 378                 return -EFAULT;
 379         tty->termios->c_cc[VINTR] = tmp.t_intrc;
 380         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
 381         tty->termios->c_cc[VSTART] = tmp.t_startc;
 382         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
 383         tty->termios->c_cc[VEOF] = tmp.t_eofc;
 384         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
 385         return 0;
 386 }
 387 #endif
 388
 389 #ifdef TIOCGLTC
 390 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
 391 {
 392         struct ltchars tmp;
 393
 394         tmp.t_suspc = tty->termios->c_cc[VSUSP];
 395         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];       /* what is dsuspc anyway? */
 396         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
 397         tmp.t_flushc = tty->termios->c_cc[VEOL2];       /* what is flushc anyway? */
 398         tmp.t_werasc = tty->termios->c_cc[VWERASE];
 399         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
 400         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 401 }
 402
 403 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
 404 {
 405         struct ltchars tmp;
 406
 407         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
 408                 return -EFAULT;
 409
 410         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
 411         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;       /* what is dsuspc anyway? */
 412         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
 413         tty->termios->c_cc[VEOL2] = tmp.t_flushc;       /* what is flushc anyway? */
 414         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
 415         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
 416         return 0;
 417 }
 418 #endif
 419
 420 /**
 421  *      send_prio_char          -       send priority character
 422  *
 423  *      Send a high priority character to the tty even if stopped
 424  *
 425  *      Locking: none
 426  *
 427  *      FIXME: overlapping calls with start/stop tty lose state of tty
 428  */
 429
 430 static void send_prio_char(struct tty_struct *tty, char ch)
 431 {
 432         int     was_stopped = tty->stopped;
 433
 434         if (tty->driver->send_xchar) {
 435                 tty->driver->send_xchar(tty, ch);
 436                 return;
 437         }
 438         if (was_stopped)
 439                 start_tty(tty);
 440         tty->driver->write(tty, &ch, 1);
 441         if (was_stopped)
 442                 stop_tty(tty);
 443 }
 444
 445 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
 446                        unsigned int cmd, unsigned long arg)
 447 {
 448         struct tty_struct * real_tty;
 449         void __user *p = (void __user *)arg;
 450         int retval;
 451         struct tty_ldisc *ld;
 452
 453         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 454             tty->driver->subtype == PTY_TYPE_MASTER)
 455                 real_tty = tty->link;
 456         else
 457                 real_tty = tty;
 458
 459         switch (cmd) {
 460 #ifdef TIOCGETP
 461                 case TIOCGETP:
 462                         return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
 463                 case TIOCSETP:
 464                 case TIOCSETN:
 465                         return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
 466 #endif
 467 #ifdef TIOCGETC
 468                 case TIOCGETC:
 469                         return get_tchars(real_tty, p);
 470                 case TIOCSETC:
 471                         return set_tchars(real_tty, p);
 472 #endif
 473 #ifdef TIOCGLTC
 474                 case TIOCGLTC:
 475                         return get_ltchars(real_tty, p);
 476                 case TIOCSLTC:
 477                         return set_ltchars(real_tty, p);
 478 #endif
 479                 case TCGETS:
 480                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
 481                                 return -EFAULT;
 482                         return 0;
 483                 case TCSETSF:
 484                         return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
 485                 case TCSETSW:
 486                         return set_termios(real_tty, p, TERMIOS_WAIT);
 487                 case TCSETS:
 488                         return set_termios(real_tty, p, 0);
 489                 case TCGETA:
 490                         return get_termio(real_tty, p);
 491                 case TCSETAF:
 492                         return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
 493                 case TCSETAW:
 494                         return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
 495                 case TCSETA:
 496                         return set_termios(real_tty, p, TERMIOS_TERMIO);
 497                 case TCXONC:
 498                         retval = tty_check_change(tty);
 499                         if (retval)
 500                                 return retval;
 501                         switch (arg) {
 502                         case TCOOFF:
 503                                 if (!tty->flow_stopped) {
 504                                         tty->flow_stopped = 1;
 505                                         stop_tty(tty);
 506                                 }
 507                                 break;
 508                         case TCOON:
 509                                 if (tty->flow_stopped) {
 510                                         tty->flow_stopped = 0;
 511                                         start_tty(tty);
 512                                 }
 513                                 break;
 514                         case TCIOFF:
 515                                 if (STOP_CHAR(tty) != __DISABLED_CHAR)
 516                                         send_prio_char(tty, STOP_CHAR(tty));
 517                                 break;
 518                         case TCION:
 519                                 if (START_CHAR(tty) != __DISABLED_CHAR)
 520                                         send_prio_char(tty, START_CHAR(tty));
 521                                 break;
 522                         default:
 523                                 return -EINVAL;
 524                         }
 525                         return 0;
 526                 case TCFLSH:
 527                         retval = tty_check_change(tty);
 528                         if (retval)
 529                                 return retval;
 530
 531                         ld = tty_ldisc_ref(tty);
 532                         switch (arg) {
 533                         case TCIFLUSH:
 534                                 if (ld && ld->flush_buffer)
 535                                         ld->flush_buffer(tty);
 536                                 break;
 537                         case TCIOFLUSH:
 538                                 if (ld && ld->flush_buffer)
 539                                         ld->flush_buffer(tty);
 540                                 /* fall through */
 541                         case TCOFLUSH:
 542                                 if (tty->driver->flush_buffer)
 543                                         tty->driver->flush_buffer(tty);
 544                                 break;
 545                         default:
 546                                 tty_ldisc_deref(ld);
 547                                 return -EINVAL;
 548                         }
 549                         tty_ldisc_deref(ld);
 550                         return 0;
 551                 case TIOCOUTQ:
 552                         return put_user(tty->driver->chars_in_buffer ?
 553                                         tty->driver->chars_in_buffer(tty) : 0,
 554                                         (int __user *) arg);
 555                 case TIOCINQ:
 556                         retval = tty->read_cnt;
 557                         if (L_ICANON(tty))
 558                                 retval = inq_canon(tty);
 559                         return put_user(retval, (unsigned int __user *) arg);
 560                 case TIOCGLCKTRMIOS:
 561                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
 562                                 return -EFAULT;
 563                         return 0;
 564
 565                 case TIOCSLCKTRMIOS:
 566                         if (!capable(CAP_SYS_ADMIN))
 567                                 return -EPERM;
 568                         if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
 569                                 return -EFAULT;
 570                         return 0;
 571
 572                 case TIOCPKT:
 573                 {
 574                         int pktmode;
 575
 576                         if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
 577                             tty->driver->subtype != PTY_TYPE_MASTER)
 578                                 return -ENOTTY;
 579                         if (get_user(pktmode, (int __user *) arg))
 580                                 return -EFAULT;
 581                         if (pktmode) {
 582                                 if (!tty->packet) {
 583                                         tty->packet = 1;
 584                                         tty->link->ctrl_status = 0;
 585                                 }
 586                         } else
 587                                 tty->packet = 0;
 588                         return 0;
 589                 }
 590                 case TIOCGSOFTCAR:
 591                         return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
 592                 case TIOCSSOFTCAR:
 593                         if (get_user(arg, (unsigned int __user *) arg))
 594                                 return -EFAULT;
 595                         down(&tty->termios_sem);
 596                         tty->termios->c_cflag =
 597                                 ((tty->termios->c_cflag & ~CLOCAL) |
 598                                  (arg ? CLOCAL : 0));
 599                         up(&tty->termios_sem);
 600                         return 0;
 601                 default:
 602                         return -ENOIOCTLCMD;
 603                 }
 604 }
 605
 606 EXPORT_SYMBOL(n_tty_ioctl);