drivers/char/pty.c

   1 /*
   2  *  linux/drivers/char/pty.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  Added support for a Unix98-style ptmx device.
   7  *    -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
   8  *
   9  *  When reading this code see also fs/devpts. In particular note that the
  10  *  driver_data field is used by the devpts side as a binding to the devpts
  11  *  inode.
  12  */
  13
  14 #include <linux/module.h>
  15
  16 #include <linux/errno.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/tty.h>
  19 #include <linux/tty_flip.h>
  20 #include <linux/fcntl.h>
  21 #include <linux/string.h>
  22 #include <linux/major.h>
  23 #include <linux/mm.h>
  24 #include <linux/init.h>
  25 #include <linux/smp_lock.h>
  26 #include <linux/sysctl.h>
  27 #include <linux/device.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/bitops.h>
  30 #include <linux/devpts_fs.h>
  31
  32 #include <asm/system.h>
  33
  34 #ifdef CONFIG_UNIX98_PTYS
  35 static struct tty_driver *ptm_driver;
  36 static struct tty_driver *pts_driver;
  37 #endif
  38
  39 static void pty_close(struct tty_struct *tty, struct file *filp)
  40 {
  41         BUG_ON(!tty);
  42         if (tty->driver->subtype == PTY_TYPE_MASTER)
  43                 WARN_ON(tty->count > 1);
  44         else {
  45                 if (tty->count > 2)
  46                         return;
  47         }
  48         wake_up_interruptible(&tty->read_wait);
  49         wake_up_interruptible(&tty->write_wait);
  50         tty->packet = 0;
  51         if (!tty->link)
  52                 return;
  53         tty->link->packet = 0;
  54         set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
  55         wake_up_interruptible(&tty->link->read_wait);
  56         wake_up_interruptible(&tty->link->write_wait);
  57         if (tty->driver->subtype == PTY_TYPE_MASTER) {
  58                 set_bit(TTY_OTHER_CLOSED, &tty->flags);
  59 #ifdef CONFIG_UNIX98_PTYS
  60                 if (tty->driver == ptm_driver)
  61                         devpts_pty_kill(tty->link);
  62 #endif
  63                 tty_vhangup(tty->link);
  64         }
  65 }
  66
  67 /*
  68  * The unthrottle routine is called by the line discipline to signal
  69  * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  70  * flag is always set, to force the line discipline to always call the
  71  * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  72  * characters in the queue.  This is necessary since each time this
  73  * happens, we need to wake up any sleeping processes that could be
  74  * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  75  * for the pty buffer to be drained.
  76  */
  77 static void pty_unthrottle(struct tty_struct *tty)
  78 {
  79         tty_wakeup(tty->link);
  80         set_bit(TTY_THROTTLED, &tty->flags);
  81 }
  82
  83 /**
  84  *      pty_space       -       report space left for writing
  85  *      @to: tty we are writing into
  86  *
  87  *      The tty buffers allow 64K but we sneak a peak and clip at 8K this
  88  *      allows a lot of overspill room for echo and other fun messes to
  89  *      be handled properly
  90  */
  91
  92 static int pty_space(struct tty_struct *to)
  93 {
  94         int n = 8192 - to->buf.memory_used;
  95         if (n < 0)
  96                 return 0;
  97         return n;
  98 }
  99
 100 /**
 101  *      pty_write               -       write to a pty
 102  *      @tty: the tty we write from
 103  *      @buf: kernel buffer of data
 104  *      @count: bytes to write
 105  *
 106  *      Our "hardware" write method. Data is coming from the ldisc which
 107  *      may be in a non sleeping state. We simply throw this at the other
 108  *      end of the link as if we were an IRQ handler receiving stuff for
 109  *      the other side of the pty/tty pair.
 110  */
 111
 112 static int pty_write(struct tty_struct *tty, const unsigned char *buf,
 113                                                                 int count)
 114 {
 115         struct tty_struct *to = tty->link;
 116         int c;
 117
 118         if (tty->stopped)
 119                 return 0;
 120
 121         /* This isn't locked but our 8K is quite sloppy so no
 122            big deal */
 123
 124         c = pty_space(to);
 125         if (c > count)
 126                 c = count;
 127         if (c > 0) {
 128                 /* Stuff the data into the input queue of the other end */
 129                 c = tty_insert_flip_string(to, buf, c);
 130                 /* And shovel */
 131                 tty_flip_buffer_push(to);
 132                 tty_wakeup(tty);
 133         }
 134         return c;
 135 }
 136
 137 /**
 138  *      pty_write_room  -       write space
 139  *      @tty: tty we are writing from
 140  *
 141  *      Report how many bytes the ldisc can send into the queue for
 142  *      the other device.
 143  */
 144
 145 static int pty_write_room(struct tty_struct *tty)
 146 {
 147         if (tty->stopped)
 148                 return 0;
 149         return pty_space(tty->link);
 150 }
 151
 152 /**
 153  *      pty_chars_in_buffer     -       characters currently in our tx queue
 154  *      @tty: our tty
 155  *
 156  *      Report how much we have in the transmit queue. As everything is
 157  *      instantly at the other end this is easy to implement.
 158  */
 159
 160 static int pty_chars_in_buffer(struct tty_struct *tty)
 161 {
 162         return 0;
 163 }
 164
 165 /* Set the lock flag on a pty */
 166 static int pty_set_lock(struct tty_struct *tty, int __user *arg)
 167 {
 168         int val;
 169         if (get_user(val, arg))
 170                 return -EFAULT;
 171         if (val)
 172                 set_bit(TTY_PTY_LOCK, &tty->flags);
 173         else
 174                 clear_bit(TTY_PTY_LOCK, &tty->flags);
 175         return 0;
 176 }
 177
 178 static void pty_flush_buffer(struct tty_struct *tty)
 179 {
 180         struct tty_struct *to = tty->link;
 181         unsigned long flags;
 182
 183         if (!to)
 184                 return;
 185         /* tty_buffer_flush(to); FIXME */
 186         if (to->packet) {
 187                 spin_lock_irqsave(&tty->ctrl_lock, flags);
 188                 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
 189                 wake_up_interruptible(&to->read_wait);
 190                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 191         }
 192 }
 193
 194 static int pty_open(struct tty_struct *tty, struct file *filp)
 195 {
 196         int     retval = -ENODEV;
 197
 198         if (!tty || !tty->link)
 199                 goto out;
 200
 201         retval = -EIO;
 202         if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
 203                 goto out;
 204         if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
 205                 goto out;
 206         if (tty->link->count != 1)
 207                 goto out;
 208
 209         clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 210         set_bit(TTY_THROTTLED, &tty->flags);
 211         retval = 0;
 212 out:
 213         return retval;
 214 }
 215
 216 static void pty_set_termios(struct tty_struct *tty,
 217                                         struct ktermios *old_termios)
 218 {
 219         tty->termios->c_cflag &= ~(CSIZE | PARENB);
 220         tty->termios->c_cflag |= (CS8 | CREAD);
 221 }
 222
 223 /**
 224  *      pty_do_resize           -       resize event
 225  *      @tty: tty being resized
 226  *      @ws: window size being set.
 227  *
 228  *      Update the termios variables and send the neccessary signals to
 229  *      peform a terminal resize correctly
 230  */
 231
 232 int pty_resize(struct tty_struct *tty,  struct winsize *ws)
 233 {
 234         struct pid *pgrp, *rpgrp;
 235         unsigned long flags;
 236         struct tty_struct *pty = tty->link;
 237
 238         /* For a PTY we need to lock the tty side */
 239         mutex_lock(&tty->termios_mutex);
 240         if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 241                 goto done;
 242
 243         /* Get the PID values and reference them so we can
 244            avoid holding the tty ctrl lock while sending signals.
 245            We need to lock these individually however. */
 246
 247         spin_lock_irqsave(&tty->ctrl_lock, flags);
 248         pgrp = get_pid(tty->pgrp);
 249         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 250
 251         spin_lock_irqsave(&pty->ctrl_lock, flags);
 252         rpgrp = get_pid(pty->pgrp);
 253         spin_unlock_irqrestore(&pty->ctrl_lock, flags);
 254
 255         if (pgrp)
 256                 kill_pgrp(pgrp, SIGWINCH, 1);
 257         if (rpgrp != pgrp && rpgrp)
 258                 kill_pgrp(rpgrp, SIGWINCH, 1);
 259
 260         put_pid(pgrp);
 261         put_pid(rpgrp);
 262
 263         tty->winsize = *ws;
 264         pty->winsize = *ws;     /* Never used so will go away soon */
 265 done:
 266         mutex_unlock(&tty->termios_mutex);
 267         return 0;
 268 }
 269
 270 static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
 271 {
 272         struct tty_struct *o_tty;
 273         int idx = tty->index;
 274         int retval;
 275
 276         o_tty = alloc_tty_struct();
 277         if (!o_tty)
 278                 return -ENOMEM;
 279         if (!try_module_get(driver->other->owner)) {
 280                 /* This cannot in fact currently happen */
 281                 free_tty_struct(o_tty);
 282                 return -ENOMEM;
 283         }
 284         initialize_tty_struct(o_tty, driver->other, idx);
 285
 286         /* We always use new tty termios data so we can do this
 287            the easy way .. */
 288         retval = tty_init_termios(tty);
 289         if (retval)
 290                 goto free_mem_out;
 291
 292         retval = tty_init_termios(o_tty);
 293         if (retval) {
 294                 tty_free_termios(tty);
 295                 goto free_mem_out;
 296         }
 297
 298         /*
 299          * Everything allocated ... set up the o_tty structure.
 300          */
 301         driver->other->ttys[idx] = o_tty;
 302         tty_driver_kref_get(driver->other);
 303         if (driver->subtype == PTY_TYPE_MASTER)
 304                 o_tty->count++;
 305         /* Establish the links in both directions */
 306         tty->link   = o_tty;
 307         o_tty->link = tty;
 308
 309         tty_driver_kref_get(driver);
 310         tty->count++;
 311         driver->ttys[idx] = tty;
 312         return 0;
 313 free_mem_out:
 314         module_put(o_tty->driver->owner);
 315         free_tty_struct(o_tty);
 316         return -ENOMEM;
 317 }
 318
 319
 320 static const struct tty_operations pty_ops = {
 321         .install = pty_install,
 322         .open = pty_open,
 323         .close = pty_close,
 324         .write = pty_write,
 325         .write_room = pty_write_room,
 326         .flush_buffer = pty_flush_buffer,
 327         .chars_in_buffer = pty_chars_in_buffer,
 328         .unthrottle = pty_unthrottle,
 329         .set_termios = pty_set_termios,
 330         .resize = pty_resize
 331 };
 332
 333 /* Traditional BSD devices */
 334 #ifdef CONFIG_LEGACY_PTYS
 335 static struct tty_driver *pty_driver, *pty_slave_driver;
 336
 337 static int pty_bsd_ioctl(struct tty_struct *tty, struct file *file,
 338                          unsigned int cmd, unsigned long arg)
 339 {
 340         switch (cmd) {
 341         case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 342                 return pty_set_lock(tty, (int __user *) arg);
 343         }
 344         return -ENOIOCTLCMD;
 345 }
 346
 347 static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
 348 module_param(legacy_count, int, 0);
 349
 350 static const struct tty_operations pty_ops_bsd = {
 351         .open = pty_open,
 352         .close = pty_close,
 353         .write = pty_write,
 354         .write_room = pty_write_room,
 355         .flush_buffer = pty_flush_buffer,
 356         .chars_in_buffer = pty_chars_in_buffer,
 357         .unthrottle = pty_unthrottle,
 358         .set_termios = pty_set_termios,
 359         .ioctl = pty_bsd_ioctl,
 360         .resize = pty_resize
 361 };
 362
 363 static void __init legacy_pty_init(void)
 364 {
 365         if (legacy_count <= 0)
 366                 return;
 367
 368         pty_driver = alloc_tty_driver(legacy_count);
 369         if (!pty_driver)
 370                 panic("Couldn't allocate pty driver");
 371
 372         pty_slave_driver = alloc_tty_driver(legacy_count);
 373         if (!pty_slave_driver)
 374                 panic("Couldn't allocate pty slave driver");
 375
 376         pty_driver->owner = THIS_MODULE;
 377         pty_driver->driver_name = "pty_master";
 378         pty_driver->name = "pty";
 379         pty_driver->major = PTY_MASTER_MAJOR;
 380         pty_driver->minor_start = 0;
 381         pty_driver->type = TTY_DRIVER_TYPE_PTY;
 382         pty_driver->subtype = PTY_TYPE_MASTER;
 383         pty_driver->init_termios = tty_std_termios;
 384         pty_driver->init_termios.c_iflag = 0;
 385         pty_driver->init_termios.c_oflag = 0;
 386         pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 387         pty_driver->init_termios.c_lflag = 0;
 388         pty_driver->init_termios.c_ispeed = 38400;
 389         pty_driver->init_termios.c_ospeed = 38400;
 390         pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW;
 391         pty_driver->other = pty_slave_driver;
 392         tty_set_operations(pty_driver, &pty_ops);
 393
 394         pty_slave_driver->owner = THIS_MODULE;
 395         pty_slave_driver->driver_name = "pty_slave";
 396         pty_slave_driver->name = "ttyp";
 397         pty_slave_driver->major = PTY_SLAVE_MAJOR;
 398         pty_slave_driver->minor_start = 0;
 399         pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
 400         pty_slave_driver->subtype = PTY_TYPE_SLAVE;
 401         pty_slave_driver->init_termios = tty_std_termios;
 402         pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 403         pty_slave_driver->init_termios.c_ispeed = 38400;
 404         pty_slave_driver->init_termios.c_ospeed = 38400;
 405         pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS |
 406                                         TTY_DRIVER_REAL_RAW;
 407         pty_slave_driver->other = pty_driver;
 408         tty_set_operations(pty_slave_driver, &pty_ops);
 409
 410         if (tty_register_driver(pty_driver))
 411                 panic("Couldn't register pty driver");
 412         if (tty_register_driver(pty_slave_driver))
 413                 panic("Couldn't register pty slave driver");
 414 }
 415 #else
 416 static inline void legacy_pty_init(void) { }
 417 #endif
 418
 419 /* Unix98 devices */
 420 #ifdef CONFIG_UNIX98_PTYS
 421 /*
 422  * sysctl support for setting limits on the number of Unix98 ptys allocated.
 423  * Otherwise one can eat up all kernel memory by opening /dev/ptmx repeatedly.
 424  */
 425 int pty_limit = NR_UNIX98_PTY_DEFAULT;
 426 static int pty_limit_min;
 427 static int pty_limit_max = NR_UNIX98_PTY_MAX;
 428 static int pty_count;
 429
 430 static struct cdev ptmx_cdev;
 431
 432 static struct ctl_table pty_table[] = {
 433         {
 434                 .ctl_name       = PTY_MAX,
 435                 .procname       = "max",
 436                 .maxlen         = sizeof(int),
 437                 .mode           = 0644,
 438                 .data           = &pty_limit,
 439                 .proc_handler   = &proc_dointvec_minmax,
 440                 .strategy       = &sysctl_intvec,
 441                 .extra1         = &pty_limit_min,
 442                 .extra2         = &pty_limit_max,
 443         }, {
 444                 .ctl_name       = PTY_NR,
 445                 .procname       = "nr",
 446                 .maxlen         = sizeof(int),
 447                 .mode           = 0444,
 448                 .data           = &pty_count,
 449                 .proc_handler   = &proc_dointvec,
 450         }, {
 451                 .ctl_name       = 0
 452         }
 453 };
 454
 455 static struct ctl_table pty_kern_table[] = {
 456         {
 457                 .ctl_name       = KERN_PTY,
 458                 .procname       = "pty",
 459                 .mode           = 0555,
 460                 .child          = pty_table,
 461         },
 462         {}
 463 };
 464
 465 static struct ctl_table pty_root_table[] = {
 466         {
 467                 .ctl_name       = CTL_KERN,
 468                 .procname       = "kernel",
 469                 .mode           = 0555,
 470                 .child          = pty_kern_table,
 471         },
 472         {}
 473 };
 474
 475
 476 static int pty_unix98_ioctl(struct tty_struct *tty, struct file *file,
 477                             unsigned int cmd, unsigned long arg)
 478 {
 479         switch (cmd) {
 480         case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 481                 return pty_set_lock(tty, (int __user *)arg);
 482         case TIOCGPTN: /* Get PT Number */
 483                 return put_user(tty->index, (unsigned int __user *)arg);
 484         }
 485
 486         return -ENOIOCTLCMD;
 487 }
 488
 489 /**
 490  *      ptm_unix98_lookup       -       find a pty master
 491  *      @driver: ptm driver
 492  *      @idx: tty index
 493  *
 494  *      Look up a pty master device. Called under the tty_mutex for now.
 495  *      This provides our locking.
 496  */
 497
 498 static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
 499                 struct inode *ptm_inode, int idx)
 500 {
 501         struct tty_struct *tty = devpts_get_tty(ptm_inode, idx);
 502         if (tty)
 503                 tty = tty->link;
 504         return tty;
 505 }
 506
 507 /**
 508  *      pts_unix98_lookup       -       find a pty slave
 509  *      @driver: pts driver
 510  *      @idx: tty index
 511  *
 512  *      Look up a pty master device. Called under the tty_mutex for now.
 513  *      This provides our locking.
 514  */
 515
 516 static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
 517                 struct inode *pts_inode, int idx)
 518 {
 519         struct tty_struct *tty = devpts_get_tty(pts_inode, idx);
 520         /* Master must be open before slave */
 521         if (!tty)
 522                 return ERR_PTR(-EIO);
 523         return tty;
 524 }
 525
 526 static void pty_unix98_shutdown(struct tty_struct *tty)
 527 {
 528         /* We have our own method as we don't use the tty index */
 529         kfree(tty->termios);
 530 }
 531
 532 /* We have no need to install and remove our tty objects as devpts does all
 533    the work for us */
 534
 535 static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
 536 {
 537         struct tty_struct *o_tty;
 538         int idx = tty->index;
 539
 540         o_tty = alloc_tty_struct();
 541         if (!o_tty)
 542                 return -ENOMEM;
 543         if (!try_module_get(driver->other->owner)) {
 544                 /* This cannot in fact currently happen */
 545                 free_tty_struct(o_tty);
 546                 return -ENOMEM;
 547         }
 548         initialize_tty_struct(o_tty, driver->other, idx);
 549
 550         tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
 551         if (tty->termios == NULL)
 552                 goto free_mem_out;
 553         *tty->termios = driver->init_termios;
 554         tty->termios_locked = tty->termios + 1;
 555
 556         o_tty->termios = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);
 557         if (o_tty->termios == NULL)
 558                 goto free_mem_out;
 559         *o_tty->termios = driver->other->init_termios;
 560         o_tty->termios_locked = o_tty->termios + 1;
 561
 562         tty_driver_kref_get(driver->other);
 563         if (driver->subtype == PTY_TYPE_MASTER)
 564                 o_tty->count++;
 565         /* Establish the links in both directions */
 566         tty->link   = o_tty;
 567         o_tty->link = tty;
 568         /*
 569          * All structures have been allocated, so now we install them.
 570          * Failures after this point use release_tty to clean up, so
 571          * there's no need to null out the local pointers.
 572          */
 573         tty_driver_kref_get(driver);
 574         tty->count++;
 575         pty_count++;
 576         return 0;
 577 free_mem_out:
 578         kfree(o_tty->termios);
 579         module_put(o_tty->driver->owner);
 580         free_tty_struct(o_tty);
 581         kfree(tty->termios);
 582         return -ENOMEM;
 583 }
 584
 585 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 586 {
 587         pty_count--;
 588 }
 589
 590 static const struct tty_operations ptm_unix98_ops = {
 591         .lookup = ptm_unix98_lookup,
 592         .install = pty_unix98_install,
 593         .remove = pty_unix98_remove,
 594         .open = pty_open,
 595         .close = pty_close,
 596         .write = pty_write,
 597         .write_room = pty_write_room,
 598         .flush_buffer = pty_flush_buffer,
 599         .chars_in_buffer = pty_chars_in_buffer,
 600         .unthrottle = pty_unthrottle,
 601         .set_termios = pty_set_termios,
 602         .ioctl = pty_unix98_ioctl,
 603         .shutdown = pty_unix98_shutdown,
 604         .resize = pty_resize
 605 };
 606
 607 static const struct tty_operations pty_unix98_ops = {
 608         .lookup = pts_unix98_lookup,
 609         .install = pty_unix98_install,
 610         .remove = pty_unix98_remove,
 611         .open = pty_open,
 612         .close = pty_close,
 613         .write = pty_write,
 614         .write_room = pty_write_room,
 615         .flush_buffer = pty_flush_buffer,
 616         .chars_in_buffer = pty_chars_in_buffer,
 617         .unthrottle = pty_unthrottle,
 618         .set_termios = pty_set_termios,
 619         .shutdown = pty_unix98_shutdown
 620 };
 621
 622 /**
 623  *      ptmx_open               -       open a unix 98 pty master
 624  *      @inode: inode of device file
 625  *      @filp: file pointer to tty
 626  *
 627  *      Allocate a unix98 pty master device from the ptmx driver.
 628  *
 629  *      Locking: tty_mutex protects the init_dev work. tty->count should
 630  *              protect the rest.
 631  *              allocated_ptys_lock handles the list of free pty numbers
 632  */
 633
 634 static int __ptmx_open(struct inode *inode, struct file *filp)
 635 {
 636         struct tty_struct *tty;
 637         int retval;
 638         int index;
 639
 640         nonseekable_open(inode, filp);
 641
 642         /* find a device that is not in use. */
 643         index = devpts_new_index(inode);
 644         if (index < 0)
 645                 return index;
 646
 647         mutex_lock(&tty_mutex);
 648         tty = tty_init_dev(ptm_driver, index, 1);
 649         mutex_unlock(&tty_mutex);
 650
 651         if (IS_ERR(tty)) {
 652                 retval = PTR_ERR(tty);
 653                 goto out;
 654         }
 655
 656         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
 657         filp->private_data = tty;
 658         file_move(filp, &tty->tty_files);
 659
 660         retval = devpts_pty_new(inode, tty->link);
 661         if (retval)
 662                 goto out1;
 663
 664         retval = ptm_driver->ops->open(tty, filp);
 665         if (!retval)
 666                 return 0;
 667 out1:
 668         tty_release_dev(filp);
 669         return retval;
 670 out:
 671         devpts_kill_index(inode, index);
 672         return retval;
 673 }
 674
 675 static int ptmx_open(struct inode *inode, struct file *filp)
 676 {
 677         int ret;
 678
 679         lock_kernel();
 680         ret = __ptmx_open(inode, filp);
 681         unlock_kernel();
 682         return ret;
 683 }
 684
 685 static struct file_operations ptmx_fops;
 686
 687 static void __init unix98_pty_init(void)
 688 {
 689         ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
 690         if (!ptm_driver)
 691                 panic("Couldn't allocate Unix98 ptm driver");
 692         pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX);
 693         if (!pts_driver)
 694                 panic("Couldn't allocate Unix98 pts driver");
 695
 696         ptm_driver->owner = THIS_MODULE;
 697         ptm_driver->driver_name = "pty_master";
 698         ptm_driver->name = "ptm";
 699         ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
 700         ptm_driver->minor_start = 0;
 701         ptm_driver->type = TTY_DRIVER_TYPE_PTY;
 702         ptm_driver->subtype = PTY_TYPE_MASTER;
 703         ptm_driver->init_termios = tty_std_termios;
 704         ptm_driver->init_termios.c_iflag = 0;
 705         ptm_driver->init_termios.c_oflag = 0;
 706         ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 707         ptm_driver->init_termios.c_lflag = 0;
 708         ptm_driver->init_termios.c_ispeed = 38400;
 709         ptm_driver->init_termios.c_ospeed = 38400;
 710         ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
 711                 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
 712         ptm_driver->other = pts_driver;
 713         tty_set_operations(ptm_driver, &ptm_unix98_ops);
 714
 715         pts_driver->owner = THIS_MODULE;
 716         pts_driver->driver_name = "pty_slave";
 717         pts_driver->name = "pts";
 718         pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
 719         pts_driver->minor_start = 0;
 720         pts_driver->type = TTY_DRIVER_TYPE_PTY;
 721         pts_driver->subtype = PTY_TYPE_SLAVE;
 722         pts_driver->init_termios = tty_std_termios;
 723         pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 724         pts_driver->init_termios.c_ispeed = 38400;
 725         pts_driver->init_termios.c_ospeed = 38400;
 726         pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW |
 727                 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_DEVPTS_MEM;
 728         pts_driver->other = ptm_driver;
 729         tty_set_operations(pts_driver, &pty_unix98_ops);
 730
 731         if (tty_register_driver(ptm_driver))
 732                 panic("Couldn't register Unix98 ptm driver");
 733         if (tty_register_driver(pts_driver))
 734                 panic("Couldn't register Unix98 pts driver");
 735
 736         register_sysctl_table(pty_root_table);
 737
 738         /* Now create the /dev/ptmx special device */
 739         tty_default_fops(&ptmx_fops);
 740         ptmx_fops.open = ptmx_open;
 741
 742         cdev_init(&ptmx_cdev, &ptmx_fops);
 743         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
 744             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
 745                 panic("Couldn't register /dev/ptmx driver\n");
 746         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 747 }
 748
 749 #else
 750 static inline void unix98_pty_init(void) { }
 751 #endif
 752
 753 static int __init pty_init(void)
 754 {
 755         legacy_pty_init();
 756         unix98_pty_init();
 757         return 0;
 758 }
 759 module_init(pty_init);