1#include <linux/types.h> 2#include <linux/major.h> 3#include <linux/errno.h> 4#include <linux/signal.h> 5#include <linux/fcntl.h> 6#include <linux/sched.h> 7#include <linux/interrupt.h> 8#include <linux/tty.h> 9#include <linux/tty_driver.h> 10#include <linux/tty_flip.h> 11#include <linux/devpts_fs.h> 12#include <linux/file.h> 13#include <linux/console.h> 14#include <linux/timer.h> 15#include <linux/ctype.h> 16#include <linux/kd.h> 17#include <linux/mm.h> 18#include <linux/string.h> 19#include <linux/slab.h> 20#include <linux/poll.h> 21#include <linux/proc_fs.h> 22#include <linux/init.h> 23#include <linux/module.h> 24#include <linux/device.h> 25#include <linux/wait.h> 26#include <linux/bitops.h> 27#include <linux/delay.h> 28#include <linux/seq_file.h> 29 30#include <linux/uaccess.h> 31#include <asm/system.h> 32 33#include <linux/kbd_kern.h> 34#include <linux/vt_kern.h> 35#include <linux/selection.h> 36 37#include <linux/smp_lock.h> /* For the moment */ 38 39#include <linux/kmod.h> 40#include <linux/nsproxy.h> 41 42/* 43 * This guards the refcounted line discipline lists. The lock 44 * must be taken with irqs off because there are hangup path 45 * callers who will do ldisc lookups and cannot sleep. 46 */ 47 48static DEFINE_SPINLOCK(tty_ldisc_lock); 49static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait); 50static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_idle); 51/* Line disc dispatch table */ 52static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS]; 53 54static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld) 55{ 56 if (ld) 57 atomic_inc(&ld->users); 58 return ld; 59} 60 61static void put_ldisc(struct tty_ldisc *ld) 62{ 63 unsigned long flags; 64 65 if (WARN_ON_ONCE(!ld)) 66 return; 67 68 /* 69 * If this is the last user, free the ldisc, and 70 * release the ldisc ops. 71 * 72 * We really want an "atomic_dec_and_lock_irqsave()", 73 * but we don't have it, so this does it by hand. 74 */ 75 local_irq_save(flags); 76 if (atomic_dec_and_lock(&ld->users, &tty_ldisc_lock)) { 77 struct tty_ldisc_ops *ldo = ld->ops; 78 79 ldo->refcount--; 80 module_put(ldo->owner); 81 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 82 83 kfree(ld); 84 return; 85 } 86 local_irq_restore(flags); 87 wake_up(&tty_ldisc_idle); 88} 89 90/** 91 * tty_register_ldisc - install a line discipline 92 * @disc: ldisc number 93 * @new_ldisc: pointer to the ldisc object 94 * 95 * Installs a new line discipline into the kernel. The discipline 96 * is set up as unreferenced and then made available to the kernel 97 * from this point onwards. 98 * 99 * Locking: 100 * takes tty_ldisc_lock to guard against ldisc races 101 */ 102 103int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc) 104{ 105 unsigned long flags; 106 int ret = 0; 107 108 if (disc < N_TTY || disc >= NR_LDISCS) 109 return -EINVAL; 110 111 spin_lock_irqsave(&tty_ldisc_lock, flags); 112 tty_ldiscs[disc] = new_ldisc; 113 new_ldisc->num = disc; 114 new_ldisc->refcount = 0; 115 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 116 117 return ret; 118} 119EXPORT_SYMBOL(tty_register_ldisc); 120 121/** 122 * tty_unregister_ldisc - unload a line discipline 123 * @disc: ldisc number 124 * @new_ldisc: pointer to the ldisc object 125 * 126 * Remove a line discipline from the kernel providing it is not 127 * currently in use. 128 * 129 * Locking: 130 * takes tty_ldisc_lock to guard against ldisc races 131 */ 132 133int tty_unregister_ldisc(int disc) 134{ 135 unsigned long flags; 136 int ret = 0; 137 138 if (disc < N_TTY || disc >= NR_LDISCS) 139 return -EINVAL; 140 141 spin_lock_irqsave(&tty_ldisc_lock, flags); 142 if (tty_ldiscs[disc]->refcount) 143 ret = -EBUSY; 144 else 145 tty_ldiscs[disc] = NULL; 146 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 147 148 return ret; 149} 150EXPORT_SYMBOL(tty_unregister_ldisc); 151 152static struct tty_ldisc_ops *get_ldops(int disc) 153{ 154 unsigned long flags; 155 struct tty_ldisc_ops *ldops, *ret; 156 157 spin_lock_irqsave(&tty_ldisc_lock, flags); 158 ret = ERR_PTR(-EINVAL); 159 ldops = tty_ldiscs[disc]; 160 if (ldops) { 161 ret = ERR_PTR(-EAGAIN); 162 if (try_module_get(ldops->owner)) { 163 ldops->refcount++; 164 ret = ldops; 165 } 166 } 167 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 168 return ret; 169} 170 171static void put_ldops(struct tty_ldisc_ops *ldops) 172{ 173 unsigned long flags; 174 175 spin_lock_irqsave(&tty_ldisc_lock, flags); 176 ldops->refcount--; 177 module_put(ldops->owner); 178 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 179} 180 181/** 182 * tty_ldisc_get - take a reference to an ldisc 183 * @disc: ldisc number 184 * 185 * Takes a reference to a line discipline. Deals with refcounts and 186 * module locking counts. Returns NULL if the discipline is not available. 187 * Returns a pointer to the discipline and bumps the ref count if it is 188 * available 189 * 190 * Locking: 191 * takes tty_ldisc_lock to guard against ldisc races 192 */ 193 194static struct tty_ldisc *tty_ldisc_get(int disc) 195{ 196 struct tty_ldisc *ld; 197 struct tty_ldisc_ops *ldops; 198 199 if (disc < N_TTY || disc >= NR_LDISCS) 200 return ERR_PTR(-EINVAL); 201 202 /* 203 * Get the ldisc ops - we may need to request them to be loaded 204 * dynamically and try again. 205 */ 206 ldops = get_ldops(disc); 207 if (IS_ERR(ldops)) { 208 request_module("tty-ldisc-%d", disc); 209 ldops = get_ldops(disc); 210 if (IS_ERR(ldops)) 211 return ERR_CAST(ldops); 212 } 213 214 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL); 215 if (ld == NULL) { 216 put_ldops(ldops); 217 return ERR_PTR(-ENOMEM); 218 } 219 220 ld->ops = ldops; 221 atomic_set(&ld->users, 1); 222 return ld; 223} 224 225static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos) 226{ 227 return (*pos < NR_LDISCS) ? pos : NULL; 228} 229 230static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos) 231{ 232 (*pos)++; 233 return (*pos < NR_LDISCS) ? pos : NULL; 234} 235 236static void tty_ldiscs_seq_stop(struct seq_file *m, void *v) 237{ 238} 239 240static int tty_ldiscs_seq_show(struct seq_file *m, void *v) 241{ 242 int i = *(loff_t *)v; 243 struct tty_ldisc_ops *ldops; 244 245 ldops = get_ldops(i); 246 if (IS_ERR(ldops)) 247 return 0; 248 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i); 249 put_ldops(ldops); 250 return 0; 251} 252 253static const struct seq_operations tty_ldiscs_seq_ops = { 254 .start = tty_ldiscs_seq_start, 255 .next = tty_ldiscs_seq_next, 256 .stop = tty_ldiscs_seq_stop, 257 .show = tty_ldiscs_seq_show, 258}; 259 260static int proc_tty_ldiscs_open(struct inode *inode, struct file *file) 261{ 262 return seq_open(file, &tty_ldiscs_seq_ops); 263} 264 265const struct file_operations tty_ldiscs_proc_fops = { 266 .owner = THIS_MODULE, 267 .open = proc_tty_ldiscs_open, 268 .read = seq_read, 269 .llseek = seq_lseek, 270 .release = seq_release, 271}; 272 273/** 274 * tty_ldisc_assign - set ldisc on a tty 275 * @tty: tty to assign 276 * @ld: line discipline 277 * 278 * Install an instance of a line discipline into a tty structure. The 279 * ldisc must have a reference count above zero to ensure it remains. 280 * The tty instance refcount starts at zero. 281 * 282 * Locking: 283 * Caller must hold references 284 */ 285 286static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld) 287{ 288 tty->ldisc = ld; 289} 290 291/** 292 * tty_ldisc_try - internal helper 293 * @tty: the tty 294 * 295 * Make a single attempt to grab and bump the refcount on 296 * the tty ldisc. Return 0 on failure or 1 on success. This is 297 * used to implement both the waiting and non waiting versions 298 * of tty_ldisc_ref 299 * 300 * Locking: takes tty_ldisc_lock 301 */ 302 303static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty) 304{ 305 unsigned long flags; 306 struct tty_ldisc *ld; 307 308 spin_lock_irqsave(&tty_ldisc_lock, flags); 309 ld = NULL; 310 if (test_bit(TTY_LDISC, &tty->flags)) 311 ld = get_ldisc(tty->ldisc); 312 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 313 return ld; 314} 315 316/** 317 * tty_ldisc_ref_wait - wait for the tty ldisc 318 * @tty: tty device 319 * 320 * Dereference the line discipline for the terminal and take a 321 * reference to it. If the line discipline is in flux then 322 * wait patiently until it changes. 323 * 324 * Note: Must not be called from an IRQ/timer context. The caller 325 * must also be careful not to hold other locks that will deadlock 326 * against a discipline change, such as an existing ldisc reference 327 * (which we check for) 328 * 329 * Locking: call functions take tty_ldisc_lock 330 */ 331 332struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty) 333{ 334 struct tty_ldisc *ld; 335 336 /* wait_event is a macro */ 337 wait_event(tty_ldisc_wait, (ld = tty_ldisc_try(tty)) != NULL); 338 return ld; 339} 340EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait); 341 342/** 343 * tty_ldisc_ref - get the tty ldisc 344 * @tty: tty device 345 * 346 * Dereference the line discipline for the terminal and take a 347 * reference to it. If the line discipline is in flux then 348 * return NULL. Can be called from IRQ and timer functions. 349 * 350 * Locking: called functions take tty_ldisc_lock 351 */ 352 353struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty) 354{ 355 return tty_ldisc_try(tty); 356} 357EXPORT_SYMBOL_GPL(tty_ldisc_ref); 358 359/** 360 * tty_ldisc_deref - free a tty ldisc reference 361 * @ld: reference to free up 362 * 363 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May 364 * be called in IRQ context. 365 * 366 * Locking: takes tty_ldisc_lock 367 */ 368 369void tty_ldisc_deref(struct tty_ldisc *ld) 370{ 371 put_ldisc(ld); 372} 373EXPORT_SYMBOL_GPL(tty_ldisc_deref); 374 375static inline void tty_ldisc_put(struct tty_ldisc *ld) 376{ 377 put_ldisc(ld); 378} 379 380/** 381 * tty_ldisc_enable - allow ldisc use 382 * @tty: terminal to activate ldisc on 383 * 384 * Set the TTY_LDISC flag when the line discipline can be called 385 * again. Do necessary wakeups for existing sleepers. Clear the LDISC 386 * changing flag to indicate any ldisc change is now over. 387 * 388 * Note: nobody should set the TTY_LDISC bit except via this function. 389 * Clearing directly is allowed. 390 */ 391 392void tty_ldisc_enable(struct tty_struct *tty) 393{ 394 set_bit(TTY_LDISC, &tty->flags); 395 clear_bit(TTY_LDISC_CHANGING, &tty->flags); 396 wake_up(&tty_ldisc_wait); 397} 398 399/** 400 * tty_ldisc_flush - flush line discipline queue 401 * @tty: tty 402 * 403 * Flush the line discipline queue (if any) for this tty. If there 404 * is no line discipline active this is a no-op. 405 */ 406 407void tty_ldisc_flush(struct tty_struct *tty) 408{ 409 struct tty_ldisc *ld = tty_ldisc_ref(tty); 410 if (ld) { 411 if (ld->ops->flush_buffer) 412 ld->ops->flush_buffer(tty); 413 tty_ldisc_deref(ld); 414 } 415 tty_buffer_flush(tty); 416} 417EXPORT_SYMBOL_GPL(tty_ldisc_flush); 418 419/** 420 * tty_set_termios_ldisc - set ldisc field 421 * @tty: tty structure 422 * @num: line discipline number 423 * 424 * This is probably overkill for real world processors but 425 * they are not on hot paths so a little discipline won't do 426 * any harm. 427 * 428 * Locking: takes termios_mutex 429 */ 430 431static void tty_set_termios_ldisc(struct tty_struct *tty, int num) 432{ 433 mutex_lock(&tty->termios_mutex); 434 tty->termios->c_line = num; 435 mutex_unlock(&tty->termios_mutex); 436} 437 438/** 439 * tty_ldisc_open - open a line discipline 440 * @tty: tty we are opening the ldisc on 441 * @ld: discipline to open 442 * 443 * A helper opening method. Also a convenient debugging and check 444 * point. 445 * 446 * Locking: always called with BTM already held. 447 */ 448 449static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld) 450{ 451 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags)); 452 if (ld->ops->open) { 453 int ret; 454 /* BTM here locks versus a hangup event */ 455 WARN_ON(!tty_locked()); 456 ret = ld->ops->open(tty); 457 if (ret) 458 clear_bit(TTY_LDISC_OPEN, &tty->flags); 459 return ret; 460 } 461 return 0; 462} 463 464/** 465 * tty_ldisc_close - close a line discipline 466 * @tty: tty we are opening the ldisc on 467 * @ld: discipline to close 468 * 469 * A helper close method. Also a convenient debugging and check 470 * point. 471 */ 472 473static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld) 474{ 475 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags)); 476 clear_bit(TTY_LDISC_OPEN, &tty->flags); 477 if (ld->ops->close) 478 ld->ops->close(tty); 479} 480 481/** 482 * tty_ldisc_restore - helper for tty ldisc change 483 * @tty: tty to recover 484 * @old: previous ldisc 485 * 486 * Restore the previous line discipline or N_TTY when a line discipline 487 * change fails due to an open error 488 */ 489 490static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old) 491{ 492 char buf[64]; 493 struct tty_ldisc *new_ldisc; 494 int r; 495 496 /* There is an outstanding reference here so this is safe */ 497 old = tty_ldisc_get(old->ops->num); 498 WARN_ON(IS_ERR(old)); 499 tty_ldisc_assign(tty, old); 500 tty_set_termios_ldisc(tty, old->ops->num); 501 if (tty_ldisc_open(tty, old) < 0) { 502 tty_ldisc_put(old); 503 /* This driver is always present */ 504 new_ldisc = tty_ldisc_get(N_TTY); 505 if (IS_ERR(new_ldisc)) 506 panic("n_tty: get"); 507 tty_ldisc_assign(tty, new_ldisc); 508 tty_set_termios_ldisc(tty, N_TTY); 509 r = tty_ldisc_open(tty, new_ldisc); 510 if (r < 0) 511 panic("Couldn't open N_TTY ldisc for " 512 "%s --- error %d.", 513 tty_name(tty, buf), r); 514 } 515} 516 517/** 518 * tty_ldisc_halt - shut down the line discipline 519 * @tty: tty device 520 * 521 * Shut down the line discipline and work queue for this tty device. 522 * The TTY_LDISC flag being cleared ensures no further references can 523 * be obtained while the delayed work queue halt ensures that no more 524 * data is fed to the ldisc. 525 * 526 * You need to do a 'flush_scheduled_work()' (outside the ldisc_mutex) 527 * in order to make sure any currently executing ldisc work is also 528 * flushed. 529 */ 530 531static int tty_ldisc_halt(struct tty_struct *tty) 532{ 533 clear_bit(TTY_LDISC, &tty->flags); 534 return cancel_delayed_work_sync(&tty->buf.work); 535} 536 537/** 538 * tty_ldisc_wait_idle - wait for the ldisc to become idle 539 * @tty: tty to wait for 540 * 541 * Wait for the line discipline to become idle. The discipline must 542 * have been halted for this to guarantee it remains idle. 543 */ 544static int tty_ldisc_wait_idle(struct tty_struct *tty) 545{ 546 int ret; 547 ret = wait_event_interruptible_timeout(tty_ldisc_idle, 548 atomic_read(&tty->ldisc->users) == 1, 5 * HZ); 549 if (ret < 0) 550 return ret; 551 return ret > 0 ? 0 : -EBUSY; 552} 553 554/** 555 * tty_set_ldisc - set line discipline 556 * @tty: the terminal to set 557 * @ldisc: the line discipline 558 * 559 * Set the discipline of a tty line. Must be called from a process 560 * context. The ldisc change logic has to protect itself against any 561 * overlapping ldisc change (including on the other end of pty pairs), 562 * the close of one side of a tty/pty pair, and eventually hangup. 563 * 564 * Locking: takes tty_ldisc_lock, termios_mutex 565 */ 566 567int tty_set_ldisc(struct tty_struct *tty, int ldisc) 568{ 569 int retval; 570 struct tty_ldisc *o_ldisc, *new_ldisc; 571 int work, o_work = 0; 572 struct tty_struct *o_tty; 573 574 new_ldisc = tty_ldisc_get(ldisc); 575 if (IS_ERR(new_ldisc)) 576 return PTR_ERR(new_ldisc); 577 578 tty_lock(); 579 /* 580 * We need to look at the tty locking here for pty/tty pairs 581 * when both sides try to change in parallel. 582 */ 583 584 o_tty = tty->link; /* o_tty is the pty side or NULL */ 585 586 587 /* 588 * Check the no-op case 589 */ 590 591 if (tty->ldisc->ops->num == ldisc) { 592 tty_unlock(); 593 tty_ldisc_put(new_ldisc); 594 return 0; 595 } 596 597 tty_unlock(); 598 /* 599 * Problem: What do we do if this blocks ? 600 * We could deadlock here 601 */ 602 603 tty_wait_until_sent(tty, 0); 604 605 tty_lock(); 606 mutex_lock(&tty->ldisc_mutex); 607 608 /* 609 * We could be midstream of another ldisc change which has 610 * dropped the lock during processing. If so we need to wait. 611 */ 612 613 while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) { 614 mutex_unlock(&tty->ldisc_mutex); 615 tty_unlock(); 616 wait_event(tty_ldisc_wait, 617 test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0); 618 tty_lock(); 619 mutex_lock(&tty->ldisc_mutex); 620 } 621 622 set_bit(TTY_LDISC_CHANGING, &tty->flags); 623 624 /* 625 * No more input please, we are switching. The new ldisc 626 * will update this value in the ldisc open function 627 */ 628 629 tty->receive_room = 0; 630 631 o_ldisc = tty->ldisc; 632 633 tty_unlock(); 634 /* 635 * Make sure we don't change while someone holds a 636 * reference to the line discipline. The TTY_LDISC bit 637 * prevents anyone taking a reference once it is clear. 638 * We need the lock to avoid racing reference takers. 639 * 640 * We must clear the TTY_LDISC bit here to avoid a livelock 641 * with a userspace app continually trying to use the tty in 642 * parallel to the change and re-referencing the tty. 643 */ 644 645 work = tty_ldisc_halt(tty); 646 if (o_tty) 647 o_work = tty_ldisc_halt(o_tty); 648 649 /* 650 * Wait for ->hangup_work and ->buf.work handlers to terminate. 651 * We must drop the mutex here in case a hangup is also in process. 652 */ 653 654 mutex_unlock(&tty->ldisc_mutex); 655 656 flush_scheduled_work(); 657 658 retval = tty_ldisc_wait_idle(tty); 659 660 tty_lock(); 661 mutex_lock(&tty->ldisc_mutex); 662 663 /* handle wait idle failure locked */ 664 if (retval) { 665 tty_ldisc_put(new_ldisc); 666 goto enable; 667 } 668 669 if (test_bit(TTY_HUPPED, &tty->flags)) { 670 /* We were raced by the hangup method. It will have stomped 671 the ldisc data and closed the ldisc down */ 672 clear_bit(TTY_LDISC_CHANGING, &tty->flags); 673 mutex_unlock(&tty->ldisc_mutex); 674 tty_ldisc_put(new_ldisc); 675 tty_unlock(); 676 return -EIO; 677 } 678 679 /* Shutdown the current discipline. */ 680 tty_ldisc_close(tty, o_ldisc); 681 682 /* Now set up the new line discipline. */ 683 tty_ldisc_assign(tty, new_ldisc); 684 tty_set_termios_ldisc(tty, ldisc); 685 686 retval = tty_ldisc_open(tty, new_ldisc); 687 if (retval < 0) { 688 /* Back to the old one or N_TTY if we can't */ 689 tty_ldisc_put(new_ldisc); 690 tty_ldisc_restore(tty, o_ldisc); 691 } 692 693 /* At this point we hold a reference to the new ldisc and a 694 a reference to the old ldisc. If we ended up flipping back 695 to the existing ldisc we have two references to it */ 696 697 if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc) 698 tty->ops->set_ldisc(tty); 699 700 tty_ldisc_put(o_ldisc); 701 702enable: 703 /* 704 * Allow ldisc referencing to occur again 705 */ 706 707 tty_ldisc_enable(tty); 708 if (o_tty) 709 tty_ldisc_enable(o_tty); 710 711 /* Restart the work queue in case no characters kick it off. Safe if 712 already running */ 713 if (work) 714 schedule_delayed_work(&tty->buf.work, 1); 715 if (o_work) 716 schedule_delayed_work(&o_tty->buf.work, 1); 717 mutex_unlock(&tty->ldisc_mutex); 718 tty_unlock(); 719 return retval; 720} 721 722/** 723 * tty_reset_termios - reset terminal state 724 * @tty: tty to reset 725 * 726 * Restore a terminal to the driver default state. 727 */ 728 729static void tty_reset_termios(struct tty_struct *tty) 730{ 731 mutex_lock(&tty->termios_mutex); 732 *tty->termios = tty->driver->init_termios; 733 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios); 734 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios); 735 mutex_unlock(&tty->termios_mutex); 736} 737 738 739/** 740 * tty_ldisc_reinit - reinitialise the tty ldisc 741 * @tty: tty to reinit 742 * @ldisc: line discipline to reinitialize 743 * 744 * Switch the tty to a line discipline and leave the ldisc 745 * state closed 746 */ 747 748static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc) 749{ 750 struct tty_ldisc *ld = tty_ldisc_get(ldisc); 751 752 if (IS_ERR(ld)) 753 return -1; 754 755 tty_ldisc_close(tty, tty->ldisc); 756 tty_ldisc_put(tty->ldisc); 757 tty->ldisc = NULL; 758 /* 759 * Switch the line discipline back 760 */ 761 tty_ldisc_assign(tty, ld); 762 tty_set_termios_ldisc(tty, ldisc); 763 764 return 0; 765} 766 767/** 768 * tty_ldisc_hangup - hangup ldisc reset 769 * @tty: tty being hung up 770 * 771 * Some tty devices reset their termios when they receive a hangup 772 * event. In that situation we must also switch back to N_TTY properly 773 * before we reset the termios data. 774 * 775 * Locking: We can take the ldisc mutex as the rest of the code is 776 * careful to allow for this. 777 * 778 * In the pty pair case this occurs in the close() path of the 779 * tty itself so we must be careful about locking rules. 780 */ 781 782void tty_ldisc_hangup(struct tty_struct *tty) 783{ 784 struct tty_ldisc *ld; 785 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS; 786 int err = 0; 787 788 ld = tty_ldisc_ref(tty); 789 if (ld != NULL) { 790 /* We may have no line discipline at this point */ 791 if (ld->ops->flush_buffer) 792 ld->ops->flush_buffer(tty); 793 tty_driver_flush_buffer(tty); 794 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) && 795 ld->ops->write_wakeup) 796 ld->ops->write_wakeup(tty); 797 if (ld->ops->hangup) 798 ld->ops->hangup(tty); 799 tty_ldisc_deref(ld); 800 } 801 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 802 wake_up_interruptible_poll(&tty->read_wait, POLLIN); 803 /* 804 * Shutdown the current line discipline, and reset it to 805 * N_TTY if need be. 806 * 807 * Avoid racing set_ldisc or tty_ldisc_release 808 */ 809 mutex_lock(&tty->ldisc_mutex); 810 811 /* 812 * this is like tty_ldisc_halt, but we need to give up 813 * the BTM before calling cancel_delayed_work_sync, 814 * which may need to wait for another function taking the BTM 815 */ 816 clear_bit(TTY_LDISC, &tty->flags); 817 tty_unlock(); 818 cancel_delayed_work_sync(&tty->buf.work); 819 mutex_unlock(&tty->ldisc_mutex); 820 821 tty_lock(); 822 mutex_lock(&tty->ldisc_mutex); 823 824 if (tty->ldisc) { /* Not yet closed */ 825 if (reset == 0) { 826 827 if (!tty_ldisc_reinit(tty, tty->termios->c_line)) 828 err = tty_ldisc_open(tty, tty->ldisc); 829 else 830 err = 1; 831 } 832 /* If the re-open fails or we reset then go to N_TTY. The 833 N_TTY open cannot fail */ 834 if (reset || err) { 835 BUG_ON(tty_ldisc_reinit(tty, N_TTY)); 836 WARN_ON(tty_ldisc_open(tty, tty->ldisc)); 837 } 838 tty_ldisc_enable(tty); 839 } 840 mutex_unlock(&tty->ldisc_mutex); 841 if (reset) 842 tty_reset_termios(tty); 843} 844 845/** 846 * tty_ldisc_setup - open line discipline 847 * @tty: tty being shut down 848 * @o_tty: pair tty for pty/tty pairs 849 * 850 * Called during the initial open of a tty/pty pair in order to set up the 851 * line disciplines and bind them to the tty. This has no locking issues 852 * as the device isn't yet active. 853 */ 854 855int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty) 856{ 857 struct tty_ldisc *ld = tty->ldisc; 858 int retval; 859 860 retval = tty_ldisc_open(tty, ld); 861 if (retval) 862 return retval; 863 864 if (o_tty) { 865 retval = tty_ldisc_open(o_tty, o_tty->ldisc); 866 if (retval) { 867 tty_ldisc_close(tty, ld); 868 return retval; 869 } 870 tty_ldisc_enable(o_tty); 871 } 872 tty_ldisc_enable(tty); 873 return 0; 874} 875/** 876 * tty_ldisc_release - release line discipline 877 * @tty: tty being shut down 878 * @o_tty: pair tty for pty/tty pairs 879 * 880 * Called during the final close of a tty/pty pair in order to shut down 881 * the line discpline layer. On exit the ldisc assigned is N_TTY and the 882 * ldisc has not been opened. 883 */ 884 885void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty) 886{ 887 /* 888 * Prevent flush_to_ldisc() from rescheduling the work for later. Then 889 * kill any delayed work. As this is the final close it does not 890 * race with the set_ldisc code path. 891 */ 892 893 tty_unlock(); 894 tty_ldisc_halt(tty); 895 flush_scheduled_work(); 896 tty_lock(); 897 898 mutex_lock(&tty->ldisc_mutex); 899 /* 900 * Now kill off the ldisc 901 */ 902 tty_ldisc_close(tty, tty->ldisc); 903 tty_ldisc_put(tty->ldisc); 904 /* Force an oops if we mess this up */ 905 tty->ldisc = NULL; 906 907 /* Ensure the next open requests the N_TTY ldisc */ 908 tty_set_termios_ldisc(tty, N_TTY); 909 mutex_unlock(&tty->ldisc_mutex); 910 911 /* This will need doing differently if we need to lock */ 912 if (o_tty) 913 tty_ldisc_release(o_tty, NULL); 914 915 /* And the memory resources remaining (buffers, termios) will be 916 disposed of when the kref hits zero */ 917} 918 919/** 920 * tty_ldisc_init - ldisc setup for new tty 921 * @tty: tty being allocated 922 * 923 * Set up the line discipline objects for a newly allocated tty. Note that 924 * the tty structure is not completely set up when this call is made. 925 */ 926 927void tty_ldisc_init(struct tty_struct *tty) 928{ 929 struct tty_ldisc *ld = tty_ldisc_get(N_TTY); 930 if (IS_ERR(ld)) 931 panic("n_tty: init_tty"); 932 tty_ldisc_assign(tty, ld); 933} 934 935void tty_ldisc_begin(void) 936{ 937 /* Setup the default TTY line discipline. */ 938 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY); 939} 940