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