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