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