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