1 /* 2 * Copyright (C) 1991, 1992 Linus Torvalds 3 */ 4 5 /* 6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles 7 * or rs-channels. It also implements echoing, cooked mode etc. 8 * 9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0. 10 * 11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the 12 * tty_struct and tty_queue structures. Previously there was an array 13 * of 256 tty_struct's which was statically allocated, and the 14 * tty_queue structures were allocated at boot time. Both are now 15 * dynamically allocated only when the tty is open. 16 * 17 * Also restructured routines so that there is more of a separation 18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and 19 * the low-level tty routines (serial.c, pty.c, console.c). This 20 * makes for cleaner and more compact code. -TYT, 9/17/92 21 * 22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines 23 * which can be dynamically activated and de-activated by the line 24 * discipline handling modules (like SLIP). 25 * 26 * NOTE: pay no attention to the line discipline code (yet); its 27 * interface is still subject to change in this version... 28 * -- TYT, 1/31/92 29 * 30 * Added functionality to the OPOST tty handling. No delays, but all 31 * other bits should be there. 32 * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993. 33 * 34 * Rewrote canonical mode and added more termios flags. 35 * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94 36 * 37 * Reorganized FASYNC support so mouse code can share it. 38 * -- ctm@ardi.com, 9Sep95 39 * 40 * New TIOCLINUX variants added. 41 * -- mj@k332.feld.cvut.cz, 19-Nov-95 42 * 43 * Restrict vt switching via ioctl() 44 * -- grif@cs.ucr.edu, 5-Dec-95 45 * 46 * Move console and virtual terminal code to more appropriate files, 47 * implement CONFIG_VT and generalize console device interface. 48 * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97 49 * 50 * Rewrote tty_init_dev and tty_release_dev to eliminate races. 51 * -- Bill Hawes <whawes@star.net>, June 97 52 * 53 * Added devfs support. 54 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998 55 * 56 * Added support for a Unix98-style ptmx device. 57 * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998 58 * 59 * Reduced memory usage for older ARM systems 60 * -- Russell King <rmk@arm.linux.org.uk> 61 * 62 * Move do_SAK() into process context. Less stack use in devfs functions. 63 * alloc_tty_struct() always uses kmalloc() 64 * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01 65 */ 66 67 #include <linux/types.h> 68 #include <linux/major.h> 69 #include <linux/errno.h> 70 #include <linux/signal.h> 71 #include <linux/fcntl.h> 72 #include <linux/sched.h> 73 #include <linux/interrupt.h> 74 #include <linux/tty.h> 75 #include <linux/tty_driver.h> 76 #include <linux/tty_flip.h> 77 #include <linux/devpts_fs.h> 78 #include <linux/file.h> 79 #include <linux/fdtable.h> 80 #include <linux/console.h> 81 #include <linux/timer.h> 82 #include <linux/ctype.h> 83 #include <linux/kd.h> 84 #include <linux/mm.h> 85 #include <linux/string.h> 86 #include <linux/slab.h> 87 #include <linux/poll.h> 88 #include <linux/proc_fs.h> 89 #include <linux/init.h> 90 #include <linux/module.h> 91 #include <linux/device.h> 92 #include <linux/wait.h> 93 #include <linux/bitops.h> 94 #include <linux/delay.h> 95 #include <linux/seq_file.h> 96 #include <linux/serial.h> 97 #include <linux/ratelimit.h> 98 99 #include <linux/uaccess.h> 100 #include <asm/system.h> 101 102 #include <linux/kbd_kern.h> 103 #include <linux/vt_kern.h> 104 #include <linux/selection.h> 105 106 #include <linux/kmod.h> 107 #include <linux/nsproxy.h> 108 109 #undef TTY_DEBUG_HANGUP 110 111 #define TTY_PARANOIA_CHECK 1 112 #define CHECK_TTY_COUNT 1 113 114 struct ktermios tty_std_termios = { /* for the benefit of tty drivers */ 115 .c_iflag = ICRNL | IXON, 116 .c_oflag = OPOST | ONLCR, 117 .c_cflag = B38400 | CS8 | CREAD | HUPCL, 118 .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | 119 ECHOCTL | ECHOKE | IEXTEN, 120 .c_cc = INIT_C_CC, 121 .c_ispeed = 38400, 122 .c_ospeed = 38400 123 }; 124 125 EXPORT_SYMBOL(tty_std_termios); 126 127 /* This list gets poked at by procfs and various bits of boot up code. This 128 could do with some rationalisation such as pulling the tty proc function 129 into this file */ 130 131 LIST_HEAD(tty_drivers); /* linked list of tty drivers */ 132 133 /* Mutex to protect creating and releasing a tty. This is shared with 134 vt.c for deeply disgusting hack reasons */ 135 DEFINE_MUTEX(tty_mutex); 136 EXPORT_SYMBOL(tty_mutex); 137 138 /* Spinlock to protect the tty->tty_files list */ 139 DEFINE_SPINLOCK(tty_files_lock); 140 141 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *); 142 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *); 143 ssize_t redirected_tty_write(struct file *, const char __user *, 144 size_t, loff_t *); 145 static unsigned int tty_poll(struct file *, poll_table *); 146 static int tty_open(struct inode *, struct file *); 147 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 148 #ifdef CONFIG_COMPAT 149 static long tty_compat_ioctl(struct file *file, unsigned int cmd, 150 unsigned long arg); 151 #else 152 #define tty_compat_ioctl NULL 153 #endif 154 static int __tty_fasync(int fd, struct file *filp, int on); 155 static int tty_fasync(int fd, struct file *filp, int on); 156 static void release_tty(struct tty_struct *tty, int idx); 157 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty); 158 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty); 159 160 /** 161 * alloc_tty_struct - allocate a tty object 162 * 163 * Return a new empty tty structure. The data fields have not 164 * been initialized in any way but has been zeroed 165 * 166 * Locking: none 167 */ 168 169 struct tty_struct *alloc_tty_struct(void) 170 { 171 return kzalloc(sizeof(struct tty_struct), GFP_KERNEL); 172 } 173 174 /** 175 * free_tty_struct - free a disused tty 176 * @tty: tty struct to free 177 * 178 * Free the write buffers, tty queue and tty memory itself. 179 * 180 * Locking: none. Must be called after tty is definitely unused 181 */ 182 183 void free_tty_struct(struct tty_struct *tty) 184 { 185 if (tty->dev) 186 put_device(tty->dev); 187 kfree(tty->write_buf); 188 tty_buffer_free_all(tty); 189 kfree(tty); 190 } 191 192 static inline struct tty_struct *file_tty(struct file *file) 193 { 194 return ((struct tty_file_private *)file->private_data)->tty; 195 } 196 197 int tty_alloc_file(struct file *file) 198 { 199 struct tty_file_private *priv; 200 201 priv = kmalloc(sizeof(*priv), GFP_KERNEL); 202 if (!priv) 203 return -ENOMEM; 204 205 file->private_data = priv; 206 207 return 0; 208 } 209 210 /* Associate a new file with the tty structure */ 211 void tty_add_file(struct tty_struct *tty, struct file *file) 212 { 213 struct tty_file_private *priv = file->private_data; 214 215 priv->tty = tty; 216 priv->file = file; 217 218 spin_lock(&tty_files_lock); 219 list_add(&priv->list, &tty->tty_files); 220 spin_unlock(&tty_files_lock); 221 } 222 223 /** 224 * tty_free_file - free file->private_data 225 * 226 * This shall be used only for fail path handling when tty_add_file was not 227 * called yet. 228 */ 229 void tty_free_file(struct file *file) 230 { 231 struct tty_file_private *priv = file->private_data; 232 233 file->private_data = NULL; 234 kfree(priv); 235 } 236 237 /* Delete file from its tty */ 238 void tty_del_file(struct file *file) 239 { 240 struct tty_file_private *priv = file->private_data; 241 242 spin_lock(&tty_files_lock); 243 list_del(&priv->list); 244 spin_unlock(&tty_files_lock); 245 tty_free_file(file); 246 } 247 248 249 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base) 250 251 /** 252 * tty_name - return tty naming 253 * @tty: tty structure 254 * @buf: buffer for output 255 * 256 * Convert a tty structure into a name. The name reflects the kernel 257 * naming policy and if udev is in use may not reflect user space 258 * 259 * Locking: none 260 */ 261 262 char *tty_name(struct tty_struct *tty, char *buf) 263 { 264 if (!tty) /* Hmm. NULL pointer. That's fun. */ 265 strcpy(buf, "NULL tty"); 266 else 267 strcpy(buf, tty->name); 268 return buf; 269 } 270 271 EXPORT_SYMBOL(tty_name); 272 273 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode, 274 const char *routine) 275 { 276 #ifdef TTY_PARANOIA_CHECK 277 if (!tty) { 278 printk(KERN_WARNING 279 "null TTY for (%d:%d) in %s\n", 280 imajor(inode), iminor(inode), routine); 281 return 1; 282 } 283 if (tty->magic != TTY_MAGIC) { 284 printk(KERN_WARNING 285 "bad magic number for tty struct (%d:%d) in %s\n", 286 imajor(inode), iminor(inode), routine); 287 return 1; 288 } 289 #endif 290 return 0; 291 } 292 293 static int check_tty_count(struct tty_struct *tty, const char *routine) 294 { 295 #ifdef CHECK_TTY_COUNT 296 struct list_head *p; 297 int count = 0; 298 299 spin_lock(&tty_files_lock); 300 list_for_each(p, &tty->tty_files) { 301 count++; 302 } 303 spin_unlock(&tty_files_lock); 304 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 305 tty->driver->subtype == PTY_TYPE_SLAVE && 306 tty->link && tty->link->count) 307 count++; 308 if (tty->count != count) { 309 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) " 310 "!= #fd's(%d) in %s\n", 311 tty->name, tty->count, count, routine); 312 return count; 313 } 314 #endif 315 return 0; 316 } 317 318 /** 319 * get_tty_driver - find device of a tty 320 * @dev_t: device identifier 321 * @index: returns the index of the tty 322 * 323 * This routine returns a tty driver structure, given a device number 324 * and also passes back the index number. 325 * 326 * Locking: caller must hold tty_mutex 327 */ 328 329 static struct tty_driver *get_tty_driver(dev_t device, int *index) 330 { 331 struct tty_driver *p; 332 333 list_for_each_entry(p, &tty_drivers, tty_drivers) { 334 dev_t base = MKDEV(p->major, p->minor_start); 335 if (device < base || device >= base + p->num) 336 continue; 337 *index = device - base; 338 return tty_driver_kref_get(p); 339 } 340 return NULL; 341 } 342 343 #ifdef CONFIG_CONSOLE_POLL 344 345 /** 346 * tty_find_polling_driver - find device of a polled tty 347 * @name: name string to match 348 * @line: pointer to resulting tty line nr 349 * 350 * This routine returns a tty driver structure, given a name 351 * and the condition that the tty driver is capable of polled 352 * operation. 353 */ 354 struct tty_driver *tty_find_polling_driver(char *name, int *line) 355 { 356 struct tty_driver *p, *res = NULL; 357 int tty_line = 0; 358 int len; 359 char *str, *stp; 360 361 for (str = name; *str; str++) 362 if ((*str >= '0' && *str <= '9') || *str == ',') 363 break; 364 if (!*str) 365 return NULL; 366 367 len = str - name; 368 tty_line = simple_strtoul(str, &str, 10); 369 370 mutex_lock(&tty_mutex); 371 /* Search through the tty devices to look for a match */ 372 list_for_each_entry(p, &tty_drivers, tty_drivers) { 373 if (strncmp(name, p->name, len) != 0) 374 continue; 375 stp = str; 376 if (*stp == ',') 377 stp++; 378 if (*stp == '\0') 379 stp = NULL; 380 381 if (tty_line >= 0 && tty_line < p->num && p->ops && 382 p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) { 383 res = tty_driver_kref_get(p); 384 *line = tty_line; 385 break; 386 } 387 } 388 mutex_unlock(&tty_mutex); 389 390 return res; 391 } 392 EXPORT_SYMBOL_GPL(tty_find_polling_driver); 393 #endif 394 395 /** 396 * tty_check_change - check for POSIX terminal changes 397 * @tty: tty to check 398 * 399 * If we try to write to, or set the state of, a terminal and we're 400 * not in the foreground, send a SIGTTOU. If the signal is blocked or 401 * ignored, go ahead and perform the operation. (POSIX 7.2) 402 * 403 * Locking: ctrl_lock 404 */ 405 406 int tty_check_change(struct tty_struct *tty) 407 { 408 unsigned long flags; 409 int ret = 0; 410 411 if (current->signal->tty != tty) 412 return 0; 413 414 spin_lock_irqsave(&tty->ctrl_lock, flags); 415 416 if (!tty->pgrp) { 417 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n"); 418 goto out_unlock; 419 } 420 if (task_pgrp(current) == tty->pgrp) 421 goto out_unlock; 422 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 423 if (is_ignored(SIGTTOU)) 424 goto out; 425 if (is_current_pgrp_orphaned()) { 426 ret = -EIO; 427 goto out; 428 } 429 kill_pgrp(task_pgrp(current), SIGTTOU, 1); 430 set_thread_flag(TIF_SIGPENDING); 431 ret = -ERESTARTSYS; 432 out: 433 return ret; 434 out_unlock: 435 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 436 return ret; 437 } 438 439 EXPORT_SYMBOL(tty_check_change); 440 441 static ssize_t hung_up_tty_read(struct file *file, char __user *buf, 442 size_t count, loff_t *ppos) 443 { 444 return 0; 445 } 446 447 static ssize_t hung_up_tty_write(struct file *file, const char __user *buf, 448 size_t count, loff_t *ppos) 449 { 450 return -EIO; 451 } 452 453 /* No kernel lock held - none needed ;) */ 454 static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait) 455 { 456 return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM; 457 } 458 459 static long hung_up_tty_ioctl(struct file *file, unsigned int cmd, 460 unsigned long arg) 461 { 462 return cmd == TIOCSPGRP ? -ENOTTY : -EIO; 463 } 464 465 static long hung_up_tty_compat_ioctl(struct file *file, 466 unsigned int cmd, unsigned long arg) 467 { 468 return cmd == TIOCSPGRP ? -ENOTTY : -EIO; 469 } 470 471 static const struct file_operations tty_fops = { 472 .llseek = no_llseek, 473 .read = tty_read, 474 .write = tty_write, 475 .poll = tty_poll, 476 .unlocked_ioctl = tty_ioctl, 477 .compat_ioctl = tty_compat_ioctl, 478 .open = tty_open, 479 .release = tty_release, 480 .fasync = tty_fasync, 481 }; 482 483 static const struct file_operations console_fops = { 484 .llseek = no_llseek, 485 .read = tty_read, 486 .write = redirected_tty_write, 487 .poll = tty_poll, 488 .unlocked_ioctl = tty_ioctl, 489 .compat_ioctl = tty_compat_ioctl, 490 .open = tty_open, 491 .release = tty_release, 492 .fasync = tty_fasync, 493 }; 494 495 static const struct file_operations hung_up_tty_fops = { 496 .llseek = no_llseek, 497 .read = hung_up_tty_read, 498 .write = hung_up_tty_write, 499 .poll = hung_up_tty_poll, 500 .unlocked_ioctl = hung_up_tty_ioctl, 501 .compat_ioctl = hung_up_tty_compat_ioctl, 502 .release = tty_release, 503 }; 504 505 static DEFINE_SPINLOCK(redirect_lock); 506 static struct file *redirect; 507 508 /** 509 * tty_wakeup - request more data 510 * @tty: terminal 511 * 512 * Internal and external helper for wakeups of tty. This function 513 * informs the line discipline if present that the driver is ready 514 * to receive more output data. 515 */ 516 517 void tty_wakeup(struct tty_struct *tty) 518 { 519 struct tty_ldisc *ld; 520 521 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) { 522 ld = tty_ldisc_ref(tty); 523 if (ld) { 524 if (ld->ops->write_wakeup) 525 ld->ops->write_wakeup(tty); 526 tty_ldisc_deref(ld); 527 } 528 } 529 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 530 } 531 532 EXPORT_SYMBOL_GPL(tty_wakeup); 533 534 /** 535 * __tty_hangup - actual handler for hangup events 536 * @work: tty device 537 * 538 * This can be called by the "eventd" kernel thread. That is process 539 * synchronous but doesn't hold any locks, so we need to make sure we 540 * have the appropriate locks for what we're doing. 541 * 542 * The hangup event clears any pending redirections onto the hung up 543 * device. It ensures future writes will error and it does the needed 544 * line discipline hangup and signal delivery. The tty object itself 545 * remains intact. 546 * 547 * Locking: 548 * BTM 549 * redirect lock for undoing redirection 550 * file list lock for manipulating list of ttys 551 * tty_ldisc_lock from called functions 552 * termios_mutex resetting termios data 553 * tasklist_lock to walk task list for hangup event 554 * ->siglock to protect ->signal/->sighand 555 */ 556 void __tty_hangup(struct tty_struct *tty) 557 { 558 struct file *cons_filp = NULL; 559 struct file *filp, *f = NULL; 560 struct task_struct *p; 561 struct tty_file_private *priv; 562 int closecount = 0, n; 563 unsigned long flags; 564 int refs = 0; 565 566 if (!tty) 567 return; 568 569 570 spin_lock(&redirect_lock); 571 if (redirect && file_tty(redirect) == tty) { 572 f = redirect; 573 redirect = NULL; 574 } 575 spin_unlock(&redirect_lock); 576 577 tty_lock(); 578 579 /* some functions below drop BTM, so we need this bit */ 580 set_bit(TTY_HUPPING, &tty->flags); 581 582 /* inuse_filps is protected by the single tty lock, 583 this really needs to change if we want to flush the 584 workqueue with the lock held */ 585 check_tty_count(tty, "tty_hangup"); 586 587 spin_lock(&tty_files_lock); 588 /* This breaks for file handles being sent over AF_UNIX sockets ? */ 589 list_for_each_entry(priv, &tty->tty_files, list) { 590 filp = priv->file; 591 if (filp->f_op->write == redirected_tty_write) 592 cons_filp = filp; 593 if (filp->f_op->write != tty_write) 594 continue; 595 closecount++; 596 __tty_fasync(-1, filp, 0); /* can't block */ 597 filp->f_op = &hung_up_tty_fops; 598 } 599 spin_unlock(&tty_files_lock); 600 601 /* 602 * it drops BTM and thus races with reopen 603 * we protect the race by TTY_HUPPING 604 */ 605 tty_ldisc_hangup(tty); 606 607 read_lock(&tasklist_lock); 608 if (tty->session) { 609 do_each_pid_task(tty->session, PIDTYPE_SID, p) { 610 spin_lock_irq(&p->sighand->siglock); 611 if (p->signal->tty == tty) { 612 p->signal->tty = NULL; 613 /* We defer the dereferences outside fo 614 the tasklist lock */ 615 refs++; 616 } 617 if (!p->signal->leader) { 618 spin_unlock_irq(&p->sighand->siglock); 619 continue; 620 } 621 __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p); 622 __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p); 623 put_pid(p->signal->tty_old_pgrp); /* A noop */ 624 spin_lock_irqsave(&tty->ctrl_lock, flags); 625 if (tty->pgrp) 626 p->signal->tty_old_pgrp = get_pid(tty->pgrp); 627 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 628 spin_unlock_irq(&p->sighand->siglock); 629 } while_each_pid_task(tty->session, PIDTYPE_SID, p); 630 } 631 read_unlock(&tasklist_lock); 632 633 spin_lock_irqsave(&tty->ctrl_lock, flags); 634 clear_bit(TTY_THROTTLED, &tty->flags); 635 clear_bit(TTY_PUSH, &tty->flags); 636 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags); 637 put_pid(tty->session); 638 put_pid(tty->pgrp); 639 tty->session = NULL; 640 tty->pgrp = NULL; 641 tty->ctrl_status = 0; 642 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 643 644 /* Account for the p->signal references we killed */ 645 while (refs--) 646 tty_kref_put(tty); 647 648 /* 649 * If one of the devices matches a console pointer, we 650 * cannot just call hangup() because that will cause 651 * tty->count and state->count to go out of sync. 652 * So we just call close() the right number of times. 653 */ 654 if (cons_filp) { 655 if (tty->ops->close) 656 for (n = 0; n < closecount; n++) 657 tty->ops->close(tty, cons_filp); 658 } else if (tty->ops->hangup) 659 (tty->ops->hangup)(tty); 660 /* 661 * We don't want to have driver/ldisc interactions beyond 662 * the ones we did here. The driver layer expects no 663 * calls after ->hangup() from the ldisc side. However we 664 * can't yet guarantee all that. 665 */ 666 set_bit(TTY_HUPPED, &tty->flags); 667 clear_bit(TTY_HUPPING, &tty->flags); 668 tty_ldisc_enable(tty); 669 670 tty_unlock(); 671 672 if (f) 673 fput(f); 674 } 675 676 static void do_tty_hangup(struct work_struct *work) 677 { 678 struct tty_struct *tty = 679 container_of(work, struct tty_struct, hangup_work); 680 681 __tty_hangup(tty); 682 } 683 684 /** 685 * tty_hangup - trigger a hangup event 686 * @tty: tty to hangup 687 * 688 * A carrier loss (virtual or otherwise) has occurred on this like 689 * schedule a hangup sequence to run after this event. 690 */ 691 692 void tty_hangup(struct tty_struct *tty) 693 { 694 #ifdef TTY_DEBUG_HANGUP 695 char buf[64]; 696 printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf)); 697 #endif 698 schedule_work(&tty->hangup_work); 699 } 700 701 EXPORT_SYMBOL(tty_hangup); 702 703 /** 704 * tty_vhangup - process vhangup 705 * @tty: tty to hangup 706 * 707 * The user has asked via system call for the terminal to be hung up. 708 * We do this synchronously so that when the syscall returns the process 709 * is complete. That guarantee is necessary for security reasons. 710 */ 711 712 void tty_vhangup(struct tty_struct *tty) 713 { 714 #ifdef TTY_DEBUG_HANGUP 715 char buf[64]; 716 717 printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf)); 718 #endif 719 __tty_hangup(tty); 720 } 721 722 EXPORT_SYMBOL(tty_vhangup); 723 724 725 /** 726 * tty_vhangup_self - process vhangup for own ctty 727 * 728 * Perform a vhangup on the current controlling tty 729 */ 730 731 void tty_vhangup_self(void) 732 { 733 struct tty_struct *tty; 734 735 tty = get_current_tty(); 736 if (tty) { 737 tty_vhangup(tty); 738 tty_kref_put(tty); 739 } 740 } 741 742 /** 743 * tty_hung_up_p - was tty hung up 744 * @filp: file pointer of tty 745 * 746 * Return true if the tty has been subject to a vhangup or a carrier 747 * loss 748 */ 749 750 int tty_hung_up_p(struct file *filp) 751 { 752 return (filp->f_op == &hung_up_tty_fops); 753 } 754 755 EXPORT_SYMBOL(tty_hung_up_p); 756 757 static void session_clear_tty(struct pid *session) 758 { 759 struct task_struct *p; 760 do_each_pid_task(session, PIDTYPE_SID, p) { 761 proc_clear_tty(p); 762 } while_each_pid_task(session, PIDTYPE_SID, p); 763 } 764 765 /** 766 * disassociate_ctty - disconnect controlling tty 767 * @on_exit: true if exiting so need to "hang up" the session 768 * 769 * This function is typically called only by the session leader, when 770 * it wants to disassociate itself from its controlling tty. 771 * 772 * It performs the following functions: 773 * (1) Sends a SIGHUP and SIGCONT to the foreground process group 774 * (2) Clears the tty from being controlling the session 775 * (3) Clears the controlling tty for all processes in the 776 * session group. 777 * 778 * The argument on_exit is set to 1 if called when a process is 779 * exiting; it is 0 if called by the ioctl TIOCNOTTY. 780 * 781 * Locking: 782 * BTM is taken for hysterical raisins, and held when 783 * called from no_tty(). 784 * tty_mutex is taken to protect tty 785 * ->siglock is taken to protect ->signal/->sighand 786 * tasklist_lock is taken to walk process list for sessions 787 * ->siglock is taken to protect ->signal/->sighand 788 */ 789 790 void disassociate_ctty(int on_exit) 791 { 792 struct tty_struct *tty; 793 794 if (!current->signal->leader) 795 return; 796 797 tty = get_current_tty(); 798 if (tty) { 799 struct pid *tty_pgrp = get_pid(tty->pgrp); 800 if (on_exit) { 801 if (tty->driver->type != TTY_DRIVER_TYPE_PTY) 802 tty_vhangup(tty); 803 } 804 tty_kref_put(tty); 805 if (tty_pgrp) { 806 kill_pgrp(tty_pgrp, SIGHUP, on_exit); 807 if (!on_exit) 808 kill_pgrp(tty_pgrp, SIGCONT, on_exit); 809 put_pid(tty_pgrp); 810 } 811 } else if (on_exit) { 812 struct pid *old_pgrp; 813 spin_lock_irq(¤t->sighand->siglock); 814 old_pgrp = current->signal->tty_old_pgrp; 815 current->signal->tty_old_pgrp = NULL; 816 spin_unlock_irq(¤t->sighand->siglock); 817 if (old_pgrp) { 818 kill_pgrp(old_pgrp, SIGHUP, on_exit); 819 kill_pgrp(old_pgrp, SIGCONT, on_exit); 820 put_pid(old_pgrp); 821 } 822 return; 823 } 824 825 spin_lock_irq(¤t->sighand->siglock); 826 put_pid(current->signal->tty_old_pgrp); 827 current->signal->tty_old_pgrp = NULL; 828 spin_unlock_irq(¤t->sighand->siglock); 829 830 tty = get_current_tty(); 831 if (tty) { 832 unsigned long flags; 833 spin_lock_irqsave(&tty->ctrl_lock, flags); 834 put_pid(tty->session); 835 put_pid(tty->pgrp); 836 tty->session = NULL; 837 tty->pgrp = NULL; 838 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 839 tty_kref_put(tty); 840 } else { 841 #ifdef TTY_DEBUG_HANGUP 842 printk(KERN_DEBUG "error attempted to write to tty [0x%p]" 843 " = NULL", tty); 844 #endif 845 } 846 847 /* Now clear signal->tty under the lock */ 848 read_lock(&tasklist_lock); 849 session_clear_tty(task_session(current)); 850 read_unlock(&tasklist_lock); 851 } 852 853 /** 854 * 855 * no_tty - Ensure the current process does not have a controlling tty 856 */ 857 void no_tty(void) 858 { 859 struct task_struct *tsk = current; 860 tty_lock(); 861 disassociate_ctty(0); 862 tty_unlock(); 863 proc_clear_tty(tsk); 864 } 865 866 867 /** 868 * stop_tty - propagate flow control 869 * @tty: tty to stop 870 * 871 * Perform flow control to the driver. For PTY/TTY pairs we 872 * must also propagate the TIOCKPKT status. May be called 873 * on an already stopped device and will not re-call the driver 874 * method. 875 * 876 * This functionality is used by both the line disciplines for 877 * halting incoming flow and by the driver. It may therefore be 878 * called from any context, may be under the tty atomic_write_lock 879 * but not always. 880 * 881 * Locking: 882 * Uses the tty control lock internally 883 */ 884 885 void stop_tty(struct tty_struct *tty) 886 { 887 unsigned long flags; 888 spin_lock_irqsave(&tty->ctrl_lock, flags); 889 if (tty->stopped) { 890 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 891 return; 892 } 893 tty->stopped = 1; 894 if (tty->link && tty->link->packet) { 895 tty->ctrl_status &= ~TIOCPKT_START; 896 tty->ctrl_status |= TIOCPKT_STOP; 897 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN); 898 } 899 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 900 if (tty->ops->stop) 901 (tty->ops->stop)(tty); 902 } 903 904 EXPORT_SYMBOL(stop_tty); 905 906 /** 907 * start_tty - propagate flow control 908 * @tty: tty to start 909 * 910 * Start a tty that has been stopped if at all possible. Perform 911 * any necessary wakeups and propagate the TIOCPKT status. If this 912 * is the tty was previous stopped and is being started then the 913 * driver start method is invoked and the line discipline woken. 914 * 915 * Locking: 916 * ctrl_lock 917 */ 918 919 void start_tty(struct tty_struct *tty) 920 { 921 unsigned long flags; 922 spin_lock_irqsave(&tty->ctrl_lock, flags); 923 if (!tty->stopped || tty->flow_stopped) { 924 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 925 return; 926 } 927 tty->stopped = 0; 928 if (tty->link && tty->link->packet) { 929 tty->ctrl_status &= ~TIOCPKT_STOP; 930 tty->ctrl_status |= TIOCPKT_START; 931 wake_up_interruptible_poll(&tty->link->read_wait, POLLIN); 932 } 933 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 934 if (tty->ops->start) 935 (tty->ops->start)(tty); 936 /* If we have a running line discipline it may need kicking */ 937 tty_wakeup(tty); 938 } 939 940 EXPORT_SYMBOL(start_tty); 941 942 /** 943 * tty_read - read method for tty device files 944 * @file: pointer to tty file 945 * @buf: user buffer 946 * @count: size of user buffer 947 * @ppos: unused 948 * 949 * Perform the read system call function on this terminal device. Checks 950 * for hung up devices before calling the line discipline method. 951 * 952 * Locking: 953 * Locks the line discipline internally while needed. Multiple 954 * read calls may be outstanding in parallel. 955 */ 956 957 static ssize_t tty_read(struct file *file, char __user *buf, size_t count, 958 loff_t *ppos) 959 { 960 int i; 961 struct inode *inode = file->f_path.dentry->d_inode; 962 struct tty_struct *tty = file_tty(file); 963 struct tty_ldisc *ld; 964 965 if (tty_paranoia_check(tty, inode, "tty_read")) 966 return -EIO; 967 if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags))) 968 return -EIO; 969 970 /* We want to wait for the line discipline to sort out in this 971 situation */ 972 ld = tty_ldisc_ref_wait(tty); 973 if (ld->ops->read) 974 i = (ld->ops->read)(tty, file, buf, count); 975 else 976 i = -EIO; 977 tty_ldisc_deref(ld); 978 if (i > 0) 979 inode->i_atime = current_fs_time(inode->i_sb); 980 return i; 981 } 982 983 void tty_write_unlock(struct tty_struct *tty) 984 __releases(&tty->atomic_write_lock) 985 { 986 mutex_unlock(&tty->atomic_write_lock); 987 wake_up_interruptible_poll(&tty->write_wait, POLLOUT); 988 } 989 990 int tty_write_lock(struct tty_struct *tty, int ndelay) 991 __acquires(&tty->atomic_write_lock) 992 { 993 if (!mutex_trylock(&tty->atomic_write_lock)) { 994 if (ndelay) 995 return -EAGAIN; 996 if (mutex_lock_interruptible(&tty->atomic_write_lock)) 997 return -ERESTARTSYS; 998 } 999 return 0; 1000 } 1001 1002 /* 1003 * Split writes up in sane blocksizes to avoid 1004 * denial-of-service type attacks 1005 */ 1006 static inline ssize_t do_tty_write( 1007 ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t), 1008 struct tty_struct *tty, 1009 struct file *file, 1010 const char __user *buf, 1011 size_t count) 1012 { 1013 ssize_t ret, written = 0; 1014 unsigned int chunk; 1015 1016 ret = tty_write_lock(tty, file->f_flags & O_NDELAY); 1017 if (ret < 0) 1018 return ret; 1019 1020 /* 1021 * We chunk up writes into a temporary buffer. This 1022 * simplifies low-level drivers immensely, since they 1023 * don't have locking issues and user mode accesses. 1024 * 1025 * But if TTY_NO_WRITE_SPLIT is set, we should use a 1026 * big chunk-size.. 1027 * 1028 * The default chunk-size is 2kB, because the NTTY 1029 * layer has problems with bigger chunks. It will 1030 * claim to be able to handle more characters than 1031 * it actually does. 1032 * 1033 * FIXME: This can probably go away now except that 64K chunks 1034 * are too likely to fail unless switched to vmalloc... 1035 */ 1036 chunk = 2048; 1037 if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags)) 1038 chunk = 65536; 1039 if (count < chunk) 1040 chunk = count; 1041 1042 /* write_buf/write_cnt is protected by the atomic_write_lock mutex */ 1043 if (tty->write_cnt < chunk) { 1044 unsigned char *buf_chunk; 1045 1046 if (chunk < 1024) 1047 chunk = 1024; 1048 1049 buf_chunk = kmalloc(chunk, GFP_KERNEL); 1050 if (!buf_chunk) { 1051 ret = -ENOMEM; 1052 goto out; 1053 } 1054 kfree(tty->write_buf); 1055 tty->write_cnt = chunk; 1056 tty->write_buf = buf_chunk; 1057 } 1058 1059 /* Do the write .. */ 1060 for (;;) { 1061 size_t size = count; 1062 if (size > chunk) 1063 size = chunk; 1064 ret = -EFAULT; 1065 if (copy_from_user(tty->write_buf, buf, size)) 1066 break; 1067 ret = write(tty, file, tty->write_buf, size); 1068 if (ret <= 0) 1069 break; 1070 written += ret; 1071 buf += ret; 1072 count -= ret; 1073 if (!count) 1074 break; 1075 ret = -ERESTARTSYS; 1076 if (signal_pending(current)) 1077 break; 1078 cond_resched(); 1079 } 1080 if (written) { 1081 struct inode *inode = file->f_path.dentry->d_inode; 1082 inode->i_mtime = current_fs_time(inode->i_sb); 1083 ret = written; 1084 } 1085 out: 1086 tty_write_unlock(tty); 1087 return ret; 1088 } 1089 1090 /** 1091 * tty_write_message - write a message to a certain tty, not just the console. 1092 * @tty: the destination tty_struct 1093 * @msg: the message to write 1094 * 1095 * This is used for messages that need to be redirected to a specific tty. 1096 * We don't put it into the syslog queue right now maybe in the future if 1097 * really needed. 1098 * 1099 * We must still hold the BTM and test the CLOSING flag for the moment. 1100 */ 1101 1102 void tty_write_message(struct tty_struct *tty, char *msg) 1103 { 1104 if (tty) { 1105 mutex_lock(&tty->atomic_write_lock); 1106 tty_lock(); 1107 if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) { 1108 tty_unlock(); 1109 tty->ops->write(tty, msg, strlen(msg)); 1110 } else 1111 tty_unlock(); 1112 tty_write_unlock(tty); 1113 } 1114 return; 1115 } 1116 1117 1118 /** 1119 * tty_write - write method for tty device file 1120 * @file: tty file pointer 1121 * @buf: user data to write 1122 * @count: bytes to write 1123 * @ppos: unused 1124 * 1125 * Write data to a tty device via the line discipline. 1126 * 1127 * Locking: 1128 * Locks the line discipline as required 1129 * Writes to the tty driver are serialized by the atomic_write_lock 1130 * and are then processed in chunks to the device. The line discipline 1131 * write method will not be invoked in parallel for each device. 1132 */ 1133 1134 static ssize_t tty_write(struct file *file, const char __user *buf, 1135 size_t count, loff_t *ppos) 1136 { 1137 struct inode *inode = file->f_path.dentry->d_inode; 1138 struct tty_struct *tty = file_tty(file); 1139 struct tty_ldisc *ld; 1140 ssize_t ret; 1141 1142 if (tty_paranoia_check(tty, inode, "tty_write")) 1143 return -EIO; 1144 if (!tty || !tty->ops->write || 1145 (test_bit(TTY_IO_ERROR, &tty->flags))) 1146 return -EIO; 1147 /* Short term debug to catch buggy drivers */ 1148 if (tty->ops->write_room == NULL) 1149 printk(KERN_ERR "tty driver %s lacks a write_room method.\n", 1150 tty->driver->name); 1151 ld = tty_ldisc_ref_wait(tty); 1152 if (!ld->ops->write) 1153 ret = -EIO; 1154 else 1155 ret = do_tty_write(ld->ops->write, tty, file, buf, count); 1156 tty_ldisc_deref(ld); 1157 return ret; 1158 } 1159 1160 ssize_t redirected_tty_write(struct file *file, const char __user *buf, 1161 size_t count, loff_t *ppos) 1162 { 1163 struct file *p = NULL; 1164 1165 spin_lock(&redirect_lock); 1166 if (redirect) { 1167 get_file(redirect); 1168 p = redirect; 1169 } 1170 spin_unlock(&redirect_lock); 1171 1172 if (p) { 1173 ssize_t res; 1174 res = vfs_write(p, buf, count, &p->f_pos); 1175 fput(p); 1176 return res; 1177 } 1178 return tty_write(file, buf, count, ppos); 1179 } 1180 1181 static char ptychar[] = "pqrstuvwxyzabcde"; 1182 1183 /** 1184 * pty_line_name - generate name for a pty 1185 * @driver: the tty driver in use 1186 * @index: the minor number 1187 * @p: output buffer of at least 6 bytes 1188 * 1189 * Generate a name from a driver reference and write it to the output 1190 * buffer. 1191 * 1192 * Locking: None 1193 */ 1194 static void pty_line_name(struct tty_driver *driver, int index, char *p) 1195 { 1196 int i = index + driver->name_base; 1197 /* ->name is initialized to "ttyp", but "tty" is expected */ 1198 sprintf(p, "%s%c%x", 1199 driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name, 1200 ptychar[i >> 4 & 0xf], i & 0xf); 1201 } 1202 1203 /** 1204 * tty_line_name - generate name for a tty 1205 * @driver: the tty driver in use 1206 * @index: the minor number 1207 * @p: output buffer of at least 7 bytes 1208 * 1209 * Generate a name from a driver reference and write it to the output 1210 * buffer. 1211 * 1212 * Locking: None 1213 */ 1214 static void tty_line_name(struct tty_driver *driver, int index, char *p) 1215 { 1216 sprintf(p, "%s%d", driver->name, index + driver->name_base); 1217 } 1218 1219 /** 1220 * tty_driver_lookup_tty() - find an existing tty, if any 1221 * @driver: the driver for the tty 1222 * @idx: the minor number 1223 * 1224 * Return the tty, if found or ERR_PTR() otherwise. 1225 * 1226 * Locking: tty_mutex must be held. If tty is found, the mutex must 1227 * be held until the 'fast-open' is also done. Will change once we 1228 * have refcounting in the driver and per driver locking 1229 */ 1230 static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver, 1231 struct inode *inode, int idx) 1232 { 1233 struct tty_struct *tty; 1234 1235 if (driver->ops->lookup) 1236 return driver->ops->lookup(driver, inode, idx); 1237 1238 tty = driver->ttys[idx]; 1239 return tty; 1240 } 1241 1242 /** 1243 * tty_init_termios - helper for termios setup 1244 * @tty: the tty to set up 1245 * 1246 * Initialise the termios structures for this tty. Thus runs under 1247 * the tty_mutex currently so we can be relaxed about ordering. 1248 */ 1249 1250 int tty_init_termios(struct tty_struct *tty) 1251 { 1252 struct ktermios *tp; 1253 int idx = tty->index; 1254 1255 tp = tty->driver->termios[idx]; 1256 if (tp == NULL) { 1257 tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL); 1258 if (tp == NULL) 1259 return -ENOMEM; 1260 memcpy(tp, &tty->driver->init_termios, 1261 sizeof(struct ktermios)); 1262 tty->driver->termios[idx] = tp; 1263 } 1264 tty->termios = tp; 1265 tty->termios_locked = tp + 1; 1266 1267 /* Compatibility until drivers always set this */ 1268 tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios); 1269 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios); 1270 return 0; 1271 } 1272 EXPORT_SYMBOL_GPL(tty_init_termios); 1273 1274 /** 1275 * tty_driver_install_tty() - install a tty entry in the driver 1276 * @driver: the driver for the tty 1277 * @tty: the tty 1278 * 1279 * Install a tty object into the driver tables. The tty->index field 1280 * will be set by the time this is called. This method is responsible 1281 * for ensuring any need additional structures are allocated and 1282 * configured. 1283 * 1284 * Locking: tty_mutex for now 1285 */ 1286 static int tty_driver_install_tty(struct tty_driver *driver, 1287 struct tty_struct *tty) 1288 { 1289 int idx = tty->index; 1290 int ret; 1291 1292 if (driver->ops->install) { 1293 ret = driver->ops->install(driver, tty); 1294 return ret; 1295 } 1296 1297 if (tty_init_termios(tty) == 0) { 1298 tty_driver_kref_get(driver); 1299 tty->count++; 1300 driver->ttys[idx] = tty; 1301 return 0; 1302 } 1303 return -ENOMEM; 1304 } 1305 1306 /** 1307 * tty_driver_remove_tty() - remove a tty from the driver tables 1308 * @driver: the driver for the tty 1309 * @idx: the minor number 1310 * 1311 * Remvoe a tty object from the driver tables. The tty->index field 1312 * will be set by the time this is called. 1313 * 1314 * Locking: tty_mutex for now 1315 */ 1316 void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty) 1317 { 1318 if (driver->ops->remove) 1319 driver->ops->remove(driver, tty); 1320 else 1321 driver->ttys[tty->index] = NULL; 1322 } 1323 1324 /* 1325 * tty_reopen() - fast re-open of an open tty 1326 * @tty - the tty to open 1327 * 1328 * Return 0 on success, -errno on error. 1329 * 1330 * Locking: tty_mutex must be held from the time the tty was found 1331 * till this open completes. 1332 */ 1333 static int tty_reopen(struct tty_struct *tty) 1334 { 1335 struct tty_driver *driver = tty->driver; 1336 1337 if (test_bit(TTY_CLOSING, &tty->flags) || 1338 test_bit(TTY_HUPPING, &tty->flags) || 1339 test_bit(TTY_LDISC_CHANGING, &tty->flags)) 1340 return -EIO; 1341 1342 if (driver->type == TTY_DRIVER_TYPE_PTY && 1343 driver->subtype == PTY_TYPE_MASTER) { 1344 /* 1345 * special case for PTY masters: only one open permitted, 1346 * and the slave side open count is incremented as well. 1347 */ 1348 if (tty->count) 1349 return -EIO; 1350 1351 tty->link->count++; 1352 } 1353 tty->count++; 1354 tty->driver = driver; /* N.B. why do this every time?? */ 1355 1356 mutex_lock(&tty->ldisc_mutex); 1357 WARN_ON(!test_bit(TTY_LDISC, &tty->flags)); 1358 mutex_unlock(&tty->ldisc_mutex); 1359 1360 return 0; 1361 } 1362 1363 /** 1364 * tty_init_dev - initialise a tty device 1365 * @driver: tty driver we are opening a device on 1366 * @idx: device index 1367 * @ret_tty: returned tty structure 1368 * @first_ok: ok to open a new device (used by ptmx) 1369 * 1370 * Prepare a tty device. This may not be a "new" clean device but 1371 * could also be an active device. The pty drivers require special 1372 * handling because of this. 1373 * 1374 * Locking: 1375 * The function is called under the tty_mutex, which 1376 * protects us from the tty struct or driver itself going away. 1377 * 1378 * On exit the tty device has the line discipline attached and 1379 * a reference count of 1. If a pair was created for pty/tty use 1380 * and the other was a pty master then it too has a reference count of 1. 1381 * 1382 * WSH 06/09/97: Rewritten to remove races and properly clean up after a 1383 * failed open. The new code protects the open with a mutex, so it's 1384 * really quite straightforward. The mutex locking can probably be 1385 * relaxed for the (most common) case of reopening a tty. 1386 */ 1387 1388 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx, 1389 int first_ok) 1390 { 1391 struct tty_struct *tty; 1392 int retval; 1393 1394 /* Check if pty master is being opened multiple times */ 1395 if (driver->subtype == PTY_TYPE_MASTER && 1396 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) { 1397 return ERR_PTR(-EIO); 1398 } 1399 1400 /* 1401 * First time open is complex, especially for PTY devices. 1402 * This code guarantees that either everything succeeds and the 1403 * TTY is ready for operation, or else the table slots are vacated 1404 * and the allocated memory released. (Except that the termios 1405 * and locked termios may be retained.) 1406 */ 1407 1408 if (!try_module_get(driver->owner)) 1409 return ERR_PTR(-ENODEV); 1410 1411 tty = alloc_tty_struct(); 1412 if (!tty) { 1413 retval = -ENOMEM; 1414 goto err_module_put; 1415 } 1416 initialize_tty_struct(tty, driver, idx); 1417 1418 retval = tty_driver_install_tty(driver, tty); 1419 if (retval < 0) 1420 goto err_deinit_tty; 1421 1422 /* 1423 * Structures all installed ... call the ldisc open routines. 1424 * If we fail here just call release_tty to clean up. No need 1425 * to decrement the use counts, as release_tty doesn't care. 1426 */ 1427 retval = tty_ldisc_setup(tty, tty->link); 1428 if (retval) 1429 goto err_release_tty; 1430 return tty; 1431 1432 err_deinit_tty: 1433 deinitialize_tty_struct(tty); 1434 free_tty_struct(tty); 1435 err_module_put: 1436 module_put(driver->owner); 1437 return ERR_PTR(retval); 1438 1439 /* call the tty release_tty routine to clean out this slot */ 1440 err_release_tty: 1441 printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, " 1442 "clearing slot %d\n", idx); 1443 release_tty(tty, idx); 1444 return ERR_PTR(retval); 1445 } 1446 1447 void tty_free_termios(struct tty_struct *tty) 1448 { 1449 struct ktermios *tp; 1450 int idx = tty->index; 1451 /* Kill this flag and push into drivers for locking etc */ 1452 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) { 1453 /* FIXME: Locking on ->termios array */ 1454 tp = tty->termios; 1455 tty->driver->termios[idx] = NULL; 1456 kfree(tp); 1457 } 1458 } 1459 EXPORT_SYMBOL(tty_free_termios); 1460 1461 void tty_shutdown(struct tty_struct *tty) 1462 { 1463 tty_driver_remove_tty(tty->driver, tty); 1464 tty_free_termios(tty); 1465 } 1466 EXPORT_SYMBOL(tty_shutdown); 1467 1468 /** 1469 * release_one_tty - release tty structure memory 1470 * @kref: kref of tty we are obliterating 1471 * 1472 * Releases memory associated with a tty structure, and clears out the 1473 * driver table slots. This function is called when a device is no longer 1474 * in use. It also gets called when setup of a device fails. 1475 * 1476 * Locking: 1477 * tty_mutex - sometimes only 1478 * takes the file list lock internally when working on the list 1479 * of ttys that the driver keeps. 1480 * 1481 * This method gets called from a work queue so that the driver private 1482 * cleanup ops can sleep (needed for USB at least) 1483 */ 1484 static void release_one_tty(struct work_struct *work) 1485 { 1486 struct tty_struct *tty = 1487 container_of(work, struct tty_struct, hangup_work); 1488 struct tty_driver *driver = tty->driver; 1489 1490 if (tty->ops->cleanup) 1491 tty->ops->cleanup(tty); 1492 1493 tty->magic = 0; 1494 tty_driver_kref_put(driver); 1495 module_put(driver->owner); 1496 1497 spin_lock(&tty_files_lock); 1498 list_del_init(&tty->tty_files); 1499 spin_unlock(&tty_files_lock); 1500 1501 put_pid(tty->pgrp); 1502 put_pid(tty->session); 1503 free_tty_struct(tty); 1504 } 1505 1506 static void queue_release_one_tty(struct kref *kref) 1507 { 1508 struct tty_struct *tty = container_of(kref, struct tty_struct, kref); 1509 1510 if (tty->ops->shutdown) 1511 tty->ops->shutdown(tty); 1512 else 1513 tty_shutdown(tty); 1514 1515 /* The hangup queue is now free so we can reuse it rather than 1516 waste a chunk of memory for each port */ 1517 INIT_WORK(&tty->hangup_work, release_one_tty); 1518 schedule_work(&tty->hangup_work); 1519 } 1520 1521 /** 1522 * tty_kref_put - release a tty kref 1523 * @tty: tty device 1524 * 1525 * Release a reference to a tty device and if need be let the kref 1526 * layer destruct the object for us 1527 */ 1528 1529 void tty_kref_put(struct tty_struct *tty) 1530 { 1531 if (tty) 1532 kref_put(&tty->kref, queue_release_one_tty); 1533 } 1534 EXPORT_SYMBOL(tty_kref_put); 1535 1536 /** 1537 * release_tty - release tty structure memory 1538 * 1539 * Release both @tty and a possible linked partner (think pty pair), 1540 * and decrement the refcount of the backing module. 1541 * 1542 * Locking: 1543 * tty_mutex - sometimes only 1544 * takes the file list lock internally when working on the list 1545 * of ttys that the driver keeps. 1546 * FIXME: should we require tty_mutex is held here ?? 1547 * 1548 */ 1549 static void release_tty(struct tty_struct *tty, int idx) 1550 { 1551 /* This should always be true but check for the moment */ 1552 WARN_ON(tty->index != idx); 1553 1554 if (tty->link) 1555 tty_kref_put(tty->link); 1556 tty_kref_put(tty); 1557 } 1558 1559 /** 1560 * tty_release_checks - check a tty before real release 1561 * @tty: tty to check 1562 * @o_tty: link of @tty (if any) 1563 * @idx: index of the tty 1564 * 1565 * Performs some paranoid checking before true release of the @tty. 1566 * This is a no-op unless TTY_PARANOIA_CHECK is defined. 1567 */ 1568 static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty, 1569 int idx) 1570 { 1571 #ifdef TTY_PARANOIA_CHECK 1572 if (idx < 0 || idx >= tty->driver->num) { 1573 printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n", 1574 __func__, tty->name); 1575 return -1; 1576 } 1577 1578 /* not much to check for devpts */ 1579 if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) 1580 return 0; 1581 1582 if (tty != tty->driver->ttys[idx]) { 1583 printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n", 1584 __func__, idx, tty->name); 1585 return -1; 1586 } 1587 if (tty->termios != tty->driver->termios[idx]) { 1588 printk(KERN_DEBUG "%s: driver.termios[%d] not termios for (%s)\n", 1589 __func__, idx, tty->name); 1590 return -1; 1591 } 1592 if (tty->driver->other) { 1593 if (o_tty != tty->driver->other->ttys[idx]) { 1594 printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n", 1595 __func__, idx, tty->name); 1596 return -1; 1597 } 1598 if (o_tty->termios != tty->driver->other->termios[idx]) { 1599 printk(KERN_DEBUG "%s: other->termios[%d] not o_termios for (%s)\n", 1600 __func__, idx, tty->name); 1601 return -1; 1602 } 1603 if (o_tty->link != tty) { 1604 printk(KERN_DEBUG "%s: bad pty pointers\n", __func__); 1605 return -1; 1606 } 1607 } 1608 #endif 1609 return 0; 1610 } 1611 1612 /** 1613 * tty_release - vfs callback for close 1614 * @inode: inode of tty 1615 * @filp: file pointer for handle to tty 1616 * 1617 * Called the last time each file handle is closed that references 1618 * this tty. There may however be several such references. 1619 * 1620 * Locking: 1621 * Takes bkl. See tty_release_dev 1622 * 1623 * Even releasing the tty structures is a tricky business.. We have 1624 * to be very careful that the structures are all released at the 1625 * same time, as interrupts might otherwise get the wrong pointers. 1626 * 1627 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could 1628 * lead to double frees or releasing memory still in use. 1629 */ 1630 1631 int tty_release(struct inode *inode, struct file *filp) 1632 { 1633 struct tty_struct *tty = file_tty(filp); 1634 struct tty_struct *o_tty; 1635 int pty_master, tty_closing, o_tty_closing, do_sleep; 1636 int devpts; 1637 int idx; 1638 char buf[64]; 1639 1640 if (tty_paranoia_check(tty, inode, __func__)) 1641 return 0; 1642 1643 tty_lock(); 1644 check_tty_count(tty, __func__); 1645 1646 __tty_fasync(-1, filp, 0); 1647 1648 idx = tty->index; 1649 pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY && 1650 tty->driver->subtype == PTY_TYPE_MASTER); 1651 devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0; 1652 o_tty = tty->link; 1653 1654 if (tty_release_checks(tty, o_tty, idx)) { 1655 tty_unlock(); 1656 return 0; 1657 } 1658 1659 #ifdef TTY_DEBUG_HANGUP 1660 printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__, 1661 tty_name(tty, buf), tty->count); 1662 #endif 1663 1664 if (tty->ops->close) 1665 tty->ops->close(tty, filp); 1666 1667 tty_unlock(); 1668 /* 1669 * Sanity check: if tty->count is going to zero, there shouldn't be 1670 * any waiters on tty->read_wait or tty->write_wait. We test the 1671 * wait queues and kick everyone out _before_ actually starting to 1672 * close. This ensures that we won't block while releasing the tty 1673 * structure. 1674 * 1675 * The test for the o_tty closing is necessary, since the master and 1676 * slave sides may close in any order. If the slave side closes out 1677 * first, its count will be one, since the master side holds an open. 1678 * Thus this test wouldn't be triggered at the time the slave closes, 1679 * so we do it now. 1680 * 1681 * Note that it's possible for the tty to be opened again while we're 1682 * flushing out waiters. By recalculating the closing flags before 1683 * each iteration we avoid any problems. 1684 */ 1685 while (1) { 1686 /* Guard against races with tty->count changes elsewhere and 1687 opens on /dev/tty */ 1688 1689 mutex_lock(&tty_mutex); 1690 tty_lock(); 1691 tty_closing = tty->count <= 1; 1692 o_tty_closing = o_tty && 1693 (o_tty->count <= (pty_master ? 1 : 0)); 1694 do_sleep = 0; 1695 1696 if (tty_closing) { 1697 if (waitqueue_active(&tty->read_wait)) { 1698 wake_up_poll(&tty->read_wait, POLLIN); 1699 do_sleep++; 1700 } 1701 if (waitqueue_active(&tty->write_wait)) { 1702 wake_up_poll(&tty->write_wait, POLLOUT); 1703 do_sleep++; 1704 } 1705 } 1706 if (o_tty_closing) { 1707 if (waitqueue_active(&o_tty->read_wait)) { 1708 wake_up_poll(&o_tty->read_wait, POLLIN); 1709 do_sleep++; 1710 } 1711 if (waitqueue_active(&o_tty->write_wait)) { 1712 wake_up_poll(&o_tty->write_wait, POLLOUT); 1713 do_sleep++; 1714 } 1715 } 1716 if (!do_sleep) 1717 break; 1718 1719 printk(KERN_WARNING "%s: %s: read/write wait queue active!\n", 1720 __func__, tty_name(tty, buf)); 1721 tty_unlock(); 1722 mutex_unlock(&tty_mutex); 1723 schedule(); 1724 } 1725 1726 /* 1727 * The closing flags are now consistent with the open counts on 1728 * both sides, and we've completed the last operation that could 1729 * block, so it's safe to proceed with closing. 1730 */ 1731 if (pty_master) { 1732 if (--o_tty->count < 0) { 1733 printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n", 1734 __func__, o_tty->count, tty_name(o_tty, buf)); 1735 o_tty->count = 0; 1736 } 1737 } 1738 if (--tty->count < 0) { 1739 printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n", 1740 __func__, tty->count, tty_name(tty, buf)); 1741 tty->count = 0; 1742 } 1743 1744 /* 1745 * We've decremented tty->count, so we need to remove this file 1746 * descriptor off the tty->tty_files list; this serves two 1747 * purposes: 1748 * - check_tty_count sees the correct number of file descriptors 1749 * associated with this tty. 1750 * - do_tty_hangup no longer sees this file descriptor as 1751 * something that needs to be handled for hangups. 1752 */ 1753 tty_del_file(filp); 1754 1755 /* 1756 * Perform some housekeeping before deciding whether to return. 1757 * 1758 * Set the TTY_CLOSING flag if this was the last open. In the 1759 * case of a pty we may have to wait around for the other side 1760 * to close, and TTY_CLOSING makes sure we can't be reopened. 1761 */ 1762 if (tty_closing) 1763 set_bit(TTY_CLOSING, &tty->flags); 1764 if (o_tty_closing) 1765 set_bit(TTY_CLOSING, &o_tty->flags); 1766 1767 /* 1768 * If _either_ side is closing, make sure there aren't any 1769 * processes that still think tty or o_tty is their controlling 1770 * tty. 1771 */ 1772 if (tty_closing || o_tty_closing) { 1773 read_lock(&tasklist_lock); 1774 session_clear_tty(tty->session); 1775 if (o_tty) 1776 session_clear_tty(o_tty->session); 1777 read_unlock(&tasklist_lock); 1778 } 1779 1780 mutex_unlock(&tty_mutex); 1781 1782 /* check whether both sides are closing ... */ 1783 if (!tty_closing || (o_tty && !o_tty_closing)) { 1784 tty_unlock(); 1785 return 0; 1786 } 1787 1788 #ifdef TTY_DEBUG_HANGUP 1789 printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__); 1790 #endif 1791 /* 1792 * Ask the line discipline code to release its structures 1793 */ 1794 tty_ldisc_release(tty, o_tty); 1795 /* 1796 * The release_tty function takes care of the details of clearing 1797 * the slots and preserving the termios structure. 1798 */ 1799 release_tty(tty, idx); 1800 1801 /* Make this pty number available for reallocation */ 1802 if (devpts) 1803 devpts_kill_index(inode, idx); 1804 tty_unlock(); 1805 return 0; 1806 } 1807 1808 /** 1809 * tty_open_current_tty - get tty of current task for open 1810 * @device: device number 1811 * @filp: file pointer to tty 1812 * @return: tty of the current task iff @device is /dev/tty 1813 * 1814 * We cannot return driver and index like for the other nodes because 1815 * devpts will not work then. It expects inodes to be from devpts FS. 1816 */ 1817 static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp) 1818 { 1819 struct tty_struct *tty; 1820 1821 if (device != MKDEV(TTYAUX_MAJOR, 0)) 1822 return NULL; 1823 1824 tty = get_current_tty(); 1825 if (!tty) 1826 return ERR_PTR(-ENXIO); 1827 1828 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */ 1829 /* noctty = 1; */ 1830 tty_kref_put(tty); 1831 /* FIXME: we put a reference and return a TTY! */ 1832 return tty; 1833 } 1834 1835 /** 1836 * tty_lookup_driver - lookup a tty driver for a given device file 1837 * @device: device number 1838 * @filp: file pointer to tty 1839 * @noctty: set if the device should not become a controlling tty 1840 * @index: index for the device in the @return driver 1841 * @return: driver for this inode (with increased refcount) 1842 * 1843 * If @return is not erroneous, the caller is responsible to decrement the 1844 * refcount by tty_driver_kref_put. 1845 * 1846 * Locking: tty_mutex protects get_tty_driver 1847 */ 1848 static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp, 1849 int *noctty, int *index) 1850 { 1851 struct tty_driver *driver; 1852 1853 switch (device) { 1854 #ifdef CONFIG_VT 1855 case MKDEV(TTY_MAJOR, 0): { 1856 extern struct tty_driver *console_driver; 1857 driver = tty_driver_kref_get(console_driver); 1858 *index = fg_console; 1859 *noctty = 1; 1860 break; 1861 } 1862 #endif 1863 case MKDEV(TTYAUX_MAJOR, 1): { 1864 struct tty_driver *console_driver = console_device(index); 1865 if (console_driver) { 1866 driver = tty_driver_kref_get(console_driver); 1867 if (driver) { 1868 /* Don't let /dev/console block */ 1869 filp->f_flags |= O_NONBLOCK; 1870 *noctty = 1; 1871 break; 1872 } 1873 } 1874 return ERR_PTR(-ENODEV); 1875 } 1876 default: 1877 driver = get_tty_driver(device, index); 1878 if (!driver) 1879 return ERR_PTR(-ENODEV); 1880 break; 1881 } 1882 return driver; 1883 } 1884 1885 /** 1886 * tty_open - open a tty device 1887 * @inode: inode of device file 1888 * @filp: file pointer to tty 1889 * 1890 * tty_open and tty_release keep up the tty count that contains the 1891 * number of opens done on a tty. We cannot use the inode-count, as 1892 * different inodes might point to the same tty. 1893 * 1894 * Open-counting is needed for pty masters, as well as for keeping 1895 * track of serial lines: DTR is dropped when the last close happens. 1896 * (This is not done solely through tty->count, now. - Ted 1/27/92) 1897 * 1898 * The termios state of a pty is reset on first open so that 1899 * settings don't persist across reuse. 1900 * 1901 * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev. 1902 * tty->count should protect the rest. 1903 * ->siglock protects ->signal/->sighand 1904 */ 1905 1906 static int tty_open(struct inode *inode, struct file *filp) 1907 { 1908 struct tty_struct *tty; 1909 int noctty, retval; 1910 struct tty_driver *driver = NULL; 1911 int index; 1912 dev_t device = inode->i_rdev; 1913 unsigned saved_flags = filp->f_flags; 1914 1915 nonseekable_open(inode, filp); 1916 1917 retry_open: 1918 retval = tty_alloc_file(filp); 1919 if (retval) 1920 return -ENOMEM; 1921 1922 noctty = filp->f_flags & O_NOCTTY; 1923 index = -1; 1924 retval = 0; 1925 1926 mutex_lock(&tty_mutex); 1927 tty_lock(); 1928 1929 tty = tty_open_current_tty(device, filp); 1930 if (IS_ERR(tty)) { 1931 retval = PTR_ERR(tty); 1932 goto err_unlock; 1933 } else if (!tty) { 1934 driver = tty_lookup_driver(device, filp, &noctty, &index); 1935 if (IS_ERR(driver)) { 1936 retval = PTR_ERR(driver); 1937 goto err_unlock; 1938 } 1939 1940 /* check whether we're reopening an existing tty */ 1941 tty = tty_driver_lookup_tty(driver, inode, index); 1942 if (IS_ERR(tty)) { 1943 retval = PTR_ERR(tty); 1944 goto err_unlock; 1945 } 1946 } 1947 1948 if (tty) { 1949 retval = tty_reopen(tty); 1950 if (retval) 1951 tty = ERR_PTR(retval); 1952 } else 1953 tty = tty_init_dev(driver, index, 0); 1954 1955 mutex_unlock(&tty_mutex); 1956 if (driver) 1957 tty_driver_kref_put(driver); 1958 if (IS_ERR(tty)) { 1959 tty_unlock(); 1960 retval = PTR_ERR(tty); 1961 goto err_file; 1962 } 1963 1964 tty_add_file(tty, filp); 1965 1966 check_tty_count(tty, __func__); 1967 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 1968 tty->driver->subtype == PTY_TYPE_MASTER) 1969 noctty = 1; 1970 #ifdef TTY_DEBUG_HANGUP 1971 printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name); 1972 #endif 1973 if (tty->ops->open) 1974 retval = tty->ops->open(tty, filp); 1975 else 1976 retval = -ENODEV; 1977 filp->f_flags = saved_flags; 1978 1979 if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && 1980 !capable(CAP_SYS_ADMIN)) 1981 retval = -EBUSY; 1982 1983 if (retval) { 1984 #ifdef TTY_DEBUG_HANGUP 1985 printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__, 1986 retval, tty->name); 1987 #endif 1988 tty_unlock(); /* need to call tty_release without BTM */ 1989 tty_release(inode, filp); 1990 if (retval != -ERESTARTSYS) 1991 return retval; 1992 1993 if (signal_pending(current)) 1994 return retval; 1995 1996 schedule(); 1997 /* 1998 * Need to reset f_op in case a hangup happened. 1999 */ 2000 tty_lock(); 2001 if (filp->f_op == &hung_up_tty_fops) 2002 filp->f_op = &tty_fops; 2003 tty_unlock(); 2004 goto retry_open; 2005 } 2006 tty_unlock(); 2007 2008 2009 mutex_lock(&tty_mutex); 2010 tty_lock(); 2011 spin_lock_irq(¤t->sighand->siglock); 2012 if (!noctty && 2013 current->signal->leader && 2014 !current->signal->tty && 2015 tty->session == NULL) 2016 __proc_set_tty(current, tty); 2017 spin_unlock_irq(¤t->sighand->siglock); 2018 tty_unlock(); 2019 mutex_unlock(&tty_mutex); 2020 return 0; 2021 err_unlock: 2022 tty_unlock(); 2023 mutex_unlock(&tty_mutex); 2024 /* after locks to avoid deadlock */ 2025 if (!IS_ERR_OR_NULL(driver)) 2026 tty_driver_kref_put(driver); 2027 err_file: 2028 tty_free_file(filp); 2029 return retval; 2030 } 2031 2032 2033 2034 /** 2035 * tty_poll - check tty status 2036 * @filp: file being polled 2037 * @wait: poll wait structures to update 2038 * 2039 * Call the line discipline polling method to obtain the poll 2040 * status of the device. 2041 * 2042 * Locking: locks called line discipline but ldisc poll method 2043 * may be re-entered freely by other callers. 2044 */ 2045 2046 static unsigned int tty_poll(struct file *filp, poll_table *wait) 2047 { 2048 struct tty_struct *tty = file_tty(filp); 2049 struct tty_ldisc *ld; 2050 int ret = 0; 2051 2052 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll")) 2053 return 0; 2054 2055 ld = tty_ldisc_ref_wait(tty); 2056 if (ld->ops->poll) 2057 ret = (ld->ops->poll)(tty, filp, wait); 2058 tty_ldisc_deref(ld); 2059 return ret; 2060 } 2061 2062 static int __tty_fasync(int fd, struct file *filp, int on) 2063 { 2064 struct tty_struct *tty = file_tty(filp); 2065 unsigned long flags; 2066 int retval = 0; 2067 2068 if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync")) 2069 goto out; 2070 2071 retval = fasync_helper(fd, filp, on, &tty->fasync); 2072 if (retval <= 0) 2073 goto out; 2074 2075 if (on) { 2076 enum pid_type type; 2077 struct pid *pid; 2078 if (!waitqueue_active(&tty->read_wait)) 2079 tty->minimum_to_wake = 1; 2080 spin_lock_irqsave(&tty->ctrl_lock, flags); 2081 if (tty->pgrp) { 2082 pid = tty->pgrp; 2083 type = PIDTYPE_PGID; 2084 } else { 2085 pid = task_pid(current); 2086 type = PIDTYPE_PID; 2087 } 2088 get_pid(pid); 2089 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2090 retval = __f_setown(filp, pid, type, 0); 2091 put_pid(pid); 2092 if (retval) 2093 goto out; 2094 } else { 2095 if (!tty->fasync && !waitqueue_active(&tty->read_wait)) 2096 tty->minimum_to_wake = N_TTY_BUF_SIZE; 2097 } 2098 retval = 0; 2099 out: 2100 return retval; 2101 } 2102 2103 static int tty_fasync(int fd, struct file *filp, int on) 2104 { 2105 int retval; 2106 tty_lock(); 2107 retval = __tty_fasync(fd, filp, on); 2108 tty_unlock(); 2109 return retval; 2110 } 2111 2112 /** 2113 * tiocsti - fake input character 2114 * @tty: tty to fake input into 2115 * @p: pointer to character 2116 * 2117 * Fake input to a tty device. Does the necessary locking and 2118 * input management. 2119 * 2120 * FIXME: does not honour flow control ?? 2121 * 2122 * Locking: 2123 * Called functions take tty_ldisc_lock 2124 * current->signal->tty check is safe without locks 2125 * 2126 * FIXME: may race normal receive processing 2127 */ 2128 2129 static int tiocsti(struct tty_struct *tty, char __user *p) 2130 { 2131 char ch, mbz = 0; 2132 struct tty_ldisc *ld; 2133 2134 if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN)) 2135 return -EPERM; 2136 if (get_user(ch, p)) 2137 return -EFAULT; 2138 tty_audit_tiocsti(tty, ch); 2139 ld = tty_ldisc_ref_wait(tty); 2140 ld->ops->receive_buf(tty, &ch, &mbz, 1); 2141 tty_ldisc_deref(ld); 2142 return 0; 2143 } 2144 2145 /** 2146 * tiocgwinsz - implement window query ioctl 2147 * @tty; tty 2148 * @arg: user buffer for result 2149 * 2150 * Copies the kernel idea of the window size into the user buffer. 2151 * 2152 * Locking: tty->termios_mutex is taken to ensure the winsize data 2153 * is consistent. 2154 */ 2155 2156 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg) 2157 { 2158 int err; 2159 2160 mutex_lock(&tty->termios_mutex); 2161 err = copy_to_user(arg, &tty->winsize, sizeof(*arg)); 2162 mutex_unlock(&tty->termios_mutex); 2163 2164 return err ? -EFAULT: 0; 2165 } 2166 2167 /** 2168 * tty_do_resize - resize event 2169 * @tty: tty being resized 2170 * @rows: rows (character) 2171 * @cols: cols (character) 2172 * 2173 * Update the termios variables and send the necessary signals to 2174 * peform a terminal resize correctly 2175 */ 2176 2177 int tty_do_resize(struct tty_struct *tty, struct winsize *ws) 2178 { 2179 struct pid *pgrp; 2180 unsigned long flags; 2181 2182 /* Lock the tty */ 2183 mutex_lock(&tty->termios_mutex); 2184 if (!memcmp(ws, &tty->winsize, sizeof(*ws))) 2185 goto done; 2186 /* Get the PID values and reference them so we can 2187 avoid holding the tty ctrl lock while sending signals */ 2188 spin_lock_irqsave(&tty->ctrl_lock, flags); 2189 pgrp = get_pid(tty->pgrp); 2190 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2191 2192 if (pgrp) 2193 kill_pgrp(pgrp, SIGWINCH, 1); 2194 put_pid(pgrp); 2195 2196 tty->winsize = *ws; 2197 done: 2198 mutex_unlock(&tty->termios_mutex); 2199 return 0; 2200 } 2201 2202 /** 2203 * tiocswinsz - implement window size set ioctl 2204 * @tty; tty side of tty 2205 * @arg: user buffer for result 2206 * 2207 * Copies the user idea of the window size to the kernel. Traditionally 2208 * this is just advisory information but for the Linux console it 2209 * actually has driver level meaning and triggers a VC resize. 2210 * 2211 * Locking: 2212 * Driver dependent. The default do_resize method takes the 2213 * tty termios mutex and ctrl_lock. The console takes its own lock 2214 * then calls into the default method. 2215 */ 2216 2217 static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg) 2218 { 2219 struct winsize tmp_ws; 2220 if (copy_from_user(&tmp_ws, arg, sizeof(*arg))) 2221 return -EFAULT; 2222 2223 if (tty->ops->resize) 2224 return tty->ops->resize(tty, &tmp_ws); 2225 else 2226 return tty_do_resize(tty, &tmp_ws); 2227 } 2228 2229 /** 2230 * tioccons - allow admin to move logical console 2231 * @file: the file to become console 2232 * 2233 * Allow the administrator to move the redirected console device 2234 * 2235 * Locking: uses redirect_lock to guard the redirect information 2236 */ 2237 2238 static int tioccons(struct file *file) 2239 { 2240 if (!capable(CAP_SYS_ADMIN)) 2241 return -EPERM; 2242 if (file->f_op->write == redirected_tty_write) { 2243 struct file *f; 2244 spin_lock(&redirect_lock); 2245 f = redirect; 2246 redirect = NULL; 2247 spin_unlock(&redirect_lock); 2248 if (f) 2249 fput(f); 2250 return 0; 2251 } 2252 spin_lock(&redirect_lock); 2253 if (redirect) { 2254 spin_unlock(&redirect_lock); 2255 return -EBUSY; 2256 } 2257 get_file(file); 2258 redirect = file; 2259 spin_unlock(&redirect_lock); 2260 return 0; 2261 } 2262 2263 /** 2264 * fionbio - non blocking ioctl 2265 * @file: file to set blocking value 2266 * @p: user parameter 2267 * 2268 * Historical tty interfaces had a blocking control ioctl before 2269 * the generic functionality existed. This piece of history is preserved 2270 * in the expected tty API of posix OS's. 2271 * 2272 * Locking: none, the open file handle ensures it won't go away. 2273 */ 2274 2275 static int fionbio(struct file *file, int __user *p) 2276 { 2277 int nonblock; 2278 2279 if (get_user(nonblock, p)) 2280 return -EFAULT; 2281 2282 spin_lock(&file->f_lock); 2283 if (nonblock) 2284 file->f_flags |= O_NONBLOCK; 2285 else 2286 file->f_flags &= ~O_NONBLOCK; 2287 spin_unlock(&file->f_lock); 2288 return 0; 2289 } 2290 2291 /** 2292 * tiocsctty - set controlling tty 2293 * @tty: tty structure 2294 * @arg: user argument 2295 * 2296 * This ioctl is used to manage job control. It permits a session 2297 * leader to set this tty as the controlling tty for the session. 2298 * 2299 * Locking: 2300 * Takes tty_mutex() to protect tty instance 2301 * Takes tasklist_lock internally to walk sessions 2302 * Takes ->siglock() when updating signal->tty 2303 */ 2304 2305 static int tiocsctty(struct tty_struct *tty, int arg) 2306 { 2307 int ret = 0; 2308 if (current->signal->leader && (task_session(current) == tty->session)) 2309 return ret; 2310 2311 mutex_lock(&tty_mutex); 2312 /* 2313 * The process must be a session leader and 2314 * not have a controlling tty already. 2315 */ 2316 if (!current->signal->leader || current->signal->tty) { 2317 ret = -EPERM; 2318 goto unlock; 2319 } 2320 2321 if (tty->session) { 2322 /* 2323 * This tty is already the controlling 2324 * tty for another session group! 2325 */ 2326 if (arg == 1 && capable(CAP_SYS_ADMIN)) { 2327 /* 2328 * Steal it away 2329 */ 2330 read_lock(&tasklist_lock); 2331 session_clear_tty(tty->session); 2332 read_unlock(&tasklist_lock); 2333 } else { 2334 ret = -EPERM; 2335 goto unlock; 2336 } 2337 } 2338 proc_set_tty(current, tty); 2339 unlock: 2340 mutex_unlock(&tty_mutex); 2341 return ret; 2342 } 2343 2344 /** 2345 * tty_get_pgrp - return a ref counted pgrp pid 2346 * @tty: tty to read 2347 * 2348 * Returns a refcounted instance of the pid struct for the process 2349 * group controlling the tty. 2350 */ 2351 2352 struct pid *tty_get_pgrp(struct tty_struct *tty) 2353 { 2354 unsigned long flags; 2355 struct pid *pgrp; 2356 2357 spin_lock_irqsave(&tty->ctrl_lock, flags); 2358 pgrp = get_pid(tty->pgrp); 2359 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2360 2361 return pgrp; 2362 } 2363 EXPORT_SYMBOL_GPL(tty_get_pgrp); 2364 2365 /** 2366 * tiocgpgrp - get process group 2367 * @tty: tty passed by user 2368 * @real_tty: tty side of the tty passed by the user if a pty else the tty 2369 * @p: returned pid 2370 * 2371 * Obtain the process group of the tty. If there is no process group 2372 * return an error. 2373 * 2374 * Locking: none. Reference to current->signal->tty is safe. 2375 */ 2376 2377 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2378 { 2379 struct pid *pid; 2380 int ret; 2381 /* 2382 * (tty == real_tty) is a cheap way of 2383 * testing if the tty is NOT a master pty. 2384 */ 2385 if (tty == real_tty && current->signal->tty != real_tty) 2386 return -ENOTTY; 2387 pid = tty_get_pgrp(real_tty); 2388 ret = put_user(pid_vnr(pid), p); 2389 put_pid(pid); 2390 return ret; 2391 } 2392 2393 /** 2394 * tiocspgrp - attempt to set process group 2395 * @tty: tty passed by user 2396 * @real_tty: tty side device matching tty passed by user 2397 * @p: pid pointer 2398 * 2399 * Set the process group of the tty to the session passed. Only 2400 * permitted where the tty session is our session. 2401 * 2402 * Locking: RCU, ctrl lock 2403 */ 2404 2405 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2406 { 2407 struct pid *pgrp; 2408 pid_t pgrp_nr; 2409 int retval = tty_check_change(real_tty); 2410 unsigned long flags; 2411 2412 if (retval == -EIO) 2413 return -ENOTTY; 2414 if (retval) 2415 return retval; 2416 if (!current->signal->tty || 2417 (current->signal->tty != real_tty) || 2418 (real_tty->session != task_session(current))) 2419 return -ENOTTY; 2420 if (get_user(pgrp_nr, p)) 2421 return -EFAULT; 2422 if (pgrp_nr < 0) 2423 return -EINVAL; 2424 rcu_read_lock(); 2425 pgrp = find_vpid(pgrp_nr); 2426 retval = -ESRCH; 2427 if (!pgrp) 2428 goto out_unlock; 2429 retval = -EPERM; 2430 if (session_of_pgrp(pgrp) != task_session(current)) 2431 goto out_unlock; 2432 retval = 0; 2433 spin_lock_irqsave(&tty->ctrl_lock, flags); 2434 put_pid(real_tty->pgrp); 2435 real_tty->pgrp = get_pid(pgrp); 2436 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 2437 out_unlock: 2438 rcu_read_unlock(); 2439 return retval; 2440 } 2441 2442 /** 2443 * tiocgsid - get session id 2444 * @tty: tty passed by user 2445 * @real_tty: tty side of the tty passed by the user if a pty else the tty 2446 * @p: pointer to returned session id 2447 * 2448 * Obtain the session id of the tty. If there is no session 2449 * return an error. 2450 * 2451 * Locking: none. Reference to current->signal->tty is safe. 2452 */ 2453 2454 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) 2455 { 2456 /* 2457 * (tty == real_tty) is a cheap way of 2458 * testing if the tty is NOT a master pty. 2459 */ 2460 if (tty == real_tty && current->signal->tty != real_tty) 2461 return -ENOTTY; 2462 if (!real_tty->session) 2463 return -ENOTTY; 2464 return put_user(pid_vnr(real_tty->session), p); 2465 } 2466 2467 /** 2468 * tiocsetd - set line discipline 2469 * @tty: tty device 2470 * @p: pointer to user data 2471 * 2472 * Set the line discipline according to user request. 2473 * 2474 * Locking: see tty_set_ldisc, this function is just a helper 2475 */ 2476 2477 static int tiocsetd(struct tty_struct *tty, int __user *p) 2478 { 2479 int ldisc; 2480 int ret; 2481 2482 if (get_user(ldisc, p)) 2483 return -EFAULT; 2484 2485 ret = tty_set_ldisc(tty, ldisc); 2486 2487 return ret; 2488 } 2489 2490 /** 2491 * send_break - performed time break 2492 * @tty: device to break on 2493 * @duration: timeout in mS 2494 * 2495 * Perform a timed break on hardware that lacks its own driver level 2496 * timed break functionality. 2497 * 2498 * Locking: 2499 * atomic_write_lock serializes 2500 * 2501 */ 2502 2503 static int send_break(struct tty_struct *tty, unsigned int duration) 2504 { 2505 int retval; 2506 2507 if (tty->ops->break_ctl == NULL) 2508 return 0; 2509 2510 if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK) 2511 retval = tty->ops->break_ctl(tty, duration); 2512 else { 2513 /* Do the work ourselves */ 2514 if (tty_write_lock(tty, 0) < 0) 2515 return -EINTR; 2516 retval = tty->ops->break_ctl(tty, -1); 2517 if (retval) 2518 goto out; 2519 if (!signal_pending(current)) 2520 msleep_interruptible(duration); 2521 retval = tty->ops->break_ctl(tty, 0); 2522 out: 2523 tty_write_unlock(tty); 2524 if (signal_pending(current)) 2525 retval = -EINTR; 2526 } 2527 return retval; 2528 } 2529 2530 /** 2531 * tty_tiocmget - get modem status 2532 * @tty: tty device 2533 * @file: user file pointer 2534 * @p: pointer to result 2535 * 2536 * Obtain the modem status bits from the tty driver if the feature 2537 * is supported. Return -EINVAL if it is not available. 2538 * 2539 * Locking: none (up to the driver) 2540 */ 2541 2542 static int tty_tiocmget(struct tty_struct *tty, int __user *p) 2543 { 2544 int retval = -EINVAL; 2545 2546 if (tty->ops->tiocmget) { 2547 retval = tty->ops->tiocmget(tty); 2548 2549 if (retval >= 0) 2550 retval = put_user(retval, p); 2551 } 2552 return retval; 2553 } 2554 2555 /** 2556 * tty_tiocmset - set modem status 2557 * @tty: tty device 2558 * @cmd: command - clear bits, set bits or set all 2559 * @p: pointer to desired bits 2560 * 2561 * Set the modem status bits from the tty driver if the feature 2562 * is supported. Return -EINVAL if it is not available. 2563 * 2564 * Locking: none (up to the driver) 2565 */ 2566 2567 static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd, 2568 unsigned __user *p) 2569 { 2570 int retval; 2571 unsigned int set, clear, val; 2572 2573 if (tty->ops->tiocmset == NULL) 2574 return -EINVAL; 2575 2576 retval = get_user(val, p); 2577 if (retval) 2578 return retval; 2579 set = clear = 0; 2580 switch (cmd) { 2581 case TIOCMBIS: 2582 set = val; 2583 break; 2584 case TIOCMBIC: 2585 clear = val; 2586 break; 2587 case TIOCMSET: 2588 set = val; 2589 clear = ~val; 2590 break; 2591 } 2592 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP; 2593 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP; 2594 return tty->ops->tiocmset(tty, set, clear); 2595 } 2596 2597 static int tty_tiocgicount(struct tty_struct *tty, void __user *arg) 2598 { 2599 int retval = -EINVAL; 2600 struct serial_icounter_struct icount; 2601 memset(&icount, 0, sizeof(icount)); 2602 if (tty->ops->get_icount) 2603 retval = tty->ops->get_icount(tty, &icount); 2604 if (retval != 0) 2605 return retval; 2606 if (copy_to_user(arg, &icount, sizeof(icount))) 2607 return -EFAULT; 2608 return 0; 2609 } 2610 2611 struct tty_struct *tty_pair_get_tty(struct tty_struct *tty) 2612 { 2613 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 2614 tty->driver->subtype == PTY_TYPE_MASTER) 2615 tty = tty->link; 2616 return tty; 2617 } 2618 EXPORT_SYMBOL(tty_pair_get_tty); 2619 2620 struct tty_struct *tty_pair_get_pty(struct tty_struct *tty) 2621 { 2622 if (tty->driver->type == TTY_DRIVER_TYPE_PTY && 2623 tty->driver->subtype == PTY_TYPE_MASTER) 2624 return tty; 2625 return tty->link; 2626 } 2627 EXPORT_SYMBOL(tty_pair_get_pty); 2628 2629 /* 2630 * Split this up, as gcc can choke on it otherwise.. 2631 */ 2632 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2633 { 2634 struct tty_struct *tty = file_tty(file); 2635 struct tty_struct *real_tty; 2636 void __user *p = (void __user *)arg; 2637 int retval; 2638 struct tty_ldisc *ld; 2639 struct inode *inode = file->f_dentry->d_inode; 2640 2641 if (tty_paranoia_check(tty, inode, "tty_ioctl")) 2642 return -EINVAL; 2643 2644 real_tty = tty_pair_get_tty(tty); 2645 2646 /* 2647 * Factor out some common prep work 2648 */ 2649 switch (cmd) { 2650 case TIOCSETD: 2651 case TIOCSBRK: 2652 case TIOCCBRK: 2653 case TCSBRK: 2654 case TCSBRKP: 2655 retval = tty_check_change(tty); 2656 if (retval) 2657 return retval; 2658 if (cmd != TIOCCBRK) { 2659 tty_wait_until_sent(tty, 0); 2660 if (signal_pending(current)) 2661 return -EINTR; 2662 } 2663 break; 2664 } 2665 2666 /* 2667 * Now do the stuff. 2668 */ 2669 switch (cmd) { 2670 case TIOCSTI: 2671 return tiocsti(tty, p); 2672 case TIOCGWINSZ: 2673 return tiocgwinsz(real_tty, p); 2674 case TIOCSWINSZ: 2675 return tiocswinsz(real_tty, p); 2676 case TIOCCONS: 2677 return real_tty != tty ? -EINVAL : tioccons(file); 2678 case FIONBIO: 2679 return fionbio(file, p); 2680 case TIOCEXCL: 2681 set_bit(TTY_EXCLUSIVE, &tty->flags); 2682 return 0; 2683 case TIOCNXCL: 2684 clear_bit(TTY_EXCLUSIVE, &tty->flags); 2685 return 0; 2686 case TIOCNOTTY: 2687 if (current->signal->tty != tty) 2688 return -ENOTTY; 2689 no_tty(); 2690 return 0; 2691 case TIOCSCTTY: 2692 return tiocsctty(tty, arg); 2693 case TIOCGPGRP: 2694 return tiocgpgrp(tty, real_tty, p); 2695 case TIOCSPGRP: 2696 return tiocspgrp(tty, real_tty, p); 2697 case TIOCGSID: 2698 return tiocgsid(tty, real_tty, p); 2699 case TIOCGETD: 2700 return put_user(tty->ldisc->ops->num, (int __user *)p); 2701 case TIOCSETD: 2702 return tiocsetd(tty, p); 2703 case TIOCVHANGUP: 2704 if (!capable(CAP_SYS_ADMIN)) 2705 return -EPERM; 2706 tty_vhangup(tty); 2707 return 0; 2708 case TIOCGDEV: 2709 { 2710 unsigned int ret = new_encode_dev(tty_devnum(real_tty)); 2711 return put_user(ret, (unsigned int __user *)p); 2712 } 2713 /* 2714 * Break handling 2715 */ 2716 case TIOCSBRK: /* Turn break on, unconditionally */ 2717 if (tty->ops->break_ctl) 2718 return tty->ops->break_ctl(tty, -1); 2719 return 0; 2720 case TIOCCBRK: /* Turn break off, unconditionally */ 2721 if (tty->ops->break_ctl) 2722 return tty->ops->break_ctl(tty, 0); 2723 return 0; 2724 case TCSBRK: /* SVID version: non-zero arg --> no break */ 2725 /* non-zero arg means wait for all output data 2726 * to be sent (performed above) but don't send break. 2727 * This is used by the tcdrain() termios function. 2728 */ 2729 if (!arg) 2730 return send_break(tty, 250); 2731 return 0; 2732 case TCSBRKP: /* support for POSIX tcsendbreak() */ 2733 return send_break(tty, arg ? arg*100 : 250); 2734 2735 case TIOCMGET: 2736 return tty_tiocmget(tty, p); 2737 case TIOCMSET: 2738 case TIOCMBIC: 2739 case TIOCMBIS: 2740 return tty_tiocmset(tty, cmd, p); 2741 case TIOCGICOUNT: 2742 retval = tty_tiocgicount(tty, p); 2743 /* For the moment allow fall through to the old method */ 2744 if (retval != -EINVAL) 2745 return retval; 2746 break; 2747 case TCFLSH: 2748 switch (arg) { 2749 case TCIFLUSH: 2750 case TCIOFLUSH: 2751 /* flush tty buffer and allow ldisc to process ioctl */ 2752 tty_buffer_flush(tty); 2753 break; 2754 } 2755 break; 2756 } 2757 if (tty->ops->ioctl) { 2758 retval = (tty->ops->ioctl)(tty, cmd, arg); 2759 if (retval != -ENOIOCTLCMD) 2760 return retval; 2761 } 2762 ld = tty_ldisc_ref_wait(tty); 2763 retval = -EINVAL; 2764 if (ld->ops->ioctl) { 2765 retval = ld->ops->ioctl(tty, file, cmd, arg); 2766 if (retval == -ENOIOCTLCMD) 2767 retval = -EINVAL; 2768 } 2769 tty_ldisc_deref(ld); 2770 return retval; 2771 } 2772 2773 #ifdef CONFIG_COMPAT 2774 static long tty_compat_ioctl(struct file *file, unsigned int cmd, 2775 unsigned long arg) 2776 { 2777 struct inode *inode = file->f_dentry->d_inode; 2778 struct tty_struct *tty = file_tty(file); 2779 struct tty_ldisc *ld; 2780 int retval = -ENOIOCTLCMD; 2781 2782 if (tty_paranoia_check(tty, inode, "tty_ioctl")) 2783 return -EINVAL; 2784 2785 if (tty->ops->compat_ioctl) { 2786 retval = (tty->ops->compat_ioctl)(tty, cmd, arg); 2787 if (retval != -ENOIOCTLCMD) 2788 return retval; 2789 } 2790 2791 ld = tty_ldisc_ref_wait(tty); 2792 if (ld->ops->compat_ioctl) 2793 retval = ld->ops->compat_ioctl(tty, file, cmd, arg); 2794 else 2795 retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg); 2796 tty_ldisc_deref(ld); 2797 2798 return retval; 2799 } 2800 #endif 2801 2802 /* 2803 * This implements the "Secure Attention Key" --- the idea is to 2804 * prevent trojan horses by killing all processes associated with this 2805 * tty when the user hits the "Secure Attention Key". Required for 2806 * super-paranoid applications --- see the Orange Book for more details. 2807 * 2808 * This code could be nicer; ideally it should send a HUP, wait a few 2809 * seconds, then send a INT, and then a KILL signal. But you then 2810 * have to coordinate with the init process, since all processes associated 2811 * with the current tty must be dead before the new getty is allowed 2812 * to spawn. 2813 * 2814 * Now, if it would be correct ;-/ The current code has a nasty hole - 2815 * it doesn't catch files in flight. We may send the descriptor to ourselves 2816 * via AF_UNIX socket, close it and later fetch from socket. FIXME. 2817 * 2818 * Nasty bug: do_SAK is being called in interrupt context. This can 2819 * deadlock. We punt it up to process context. AKPM - 16Mar2001 2820 */ 2821 void __do_SAK(struct tty_struct *tty) 2822 { 2823 #ifdef TTY_SOFT_SAK 2824 tty_hangup(tty); 2825 #else 2826 struct task_struct *g, *p; 2827 struct pid *session; 2828 int i; 2829 struct file *filp; 2830 struct fdtable *fdt; 2831 2832 if (!tty) 2833 return; 2834 session = tty->session; 2835 2836 tty_ldisc_flush(tty); 2837 2838 tty_driver_flush_buffer(tty); 2839 2840 read_lock(&tasklist_lock); 2841 /* Kill the entire session */ 2842 do_each_pid_task(session, PIDTYPE_SID, p) { 2843 printk(KERN_NOTICE "SAK: killed process %d" 2844 " (%s): task_session(p)==tty->session\n", 2845 task_pid_nr(p), p->comm); 2846 send_sig(SIGKILL, p, 1); 2847 } while_each_pid_task(session, PIDTYPE_SID, p); 2848 /* Now kill any processes that happen to have the 2849 * tty open. 2850 */ 2851 do_each_thread(g, p) { 2852 if (p->signal->tty == tty) { 2853 printk(KERN_NOTICE "SAK: killed process %d" 2854 " (%s): task_session(p)==tty->session\n", 2855 task_pid_nr(p), p->comm); 2856 send_sig(SIGKILL, p, 1); 2857 continue; 2858 } 2859 task_lock(p); 2860 if (p->files) { 2861 /* 2862 * We don't take a ref to the file, so we must 2863 * hold ->file_lock instead. 2864 */ 2865 spin_lock(&p->files->file_lock); 2866 fdt = files_fdtable(p->files); 2867 for (i = 0; i < fdt->max_fds; i++) { 2868 filp = fcheck_files(p->files, i); 2869 if (!filp) 2870 continue; 2871 if (filp->f_op->read == tty_read && 2872 file_tty(filp) == tty) { 2873 printk(KERN_NOTICE "SAK: killed process %d" 2874 " (%s): fd#%d opened to the tty\n", 2875 task_pid_nr(p), p->comm, i); 2876 force_sig(SIGKILL, p); 2877 break; 2878 } 2879 } 2880 spin_unlock(&p->files->file_lock); 2881 } 2882 task_unlock(p); 2883 } while_each_thread(g, p); 2884 read_unlock(&tasklist_lock); 2885 #endif 2886 } 2887 2888 static void do_SAK_work(struct work_struct *work) 2889 { 2890 struct tty_struct *tty = 2891 container_of(work, struct tty_struct, SAK_work); 2892 __do_SAK(tty); 2893 } 2894 2895 /* 2896 * The tq handling here is a little racy - tty->SAK_work may already be queued. 2897 * Fortunately we don't need to worry, because if ->SAK_work is already queued, 2898 * the values which we write to it will be identical to the values which it 2899 * already has. --akpm 2900 */ 2901 void do_SAK(struct tty_struct *tty) 2902 { 2903 if (!tty) 2904 return; 2905 schedule_work(&tty->SAK_work); 2906 } 2907 2908 EXPORT_SYMBOL(do_SAK); 2909 2910 static int dev_match_devt(struct device *dev, void *data) 2911 { 2912 dev_t *devt = data; 2913 return dev->devt == *devt; 2914 } 2915 2916 /* Must put_device() after it's unused! */ 2917 static struct device *tty_get_device(struct tty_struct *tty) 2918 { 2919 dev_t devt = tty_devnum(tty); 2920 return class_find_device(tty_class, NULL, &devt, dev_match_devt); 2921 } 2922 2923 2924 /** 2925 * initialize_tty_struct 2926 * @tty: tty to initialize 2927 * 2928 * This subroutine initializes a tty structure that has been newly 2929 * allocated. 2930 * 2931 * Locking: none - tty in question must not be exposed at this point 2932 */ 2933 2934 void initialize_tty_struct(struct tty_struct *tty, 2935 struct tty_driver *driver, int idx) 2936 { 2937 memset(tty, 0, sizeof(struct tty_struct)); 2938 kref_init(&tty->kref); 2939 tty->magic = TTY_MAGIC; 2940 tty_ldisc_init(tty); 2941 tty->session = NULL; 2942 tty->pgrp = NULL; 2943 tty->overrun_time = jiffies; 2944 tty->buf.head = tty->buf.tail = NULL; 2945 tty_buffer_init(tty); 2946 mutex_init(&tty->termios_mutex); 2947 mutex_init(&tty->ldisc_mutex); 2948 init_waitqueue_head(&tty->write_wait); 2949 init_waitqueue_head(&tty->read_wait); 2950 INIT_WORK(&tty->hangup_work, do_tty_hangup); 2951 mutex_init(&tty->atomic_read_lock); 2952 mutex_init(&tty->atomic_write_lock); 2953 mutex_init(&tty->output_lock); 2954 mutex_init(&tty->echo_lock); 2955 spin_lock_init(&tty->read_lock); 2956 spin_lock_init(&tty->ctrl_lock); 2957 INIT_LIST_HEAD(&tty->tty_files); 2958 INIT_WORK(&tty->SAK_work, do_SAK_work); 2959 2960 tty->driver = driver; 2961 tty->ops = driver->ops; 2962 tty->index = idx; 2963 tty_line_name(driver, idx, tty->name); 2964 tty->dev = tty_get_device(tty); 2965 } 2966 2967 /** 2968 * deinitialize_tty_struct 2969 * @tty: tty to deinitialize 2970 * 2971 * This subroutine deinitializes a tty structure that has been newly 2972 * allocated but tty_release cannot be called on that yet. 2973 * 2974 * Locking: none - tty in question must not be exposed at this point 2975 */ 2976 void deinitialize_tty_struct(struct tty_struct *tty) 2977 { 2978 tty_ldisc_deinit(tty); 2979 } 2980 2981 /** 2982 * tty_put_char - write one character to a tty 2983 * @tty: tty 2984 * @ch: character 2985 * 2986 * Write one byte to the tty using the provided put_char method 2987 * if present. Returns the number of characters successfully output. 2988 * 2989 * Note: the specific put_char operation in the driver layer may go 2990 * away soon. Don't call it directly, use this method 2991 */ 2992 2993 int tty_put_char(struct tty_struct *tty, unsigned char ch) 2994 { 2995 if (tty->ops->put_char) 2996 return tty->ops->put_char(tty, ch); 2997 return tty->ops->write(tty, &ch, 1); 2998 } 2999 EXPORT_SYMBOL_GPL(tty_put_char); 3000 3001 struct class *tty_class; 3002 3003 /** 3004 * tty_register_device - register a tty device 3005 * @driver: the tty driver that describes the tty device 3006 * @index: the index in the tty driver for this tty device 3007 * @device: a struct device that is associated with this tty device. 3008 * This field is optional, if there is no known struct device 3009 * for this tty device it can be set to NULL safely. 3010 * 3011 * Returns a pointer to the struct device for this tty device 3012 * (or ERR_PTR(-EFOO) on error). 3013 * 3014 * This call is required to be made to register an individual tty device 3015 * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If 3016 * that bit is not set, this function should not be called by a tty 3017 * driver. 3018 * 3019 * Locking: ?? 3020 */ 3021 3022 struct device *tty_register_device(struct tty_driver *driver, unsigned index, 3023 struct device *device) 3024 { 3025 char name[64]; 3026 dev_t dev = MKDEV(driver->major, driver->minor_start) + index; 3027 3028 if (index >= driver->num) { 3029 printk(KERN_ERR "Attempt to register invalid tty line number " 3030 " (%d).\n", index); 3031 return ERR_PTR(-EINVAL); 3032 } 3033 3034 if (driver->type == TTY_DRIVER_TYPE_PTY) 3035 pty_line_name(driver, index, name); 3036 else 3037 tty_line_name(driver, index, name); 3038 3039 return device_create(tty_class, device, dev, NULL, name); 3040 } 3041 EXPORT_SYMBOL(tty_register_device); 3042 3043 /** 3044 * tty_unregister_device - unregister a tty device 3045 * @driver: the tty driver that describes the tty device 3046 * @index: the index in the tty driver for this tty device 3047 * 3048 * If a tty device is registered with a call to tty_register_device() then 3049 * this function must be called when the tty device is gone. 3050 * 3051 * Locking: ?? 3052 */ 3053 3054 void tty_unregister_device(struct tty_driver *driver, unsigned index) 3055 { 3056 device_destroy(tty_class, 3057 MKDEV(driver->major, driver->minor_start) + index); 3058 } 3059 EXPORT_SYMBOL(tty_unregister_device); 3060 3061 struct tty_driver *alloc_tty_driver(int lines) 3062 { 3063 struct tty_driver *driver; 3064 3065 driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL); 3066 if (driver) { 3067 kref_init(&driver->kref); 3068 driver->magic = TTY_DRIVER_MAGIC; 3069 driver->num = lines; 3070 /* later we'll move allocation of tables here */ 3071 } 3072 return driver; 3073 } 3074 EXPORT_SYMBOL(alloc_tty_driver); 3075 3076 static void destruct_tty_driver(struct kref *kref) 3077 { 3078 struct tty_driver *driver = container_of(kref, struct tty_driver, kref); 3079 int i; 3080 struct ktermios *tp; 3081 void *p; 3082 3083 if (driver->flags & TTY_DRIVER_INSTALLED) { 3084 /* 3085 * Free the termios and termios_locked structures because 3086 * we don't want to get memory leaks when modular tty 3087 * drivers are removed from the kernel. 3088 */ 3089 for (i = 0; i < driver->num; i++) { 3090 tp = driver->termios[i]; 3091 if (tp) { 3092 driver->termios[i] = NULL; 3093 kfree(tp); 3094 } 3095 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) 3096 tty_unregister_device(driver, i); 3097 } 3098 p = driver->ttys; 3099 proc_tty_unregister_driver(driver); 3100 driver->ttys = NULL; 3101 driver->termios = NULL; 3102 kfree(p); 3103 cdev_del(&driver->cdev); 3104 } 3105 kfree(driver); 3106 } 3107 3108 void tty_driver_kref_put(struct tty_driver *driver) 3109 { 3110 kref_put(&driver->kref, destruct_tty_driver); 3111 } 3112 EXPORT_SYMBOL(tty_driver_kref_put); 3113 3114 void tty_set_operations(struct tty_driver *driver, 3115 const struct tty_operations *op) 3116 { 3117 driver->ops = op; 3118 }; 3119 EXPORT_SYMBOL(tty_set_operations); 3120 3121 void put_tty_driver(struct tty_driver *d) 3122 { 3123 tty_driver_kref_put(d); 3124 } 3125 EXPORT_SYMBOL(put_tty_driver); 3126 3127 /* 3128 * Called by a tty driver to register itself. 3129 */ 3130 int tty_register_driver(struct tty_driver *driver) 3131 { 3132 int error; 3133 int i; 3134 dev_t dev; 3135 void **p = NULL; 3136 struct device *d; 3137 3138 if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) { 3139 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL); 3140 if (!p) 3141 return -ENOMEM; 3142 } 3143 3144 if (!driver->major) { 3145 error = alloc_chrdev_region(&dev, driver->minor_start, 3146 driver->num, driver->name); 3147 if (!error) { 3148 driver->major = MAJOR(dev); 3149 driver->minor_start = MINOR(dev); 3150 } 3151 } else { 3152 dev = MKDEV(driver->major, driver->minor_start); 3153 error = register_chrdev_region(dev, driver->num, driver->name); 3154 } 3155 if (error < 0) { 3156 kfree(p); 3157 return error; 3158 } 3159 3160 if (p) { 3161 driver->ttys = (struct tty_struct **)p; 3162 driver->termios = (struct ktermios **)(p + driver->num); 3163 } else { 3164 driver->ttys = NULL; 3165 driver->termios = NULL; 3166 } 3167 3168 cdev_init(&driver->cdev, &tty_fops); 3169 driver->cdev.owner = driver->owner; 3170 error = cdev_add(&driver->cdev, dev, driver->num); 3171 if (error) { 3172 unregister_chrdev_region(dev, driver->num); 3173 driver->ttys = NULL; 3174 driver->termios = NULL; 3175 kfree(p); 3176 return error; 3177 } 3178 3179 mutex_lock(&tty_mutex); 3180 list_add(&driver->tty_drivers, &tty_drivers); 3181 mutex_unlock(&tty_mutex); 3182 3183 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) { 3184 for (i = 0; i < driver->num; i++) { 3185 d = tty_register_device(driver, i, NULL); 3186 if (IS_ERR(d)) { 3187 error = PTR_ERR(d); 3188 goto err; 3189 } 3190 } 3191 } 3192 proc_tty_register_driver(driver); 3193 driver->flags |= TTY_DRIVER_INSTALLED; 3194 return 0; 3195 3196 err: 3197 for (i--; i >= 0; i--) 3198 tty_unregister_device(driver, i); 3199 3200 mutex_lock(&tty_mutex); 3201 list_del(&driver->tty_drivers); 3202 mutex_unlock(&tty_mutex); 3203 3204 unregister_chrdev_region(dev, driver->num); 3205 driver->ttys = NULL; 3206 driver->termios = NULL; 3207 kfree(p); 3208 return error; 3209 } 3210 3211 EXPORT_SYMBOL(tty_register_driver); 3212 3213 /* 3214 * Called by a tty driver to unregister itself. 3215 */ 3216 int tty_unregister_driver(struct tty_driver *driver) 3217 { 3218 #if 0 3219 /* FIXME */ 3220 if (driver->refcount) 3221 return -EBUSY; 3222 #endif 3223 unregister_chrdev_region(MKDEV(driver->major, driver->minor_start), 3224 driver->num); 3225 mutex_lock(&tty_mutex); 3226 list_del(&driver->tty_drivers); 3227 mutex_unlock(&tty_mutex); 3228 return 0; 3229 } 3230 3231 EXPORT_SYMBOL(tty_unregister_driver); 3232 3233 dev_t tty_devnum(struct tty_struct *tty) 3234 { 3235 return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index; 3236 } 3237 EXPORT_SYMBOL(tty_devnum); 3238 3239 void proc_clear_tty(struct task_struct *p) 3240 { 3241 unsigned long flags; 3242 struct tty_struct *tty; 3243 spin_lock_irqsave(&p->sighand->siglock, flags); 3244 tty = p->signal->tty; 3245 p->signal->tty = NULL; 3246 spin_unlock_irqrestore(&p->sighand->siglock, flags); 3247 tty_kref_put(tty); 3248 } 3249 3250 /* Called under the sighand lock */ 3251 3252 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty) 3253 { 3254 if (tty) { 3255 unsigned long flags; 3256 /* We should not have a session or pgrp to put here but.... */ 3257 spin_lock_irqsave(&tty->ctrl_lock, flags); 3258 put_pid(tty->session); 3259 put_pid(tty->pgrp); 3260 tty->pgrp = get_pid(task_pgrp(tsk)); 3261 spin_unlock_irqrestore(&tty->ctrl_lock, flags); 3262 tty->session = get_pid(task_session(tsk)); 3263 if (tsk->signal->tty) { 3264 printk(KERN_DEBUG "tty not NULL!!\n"); 3265 tty_kref_put(tsk->signal->tty); 3266 } 3267 } 3268 put_pid(tsk->signal->tty_old_pgrp); 3269 tsk->signal->tty = tty_kref_get(tty); 3270 tsk->signal->tty_old_pgrp = NULL; 3271 } 3272 3273 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty) 3274 { 3275 spin_lock_irq(&tsk->sighand->siglock); 3276 __proc_set_tty(tsk, tty); 3277 spin_unlock_irq(&tsk->sighand->siglock); 3278 } 3279 3280 struct tty_struct *get_current_tty(void) 3281 { 3282 struct tty_struct *tty; 3283 unsigned long flags; 3284 3285 spin_lock_irqsave(¤t->sighand->siglock, flags); 3286 tty = tty_kref_get(current->signal->tty); 3287 spin_unlock_irqrestore(¤t->sighand->siglock, flags); 3288 return tty; 3289 } 3290 EXPORT_SYMBOL_GPL(get_current_tty); 3291 3292 void tty_default_fops(struct file_operations *fops) 3293 { 3294 *fops = tty_fops; 3295 } 3296 3297 /* 3298 * Initialize the console device. This is called *early*, so 3299 * we can't necessarily depend on lots of kernel help here. 3300 * Just do some early initializations, and do the complex setup 3301 * later. 3302 */ 3303 void __init console_init(void) 3304 { 3305 initcall_t *call; 3306 3307 /* Setup the default TTY line discipline. */ 3308 tty_ldisc_begin(); 3309 3310 /* 3311 * set up the console device so that later boot sequences can 3312 * inform about problems etc.. 3313 */ 3314 call = __con_initcall_start; 3315 while (call < __con_initcall_end) { 3316 (*call)(); 3317 call++; 3318 } 3319 } 3320 3321 static char *tty_devnode(struct device *dev, umode_t *mode) 3322 { 3323 if (!mode) 3324 return NULL; 3325 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) || 3326 dev->devt == MKDEV(TTYAUX_MAJOR, 2)) 3327 *mode = 0666; 3328 return NULL; 3329 } 3330 3331 static int __init tty_class_init(void) 3332 { 3333 tty_class = class_create(THIS_MODULE, "tty"); 3334 if (IS_ERR(tty_class)) 3335 return PTR_ERR(tty_class); 3336 tty_class->devnode = tty_devnode; 3337 return 0; 3338 } 3339 3340 postcore_initcall(tty_class_init); 3341 3342 /* 3/2004 jmc: why do these devices exist? */ 3343 static struct cdev tty_cdev, console_cdev; 3344 3345 static ssize_t show_cons_active(struct device *dev, 3346 struct device_attribute *attr, char *buf) 3347 { 3348 struct console *cs[16]; 3349 int i = 0; 3350 struct console *c; 3351 ssize_t count = 0; 3352 3353 console_lock(); 3354 for_each_console(c) { 3355 if (!c->device) 3356 continue; 3357 if (!c->write) 3358 continue; 3359 if ((c->flags & CON_ENABLED) == 0) 3360 continue; 3361 cs[i++] = c; 3362 if (i >= ARRAY_SIZE(cs)) 3363 break; 3364 } 3365 while (i--) 3366 count += sprintf(buf + count, "%s%d%c", 3367 cs[i]->name, cs[i]->index, i ? ' ':'\n'); 3368 console_unlock(); 3369 3370 return count; 3371 } 3372 static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL); 3373 3374 static struct device *consdev; 3375 3376 void console_sysfs_notify(void) 3377 { 3378 if (consdev) 3379 sysfs_notify(&consdev->kobj, NULL, "active"); 3380 } 3381 3382 /* 3383 * Ok, now we can initialize the rest of the tty devices and can count 3384 * on memory allocations, interrupts etc.. 3385 */ 3386 int __init tty_init(void) 3387 { 3388 cdev_init(&tty_cdev, &tty_fops); 3389 if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) || 3390 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0) 3391 panic("Couldn't register /dev/tty driver\n"); 3392 device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty"); 3393 3394 cdev_init(&console_cdev, &console_fops); 3395 if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) || 3396 register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0) 3397 panic("Couldn't register /dev/console driver\n"); 3398 consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, 3399 "console"); 3400 if (IS_ERR(consdev)) 3401 consdev = NULL; 3402 else 3403 WARN_ON(device_create_file(consdev, &dev_attr_active) < 0); 3404 3405 #ifdef CONFIG_VT 3406 vty_init(&console_fops); 3407 #endif 3408 return 0; 3409 } 3410 3411