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