SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/sched.h>
  22 #include <linux/string.h>
  23 #include <linux/major.h>
  24 #include <linux/mm.h>
  25 #include <linux/init.h>
  26 #include <linux/smp_lock.h>
  27 #include <linux/sysctl.h>
  28 #include <linux/device.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/bitops.h>
  31 #include <linux/devpts_fs.h>
  32
  33 #include <asm/system.h>
  34
  35 #ifdef CONFIG_UNIX98_PTYS
  36 static struct tty_driver *ptm_driver;
  37 static struct tty_driver *pts_driver;
  38 #endif
  39
  40 static void pty_close(struct tty_struct *tty, struct file *filp)
  41 {
  42         BUG_ON(!tty);
  43         if (tty->driver->subtype == PTY_TYPE_MASTER)
  44                 WARN_ON(tty->count > 1);
  45         else {
  46                 if (tty->count > 2)
  47                         return;
  48         }
  49         wake_up_interruptible(&tty->read_wait);
  50         wake_up_interruptible(&tty->write_wait);
  51         tty->packet = 0;
  52         if (!tty->link)
  53                 return;
  54         tty->link->packet = 0;
  55         set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
  56         wake_up_interruptible(&tty->link->read_wait);
  57         wake_up_interruptible(&tty->link->write_wait);
  58         if (tty->driver->subtype == PTY_TYPE_MASTER) {
  59                 set_bit(TTY_OTHER_CLOSED, &tty->flags);
  60 #ifdef CONFIG_UNIX98_PTYS
  61                 if (tty->driver == ptm_driver)
  62                         devpts_pty_kill(tty->link);
  63 #endif
  64                 tty_vhangup(tty->link);
  65         }
  66 }
  67
  68 /*
  69  * The unthrottle routine is called by the line discipline to signal
  70  * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  71  * flag is always set, to force the line discipline to always call the
  72  * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  73  * characters in the queue.  This is necessary since each time this
  74  * happens, we need to wake up any sleeping processes that could be
  75  * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  76  * for the pty buffer to be drained.
  77  */
  78 static void pty_unthrottle(struct tty_struct *tty)
  79 {
  80         tty_wakeup(tty->link);
  81         set_bit(TTY_THROTTLED, &tty->flags);
  82 }
  83
  84 /**
  85  *      pty_space       -       report space left for writing
  86  *      @to: tty we are writing into
  87  *
  88  *      The tty buffers allow 64K but we sneak a peak and clip at 8K this
  89  *      allows a lot of overspill room for echo and other fun messes to
  90  *      be handled properly
  91  */
  92
  93 static int pty_space(struct tty_struct *to)
  94 {
  95         int n = 8192 - to->buf.memory_used;
  96         if (n < 0)
  97                 return 0;
  98         return n;
  99 }
 100
 101 /**
 102  *      pty_write               -       write to a pty
 103  *      @tty: the tty we write from
 104  *      @buf: kernel buffer of data
 105  *      @count: bytes to write
 106  *
 107  *      Our "hardware" write method. Data is coming from the ldisc which
 108  *      may be in a non sleeping state. We simply throw this at the other
 109  *      end of the link as if we were an IRQ handler receiving stuff for
 110  *      the other side of the pty/tty pair.
 111  */
 112
 113 static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
 114 {
 115         struct tty_struct *to = tty->link;
 116
 117         if (tty->stopped)
 118                 return 0;
 119
 120         if (c > 0) {
 121                 /* Stuff the data into the input queue of the other end */
 122                 c = tty_insert_flip_string(to, buf, c);
 123                 /* And shovel */
 124                 if (c) {
 125                         tty_flip_buffer_push(to);
 126                         tty_wakeup(tty);
 127                 }
 128         }
 129         return c;
 130 }
 131
 132 /**
 133  *      pty_write_room  -       write space
 134  *      @tty: tty we are writing from
 135  *
 136  *      Report how many bytes the ldisc can send into the queue for
 137  *      the other device.
 138  */
 139
 140 static int pty_write_room(struct tty_struct *tty)
 141 {
 142         if (tty->stopped)
 143                 return 0;
 144         return pty_space(tty->link);
 145 }
 146
 147 /**
 148  *      pty_chars_in_buffer     -       characters currently in our tx queue
 149  *      @tty: our tty
 150  *
 151  *      Report how much we have in the transmit queue. As everything is
 152  *      instantly at the other end this is easy to implement.
 153  */
 154
 155 static int pty_chars_in_buffer(struct tty_struct *tty)
 156 {
 157         return 0;
 158 }
 159
 160 /* Set the lock flag on a pty */
 161 static int pty_set_lock(struct tty_struct *tty, int __user *arg)
 162 {
 163         int val;
 164         if (get_user(val, arg))
 165                 return -EFAULT;
 166         if (val)
 167                 set_bit(TTY_PTY_LOCK, &tty->flags);
 168         else
 169                 clear_bit(TTY_PTY_LOCK, &tty->flags);
 170         return 0;
 171 }
 172
 173 static void pty_flush_buffer(struct tty_struct *tty)
 174 {
 175         struct tty_struct *to = tty->link;
 176         unsigned long flags;
 177
 178         if (!to)
 179                 return;
 180         /* tty_buffer_flush(to); FIXME */
 181         if (to->packet) {
 182                 spin_lock_irqsave(&tty->ctrl_lock, flags);
 183                 tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
 184                 wake_up_interruptible(&to->read_wait);
 185                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 186         }
 187 }
 188
 189 static int pty_open(struct tty_struct *tty, struct file *filp)
 190 {
 191         int     retval = -ENODEV;
 192
 193         if (!tty || !tty->link)
 194                 goto out;
 195
 196         retval = -EIO;
 197         if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
 198                 goto out;
 199         if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
 200                 goto out;
 201         if (tty->link->count != 1)
 202                 goto out;
 203
 204         clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 205         set_bit(TTY_THROTTLED, &tty->flags);
 206         retval = 0;
 207 out:
 208         return retval;
 209 }
 210
 211 static void pty_set_termios(struct tty_struct *tty,
 212                                         struct ktermios *old_termios)
 213 {
 214         tty->termios->c_cflag &= ~(CSIZE | PARENB);
 215         tty->termios->c_cflag |= (CS8 | CREAD);
 216 }
 217
 218 /**
 219  *      pty_do_resize           -       resize event
 220  *      @tty: tty being resized
 221  *      @ws: window size being set.
 222  *
 223  *      Update the termios variables and send the neccessary signals to
 224  *      peform a terminal resize correctly
 225  */
 226
 227 int pty_resize(struct tty_struct *tty,  struct winsize *ws)
 228 {
 229         struct pid *pgrp, *rpgrp;
 230         unsigned long flags;
 231         struct tty_struct *pty = tty->link;
 232
 233         /* For a PTY we need to lock the tty side */
 234         mutex_lock(&tty->termios_mutex);
 235         if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 236                 goto done;
 237
 238         /* Get the PID values and reference them so we can
 239            avoid holding the tty ctrl lock while sending signals.
 240            We need to lock these individually however. */
 241
 242         spin_lock_irqsave(&tty->ctrl_lock, flags);
 243         pgrp = get_pid(tty->pgrp);
 244         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 245
 246         spin_lock_irqsave(&pty->ctrl_lock, flags);
 247         rpgrp = get_pid(pty->pgrp);
 248         spin_unlock_irqrestore(&pty->ctrl_lock, flags);
 249
 250         if (pgrp)
 251                 kill_pgrp(pgrp, SIGWINCH, 1);
 252         if (rpgrp != pgrp && rpgrp)
 253                 kill_pgrp(rpgrp, SIGWINCH, 1);
 254
 255         put_pid(pgrp);
 256         put_pid(rpgrp);
 257
 258         tty->winsize = *ws;
 259         pty->winsize = *ws;     /* Never used so will go away soon */
 260 done:
 261         mutex_unlock(&tty->termios_mutex);
 262         return 0;
 263 }
 264
 265 /* Traditional BSD devices */
 266 #ifdef CONFIG_LEGACY_PTYS
 267
 268 static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
 269 {
 270         struct tty_struct *o_tty;
 271         int idx = tty->index;
 272         int retval;
 273
 274         o_tty = alloc_tty_struct();
 275         if (!o_tty)
 276                 return -ENOMEM;
 277         if (!try_module_get(driver->other->owner)) {
 278                 /* This cannot in fact currently happen */
 279                 free_tty_struct(o_tty);
 280                 return -ENOMEM;
 281         }
 282         initialize_tty_struct(o_tty, driver->other, idx);
 283
 284         /* We always use new tty termios data so we can do this
 285            the easy way .. */
 286         retval = tty_init_termios(tty);
 287         if (retval)
 288                 goto free_mem_out;
 289
 290         retval = tty_init_termios(o_tty);
 291         if (retval) {
 292                 tty_free_termios(tty);
 293                 goto free_mem_out;
 294         }
 295
 296         /*
 297          * Everything allocated ... set up the o_tty structure.
 298          */
 299         driver->other->ttys[idx] = o_tty;
 300         tty_driver_kref_get(driver->other);
 301         if (driver->subtype == PTY_TYPE_MASTER)
 302                 o_tty->count++;
 303         /* Establish the links in both directions */
 304         tty->link   = o_tty;
 305         o_tty->link = tty;
 306
 307         tty_driver_kref_get(driver);
 308         tty->count++;
 309         driver->ttys[idx] = tty;
 310         return 0;
 311 free_mem_out:
 312         module_put(o_tty->driver->owner);
 313         free_tty_struct(o_tty);
 314         return -ENOMEM;
 315 }
 316
 317 static int pty_bsd_ioctl(struct tty_struct *tty, struct file *file,
 318                          unsigned int cmd, unsigned long arg)
 319 {
 320         switch (cmd) {
 321         case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 322                 return pty_set_lock(tty, (int __user *) arg);
 323         }
 324         return -ENOIOCTLCMD;
 325 }
 326
 327 static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
 328 module_param(legacy_count, int, 0);
 329
 330 /*
 331  * The master side of a pty can do TIOCSPTLCK and thus
 332  * has pty_bsd_ioctl.
 333  */
 334 static const struct tty_operations master_pty_ops_bsd = {
 335         .install = pty_install,
 336         .open = pty_open,
 337         .close = pty_close,
 338         .write = pty_write,
 339         .write_room = pty_write_room,
 340         .flush_buffer = pty_flush_buffer,
 341         .chars_in_buffer = pty_chars_in_buffer,
 342         .unthrottle = pty_unthrottle,
 343         .set_termios = pty_set_termios,
 344         .ioctl = pty_bsd_ioctl,
 345         .resize = pty_resize
 346 };
 347
 348 static const struct tty_operations slave_pty_ops_bsd = {
 349         .install = pty_install,
 350         .open = pty_open,
 351         .close = pty_close,
 352         .write = pty_write,
 353         .write_room = pty_write_room,
 354         .flush_buffer = pty_flush_buffer,
 355         .chars_in_buffer = pty_chars_in_buffer,
 356         .unthrottle = pty_unthrottle,
 357         .set_termios = pty_set_termios,
 358         .resize = pty_resize
 359 };
 360
 361 static void __init legacy_pty_init(void)
 362 {
 363         struct tty_driver *pty_driver, *pty_slave_driver;
 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, &master_pty_ops_bsd);
 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, &slave_pty_ops_bsd);
 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);