1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/types.h> 3 #include <linux/errno.h> 4 #include <linux/kmod.h> 5 #include <linux/sched.h> 6 #include <linux/interrupt.h> 7 #include <linux/tty.h> 8 #include <linux/tty_driver.h> 9 #include <linux/file.h> 10 #include <linux/mm.h> 11 #include <linux/string.h> 12 #include <linux/slab.h> 13 #include <linux/poll.h> 14 #include <linux/proc_fs.h> 15 #include <linux/module.h> 16 #include <linux/device.h> 17 #include <linux/wait.h> 18 #include <linux/bitops.h> 19 #include <linux/seq_file.h> 20 #include <linux/uaccess.h> 21 #include <linux/ratelimit.h> 22 23 #undef LDISC_DEBUG_HANGUP 24 25 #ifdef LDISC_DEBUG_HANGUP 26 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args) 27 #else 28 #define tty_ldisc_debug(tty, f, args...) 29 #endif 30 31 /* lockdep nested classes for tty->ldisc_sem */ 32 enum { 33 LDISC_SEM_NORMAL, 34 LDISC_SEM_OTHER, 35 }; 36 37 38 /* 39 * This guards the refcounted line discipline lists. The lock 40 * must be taken with irqs off because there are hangup path 41 * callers who will do ldisc lookups and cannot sleep. 42 */ 43 44 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock); 45 /* Line disc dispatch table */ 46 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS]; 47 48 /** 49 * tty_register_ldisc - install a line discipline 50 * @disc: ldisc number 51 * @new_ldisc: pointer to the ldisc object 52 * 53 * Installs a new line discipline into the kernel. The discipline 54 * is set up as unreferenced and then made available to the kernel 55 * from this point onwards. 56 * 57 * Locking: 58 * takes tty_ldiscs_lock to guard against ldisc races 59 */ 60 61 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc) 62 { 63 unsigned long flags; 64 int ret = 0; 65 66 if (disc < N_TTY || disc >= NR_LDISCS) 67 return -EINVAL; 68 69 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags); 70 tty_ldiscs[disc] = new_ldisc; 71 new_ldisc->num = disc; 72 new_ldisc->refcount = 0; 73 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags); 74 75 return ret; 76 } 77 EXPORT_SYMBOL(tty_register_ldisc); 78 79 /** 80 * tty_unregister_ldisc - unload a line discipline 81 * @disc: ldisc number 82 * 83 * Remove a line discipline from the kernel providing it is not 84 * currently in use. 85 * 86 * Locking: 87 * takes tty_ldiscs_lock to guard against ldisc races 88 */ 89 90 int tty_unregister_ldisc(int disc) 91 { 92 unsigned long flags; 93 int ret = 0; 94 95 if (disc < N_TTY || disc >= NR_LDISCS) 96 return -EINVAL; 97 98 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags); 99 if (tty_ldiscs[disc]->refcount) 100 ret = -EBUSY; 101 else 102 tty_ldiscs[disc] = NULL; 103 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags); 104 105 return ret; 106 } 107 EXPORT_SYMBOL(tty_unregister_ldisc); 108 109 static struct tty_ldisc_ops *get_ldops(int disc) 110 { 111 unsigned long flags; 112 struct tty_ldisc_ops *ldops, *ret; 113 114 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags); 115 ret = ERR_PTR(-EINVAL); 116 ldops = tty_ldiscs[disc]; 117 if (ldops) { 118 ret = ERR_PTR(-EAGAIN); 119 if (try_module_get(ldops->owner)) { 120 ldops->refcount++; 121 ret = ldops; 122 } 123 } 124 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags); 125 return ret; 126 } 127 128 static void put_ldops(struct tty_ldisc_ops *ldops) 129 { 130 unsigned long flags; 131 132 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags); 133 ldops->refcount--; 134 module_put(ldops->owner); 135 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags); 136 } 137 138 static int tty_ldisc_autoload = IS_BUILTIN(CONFIG_LDISC_AUTOLOAD); 139 /** 140 * tty_ldisc_get - take a reference to an ldisc 141 * @tty: tty device 142 * @disc: ldisc number 143 * 144 * Takes a reference to a line discipline. Deals with refcounts and 145 * module locking counts. 146 * 147 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or 148 * if the discipline is not registered 149 * -EAGAIN if request_module() failed to load or register the 150 * discipline 151 * -ENOMEM if allocation failure 152 * 153 * Otherwise, returns a pointer to the discipline and bumps the 154 * ref count 155 * 156 * Locking: 157 * takes tty_ldiscs_lock to guard against ldisc races 158 */ 159 160 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc) 161 { 162 struct tty_ldisc *ld; 163 struct tty_ldisc_ops *ldops; 164 165 if (disc < N_TTY || disc >= NR_LDISCS) 166 return ERR_PTR(-EINVAL); 167 168 /* 169 * Get the ldisc ops - we may need to request them to be loaded 170 * dynamically and try again. 171 */ 172 ldops = get_ldops(disc); 173 if (IS_ERR(ldops)) { 174 if (!capable(CAP_SYS_MODULE) && !tty_ldisc_autoload) 175 return ERR_PTR(-EPERM); 176 request_module("tty-ldisc-%d", disc); 177 ldops = get_ldops(disc); 178 if (IS_ERR(ldops)) 179 return ERR_CAST(ldops); 180 } 181 182 /* 183 * There is no way to handle allocation failure of only 16 bytes. 184 * Let's simplify error handling and save more memory. 185 */ 186 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL); 187 ld->ops = ldops; 188 ld->tty = tty; 189 190 return ld; 191 } 192 193 /* 194 * tty_ldisc_put - release the ldisc 195 * 196 * Complement of tty_ldisc_get(). 197 */ 198 static void tty_ldisc_put(struct tty_ldisc *ld) 199 { 200 if (WARN_ON_ONCE(!ld)) 201 return; 202 203 put_ldops(ld->ops); 204 kfree(ld); 205 } 206 207 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos) 208 { 209 return (*pos < NR_LDISCS) ? pos : NULL; 210 } 211 212 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos) 213 { 214 (*pos)++; 215 return (*pos < NR_LDISCS) ? pos : NULL; 216 } 217 218 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v) 219 { 220 } 221 222 static int tty_ldiscs_seq_show(struct seq_file *m, void *v) 223 { 224 int i = *(loff_t *)v; 225 struct tty_ldisc_ops *ldops; 226 227 ldops = get_ldops(i); 228 if (IS_ERR(ldops)) 229 return 0; 230 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i); 231 put_ldops(ldops); 232 return 0; 233 } 234 235 const struct seq_operations tty_ldiscs_seq_ops = { 236 .start = tty_ldiscs_seq_start, 237 .next = tty_ldiscs_seq_next, 238 .stop = tty_ldiscs_seq_stop, 239 .show = tty_ldiscs_seq_show, 240 }; 241 242 /** 243 * tty_ldisc_ref_wait - wait for the tty ldisc 244 * @tty: tty device 245 * 246 * Dereference the line discipline for the terminal and take a 247 * reference to it. If the line discipline is in flux then 248 * wait patiently until it changes. 249 * 250 * Returns: NULL if the tty has been hungup and not re-opened with 251 * a new file descriptor, otherwise valid ldisc reference 252 * 253 * Note 1: Must not be called from an IRQ/timer context. The caller 254 * must also be careful not to hold other locks that will deadlock 255 * against a discipline change, such as an existing ldisc reference 256 * (which we check for) 257 * 258 * Note 2: a file_operations routine (read/poll/write) should use this 259 * function to wait for any ldisc lifetime events to finish. 260 */ 261 262 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty) 263 { 264 struct tty_ldisc *ld; 265 266 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT); 267 ld = tty->ldisc; 268 if (!ld) 269 ldsem_up_read(&tty->ldisc_sem); 270 return ld; 271 } 272 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait); 273 274 /** 275 * tty_ldisc_ref - get the tty ldisc 276 * @tty: tty device 277 * 278 * Dereference the line discipline for the terminal and take a 279 * reference to it. If the line discipline is in flux then 280 * return NULL. Can be called from IRQ and timer functions. 281 */ 282 283 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty) 284 { 285 struct tty_ldisc *ld = NULL; 286 287 if (ldsem_down_read_trylock(&tty->ldisc_sem)) { 288 ld = tty->ldisc; 289 if (!ld) 290 ldsem_up_read(&tty->ldisc_sem); 291 } 292 return ld; 293 } 294 EXPORT_SYMBOL_GPL(tty_ldisc_ref); 295 296 /** 297 * tty_ldisc_deref - free a tty ldisc reference 298 * @ld: reference to free up 299 * 300 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May 301 * be called in IRQ context. 302 */ 303 304 void tty_ldisc_deref(struct tty_ldisc *ld) 305 { 306 ldsem_up_read(&ld->tty->ldisc_sem); 307 } 308 EXPORT_SYMBOL_GPL(tty_ldisc_deref); 309 310 311 static inline int 312 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout) 313 { 314 return ldsem_down_write(&tty->ldisc_sem, timeout); 315 } 316 317 static inline int 318 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout) 319 { 320 return ldsem_down_write_nested(&tty->ldisc_sem, 321 LDISC_SEM_OTHER, timeout); 322 } 323 324 static inline void __tty_ldisc_unlock(struct tty_struct *tty) 325 { 326 ldsem_up_write(&tty->ldisc_sem); 327 } 328 329 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout) 330 { 331 int ret; 332 333 /* Kindly asking blocked readers to release the read side */ 334 set_bit(TTY_LDISC_CHANGING, &tty->flags); 335 wake_up_interruptible_all(&tty->read_wait); 336 wake_up_interruptible_all(&tty->write_wait); 337 338 ret = __tty_ldisc_lock(tty, timeout); 339 if (!ret) 340 return -EBUSY; 341 set_bit(TTY_LDISC_HALTED, &tty->flags); 342 return 0; 343 } 344 345 void tty_ldisc_unlock(struct tty_struct *tty) 346 { 347 clear_bit(TTY_LDISC_HALTED, &tty->flags); 348 /* Can be cleared here - ldisc_unlock will wake up writers firstly */ 349 clear_bit(TTY_LDISC_CHANGING, &tty->flags); 350 __tty_ldisc_unlock(tty); 351 } 352 353 static int 354 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2, 355 unsigned long timeout) 356 { 357 int ret; 358 359 if (tty < tty2) { 360 ret = __tty_ldisc_lock(tty, timeout); 361 if (ret) { 362 ret = __tty_ldisc_lock_nested(tty2, timeout); 363 if (!ret) 364 __tty_ldisc_unlock(tty); 365 } 366 } else { 367 /* if this is possible, it has lots of implications */ 368 WARN_ON_ONCE(tty == tty2); 369 if (tty2 && tty != tty2) { 370 ret = __tty_ldisc_lock(tty2, timeout); 371 if (ret) { 372 ret = __tty_ldisc_lock_nested(tty, timeout); 373 if (!ret) 374 __tty_ldisc_unlock(tty2); 375 } 376 } else 377 ret = __tty_ldisc_lock(tty, timeout); 378 } 379 380 if (!ret) 381 return -EBUSY; 382 383 set_bit(TTY_LDISC_HALTED, &tty->flags); 384 if (tty2) 385 set_bit(TTY_LDISC_HALTED, &tty2->flags); 386 return 0; 387 } 388 389 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2) 390 { 391 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT); 392 } 393 394 static void tty_ldisc_unlock_pair(struct tty_struct *tty, 395 struct tty_struct *tty2) 396 { 397 __tty_ldisc_unlock(tty); 398 if (tty2) 399 __tty_ldisc_unlock(tty2); 400 } 401 402 /** 403 * tty_ldisc_flush - flush line discipline queue 404 * @tty: tty 405 * 406 * Flush the line discipline queue (if any) and the tty flip buffers 407 * for this tty. 408 */ 409 410 void tty_ldisc_flush(struct tty_struct *tty) 411 { 412 struct tty_ldisc *ld = tty_ldisc_ref(tty); 413 414 tty_buffer_flush(tty, ld); 415 if (ld) 416 tty_ldisc_deref(ld); 417 } 418 EXPORT_SYMBOL_GPL(tty_ldisc_flush); 419 420 /** 421 * tty_set_termios_ldisc - set ldisc field 422 * @tty: tty structure 423 * @disc: line discipline number 424 * 425 * This is probably overkill for real world processors but 426 * they are not on hot paths so a little discipline won't do 427 * any harm. 428 * 429 * The line discipline-related tty_struct fields are reset to 430 * prevent the ldisc driver from re-using stale information for 431 * the new ldisc instance. 432 * 433 * Locking: takes termios_rwsem 434 */ 435 436 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc) 437 { 438 down_write(&tty->termios_rwsem); 439 tty->termios.c_line = disc; 440 up_write(&tty->termios_rwsem); 441 442 tty->disc_data = NULL; 443 tty->receive_room = 0; 444 } 445 446 /** 447 * tty_ldisc_open - open a line discipline 448 * @tty: tty we are opening the ldisc on 449 * @ld: discipline to open 450 * 451 * A helper opening method. Also a convenient debugging and check 452 * point. 453 * 454 * Locking: always called with BTM already held. 455 */ 456 457 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld) 458 { 459 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags)); 460 if (ld->ops->open) { 461 int ret; 462 /* BTM here locks versus a hangup event */ 463 ret = ld->ops->open(tty); 464 if (ret) 465 clear_bit(TTY_LDISC_OPEN, &tty->flags); 466 467 tty_ldisc_debug(tty, "%p: opened\n", ld); 468 return ret; 469 } 470 return 0; 471 } 472 473 /** 474 * tty_ldisc_close - close a line discipline 475 * @tty: tty we are opening the ldisc on 476 * @ld: discipline to close 477 * 478 * A helper close method. Also a convenient debugging and check 479 * point. 480 */ 481 482 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld) 483 { 484 lockdep_assert_held_write(&tty->ldisc_sem); 485 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags)); 486 clear_bit(TTY_LDISC_OPEN, &tty->flags); 487 if (ld->ops->close) 488 ld->ops->close(tty); 489 tty_ldisc_debug(tty, "%p: closed\n", ld); 490 } 491 492 /** 493 * tty_ldisc_failto - helper for ldisc failback 494 * @tty: tty to open the ldisc on 495 * @ld: ldisc we are trying to fail back to 496 * 497 * Helper to try and recover a tty when switching back to the old 498 * ldisc fails and we need something attached. 499 */ 500 501 static int tty_ldisc_failto(struct tty_struct *tty, int ld) 502 { 503 struct tty_ldisc *disc = tty_ldisc_get(tty, ld); 504 int r; 505 506 lockdep_assert_held_write(&tty->ldisc_sem); 507 if (IS_ERR(disc)) 508 return PTR_ERR(disc); 509 tty->ldisc = disc; 510 tty_set_termios_ldisc(tty, ld); 511 r = tty_ldisc_open(tty, disc); 512 if (r < 0) 513 tty_ldisc_put(disc); 514 return r; 515 } 516 517 /** 518 * tty_ldisc_restore - helper for tty ldisc change 519 * @tty: tty to recover 520 * @old: previous ldisc 521 * 522 * Restore the previous line discipline or N_TTY when a line discipline 523 * change fails due to an open error 524 */ 525 526 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old) 527 { 528 /* There is an outstanding reference here so this is safe */ 529 if (tty_ldisc_failto(tty, old->ops->num) < 0) { 530 const char *name = tty_name(tty); 531 532 pr_warn("Falling back ldisc for %s.\n", name); 533 /* 534 * The traditional behaviour is to fall back to N_TTY, we 535 * want to avoid falling back to N_NULL unless we have no 536 * choice to avoid the risk of breaking anything 537 */ 538 if (tty_ldisc_failto(tty, N_TTY) < 0 && 539 tty_ldisc_failto(tty, N_NULL) < 0) 540 panic("Couldn't open N_NULL ldisc for %s.", name); 541 } 542 } 543 544 /** 545 * tty_set_ldisc - set line discipline 546 * @tty: the terminal to set 547 * @disc: the line discipline number 548 * 549 * Set the discipline of a tty line. Must be called from a process 550 * context. The ldisc change logic has to protect itself against any 551 * overlapping ldisc change (including on the other end of pty pairs), 552 * the close of one side of a tty/pty pair, and eventually hangup. 553 */ 554 555 int tty_set_ldisc(struct tty_struct *tty, int disc) 556 { 557 int retval; 558 struct tty_ldisc *old_ldisc, *new_ldisc; 559 560 new_ldisc = tty_ldisc_get(tty, disc); 561 if (IS_ERR(new_ldisc)) 562 return PTR_ERR(new_ldisc); 563 564 tty_lock(tty); 565 retval = tty_ldisc_lock(tty, 5 * HZ); 566 if (retval) 567 goto err; 568 569 if (!tty->ldisc) { 570 retval = -EIO; 571 goto out; 572 } 573 574 /* Check the no-op case */ 575 if (tty->ldisc->ops->num == disc) 576 goto out; 577 578 if (test_bit(TTY_HUPPED, &tty->flags)) { 579 /* We were raced by hangup */ 580 retval = -EIO; 581 goto out; 582 } 583 584 old_ldisc = tty->ldisc; 585 586 /* Shutdown the old discipline. */ 587 tty_ldisc_close(tty, old_ldisc); 588 589 /* Now set up the new line discipline. */ 590 tty->ldisc = new_ldisc; 591 tty_set_termios_ldisc(tty, disc); 592 593 retval = tty_ldisc_open(tty, new_ldisc); 594 if (retval < 0) { 595 /* Back to the old one or N_TTY if we can't */ 596 tty_ldisc_put(new_ldisc); 597 tty_ldisc_restore(tty, old_ldisc); 598 } 599 600 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) { 601 down_read(&tty->termios_rwsem); 602 tty->ops->set_ldisc(tty); 603 up_read(&tty->termios_rwsem); 604 } 605 606 /* 607 * At this point we hold a reference to the new ldisc and a 608 * reference to the old ldisc, or we hold two references to 609 * the old ldisc (if it was restored as part of error cleanup 610 * above). In either case, releasing a single reference from 611 * the old ldisc is correct. 612 */ 613 new_ldisc = old_ldisc; 614 out: 615 tty_ldisc_unlock(tty); 616 617 /* 618 * Restart the work queue in case no characters kick it off. Safe if 619 * already running 620 */ 621 tty_buffer_restart_work(tty->port); 622 err: 623 tty_ldisc_put(new_ldisc); /* drop the extra reference */ 624 tty_unlock(tty); 625 return retval; 626 } 627 EXPORT_SYMBOL_GPL(tty_set_ldisc); 628 629 /** 630 * tty_ldisc_kill - teardown ldisc 631 * @tty: tty being released 632 * 633 * Perform final close of the ldisc and reset tty->ldisc 634 */ 635 static void tty_ldisc_kill(struct tty_struct *tty) 636 { 637 lockdep_assert_held_write(&tty->ldisc_sem); 638 if (!tty->ldisc) 639 return; 640 /* 641 * Now kill off the ldisc 642 */ 643 tty_ldisc_close(tty, tty->ldisc); 644 tty_ldisc_put(tty->ldisc); 645 /* Force an oops if we mess this up */ 646 tty->ldisc = NULL; 647 } 648 649 /** 650 * tty_reset_termios - reset terminal state 651 * @tty: tty to reset 652 * 653 * Restore a terminal to the driver default state. 654 */ 655 656 static void tty_reset_termios(struct tty_struct *tty) 657 { 658 down_write(&tty->termios_rwsem); 659 tty->termios = tty->driver->init_termios; 660 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios); 661 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios); 662 up_write(&tty->termios_rwsem); 663 } 664 665 666 /** 667 * tty_ldisc_reinit - reinitialise the tty ldisc 668 * @tty: tty to reinit 669 * @disc: line discipline to reinitialize 670 * 671 * Completely reinitialize the line discipline state, by closing the 672 * current instance, if there is one, and opening a new instance. If 673 * an error occurs opening the new non-N_TTY instance, the instance 674 * is dropped and tty->ldisc reset to NULL. The caller can then retry 675 * with N_TTY instead. 676 * 677 * Returns 0 if successful, otherwise error code < 0 678 */ 679 680 int tty_ldisc_reinit(struct tty_struct *tty, int disc) 681 { 682 struct tty_ldisc *ld; 683 int retval; 684 685 lockdep_assert_held_write(&tty->ldisc_sem); 686 ld = tty_ldisc_get(tty, disc); 687 if (IS_ERR(ld)) { 688 BUG_ON(disc == N_TTY); 689 return PTR_ERR(ld); 690 } 691 692 if (tty->ldisc) { 693 tty_ldisc_close(tty, tty->ldisc); 694 tty_ldisc_put(tty->ldisc); 695 } 696 697 /* switch the line discipline */ 698 tty->ldisc = ld; 699 tty_set_termios_ldisc(tty, disc); 700 retval = tty_ldisc_open(tty, tty->ldisc); 701 if (retval) { 702 tty_ldisc_put(tty->ldisc); 703 tty->ldisc = NULL; 704 } 705 return retval; 706 } 707 708 /** 709 * tty_ldisc_hangup - hangup ldisc reset 710 * @tty: tty being hung up 711 * @reinit: whether to re-initialise the tty 712 * 713 * Some tty devices reset their termios when they receive a hangup 714 * event. In that situation we must also switch back to N_TTY properly 715 * before we reset the termios data. 716 * 717 * Locking: We can take the ldisc mutex as the rest of the code is 718 * careful to allow for this. 719 * 720 * In the pty pair case this occurs in the close() path of the 721 * tty itself so we must be careful about locking rules. 722 */ 723 724 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit) 725 { 726 struct tty_ldisc *ld; 727 728 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc); 729 730 ld = tty_ldisc_ref(tty); 731 if (ld != NULL) { 732 if (ld->ops->flush_buffer) 733 ld->ops->flush_buffer(tty); 734 tty_driver_flush_buffer(tty); 735 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) && 736 ld->ops->write_wakeup) 737 ld->ops->write_wakeup(tty); 738 if (ld->ops->hangup) 739 ld->ops->hangup(tty); 740 tty_ldisc_deref(ld); 741 } 742 743 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT); 744 wake_up_interruptible_poll(&tty->read_wait, EPOLLIN); 745 746 /* 747 * Shutdown the current line discipline, and reset it to 748 * N_TTY if need be. 749 * 750 * Avoid racing set_ldisc or tty_ldisc_release 751 */ 752 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT); 753 754 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) 755 tty_reset_termios(tty); 756 757 if (tty->ldisc) { 758 if (reinit) { 759 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 && 760 tty_ldisc_reinit(tty, N_TTY) < 0) 761 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0); 762 } else 763 tty_ldisc_kill(tty); 764 } 765 tty_ldisc_unlock(tty); 766 } 767 768 /** 769 * tty_ldisc_setup - open line discipline 770 * @tty: tty being shut down 771 * @o_tty: pair tty for pty/tty pairs 772 * 773 * Called during the initial open of a tty/pty pair in order to set up the 774 * line disciplines and bind them to the tty. This has no locking issues 775 * as the device isn't yet active. 776 */ 777 778 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty) 779 { 780 int retval = tty_ldisc_open(tty, tty->ldisc); 781 782 if (retval) 783 return retval; 784 785 if (o_tty) { 786 /* 787 * Called without o_tty->ldisc_sem held, as o_tty has been 788 * just allocated and no one has a reference to it. 789 */ 790 retval = tty_ldisc_open(o_tty, o_tty->ldisc); 791 if (retval) { 792 tty_ldisc_close(tty, tty->ldisc); 793 return retval; 794 } 795 } 796 return 0; 797 } 798 799 /** 800 * tty_ldisc_release - release line discipline 801 * @tty: tty being shut down (or one end of pty pair) 802 * 803 * Called during the final close of a tty or a pty pair in order to shut 804 * down the line discpline layer. On exit, each tty's ldisc is NULL. 805 */ 806 807 void tty_ldisc_release(struct tty_struct *tty) 808 { 809 struct tty_struct *o_tty = tty->link; 810 811 /* 812 * Shutdown this line discipline. As this is the final close, 813 * it does not race with the set_ldisc code path. 814 */ 815 816 tty_ldisc_lock_pair(tty, o_tty); 817 tty_ldisc_kill(tty); 818 if (o_tty) 819 tty_ldisc_kill(o_tty); 820 tty_ldisc_unlock_pair(tty, o_tty); 821 822 /* 823 * And the memory resources remaining (buffers, termios) will be 824 * disposed of when the kref hits zero 825 */ 826 827 tty_ldisc_debug(tty, "released\n"); 828 } 829 EXPORT_SYMBOL_GPL(tty_ldisc_release); 830 831 /** 832 * tty_ldisc_init - ldisc setup for new tty 833 * @tty: tty being allocated 834 * 835 * Set up the line discipline objects for a newly allocated tty. Note that 836 * the tty structure is not completely set up when this call is made. 837 */ 838 839 int tty_ldisc_init(struct tty_struct *tty) 840 { 841 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY); 842 843 if (IS_ERR(ld)) 844 return PTR_ERR(ld); 845 tty->ldisc = ld; 846 return 0; 847 } 848 849 /** 850 * tty_ldisc_deinit - ldisc cleanup for new tty 851 * @tty: tty that was allocated recently 852 * 853 * The tty structure must not becompletely set up (tty_ldisc_setup) when 854 * this call is made. 855 */ 856 void tty_ldisc_deinit(struct tty_struct *tty) 857 { 858 /* no ldisc_sem, tty is being destroyed */ 859 if (tty->ldisc) 860 tty_ldisc_put(tty->ldisc); 861 tty->ldisc = NULL; 862 } 863 864 static struct ctl_table tty_table[] = { 865 { 866 .procname = "ldisc_autoload", 867 .data = &tty_ldisc_autoload, 868 .maxlen = sizeof(tty_ldisc_autoload), 869 .mode = 0644, 870 .proc_handler = proc_dointvec, 871 .extra1 = SYSCTL_ZERO, 872 .extra2 = SYSCTL_ONE, 873 }, 874 { } 875 }; 876 877 static struct ctl_table tty_dir_table[] = { 878 { 879 .procname = "tty", 880 .mode = 0555, 881 .child = tty_table, 882 }, 883 { } 884 }; 885 886 static struct ctl_table tty_root_table[] = { 887 { 888 .procname = "dev", 889 .mode = 0555, 890 .child = tty_dir_table, 891 }, 892 { } 893 }; 894 895 void tty_sysctl_init(void) 896 { 897 register_sysctl_table(tty_root_table); 898 } 899