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