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