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