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