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