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