drivers/tty/pty.c

   1 /*
   2  *  Copyright (C) 1991, 1992  Linus Torvalds
   3  *
   4  *  Added support for a Unix98-style ptmx device.
   5  *    -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
   6  *
   7  */
   8
   9 #include <linux/module.h>
  10
  11 #include <linux/errno.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/tty.h>
  14 #include <linux/tty_flip.h>
  15 #include <linux/fcntl.h>
  16 #include <linux/sched.h>
  17 #include <linux/string.h>
  18 #include <linux/major.h>
  19 #include <linux/mm.h>
  20 #include <linux/init.h>
  21 #include <linux/device.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/bitops.h>
  24 #include <linux/devpts_fs.h>
  25 #include <linux/slab.h>
  26 #include <linux/mutex.h>
  27 #include <linux/poll.h>
  28
  29
  30 #ifdef CONFIG_UNIX98_PTYS
  31 static struct tty_driver *ptm_driver;
  32 static struct tty_driver *pts_driver;
  33 static DEFINE_MUTEX(devpts_mutex);
  34 #endif
  35
  36 static void pty_close(struct tty_struct *tty, struct file *filp)
  37 {
  38         BUG_ON(!tty);
  39         if (tty->driver->subtype == PTY_TYPE_MASTER)
  40                 WARN_ON(tty->count > 1);
  41         else {
  42                 if (test_bit(TTY_IO_ERROR, &tty->flags))
  43                         return;
  44                 if (tty->count > 2)
  45                         return;
  46         }
  47         set_bit(TTY_IO_ERROR, &tty->flags);
  48         wake_up_interruptible(&tty->read_wait);
  49         wake_up_interruptible(&tty->write_wait);
  50         spin_lock_irq(&tty->ctrl_lock);
  51         tty->packet = 0;
  52         spin_unlock_irq(&tty->ctrl_lock);
  53         /* Review - krefs on tty_link ?? */
  54         if (!tty->link)
  55                 return;
  56         tty_flush_to_ldisc(tty->link);
  57         set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
  58         wake_up_interruptible(&tty->link->read_wait);
  59         wake_up_interruptible(&tty->link->write_wait);
  60         if (tty->driver->subtype == PTY_TYPE_MASTER) {
  61                 set_bit(TTY_OTHER_CLOSED, &tty->flags);
  62 #ifdef CONFIG_UNIX98_PTYS
  63                 if (tty->driver == ptm_driver) {
  64                         mutex_lock(&devpts_mutex);
  65                         if (tty->link->driver_data)
  66                                 devpts_pty_kill(tty->link->driver_data);
  67                         mutex_unlock(&devpts_mutex);
  68                 }
  69 #endif
  70                 tty_vhangup(tty->link);
  71         }
  72 }
  73
  74 /*
  75  * The unthrottle routine is called by the line discipline to signal
  76  * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  77  * flag is always set, to force the line discipline to always call the
  78  * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  79  * characters in the queue.  This is necessary since each time this
  80  * happens, we need to wake up any sleeping processes that could be
  81  * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  82  * for the pty buffer to be drained.
  83  */
  84 static void pty_unthrottle(struct tty_struct *tty)
  85 {
  86         tty_wakeup(tty->link);
  87         set_bit(TTY_THROTTLED, &tty->flags);
  88 }
  89
  90 /**
  91  *      pty_write               -       write to a pty
  92  *      @tty: the tty we write from
  93  *      @buf: kernel buffer of data
  94  *      @count: bytes to write
  95  *
  96  *      Our "hardware" write method. Data is coming from the ldisc which
  97  *      may be in a non sleeping state. We simply throw this at the other
  98  *      end of the link as if we were an IRQ handler receiving stuff for
  99  *      the other side of the pty/tty pair.
 100  */
 101
 102 static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
 103 {
 104         struct tty_struct *to = tty->link;
 105
 106         if (tty->stopped)
 107                 return 0;
 108
 109         if (c > 0) {
 110                 /* Stuff the data into the input queue of the other end */
 111                 c = tty_insert_flip_string(to->port, buf, c);
 112                 /* And shovel */
 113                 if (c)
 114                         tty_flip_buffer_push(to->port);
 115         }
 116         return c;
 117 }
 118
 119 /**
 120  *      pty_write_room  -       write space
 121  *      @tty: tty we are writing from
 122  *
 123  *      Report how many bytes the ldisc can send into the queue for
 124  *      the other device.
 125  */
 126
 127 static int pty_write_room(struct tty_struct *tty)
 128 {
 129         if (tty->stopped)
 130                 return 0;
 131         return tty_buffer_space_avail(tty->link->port);
 132 }
 133
 134 /**
 135  *      pty_chars_in_buffer     -       characters currently in our tx queue
 136  *      @tty: our tty
 137  *
 138  *      Report how much we have in the transmit queue. As everything is
 139  *      instantly at the other end this is easy to implement.
 140  */
 141
 142 static int pty_chars_in_buffer(struct tty_struct *tty)
 143 {
 144         return 0;
 145 }
 146
 147 /* Set the lock flag on a pty */
 148 static int pty_set_lock(struct tty_struct *tty, int __user *arg)
 149 {
 150         int val;
 151         if (get_user(val, arg))
 152                 return -EFAULT;
 153         if (val)
 154                 set_bit(TTY_PTY_LOCK, &tty->flags);
 155         else
 156                 clear_bit(TTY_PTY_LOCK, &tty->flags);
 157         return 0;
 158 }
 159
 160 static int pty_get_lock(struct tty_struct *tty, int __user *arg)
 161 {
 162         int locked = test_bit(TTY_PTY_LOCK, &tty->flags);
 163         return put_user(locked, arg);
 164 }
 165
 166 /* Set the packet mode on a pty */
 167 static int pty_set_pktmode(struct tty_struct *tty, int __user *arg)
 168 {
 169         int pktmode;
 170
 171         if (get_user(pktmode, arg))
 172                 return -EFAULT;
 173
 174         spin_lock_irq(&tty->ctrl_lock);
 175         if (pktmode) {
 176                 if (!tty->packet) {
 177                         tty->link->ctrl_status = 0;
 178                         smp_mb();
 179                         tty->packet = 1;
 180                 }
 181         } else
 182                 tty->packet = 0;
 183         spin_unlock_irq(&tty->ctrl_lock);
 184
 185         return 0;
 186 }
 187
 188 /* Get the packet mode of a pty */
 189 static int pty_get_pktmode(struct tty_struct *tty, int __user *arg)
 190 {
 191         int pktmode = tty->packet;
 192         return put_user(pktmode, arg);
 193 }
 194
 195 /* Send a signal to the slave */
 196 static int pty_signal(struct tty_struct *tty, int sig)
 197 {
 198         struct pid *pgrp;
 199
 200         if (sig != SIGINT && sig != SIGQUIT && sig != SIGTSTP)
 201                 return -EINVAL;
 202
 203         if (tty->link) {
 204                 pgrp = tty_get_pgrp(tty->link);
 205                 if (pgrp)
 206                         kill_pgrp(pgrp, sig, 1);
 207                 put_pid(pgrp);
 208         }
 209         return 0;
 210 }
 211
 212 static void pty_flush_buffer(struct tty_struct *tty)
 213 {
 214         struct tty_struct *to = tty->link;
 215
 216         if (!to)
 217                 return;
 218         /* tty_buffer_flush(to); FIXME */
 219         if (to->packet) {
 220                 spin_lock_irq(&tty->ctrl_lock);
 221                 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
 222                 wake_up_interruptible(&to->read_wait);
 223                 spin_unlock_irq(&tty->ctrl_lock);
 224         }
 225 }
 226
 227 static int pty_open(struct tty_struct *tty, struct file *filp)
 228 {
 229         if (!tty || !tty->link)
 230                 return -ENODEV;
 231
 232         if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
 233                 goto out;
 234         if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
 235                 goto out;
 236         if (tty->driver->subtype == PTY_TYPE_SLAVE && tty->link->count != 1)
 237                 goto out;
 238
 239         clear_bit(TTY_IO_ERROR, &tty->flags);
 240         clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 241         set_bit(TTY_THROTTLED, &tty->flags);
 242         return 0;
 243
 244 out:
 245         set_bit(TTY_IO_ERROR, &tty->flags);
 246         return -EIO;
 247 }
 248
 249 static void pty_set_termios(struct tty_struct *tty,
 250                                         struct ktermios *old_termios)
 251 {
 252         /* See if packet mode change of state. */
 253         if (tty->link && tty->link->packet) {
 254                 int extproc = (old_termios->c_lflag & EXTPROC) |
 255                                 (tty->termios.c_lflag & EXTPROC);
 256                 int old_flow = ((old_termios->c_iflag & IXON) &&
 257                                 (old_termios->c_cc[VSTOP] == '\023') &&
 258                                 (old_termios->c_cc[VSTART] == '\021'));
 259                 int new_flow = (I_IXON(tty) &&
 260                                 STOP_CHAR(tty) == '\023' &&
 261                                 START_CHAR(tty) == '\021');
 262                 if ((old_flow != new_flow) || extproc) {
 263                         spin_lock_irq(&tty->ctrl_lock);
 264                         if (old_flow != new_flow) {
 265                                 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
 266                                 if (new_flow)
 267                                         tty->ctrl_status |= TIOCPKT_DOSTOP;
 268                                 else
 269                                         tty->ctrl_status |= TIOCPKT_NOSTOP;
 270                         }
 271                         if (extproc)
 272                                 tty->ctrl_status |= TIOCPKT_IOCTL;
 273                         spin_unlock_irq(&tty->ctrl_lock);
 274                         wake_up_interruptible(&tty->link->read_wait);
 275                 }
 276         }
 277
 278         tty->termios.c_cflag &= ~(CSIZE | PARENB);
 279         tty->termios.c_cflag |= (CS8 | CREAD);
 280 }
 281
 282 /**
 283  *      pty_do_resize           -       resize event
 284  *      @tty: tty being resized
 285  *      @ws: window size being set.
 286  *
 287  *      Update the termios variables and send the necessary signals to
 288  *      peform a terminal resize correctly
 289  */
 290
 291 static int pty_resize(struct tty_struct *tty,  struct winsize *ws)
 292 {
 293         struct pid *pgrp, *rpgrp;
 294         struct tty_struct *pty = tty->link;
 295
 296         /* For a PTY we need to lock the tty side */
 297         mutex_lock(&tty->winsize_mutex);
 298         if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 299                 goto done;
 300
 301         /* Signal the foreground process group of both ptys */
 302         pgrp = tty_get_pgrp(tty);
 303         rpgrp = tty_get_pgrp(pty);
 304
 305         if (pgrp)
 306                 kill_pgrp(pgrp, SIGWINCH, 1);
 307         if (rpgrp != pgrp && rpgrp)
 308                 kill_pgrp(rpgrp, SIGWINCH, 1);
 309
 310         put_pid(pgrp);
 311         put_pid(rpgrp);
 312
 313         tty->winsize = *ws;
 314         pty->winsize = *ws;     /* Never used so will go away soon */
 315 done:
 316         mutex_unlock(&tty->winsize_mutex);
 317         return 0;
 318 }
 319
 320 /**
 321  *      pty_start - start() handler
 322  *      pty_stop  - stop() handler
 323  *      @tty: tty being flow-controlled
 324  *
 325  *      Propagates the TIOCPKT status to the master pty.
 326  *
 327  *      NB: only the master pty can be in packet mode so only the slave
 328  *          needs start()/stop() handlers
 329  */
 330 static void pty_start(struct tty_struct *tty)
 331 {
 332         unsigned long flags;
 333
 334         if (tty->link && tty->link->packet) {
 335                 spin_lock_irqsave(&tty->ctrl_lock, flags);
 336                 tty->ctrl_status &= ~TIOCPKT_STOP;
 337                 tty->ctrl_status |= TIOCPKT_START;
 338                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 339                 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 340         }
 341 }
 342
 343 static void pty_stop(struct tty_struct *tty)
 344 {
 345         unsigned long flags;
 346
 347         if (tty->link && tty->link->packet) {
 348                 spin_lock_irqsave(&tty->ctrl_lock, flags);
 349                 tty->ctrl_status &= ~TIOCPKT_START;
 350                 tty->ctrl_status |= TIOCPKT_STOP;
 351                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 352                 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 353         }
 354 }
 355
 356 /**
 357  *      pty_common_install              -       set up the pty pair
 358  *      @driver: the pty driver
 359  *      @tty: the tty being instantiated
 360  *      @legacy: true if this is BSD style
 361  *
 362  *      Perform the initial set up for the tty/pty pair. Called from the
 363  *      tty layer when the port is first opened.
 364  *
 365  *      Locking: the caller must hold the tty_mutex
 366  */
 367 static int pty_common_install(struct tty_driver *driver, struct tty_struct *tty,
 368                 bool legacy)
 369 {
 370         struct tty_struct *o_tty;
 371         struct tty_port *ports[2];
 372         int idx = tty->index;
 373         int retval = -ENOMEM;
 374
 375         /* Opening the slave first has always returned -EIO */
 376         if (driver->subtype != PTY_TYPE_MASTER)
 377                 return -EIO;
 378
 379         ports[0] = kmalloc(sizeof **ports, GFP_KERNEL);
 380         ports[1] = kmalloc(sizeof **ports, GFP_KERNEL);
 381         if (!ports[0] || !ports[1])
 382                 goto err;
 383         if (!try_module_get(driver->other->owner)) {
 384                 /* This cannot in fact currently happen */
 385                 goto err;
 386         }
 387         o_tty = alloc_tty_struct(driver->other, idx);
 388         if (!o_tty)
 389                 goto err_put_module;
 390
 391         tty_set_lock_subclass(o_tty);
 392
 393         if (legacy) {
 394                 /* We always use new tty termios data so we can do this
 395                    the easy way .. */
 396                 retval = tty_init_termios(tty);
 397                 if (retval)
 398                         goto err_deinit_tty;
 399
 400                 retval = tty_init_termios(o_tty);
 401                 if (retval)
 402                         goto err_free_termios;
 403
 404                 driver->other->ttys[idx] = o_tty;
 405                 driver->ttys[idx] = tty;
 406         } else {
 407                 memset(&tty->termios_locked, 0, sizeof(tty->termios_locked));
 408                 tty->termios = driver->init_termios;
 409                 memset(&o_tty->termios_locked, 0, sizeof(tty->termios_locked));
 410                 o_tty->termios = driver->other->init_termios;
 411         }
 412
 413         /*
 414          * Everything allocated ... set up the o_tty structure.
 415          */
 416         tty_driver_kref_get(driver->other);
 417         /* Establish the links in both directions */
 418         tty->link   = o_tty;
 419         o_tty->link = tty;
 420         tty_port_init(ports[0]);
 421         tty_port_init(ports[1]);
 422         tty_buffer_set_limit(ports[0], 8192);
 423         tty_buffer_set_limit(ports[1], 8192);
 424         o_tty->port = ports[0];
 425         tty->port = ports[1];
 426         o_tty->port->itty = o_tty;
 427
 428         tty_driver_kref_get(driver);
 429         tty->count++;
 430         o_tty->count++;
 431         return 0;
 432 err_free_termios:
 433         if (legacy)
 434                 tty_free_termios(tty);
 435 err_deinit_tty:
 436         deinitialize_tty_struct(o_tty);
 437         free_tty_struct(o_tty);
 438 err_put_module:
 439         module_put(driver->other->owner);
 440 err:
 441         kfree(ports[0]);
 442         kfree(ports[1]);
 443         return retval;
 444 }
 445
 446 static void pty_cleanup(struct tty_struct *tty)
 447 {
 448         tty_port_put(tty->port);
 449 }
 450
 451 /* Traditional BSD devices */
 452 #ifdef CONFIG_LEGACY_PTYS
 453
 454 static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
 455 {
 456         return pty_common_install(driver, tty, true);
 457 }
 458
 459 static void pty_remove(struct tty_driver *driver, struct tty_struct *tty)
 460 {
 461         struct tty_struct *pair = tty->link;
 462         driver->ttys[tty->index] = NULL;
 463         if (pair)
 464                 pair->driver->ttys[pair->index] = NULL;
 465 }
 466
 467 static int pty_bsd_ioctl(struct tty_struct *tty,
 468                          unsigned int cmd, unsigned long arg)
 469 {
 470         switch (cmd) {
 471         case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 472                 return pty_set_lock(tty, (int __user *) arg);
 473         case TIOCGPTLCK: /* Get PT Lock status */
 474                 return pty_get_lock(tty, (int __user *)arg);
 475         case TIOCPKT: /* Set PT packet mode */
 476                 return pty_set_pktmode(tty, (int __user *)arg);
 477         case TIOCGPKT: /* Get PT packet mode */
 478                 return pty_get_pktmode(tty, (int __user *)arg);
 479         case TIOCSIG:    /* Send signal to other side of pty */
 480                 return pty_signal(tty, (int) arg);
 481         case TIOCGPTN: /* TTY returns ENOTTY, but glibc expects EINVAL here */
 482                 return -EINVAL;
 483         }
 484         return -ENOIOCTLCMD;
 485 }
 486
 487 static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
 488 module_param(legacy_count, int, 0);
 489
 490 /*
 491  * The master side of a pty can do TIOCSPTLCK and thus
 492  * has pty_bsd_ioctl.
 493  */
 494 static const struct tty_operations master_pty_ops_bsd = {
 495         .install = pty_install,
 496         .open = pty_open,
 497         .close = pty_close,
 498         .write = pty_write,
 499         .write_room = pty_write_room,
 500         .flush_buffer = pty_flush_buffer,
 501         .chars_in_buffer = pty_chars_in_buffer,
 502         .unthrottle = pty_unthrottle,
 503         .ioctl = pty_bsd_ioctl,
 504         .cleanup = pty_cleanup,
 505         .resize = pty_resize,
 506         .remove = pty_remove
 507 };
 508
 509 static const struct tty_operations slave_pty_ops_bsd = {
 510         .install = pty_install,
 511         .open = pty_open,
 512         .close = pty_close,
 513         .write = pty_write,
 514         .write_room = pty_write_room,
 515         .flush_buffer = pty_flush_buffer,
 516         .chars_in_buffer = pty_chars_in_buffer,
 517         .unthrottle = pty_unthrottle,
 518         .set_termios = pty_set_termios,
 519         .cleanup = pty_cleanup,
 520         .resize = pty_resize,
 521         .start = pty_start,
 522         .stop = pty_stop,
 523         .remove = pty_remove
 524 };
 525
 526 static void __init legacy_pty_init(void)
 527 {
 528         struct tty_driver *pty_driver, *pty_slave_driver;
 529
 530         if (legacy_count <= 0)
 531                 return;
 532
 533         pty_driver = tty_alloc_driver(legacy_count,
 534                         TTY_DRIVER_RESET_TERMIOS |
 535                         TTY_DRIVER_REAL_RAW |
 536                         TTY_DRIVER_DYNAMIC_ALLOC);
 537         if (IS_ERR(pty_driver))
 538                 panic("Couldn't allocate pty driver");
 539
 540         pty_slave_driver = tty_alloc_driver(legacy_count,
 541                         TTY_DRIVER_RESET_TERMIOS |
 542                         TTY_DRIVER_REAL_RAW |
 543                         TTY_DRIVER_DYNAMIC_ALLOC);
 544         if (IS_ERR(pty_slave_driver))
 545                 panic("Couldn't allocate pty slave driver");
 546
 547         pty_driver->driver_name = "pty_master";
 548         pty_driver->name = "pty";
 549         pty_driver->major = PTY_MASTER_MAJOR;
 550         pty_driver->minor_start = 0;
 551         pty_driver->type = TTY_DRIVER_TYPE_PTY;
 552         pty_driver->subtype = PTY_TYPE_MASTER;
 553         pty_driver->init_termios = tty_std_termios;
 554         pty_driver->init_termios.c_iflag = 0;
 555         pty_driver->init_termios.c_oflag = 0;
 556         pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 557         pty_driver->init_termios.c_lflag = 0;
 558         pty_driver->init_termios.c_ispeed = 38400;
 559         pty_driver->init_termios.c_ospeed = 38400;
 560         pty_driver->other = pty_slave_driver;
 561         tty_set_operations(pty_driver, &master_pty_ops_bsd);
 562
 563         pty_slave_driver->driver_name = "pty_slave";
 564         pty_slave_driver->name = "ttyp";
 565         pty_slave_driver->major = PTY_SLAVE_MAJOR;
 566         pty_slave_driver->minor_start = 0;
 567         pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
 568         pty_slave_driver->subtype = PTY_TYPE_SLAVE;
 569         pty_slave_driver->init_termios = tty_std_termios;
 570         pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 571         pty_slave_driver->init_termios.c_ispeed = 38400;
 572         pty_slave_driver->init_termios.c_ospeed = 38400;
 573         pty_slave_driver->other = pty_driver;
 574         tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
 575
 576         if (tty_register_driver(pty_driver))
 577                 panic("Couldn't register pty driver");
 578         if (tty_register_driver(pty_slave_driver))
 579                 panic("Couldn't register pty slave driver");
 580 }
 581 #else
 582 static inline void legacy_pty_init(void) { }
 583 #endif
 584
 585 /* Unix98 devices */
 586 #ifdef CONFIG_UNIX98_PTYS
 587
 588 static struct cdev ptmx_cdev;
 589
 590 static int pty_unix98_ioctl(struct tty_struct *tty,
 591                             unsigned int cmd, unsigned long arg)
 592 {
 593         switch (cmd) {
 594         case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 595                 return pty_set_lock(tty, (int __user *)arg);
 596         case TIOCGPTLCK: /* Get PT Lock status */
 597                 return pty_get_lock(tty, (int __user *)arg);
 598         case TIOCPKT: /* Set PT packet mode */
 599                 return pty_set_pktmode(tty, (int __user *)arg);
 600         case TIOCGPKT: /* Get PT packet mode */
 601                 return pty_get_pktmode(tty, (int __user *)arg);
 602         case TIOCGPTN: /* Get PT Number */
 603                 return put_user(tty->index, (unsigned int __user *)arg);
 604         case TIOCSIG:    /* Send signal to other side of pty */
 605                 return pty_signal(tty, (int) arg);
 606         }
 607
 608         return -ENOIOCTLCMD;
 609 }
 610
 611 /**
 612  *      ptm_unix98_lookup       -       find a pty master
 613  *      @driver: ptm driver
 614  *      @idx: tty index
 615  *
 616  *      Look up a pty master device. Called under the tty_mutex for now.
 617  *      This provides our locking.
 618  */
 619
 620 static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
 621                 struct inode *ptm_inode, int idx)
 622 {
 623         /* Master must be open via /dev/ptmx */
 624         return ERR_PTR(-EIO);
 625 }
 626
 627 /**
 628  *      pts_unix98_lookup       -       find a pty slave
 629  *      @driver: pts driver
 630  *      @idx: tty index
 631  *
 632  *      Look up a pty master device. Called under the tty_mutex for now.
 633  *      This provides our locking for the tty pointer.
 634  */
 635
 636 static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
 637                 struct inode *pts_inode, int idx)
 638 {
 639         struct tty_struct *tty;
 640
 641         mutex_lock(&devpts_mutex);
 642         tty = devpts_get_priv(pts_inode);
 643         mutex_unlock(&devpts_mutex);
 644         /* Master must be open before slave */
 645         if (!tty)
 646                 return ERR_PTR(-EIO);
 647         return tty;
 648 }
 649
 650 /* We have no need to install and remove our tty objects as devpts does all
 651    the work for us */
 652
 653 static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
 654 {
 655         return pty_common_install(driver, tty, false);
 656 }
 657
 658 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 659 {
 660 }
 661
 662 /* this is called once with whichever end is closed last */
 663 static void pty_unix98_shutdown(struct tty_struct *tty)
 664 {
 665         devpts_kill_index(tty->driver_data, tty->index);
 666 }
 667
 668 static const struct tty_operations ptm_unix98_ops = {
 669         .lookup = ptm_unix98_lookup,
 670         .install = pty_unix98_install,
 671         .remove = pty_unix98_remove,
 672         .open = pty_open,
 673         .close = pty_close,
 674         .write = pty_write,
 675         .write_room = pty_write_room,
 676         .flush_buffer = pty_flush_buffer,
 677         .chars_in_buffer = pty_chars_in_buffer,
 678         .unthrottle = pty_unthrottle,
 679         .ioctl = pty_unix98_ioctl,
 680         .resize = pty_resize,
 681         .shutdown = pty_unix98_shutdown,
 682         .cleanup = pty_cleanup
 683 };
 684
 685 static const struct tty_operations pty_unix98_ops = {
 686         .lookup = pts_unix98_lookup,
 687         .install = pty_unix98_install,
 688         .remove = pty_unix98_remove,
 689         .open = pty_open,
 690         .close = pty_close,
 691         .write = pty_write,
 692         .write_room = pty_write_room,
 693         .flush_buffer = pty_flush_buffer,
 694         .chars_in_buffer = pty_chars_in_buffer,
 695         .unthrottle = pty_unthrottle,
 696         .set_termios = pty_set_termios,
 697         .start = pty_start,
 698         .stop = pty_stop,
 699         .shutdown = pty_unix98_shutdown,
 700         .cleanup = pty_cleanup,
 701 };
 702
 703 /**
 704  *      ptmx_open               -       open a unix 98 pty master
 705  *      @inode: inode of device file
 706  *      @filp: file pointer to tty
 707  *
 708  *      Allocate a unix98 pty master device from the ptmx driver.
 709  *
 710  *      Locking: tty_mutex protects the init_dev work. tty->count should
 711  *              protect the rest.
 712  *              allocated_ptys_lock handles the list of free pty numbers
 713  */
 714
 715 static int ptmx_open(struct inode *inode, struct file *filp)
 716 {
 717         struct tty_struct *tty;
 718         struct inode *slave_inode;
 719         int retval;
 720         int index;
 721
 722         nonseekable_open(inode, filp);
 723
 724         /* We refuse fsnotify events on ptmx, since it's a shared resource */
 725         filp->f_mode |= FMODE_NONOTIFY;
 726
 727         retval = tty_alloc_file(filp);
 728         if (retval)
 729                 return retval;
 730
 731         /* find a device that is not in use. */
 732         mutex_lock(&devpts_mutex);
 733         index = devpts_new_index(inode);
 734         if (index < 0) {
 735                 retval = index;
 736                 mutex_unlock(&devpts_mutex);
 737                 goto err_file;
 738         }
 739
 740         mutex_unlock(&devpts_mutex);
 741
 742         mutex_lock(&tty_mutex);
 743         tty = tty_init_dev(ptm_driver, index);
 744
 745         if (IS_ERR(tty)) {
 746                 retval = PTR_ERR(tty);
 747                 goto out;
 748         }
 749
 750         /* The tty returned here is locked so we can safely
 751            drop the mutex */
 752         mutex_unlock(&tty_mutex);
 753
 754         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
 755         tty->driver_data = inode;
 756
 757         tty_add_file(tty, filp);
 758
 759         slave_inode = devpts_pty_new(inode,
 760                         MKDEV(UNIX98_PTY_SLAVE_MAJOR, index), index,
 761                         tty->link);
 762         if (IS_ERR(slave_inode)) {
 763                 retval = PTR_ERR(slave_inode);
 764                 goto err_release;
 765         }
 766         tty->link->driver_data = slave_inode;
 767
 768         retval = ptm_driver->ops->open(tty, filp);
 769         if (retval)
 770                 goto err_release;
 771
 772         tty_unlock(tty);
 773         return 0;
 774 err_release:
 775         tty_unlock(tty);
 776         tty_release(inode, filp);
 777         return retval;
 778 out:
 779         mutex_unlock(&tty_mutex);
 780         devpts_kill_index(inode, index);
 781 err_file:
 782         tty_free_file(filp);
 783         return retval;
 784 }
 785
 786 static struct file_operations ptmx_fops;
 787
 788 static void __init unix98_pty_init(void)
 789 {
 790         ptm_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
 791                         TTY_DRIVER_RESET_TERMIOS |
 792                         TTY_DRIVER_REAL_RAW |
 793                         TTY_DRIVER_DYNAMIC_DEV |
 794                         TTY_DRIVER_DEVPTS_MEM |
 795                         TTY_DRIVER_DYNAMIC_ALLOC);
 796         if (IS_ERR(ptm_driver))
 797                 panic("Couldn't allocate Unix98 ptm driver");
 798         pts_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
 799                         TTY_DRIVER_RESET_TERMIOS |
 800                         TTY_DRIVER_REAL_RAW |
 801                         TTY_DRIVER_DYNAMIC_DEV |
 802                         TTY_DRIVER_DEVPTS_MEM |
 803                         TTY_DRIVER_DYNAMIC_ALLOC);
 804         if (IS_ERR(pts_driver))
 805                 panic("Couldn't allocate Unix98 pts driver");
 806
 807         ptm_driver->driver_name = "pty_master";
 808         ptm_driver->name = "ptm";
 809         ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
 810         ptm_driver->minor_start = 0;
 811         ptm_driver->type = TTY_DRIVER_TYPE_PTY;
 812         ptm_driver->subtype = PTY_TYPE_MASTER;
 813         ptm_driver->init_termios = tty_std_termios;
 814         ptm_driver->init_termios.c_iflag = 0;
 815         ptm_driver->init_termios.c_oflag = 0;
 816         ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 817         ptm_driver->init_termios.c_lflag = 0;
 818         ptm_driver->init_termios.c_ispeed = 38400;
 819         ptm_driver->init_termios.c_ospeed = 38400;
 820         ptm_driver->other = pts_driver;
 821         tty_set_operations(ptm_driver, &ptm_unix98_ops);
 822
 823         pts_driver->driver_name = "pty_slave";
 824         pts_driver->name = "pts";
 825         pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
 826         pts_driver->minor_start = 0;
 827         pts_driver->type = TTY_DRIVER_TYPE_PTY;
 828         pts_driver->subtype = PTY_TYPE_SLAVE;
 829         pts_driver->init_termios = tty_std_termios;
 830         pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 831         pts_driver->init_termios.c_ispeed = 38400;
 832         pts_driver->init_termios.c_ospeed = 38400;
 833         pts_driver->other = ptm_driver;
 834         tty_set_operations(pts_driver, &pty_unix98_ops);
 835
 836         if (tty_register_driver(ptm_driver))
 837                 panic("Couldn't register Unix98 ptm driver");
 838         if (tty_register_driver(pts_driver))
 839                 panic("Couldn't register Unix98 pts driver");
 840
 841         /* Now create the /dev/ptmx special device */
 842         tty_default_fops(&ptmx_fops);
 843         ptmx_fops.open = ptmx_open;
 844
 845         cdev_init(&ptmx_cdev, &ptmx_fops);
 846         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
 847             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
 848                 panic("Couldn't register /dev/ptmx driver");
 849         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 850 }
 851
 852 #else
 853 static inline void unix98_pty_init(void) { }
 854 #endif
 855
 856 static int __init pty_init(void)
 857 {
 858         legacy_pty_init();
 859         unix98_pty_init();
 860         return 0;
 861 }
 862 module_init(pty_init);