ea18a129b0b556898a01ed8c6740ef343e9cc846
[linux-3.10.git] / drivers / char / tty_io.c
1 /*
2  *  linux/drivers/char/tty_io.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 /*
8  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9  * or rs-channels. It also implements echoing, cooked mode etc.
10  *
11  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12  *
13  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14  * tty_struct and tty_queue structures.  Previously there was an array
15  * of 256 tty_struct's which was statically allocated, and the
16  * tty_queue structures were allocated at boot time.  Both are now
17  * dynamically allocated only when the tty is open.
18  *
19  * Also restructured routines so that there is more of a separation
20  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21  * the low-level tty routines (serial.c, pty.c, console.c).  This
22  * makes for cleaner and more compact code.  -TYT, 9/17/92
23  *
24  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25  * which can be dynamically activated and de-activated by the line
26  * discipline handling modules (like SLIP).
27  *
28  * NOTE: pay no attention to the line discipline code (yet); its
29  * interface is still subject to change in this version...
30  * -- TYT, 1/31/92
31  *
32  * Added functionality to the OPOST tty handling.  No delays, but all
33  * other bits should be there.
34  *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35  *
36  * Rewrote canonical mode and added more termios flags.
37  *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38  *
39  * Reorganized FASYNC support so mouse code can share it.
40  *      -- ctm@ardi.com, 9Sep95
41  *
42  * New TIOCLINUX variants added.
43  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
44  *
45  * Restrict vt switching via ioctl()
46  *      -- grif@cs.ucr.edu, 5-Dec-95
47  *
48  * Move console and virtual terminal code to more appropriate files,
49  * implement CONFIG_VT and generalize console device interface.
50  *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51  *
52  * Rewrote tty_init_dev and tty_release_dev to eliminate races.
53  *      -- Bill Hawes <whawes@star.net>, June 97
54  *
55  * Added devfs support.
56  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57  *
58  * Added support for a Unix98-style ptmx device.
59  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60  *
61  * Reduced memory usage for older ARM systems
62  *      -- Russell King <rmk@arm.linux.org.uk>
63  *
64  * Move do_SAK() into process context.  Less stack use in devfs functions.
65  * alloc_tty_struct() always uses kmalloc()
66  *                       -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
67  */
68
69 #include <linux/types.h>
70 #include <linux/major.h>
71 #include <linux/errno.h>
72 #include <linux/signal.h>
73 #include <linux/fcntl.h>
74 #include <linux/sched.h>
75 #include <linux/interrupt.h>
76 #include <linux/tty.h>
77 #include <linux/tty_driver.h>
78 #include <linux/tty_flip.h>
79 #include <linux/devpts_fs.h>
80 #include <linux/file.h>
81 #include <linux/fdtable.h>
82 #include <linux/console.h>
83 #include <linux/timer.h>
84 #include <linux/ctype.h>
85 #include <linux/kd.h>
86 #include <linux/mm.h>
87 #include <linux/string.h>
88 #include <linux/slab.h>
89 #include <linux/poll.h>
90 #include <linux/proc_fs.h>
91 #include <linux/init.h>
92 #include <linux/module.h>
93 #include <linux/smp_lock.h>
94 #include <linux/device.h>
95 #include <linux/wait.h>
96 #include <linux/bitops.h>
97 #include <linux/delay.h>
98 #include <linux/seq_file.h>
99
100 #include <linux/uaccess.h>
101 #include <asm/system.h>
102
103 #include <linux/kbd_kern.h>
104 #include <linux/vt_kern.h>
105 #include <linux/selection.h>
106
107 #include <linux/kmod.h>
108 #include <linux/nsproxy.h>
109
110 #undef TTY_DEBUG_HANGUP
111
112 #define TTY_PARANOIA_CHECK 1
113 #define CHECK_TTY_COUNT 1
114
115 struct ktermios tty_std_termios = {     /* for the benefit of tty drivers  */
116         .c_iflag = ICRNL | IXON,
117         .c_oflag = OPOST | ONLCR,
118         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
119         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
120                    ECHOCTL | ECHOKE | IEXTEN,
121         .c_cc = INIT_C_CC,
122         .c_ispeed = 38400,
123         .c_ospeed = 38400
124 };
125
126 EXPORT_SYMBOL(tty_std_termios);
127
128 /* This list gets poked at by procfs and various bits of boot up code. This
129    could do with some rationalisation such as pulling the tty proc function
130    into this file */
131
132 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
133
134 /* Mutex to protect creating and releasing a tty. This is shared with
135    vt.c for deeply disgusting hack reasons */
136 DEFINE_MUTEX(tty_mutex);
137 EXPORT_SYMBOL(tty_mutex);
138
139 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
140 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
141 ssize_t redirected_tty_write(struct file *, const char __user *,
142                                                         size_t, loff_t *);
143 static unsigned int tty_poll(struct file *, poll_table *);
144 static int tty_open(struct inode *, struct file *);
145 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 EXPORT_SYMBOL_GPL(tty_init_termios);
1188
1189 /**
1190  *      tty_driver_install_tty() - install a tty entry in the driver
1191  *      @driver: the driver for the tty
1192  *      @tty: the tty
1193  *
1194  *      Install a tty object into the driver tables. The tty->index field
1195  *      will be set by the time this is called. This method is responsible
1196  *      for ensuring any need additional structures are allocated and
1197  *      configured.
1198  *
1199  *      Locking: tty_mutex for now
1200  */
1201 static int tty_driver_install_tty(struct tty_driver *driver,
1202                                                 struct tty_struct *tty)
1203 {
1204         int idx = tty->index;
1205
1206         if (driver->ops->install)
1207                 return driver->ops->install(driver, tty);
1208
1209         if (tty_init_termios(tty) == 0) {
1210                 tty_driver_kref_get(driver);
1211                 tty->count++;
1212                 driver->ttys[idx] = tty;
1213                 return 0;
1214         }
1215         return -ENOMEM;
1216 }
1217
1218 /**
1219  *      tty_driver_remove_tty() - remove a tty from the driver tables
1220  *      @driver: the driver for the tty
1221  *      @idx:    the minor number
1222  *
1223  *      Remvoe a tty object from the driver tables. The tty->index field
1224  *      will be set by the time this is called.
1225  *
1226  *      Locking: tty_mutex for now
1227  */
1228 static void tty_driver_remove_tty(struct tty_driver *driver,
1229                                                 struct tty_struct *tty)
1230 {
1231         if (driver->ops->remove)
1232                 driver->ops->remove(driver, tty);
1233         else
1234                 driver->ttys[tty->index] = NULL;
1235 }
1236
1237 /*
1238  *      tty_reopen()    - fast re-open of an open tty
1239  *      @tty    - the tty to open
1240  *
1241  *      Return 0 on success, -errno on error.
1242  *
1243  *      Locking: tty_mutex must be held from the time the tty was found
1244  *               till this open completes.
1245  */
1246 static int tty_reopen(struct tty_struct *tty)
1247 {
1248         struct tty_driver *driver = tty->driver;
1249
1250         if (test_bit(TTY_CLOSING, &tty->flags))
1251                 return -EIO;
1252
1253         if (driver->type == TTY_DRIVER_TYPE_PTY &&
1254             driver->subtype == PTY_TYPE_MASTER) {
1255                 /*
1256                  * special case for PTY masters: only one open permitted,
1257                  * and the slave side open count is incremented as well.
1258                  */
1259                 if (tty->count)
1260                         return -EIO;
1261
1262                 tty->link->count++;
1263         }
1264         tty->count++;
1265         tty->driver = driver; /* N.B. why do this every time?? */
1266
1267         mutex_lock(&tty->ldisc_mutex);
1268         WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
1269         mutex_unlock(&tty->ldisc_mutex);
1270
1271         return 0;
1272 }
1273
1274 /**
1275  *      tty_init_dev            -       initialise a tty device
1276  *      @driver: tty driver we are opening a device on
1277  *      @idx: device index
1278  *      @ret_tty: returned tty structure
1279  *      @first_ok: ok to open a new device (used by ptmx)
1280  *
1281  *      Prepare a tty device. This may not be a "new" clean device but
1282  *      could also be an active device. The pty drivers require special
1283  *      handling because of this.
1284  *
1285  *      Locking:
1286  *              The function is called under the tty_mutex, which
1287  *      protects us from the tty struct or driver itself going away.
1288  *
1289  *      On exit the tty device has the line discipline attached and
1290  *      a reference count of 1. If a pair was created for pty/tty use
1291  *      and the other was a pty master then it too has a reference count of 1.
1292  *
1293  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1294  * failed open.  The new code protects the open with a mutex, so it's
1295  * really quite straightforward.  The mutex locking can probably be
1296  * relaxed for the (most common) case of reopening a tty.
1297  */
1298
1299 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
1300                                                                 int first_ok)
1301 {
1302         struct tty_struct *tty;
1303         int retval;
1304
1305         /* Check if pty master is being opened multiple times */
1306         if (driver->subtype == PTY_TYPE_MASTER &&
1307                 (driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok)
1308                 return ERR_PTR(-EIO);
1309
1310         /*
1311          * First time open is complex, especially for PTY devices.
1312          * This code guarantees that either everything succeeds and the
1313          * TTY is ready for operation, or else the table slots are vacated
1314          * and the allocated memory released.  (Except that the termios
1315          * and locked termios may be retained.)
1316          */
1317
1318         if (!try_module_get(driver->owner))
1319                 return ERR_PTR(-ENODEV);
1320
1321         tty = alloc_tty_struct();
1322         if (!tty)
1323                 goto fail_no_mem;
1324         initialize_tty_struct(tty, driver, idx);
1325
1326         retval = tty_driver_install_tty(driver, tty);
1327         if (retval < 0) {
1328                 free_tty_struct(tty);
1329                 module_put(driver->owner);
1330                 return ERR_PTR(retval);
1331         }
1332
1333         /*
1334          * Structures all installed ... call the ldisc open routines.
1335          * If we fail here just call release_tty to clean up.  No need
1336          * to decrement the use counts, as release_tty doesn't care.
1337          */
1338
1339         retval = tty_ldisc_setup(tty, tty->link);
1340         if (retval)
1341                 goto release_mem_out;
1342         return tty;
1343
1344 fail_no_mem:
1345         module_put(driver->owner);
1346         return ERR_PTR(-ENOMEM);
1347
1348         /* call the tty release_tty routine to clean out this slot */
1349 release_mem_out:
1350         if (printk_ratelimit())
1351                 printk(KERN_INFO "tty_init_dev: ldisc open failed, "
1352                                  "clearing slot %d\n", idx);
1353         release_tty(tty, idx);
1354         return ERR_PTR(retval);
1355 }
1356
1357 void tty_free_termios(struct tty_struct *tty)
1358 {
1359         struct ktermios *tp;
1360         int idx = tty->index;
1361         /* Kill this flag and push into drivers for locking etc */
1362         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1363                 /* FIXME: Locking on ->termios array */
1364                 tp = tty->termios;
1365                 tty->driver->termios[idx] = NULL;
1366                 kfree(tp);
1367         }
1368 }
1369 EXPORT_SYMBOL(tty_free_termios);
1370
1371 void tty_shutdown(struct tty_struct *tty)
1372 {
1373         tty_driver_remove_tty(tty->driver, tty);
1374         tty_free_termios(tty);
1375 }
1376 EXPORT_SYMBOL(tty_shutdown);
1377
1378 /**
1379  *      release_one_tty         -       release tty structure memory
1380  *      @kref: kref of tty we are obliterating
1381  *
1382  *      Releases memory associated with a tty structure, and clears out the
1383  *      driver table slots. This function is called when a device is no longer
1384  *      in use. It also gets called when setup of a device fails.
1385  *
1386  *      Locking:
1387  *              tty_mutex - sometimes only
1388  *              takes the file list lock internally when working on the list
1389  *      of ttys that the driver keeps.
1390  *
1391  *      This method gets called from a work queue so that the driver private
1392  *      shutdown ops can sleep (needed for USB at least)
1393  */
1394 static void release_one_tty(struct work_struct *work)
1395 {
1396         struct tty_struct *tty =
1397                 container_of(work, struct tty_struct, hangup_work);
1398         struct tty_driver *driver = tty->driver;
1399
1400         if (tty->ops->shutdown)
1401                 tty->ops->shutdown(tty);
1402         else
1403                 tty_shutdown(tty);
1404         tty->magic = 0;
1405         tty_driver_kref_put(driver);
1406         module_put(driver->owner);
1407
1408         file_list_lock();
1409         list_del_init(&tty->tty_files);
1410         file_list_unlock();
1411
1412         free_tty_struct(tty);
1413 }
1414
1415 static void queue_release_one_tty(struct kref *kref)
1416 {
1417         struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1418         /* The hangup queue is now free so we can reuse it rather than
1419            waste a chunk of memory for each port */
1420         INIT_WORK(&tty->hangup_work, release_one_tty);
1421         schedule_work(&tty->hangup_work);
1422 }
1423
1424 /**
1425  *      tty_kref_put            -       release a tty kref
1426  *      @tty: tty device
1427  *
1428  *      Release a reference to a tty device and if need be let the kref
1429  *      layer destruct the object for us
1430  */
1431
1432 void tty_kref_put(struct tty_struct *tty)
1433 {
1434         if (tty)
1435                 kref_put(&tty->kref, queue_release_one_tty);
1436 }
1437 EXPORT_SYMBOL(tty_kref_put);
1438
1439 /**
1440  *      release_tty             -       release tty structure memory
1441  *
1442  *      Release both @tty and a possible linked partner (think pty pair),
1443  *      and decrement the refcount of the backing module.
1444  *
1445  *      Locking:
1446  *              tty_mutex - sometimes only
1447  *              takes the file list lock internally when working on the list
1448  *      of ttys that the driver keeps.
1449  *              FIXME: should we require tty_mutex is held here ??
1450  *
1451  */
1452 static void release_tty(struct tty_struct *tty, int idx)
1453 {
1454         /* This should always be true but check for the moment */
1455         WARN_ON(tty->index != idx);
1456
1457         if (tty->link)
1458                 tty_kref_put(tty->link);
1459         tty_kref_put(tty);
1460 }
1461
1462 /*
1463  * Even releasing the tty structures is a tricky business.. We have
1464  * to be very careful that the structures are all released at the
1465  * same time, as interrupts might otherwise get the wrong pointers.
1466  *
1467  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1468  * lead to double frees or releasing memory still in use.
1469  */
1470 void tty_release_dev(struct file *filp)
1471 {
1472         struct tty_struct *tty, *o_tty;
1473         int     pty_master, tty_closing, o_tty_closing, do_sleep;
1474         int     devpts;
1475         int     idx;
1476         char    buf[64];
1477         struct  inode *inode;
1478
1479         inode = filp->f_path.dentry->d_inode;
1480         tty = (struct tty_struct *)filp->private_data;
1481         if (tty_paranoia_check(tty, inode, "tty_release_dev"))
1482                 return;
1483
1484         check_tty_count(tty, "tty_release_dev");
1485
1486         tty_fasync(-1, filp, 0);
1487
1488         idx = tty->index;
1489         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1490                       tty->driver->subtype == PTY_TYPE_MASTER);
1491         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1492         o_tty = tty->link;
1493
1494 #ifdef TTY_PARANOIA_CHECK
1495         if (idx < 0 || idx >= tty->driver->num) {
1496                 printk(KERN_DEBUG "tty_release_dev: bad idx when trying to "
1497                                   "free (%s)\n", tty->name);
1498                 return;
1499         }
1500         if (!devpts) {
1501                 if (tty != tty->driver->ttys[idx]) {
1502                         printk(KERN_DEBUG "tty_release_dev: driver.table[%d] not tty "
1503                                "for (%s)\n", idx, tty->name);
1504                         return;
1505                 }
1506                 if (tty->termios != tty->driver->termios[idx]) {
1507                         printk(KERN_DEBUG "tty_release_dev: driver.termios[%d] not termios "
1508                                "for (%s)\n",
1509                                idx, tty->name);
1510                         return;
1511                 }
1512         }
1513 #endif
1514
1515 #ifdef TTY_DEBUG_HANGUP
1516         printk(KERN_DEBUG "tty_release_dev of %s (tty count=%d)...",
1517                tty_name(tty, buf), tty->count);
1518 #endif
1519
1520 #ifdef TTY_PARANOIA_CHECK
1521         if (tty->driver->other &&
1522              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1523                 if (o_tty != tty->driver->other->ttys[idx]) {
1524                         printk(KERN_DEBUG "tty_release_dev: other->table[%d] "
1525                                           "not o_tty for (%s)\n",
1526                                idx, tty->name);
1527                         return;
1528                 }
1529                 if (o_tty->termios != tty->driver->other->termios[idx]) {
1530                         printk(KERN_DEBUG "tty_release_dev: other->termios[%d] "
1531                                           "not o_termios for (%s)\n",
1532                                idx, tty->name);
1533                         return;
1534                 }
1535                 if (o_tty->link != tty) {
1536                         printk(KERN_DEBUG "tty_release_dev: bad pty pointers\n");
1537                         return;
1538                 }
1539         }
1540 #endif
1541         if (tty->ops->close)
1542                 tty->ops->close(tty, filp);
1543
1544         /*
1545          * Sanity check: if tty->count is going to zero, there shouldn't be
1546          * any waiters on tty->read_wait or tty->write_wait.  We test the
1547          * wait queues and kick everyone out _before_ actually starting to
1548          * close.  This ensures that we won't block while releasing the tty
1549          * structure.
1550          *
1551          * The test for the o_tty closing is necessary, since the master and
1552          * slave sides may close in any order.  If the slave side closes out
1553          * first, its count will be one, since the master side holds an open.
1554          * Thus this test wouldn't be triggered at the time the slave closes,
1555          * so we do it now.
1556          *
1557          * Note that it's possible for the tty to be opened again while we're
1558          * flushing out waiters.  By recalculating the closing flags before
1559          * each iteration we avoid any problems.
1560          */
1561         while (1) {
1562                 /* Guard against races with tty->count changes elsewhere and
1563                    opens on /dev/tty */
1564
1565                 mutex_lock(&tty_mutex);
1566                 tty_closing = tty->count <= 1;
1567                 o_tty_closing = o_tty &&
1568                         (o_tty->count <= (pty_master ? 1 : 0));
1569                 do_sleep = 0;
1570
1571                 if (tty_closing) {
1572                         if (waitqueue_active(&tty->read_wait)) {
1573                                 wake_up_poll(&tty->read_wait, POLLIN);
1574                                 do_sleep++;
1575                         }
1576                         if (waitqueue_active(&tty->write_wait)) {
1577                                 wake_up_poll(&tty->write_wait, POLLOUT);
1578                                 do_sleep++;
1579                         }
1580                 }
1581                 if (o_tty_closing) {
1582                         if (waitqueue_active(&o_tty->read_wait)) {
1583                                 wake_up_poll(&o_tty->read_wait, POLLIN);
1584                                 do_sleep++;
1585                         }
1586                         if (waitqueue_active(&o_tty->write_wait)) {
1587                                 wake_up_poll(&o_tty->write_wait, POLLOUT);
1588                                 do_sleep++;
1589                         }
1590                 }
1591                 if (!do_sleep)
1592                         break;
1593
1594                 printk(KERN_WARNING "tty_release_dev: %s: read/write wait queue "
1595                                     "active!\n", tty_name(tty, buf));
1596                 mutex_unlock(&tty_mutex);
1597                 schedule();
1598         }
1599
1600         /*
1601          * The closing flags are now consistent with the open counts on
1602          * both sides, and we've completed the last operation that could
1603          * block, so it's safe to proceed with closing.
1604          */
1605         if (pty_master) {
1606                 if (--o_tty->count < 0) {
1607                         printk(KERN_WARNING "tty_release_dev: bad pty slave count "
1608                                             "(%d) for %s\n",
1609                                o_tty->count, tty_name(o_tty, buf));
1610                         o_tty->count = 0;
1611                 }
1612         }
1613         if (--tty->count < 0) {
1614                 printk(KERN_WARNING "tty_release_dev: bad tty->count (%d) for %s\n",
1615                        tty->count, tty_name(tty, buf));
1616                 tty->count = 0;
1617         }
1618
1619         /*
1620          * We've decremented tty->count, so we need to remove this file
1621          * descriptor off the tty->tty_files list; this serves two
1622          * purposes:
1623          *  - check_tty_count sees the correct number of file descriptors
1624          *    associated with this tty.
1625          *  - do_tty_hangup no longer sees this file descriptor as
1626          *    something that needs to be handled for hangups.
1627          */
1628         file_kill(filp);
1629         filp->private_data = NULL;
1630
1631         /*
1632          * Perform some housekeeping before deciding whether to return.
1633          *
1634          * Set the TTY_CLOSING flag if this was the last open.  In the
1635          * case of a pty we may have to wait around for the other side
1636          * to close, and TTY_CLOSING makes sure we can't be reopened.
1637          */
1638         if (tty_closing)
1639                 set_bit(TTY_CLOSING, &tty->flags);
1640         if (o_tty_closing)
1641                 set_bit(TTY_CLOSING, &o_tty->flags);
1642
1643         /*
1644          * If _either_ side is closing, make sure there aren't any
1645          * processes that still think tty or o_tty is their controlling
1646          * tty.
1647          */
1648         if (tty_closing || o_tty_closing) {
1649                 read_lock(&tasklist_lock);
1650                 session_clear_tty(tty->session);
1651                 if (o_tty)
1652                         session_clear_tty(o_tty->session);
1653                 read_unlock(&tasklist_lock);
1654         }
1655
1656         mutex_unlock(&tty_mutex);
1657
1658         /* check whether both sides are closing ... */
1659         if (!tty_closing || (o_tty && !o_tty_closing))
1660                 return;
1661
1662 #ifdef TTY_DEBUG_HANGUP
1663         printk(KERN_DEBUG "freeing tty structure...");
1664 #endif
1665         /*
1666          * Ask the line discipline code to release its structures
1667          */
1668         tty_ldisc_release(tty, o_tty);
1669         /*
1670          * The release_tty function takes care of the details of clearing
1671          * the slots and preserving the termios structure.
1672          */
1673         release_tty(tty, idx);
1674
1675         /* Make this pty number available for reallocation */
1676         if (devpts)
1677                 devpts_kill_index(inode, idx);
1678 }
1679
1680 /**
1681  *      __tty_open              -       open a tty device
1682  *      @inode: inode of device file
1683  *      @filp: file pointer to tty
1684  *
1685  *      tty_open and tty_release keep up the tty count that contains the
1686  *      number of opens done on a tty. We cannot use the inode-count, as
1687  *      different inodes might point to the same tty.
1688  *
1689  *      Open-counting is needed for pty masters, as well as for keeping
1690  *      track of serial lines: DTR is dropped when the last close happens.
1691  *      (This is not done solely through tty->count, now.  - Ted 1/27/92)
1692  *
1693  *      The termios state of a pty is reset on first open so that
1694  *      settings don't persist across reuse.
1695  *
1696  *      Locking: tty_mutex protects tty, get_tty_driver and tty_init_dev work.
1697  *               tty->count should protect the rest.
1698  *               ->siglock protects ->signal/->sighand
1699  */
1700
1701 static int __tty_open(struct inode *inode, struct file *filp)
1702 {
1703         struct tty_struct *tty = NULL;
1704         int noctty, retval;
1705         struct tty_driver *driver;
1706         int index;
1707         dev_t device = inode->i_rdev;
1708         unsigned saved_flags = filp->f_flags;
1709
1710         nonseekable_open(inode, filp);
1711
1712 retry_open:
1713         noctty = filp->f_flags & O_NOCTTY;
1714         index  = -1;
1715         retval = 0;
1716
1717         mutex_lock(&tty_mutex);
1718
1719         if (device == MKDEV(TTYAUX_MAJOR, 0)) {
1720                 tty = get_current_tty();
1721                 if (!tty) {
1722                         mutex_unlock(&tty_mutex);
1723                         return -ENXIO;
1724                 }
1725                 driver = tty_driver_kref_get(tty->driver);
1726                 index = tty->index;
1727                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1728                 /* noctty = 1; */
1729                 /* FIXME: Should we take a driver reference ? */
1730                 tty_kref_put(tty);
1731                 goto got_driver;
1732         }
1733 #ifdef CONFIG_VT
1734         if (device == MKDEV(TTY_MAJOR, 0)) {
1735                 extern struct tty_driver *console_driver;
1736                 driver = tty_driver_kref_get(console_driver);
1737                 index = fg_console;
1738                 noctty = 1;
1739                 goto got_driver;
1740         }
1741 #endif
1742         if (device == MKDEV(TTYAUX_MAJOR, 1)) {
1743                 struct tty_driver *console_driver = console_device(&index);
1744                 if (console_driver) {
1745                         driver = tty_driver_kref_get(console_driver);
1746                         if (driver) {
1747                                 /* Don't let /dev/console block */
1748                                 filp->f_flags |= O_NONBLOCK;
1749                                 noctty = 1;
1750                                 goto got_driver;
1751                         }
1752                 }
1753                 mutex_unlock(&tty_mutex);
1754                 return -ENODEV;
1755         }
1756
1757         driver = get_tty_driver(device, &index);
1758         if (!driver) {
1759                 mutex_unlock(&tty_mutex);
1760                 return -ENODEV;
1761         }
1762 got_driver:
1763         if (!tty) {
1764                 /* check whether we're reopening an existing tty */
1765                 tty = tty_driver_lookup_tty(driver, inode, index);
1766
1767                 if (IS_ERR(tty)) {
1768                         mutex_unlock(&tty_mutex);
1769                         return PTR_ERR(tty);
1770                 }
1771         }
1772
1773         if (tty) {
1774                 retval = tty_reopen(tty);
1775                 if (retval)
1776                         tty = ERR_PTR(retval);
1777         } else
1778                 tty = tty_init_dev(driver, index, 0);
1779
1780         mutex_unlock(&tty_mutex);
1781         tty_driver_kref_put(driver);
1782         if (IS_ERR(tty))
1783                 return PTR_ERR(tty);
1784
1785         filp->private_data = tty;
1786         file_move(filp, &tty->tty_files);
1787         check_tty_count(tty, "tty_open");
1788         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1789             tty->driver->subtype == PTY_TYPE_MASTER)
1790                 noctty = 1;
1791 #ifdef TTY_DEBUG_HANGUP
1792         printk(KERN_DEBUG "opening %s...", tty->name);
1793 #endif
1794         if (!retval) {
1795                 if (tty->ops->open)
1796                         retval = tty->ops->open(tty, filp);
1797                 else
1798                         retval = -ENODEV;
1799         }
1800         filp->f_flags = saved_flags;
1801
1802         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
1803                                                 !capable(CAP_SYS_ADMIN))
1804                 retval = -EBUSY;
1805
1806         if (retval) {
1807 #ifdef TTY_DEBUG_HANGUP
1808                 printk(KERN_DEBUG "error %d in opening %s...", retval,
1809                        tty->name);
1810 #endif
1811                 tty_release_dev(filp);
1812                 if (retval != -ERESTARTSYS)
1813                         return retval;
1814                 if (signal_pending(current))
1815                         return retval;
1816                 schedule();
1817                 /*
1818                  * Need to reset f_op in case a hangup happened.
1819                  */
1820                 if (filp->f_op == &hung_up_tty_fops)
1821                         filp->f_op = &tty_fops;
1822                 goto retry_open;
1823         }
1824
1825         mutex_lock(&tty_mutex);
1826         spin_lock_irq(&current->sighand->siglock);
1827         if (!noctty &&
1828             current->signal->leader &&
1829             !current->signal->tty &&
1830             tty->session == NULL)
1831                 __proc_set_tty(current, tty);
1832         spin_unlock_irq(&current->sighand->siglock);
1833         mutex_unlock(&tty_mutex);
1834         return 0;
1835 }
1836
1837 /* BKL pushdown: scary code avoidance wrapper */
1838 static int tty_open(struct inode *inode, struct file *filp)
1839 {
1840         int ret;
1841
1842         lock_kernel();
1843         ret = __tty_open(inode, filp);
1844         unlock_kernel();
1845         return ret;
1846 }
1847
1848
1849
1850
1851 /**
1852  *      tty_release             -       vfs callback for close
1853  *      @inode: inode of tty
1854  *      @filp: file pointer for handle to tty
1855  *
1856  *      Called the last time each file handle is closed that references
1857  *      this tty. There may however be several such references.
1858  *
1859  *      Locking:
1860  *              Takes bkl. See tty_release_dev
1861  */
1862
1863 static int tty_release(struct inode *inode, struct file *filp)
1864 {
1865         lock_kernel();
1866         tty_release_dev(filp);
1867         unlock_kernel();
1868         return 0;
1869 }
1870
1871 /**
1872  *      tty_poll        -       check tty status
1873  *      @filp: file being polled
1874  *      @wait: poll wait structures to update
1875  *
1876  *      Call the line discipline polling method to obtain the poll
1877  *      status of the device.
1878  *
1879  *      Locking: locks called line discipline but ldisc poll method
1880  *      may be re-entered freely by other callers.
1881  */
1882
1883 static unsigned int tty_poll(struct file *filp, poll_table *wait)
1884 {
1885         struct tty_struct *tty;
1886         struct tty_ldisc *ld;
1887         int ret = 0;
1888
1889         tty = (struct tty_struct *)filp->private_data;
1890         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
1891                 return 0;
1892
1893         ld = tty_ldisc_ref_wait(tty);
1894         if (ld->ops->poll)
1895                 ret = (ld->ops->poll)(tty, filp, wait);
1896         tty_ldisc_deref(ld);
1897         return ret;
1898 }
1899
1900 static int tty_fasync(int fd, struct file *filp, int on)
1901 {
1902         struct tty_struct *tty;
1903         unsigned long flags;
1904         int retval = 0;
1905
1906         lock_kernel();
1907         tty = (struct tty_struct *)filp->private_data;
1908         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
1909                 goto out;
1910
1911         retval = fasync_helper(fd, filp, on, &tty->fasync);
1912         if (retval <= 0)
1913                 goto out;
1914
1915         if (on) {
1916                 enum pid_type type;
1917                 struct pid *pid;
1918                 if (!waitqueue_active(&tty->read_wait))
1919                         tty->minimum_to_wake = 1;
1920                 spin_lock_irqsave(&tty->ctrl_lock, flags);
1921                 if (tty->pgrp) {
1922                         pid = tty->pgrp;
1923                         type = PIDTYPE_PGID;
1924                 } else {
1925                         pid = task_pid(current);
1926                         type = PIDTYPE_PID;
1927                 }
1928                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1929                 retval = __f_setown(filp, pid, type, 0);
1930                 if (retval)
1931                         goto out;
1932         } else {
1933                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1934                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
1935         }
1936         retval = 0;
1937 out:
1938         unlock_kernel();
1939         return retval;
1940 }
1941
1942 /**
1943  *      tiocsti                 -       fake input character
1944  *      @tty: tty to fake input into
1945  *      @p: pointer to character
1946  *
1947  *      Fake input to a tty device. Does the necessary locking and
1948  *      input management.
1949  *
1950  *      FIXME: does not honour flow control ??
1951  *
1952  *      Locking:
1953  *              Called functions take tty_ldisc_lock
1954  *              current->signal->tty check is safe without locks
1955  *
1956  *      FIXME: may race normal receive processing
1957  */
1958
1959 static int tiocsti(struct tty_struct *tty, char __user *p)
1960 {
1961         char ch, mbz = 0;
1962         struct tty_ldisc *ld;
1963
1964         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1965                 return -EPERM;
1966         if (get_user(ch, p))
1967                 return -EFAULT;
1968         tty_audit_tiocsti(tty, ch);
1969         ld = tty_ldisc_ref_wait(tty);
1970         ld->ops->receive_buf(tty, &ch, &mbz, 1);
1971         tty_ldisc_deref(ld);
1972         return 0;
1973 }
1974
1975 /**
1976  *      tiocgwinsz              -       implement window query ioctl
1977  *      @tty; tty
1978  *      @arg: user buffer for result
1979  *
1980  *      Copies the kernel idea of the window size into the user buffer.
1981  *
1982  *      Locking: tty->termios_mutex is taken to ensure the winsize data
1983  *              is consistent.
1984  */
1985
1986 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
1987 {
1988         int err;
1989
1990         mutex_lock(&tty->termios_mutex);
1991         err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
1992         mutex_unlock(&tty->termios_mutex);
1993
1994         return err ? -EFAULT: 0;
1995 }
1996
1997 /**
1998  *      tty_do_resize           -       resize event
1999  *      @tty: tty being resized
2000  *      @rows: rows (character)
2001  *      @cols: cols (character)
2002  *
2003  *      Update the termios variables and send the neccessary signals to
2004  *      peform a terminal resize correctly
2005  */
2006
2007 int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2008 {
2009         struct pid *pgrp;
2010         unsigned long flags;
2011
2012         /* Lock the tty */
2013         mutex_lock(&tty->termios_mutex);
2014         if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2015                 goto done;
2016         /* Get the PID values and reference them so we can
2017            avoid holding the tty ctrl lock while sending signals */
2018         spin_lock_irqsave(&tty->ctrl_lock, flags);
2019         pgrp = get_pid(tty->pgrp);
2020         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2021
2022         if (pgrp)
2023                 kill_pgrp(pgrp, SIGWINCH, 1);
2024         put_pid(pgrp);
2025
2026         tty->winsize = *ws;
2027 done:
2028         mutex_unlock(&tty->termios_mutex);
2029         return 0;
2030 }
2031
2032 /**
2033  *      tiocswinsz              -       implement window size set ioctl
2034  *      @tty; tty side of tty
2035  *      @arg: user buffer for result
2036  *
2037  *      Copies the user idea of the window size to the kernel. Traditionally
2038  *      this is just advisory information but for the Linux console it
2039  *      actually has driver level meaning and triggers a VC resize.
2040  *
2041  *      Locking:
2042  *              Driver dependant. The default do_resize method takes the
2043  *      tty termios mutex and ctrl_lock. The console takes its own lock
2044  *      then calls into the default method.
2045  */
2046
2047 static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2048 {
2049         struct winsize tmp_ws;
2050         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2051                 return -EFAULT;
2052
2053         if (tty->ops->resize)
2054                 return tty->ops->resize(tty, &tmp_ws);
2055         else
2056                 return tty_do_resize(tty, &tmp_ws);
2057 }
2058
2059 /**
2060  *      tioccons        -       allow admin to move logical console
2061  *      @file: the file to become console
2062  *
2063  *      Allow the adminstrator to move the redirected console device
2064  *
2065  *      Locking: uses redirect_lock to guard the redirect information
2066  */
2067
2068 static int tioccons(struct file *file)
2069 {
2070         if (!capable(CAP_SYS_ADMIN))
2071                 return -EPERM;
2072         if (file->f_op->write == redirected_tty_write) {
2073                 struct file *f;
2074                 spin_lock(&redirect_lock);
2075                 f = redirect;
2076                 redirect = NULL;
2077                 spin_unlock(&redirect_lock);
2078                 if (f)
2079                         fput(f);
2080                 return 0;
2081         }
2082         spin_lock(&redirect_lock);
2083         if (redirect) {
2084                 spin_unlock(&redirect_lock);
2085                 return -EBUSY;
2086         }
2087         get_file(file);
2088         redirect = file;
2089         spin_unlock(&redirect_lock);
2090         return 0;
2091 }
2092
2093 /**
2094  *      fionbio         -       non blocking ioctl
2095  *      @file: file to set blocking value
2096  *      @p: user parameter
2097  *
2098  *      Historical tty interfaces had a blocking control ioctl before
2099  *      the generic functionality existed. This piece of history is preserved
2100  *      in the expected tty API of posix OS's.
2101  *
2102  *      Locking: none, the open file handle ensures it won't go away.
2103  */
2104
2105 static int fionbio(struct file *file, int __user *p)
2106 {
2107         int nonblock;
2108
2109         if (get_user(nonblock, p))
2110                 return -EFAULT;
2111
2112         spin_lock(&file->f_lock);
2113         if (nonblock)
2114                 file->f_flags |= O_NONBLOCK;
2115         else
2116                 file->f_flags &= ~O_NONBLOCK;
2117         spin_unlock(&file->f_lock);
2118         return 0;
2119 }
2120
2121 /**
2122  *      tiocsctty       -       set controlling tty
2123  *      @tty: tty structure
2124  *      @arg: user argument
2125  *
2126  *      This ioctl is used to manage job control. It permits a session
2127  *      leader to set this tty as the controlling tty for the session.
2128  *
2129  *      Locking:
2130  *              Takes tty_mutex() to protect tty instance
2131  *              Takes tasklist_lock internally to walk sessions
2132  *              Takes ->siglock() when updating signal->tty
2133  */
2134
2135 static int tiocsctty(struct tty_struct *tty, int arg)
2136 {
2137         int ret = 0;
2138         if (current->signal->leader && (task_session(current) == tty->session))
2139                 return ret;
2140
2141         mutex_lock(&tty_mutex);
2142         /*
2143          * The process must be a session leader and
2144          * not have a controlling tty already.
2145          */
2146         if (!current->signal->leader || current->signal->tty) {
2147                 ret = -EPERM;
2148                 goto unlock;
2149         }
2150
2151         if (tty->session) {
2152                 /*
2153                  * This tty is already the controlling
2154                  * tty for another session group!
2155                  */
2156                 if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2157                         /*
2158                          * Steal it away
2159                          */
2160                         read_lock(&tasklist_lock);
2161                         session_clear_tty(tty->session);
2162                         read_unlock(&tasklist_lock);
2163                 } else {
2164                         ret = -EPERM;
2165                         goto unlock;
2166                 }
2167         }
2168         proc_set_tty(current, tty);
2169 unlock:
2170         mutex_unlock(&tty_mutex);
2171         return ret;
2172 }
2173
2174 /**
2175  *      tty_get_pgrp    -       return a ref counted pgrp pid
2176  *      @tty: tty to read
2177  *
2178  *      Returns a refcounted instance of the pid struct for the process
2179  *      group controlling the tty.
2180  */
2181
2182 struct pid *tty_get_pgrp(struct tty_struct *tty)
2183 {
2184         unsigned long flags;
2185         struct pid *pgrp;
2186
2187         spin_lock_irqsave(&tty->ctrl_lock, flags);
2188         pgrp = get_pid(tty->pgrp);
2189         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2190
2191         return pgrp;
2192 }
2193 EXPORT_SYMBOL_GPL(tty_get_pgrp);
2194
2195 /**
2196  *      tiocgpgrp               -       get process group
2197  *      @tty: tty passed by user
2198  *      @real_tty: tty side of the tty pased by the user if a pty else the tty
2199  *      @p: returned pid
2200  *
2201  *      Obtain the process group of the tty. If there is no process group
2202  *      return an error.
2203  *
2204  *      Locking: none. Reference to current->signal->tty is safe.
2205  */
2206
2207 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2208 {
2209         struct pid *pid;
2210         int ret;
2211         /*
2212          * (tty == real_tty) is a cheap way of
2213          * testing if the tty is NOT a master pty.
2214          */
2215         if (tty == real_tty && current->signal->tty != real_tty)
2216                 return -ENOTTY;
2217         pid = tty_get_pgrp(real_tty);
2218         ret =  put_user(pid_vnr(pid), p);
2219         put_pid(pid);
2220         return ret;
2221 }
2222
2223 /**
2224  *      tiocspgrp               -       attempt to set process group
2225  *      @tty: tty passed by user
2226  *      @real_tty: tty side device matching tty passed by user
2227  *      @p: pid pointer
2228  *
2229  *      Set the process group of the tty to the session passed. Only
2230  *      permitted where the tty session is our session.
2231  *
2232  *      Locking: RCU, ctrl lock
2233  */
2234
2235 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2236 {
2237         struct pid *pgrp;
2238         pid_t pgrp_nr;
2239         int retval = tty_check_change(real_tty);
2240         unsigned long flags;
2241
2242         if (retval == -EIO)
2243                 return -ENOTTY;
2244         if (retval)
2245                 return retval;
2246         if (!current->signal->tty ||
2247             (current->signal->tty != real_tty) ||
2248             (real_tty->session != task_session(current)))
2249                 return -ENOTTY;
2250         if (get_user(pgrp_nr, p))
2251                 return -EFAULT;
2252         if (pgrp_nr < 0)
2253                 return -EINVAL;
2254         rcu_read_lock();
2255         pgrp = find_vpid(pgrp_nr);
2256         retval = -ESRCH;
2257         if (!pgrp)
2258                 goto out_unlock;
2259         retval = -EPERM;
2260         if (session_of_pgrp(pgrp) != task_session(current))
2261                 goto out_unlock;
2262         retval = 0;
2263         spin_lock_irqsave(&tty->ctrl_lock, flags);
2264         put_pid(real_tty->pgrp);
2265         real_tty->pgrp = get_pid(pgrp);
2266         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2267 out_unlock:
2268         rcu_read_unlock();
2269         return retval;
2270 }
2271
2272 /**
2273  *      tiocgsid                -       get session id
2274  *      @tty: tty passed by user
2275  *      @real_tty: tty side of the tty pased by the user if a pty else the tty
2276  *      @p: pointer to returned session id
2277  *
2278  *      Obtain the session id of the tty. If there is no session
2279  *      return an error.
2280  *
2281  *      Locking: none. Reference to current->signal->tty is safe.
2282  */
2283
2284 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2285 {
2286         /*
2287          * (tty == real_tty) is a cheap way of
2288          * testing if the tty is NOT a master pty.
2289         */
2290         if (tty == real_tty && current->signal->tty != real_tty)
2291                 return -ENOTTY;
2292         if (!real_tty->session)
2293                 return -ENOTTY;
2294         return put_user(pid_vnr(real_tty->session), p);
2295 }
2296
2297 /**
2298  *      tiocsetd        -       set line discipline
2299  *      @tty: tty device
2300  *      @p: pointer to user data
2301  *
2302  *      Set the line discipline according to user request.
2303  *
2304  *      Locking: see tty_set_ldisc, this function is just a helper
2305  */
2306
2307 static int tiocsetd(struct tty_struct *tty, int __user *p)
2308 {
2309         int ldisc;
2310         int ret;
2311
2312         if (get_user(ldisc, p))
2313                 return -EFAULT;
2314
2315         lock_kernel();
2316         ret = tty_set_ldisc(tty, ldisc);
2317         unlock_kernel();
2318
2319         return ret;
2320 }
2321
2322 /**
2323  *      send_break      -       performed time break
2324  *      @tty: device to break on
2325  *      @duration: timeout in mS
2326  *
2327  *      Perform a timed break on hardware that lacks its own driver level
2328  *      timed break functionality.
2329  *
2330  *      Locking:
2331  *              atomic_write_lock serializes
2332  *
2333  */
2334
2335 static int send_break(struct tty_struct *tty, unsigned int duration)
2336 {
2337         int retval;
2338
2339         if (tty->ops->break_ctl == NULL)
2340                 return 0;
2341
2342         if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2343                 retval = tty->ops->break_ctl(tty, duration);
2344         else {
2345                 /* Do the work ourselves */
2346                 if (tty_write_lock(tty, 0) < 0)
2347                         return -EINTR;
2348                 retval = tty->ops->break_ctl(tty, -1);
2349                 if (retval)
2350                         goto out;
2351                 if (!signal_pending(current))
2352                         msleep_interruptible(duration);
2353                 retval = tty->ops->break_ctl(tty, 0);
2354 out:
2355                 tty_write_unlock(tty);
2356                 if (signal_pending(current))
2357                         retval = -EINTR;
2358         }
2359         return retval;
2360 }
2361
2362 /**
2363  *      tty_tiocmget            -       get modem status
2364  *      @tty: tty device
2365  *      @file: user file pointer
2366  *      @p: pointer to result
2367  *
2368  *      Obtain the modem status bits from the tty driver if the feature
2369  *      is supported. Return -EINVAL if it is not available.
2370  *
2371  *      Locking: none (up to the driver)
2372  */
2373
2374 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2375 {
2376         int retval = -EINVAL;
2377
2378         if (tty->ops->tiocmget) {
2379                 retval = tty->ops->tiocmget(tty, file);
2380
2381                 if (retval >= 0)
2382                         retval = put_user(retval, p);
2383         }
2384         return retval;
2385 }
2386
2387 /**
2388  *      tty_tiocmset            -       set modem status
2389  *      @tty: tty device
2390  *      @file: user file pointer
2391  *      @cmd: command - clear bits, set bits or set all
2392  *      @p: pointer to desired bits
2393  *
2394  *      Set the modem status bits from the tty driver if the feature
2395  *      is supported. Return -EINVAL if it is not available.
2396  *
2397  *      Locking: none (up to the driver)
2398  */
2399
2400 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2401              unsigned __user *p)
2402 {
2403         int retval;
2404         unsigned int set, clear, val;
2405
2406         if (tty->ops->tiocmset == NULL)
2407                 return -EINVAL;
2408
2409         retval = get_user(val, p);
2410         if (retval)
2411                 return retval;
2412         set = clear = 0;
2413         switch (cmd) {
2414         case TIOCMBIS:
2415                 set = val;
2416                 break;
2417         case TIOCMBIC:
2418                 clear = val;
2419                 break;
2420         case TIOCMSET:
2421                 set = val;
2422                 clear = ~val;
2423                 break;
2424         }
2425         set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2426         clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2427         return tty->ops->tiocmset(tty, file, set, clear);
2428 }
2429
2430 struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2431 {
2432         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2433             tty->driver->subtype == PTY_TYPE_MASTER)
2434                 tty = tty->link;
2435         return tty;
2436 }
2437 EXPORT_SYMBOL(tty_pair_get_tty);
2438
2439 struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2440 {
2441         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2442             tty->driver->subtype == PTY_TYPE_MASTER)
2443             return tty;
2444         return tty->link;
2445 }
2446 EXPORT_SYMBOL(tty_pair_get_pty);
2447
2448 /*
2449  * Split this up, as gcc can choke on it otherwise..
2450  */
2451 long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2452 {
2453         struct tty_struct *tty, *real_tty;
2454         void __user *p = (void __user *)arg;
2455         int retval;
2456         struct tty_ldisc *ld;
2457         struct inode *inode = file->f_dentry->d_inode;
2458
2459         tty = (struct tty_struct *)file->private_data;
2460         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2461                 return -EINVAL;
2462
2463         real_tty = tty_pair_get_tty(tty);
2464
2465         /*
2466          * Factor out some common prep work
2467          */
2468         switch (cmd) {
2469         case TIOCSETD:
2470         case TIOCSBRK:
2471         case TIOCCBRK:
2472         case TCSBRK:
2473         case TCSBRKP:
2474                 retval = tty_check_change(tty);
2475                 if (retval)
2476                         return retval;
2477                 if (cmd != TIOCCBRK) {
2478                         tty_wait_until_sent(tty, 0);
2479                         if (signal_pending(current))
2480                                 return -EINTR;
2481                 }
2482                 break;
2483         }
2484
2485         /*
2486          *      Now do the stuff.
2487          */
2488         switch (cmd) {
2489         case TIOCSTI:
2490                 return tiocsti(tty, p);
2491         case TIOCGWINSZ:
2492                 return tiocgwinsz(real_tty, p);
2493         case TIOCSWINSZ:
2494                 return tiocswinsz(real_tty, p);
2495         case TIOCCONS:
2496                 return real_tty != tty ? -EINVAL : tioccons(file);
2497         case FIONBIO:
2498                 return fionbio(file, p);
2499         case TIOCEXCL:
2500                 set_bit(TTY_EXCLUSIVE, &tty->flags);
2501                 return 0;
2502         case TIOCNXCL:
2503                 clear_bit(TTY_EXCLUSIVE, &tty->flags);
2504                 return 0;
2505         case TIOCNOTTY:
2506                 if (current->signal->tty != tty)
2507                         return -ENOTTY;
2508                 no_tty();
2509                 return 0;
2510         case TIOCSCTTY:
2511                 return tiocsctty(tty, arg);
2512         case TIOCGPGRP:
2513                 return tiocgpgrp(tty, real_tty, p);
2514         case TIOCSPGRP:
2515                 return tiocspgrp(tty, real_tty, p);
2516         case TIOCGSID:
2517                 return tiocgsid(tty, real_tty, p);
2518         case TIOCGETD:
2519                 return put_user(tty->ldisc->ops->num, (int __user *)p);
2520         case TIOCSETD:
2521                 return tiocsetd(tty, p);
2522         /*
2523          * Break handling
2524          */
2525         case TIOCSBRK:  /* Turn break on, unconditionally */
2526                 if (tty->ops->break_ctl)
2527                         return tty->ops->break_ctl(tty, -1);
2528                 return 0;
2529         case TIOCCBRK:  /* Turn break off, unconditionally */
2530                 if (tty->ops->break_ctl)
2531                         return tty->ops->break_ctl(tty, 0);
2532                 return 0;
2533         case TCSBRK:   /* SVID version: non-zero arg --> no break */
2534                 /* non-zero arg means wait for all output data
2535                  * to be sent (performed above) but don't send break.
2536                  * This is used by the tcdrain() termios function.
2537                  */
2538                 if (!arg)
2539                         return send_break(tty, 250);
2540                 return 0;
2541         case TCSBRKP:   /* support for POSIX tcsendbreak() */
2542                 return send_break(tty, arg ? arg*100 : 250);
2543
2544         case TIOCMGET:
2545                 return tty_tiocmget(tty, file, p);
2546         case TIOCMSET:
2547         case TIOCMBIC:
2548         case TIOCMBIS:
2549                 return tty_tiocmset(tty, file, cmd, p);
2550         case TCFLSH:
2551                 switch (arg) {
2552                 case TCIFLUSH:
2553                 case TCIOFLUSH:
2554                 /* flush tty buffer and allow ldisc to process ioctl */
2555                         tty_buffer_flush(tty);
2556                         break;
2557                 }
2558                 break;
2559         }
2560         if (tty->ops->ioctl) {
2561                 retval = (tty->ops->ioctl)(tty, file, cmd, arg);
2562                 if (retval != -ENOIOCTLCMD)
2563                         return retval;
2564         }
2565         ld = tty_ldisc_ref_wait(tty);
2566         retval = -EINVAL;
2567         if (ld->ops->ioctl) {
2568                 retval = ld->ops->ioctl(tty, file, cmd, arg);
2569                 if (retval == -ENOIOCTLCMD)
2570                         retval = -EINVAL;
2571         }
2572         tty_ldisc_deref(ld);
2573         return retval;
2574 }
2575
2576 #ifdef CONFIG_COMPAT
2577 static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2578                                 unsigned long arg)
2579 {
2580         struct inode *inode = file->f_dentry->d_inode;
2581         struct tty_struct *tty = file->private_data;
2582         struct tty_ldisc *ld;
2583         int retval = -ENOIOCTLCMD;
2584
2585         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2586                 return -EINVAL;
2587
2588         if (tty->ops->compat_ioctl) {
2589                 retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
2590                 if (retval != -ENOIOCTLCMD)
2591                         return retval;
2592         }
2593
2594         ld = tty_ldisc_ref_wait(tty);
2595         if (ld->ops->compat_ioctl)
2596                 retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2597         tty_ldisc_deref(ld);
2598
2599         return retval;
2600 }
2601 #endif
2602
2603 /*
2604  * This implements the "Secure Attention Key" ---  the idea is to
2605  * prevent trojan horses by killing all processes associated with this
2606  * tty when the user hits the "Secure Attention Key".  Required for
2607  * super-paranoid applications --- see the Orange Book for more details.
2608  *
2609  * This code could be nicer; ideally it should send a HUP, wait a few
2610  * seconds, then send a INT, and then a KILL signal.  But you then
2611  * have to coordinate with the init process, since all processes associated
2612  * with the current tty must be dead before the new getty is allowed
2613  * to spawn.
2614  *
2615  * Now, if it would be correct ;-/ The current code has a nasty hole -
2616  * it doesn't catch files in flight. We may send the descriptor to ourselves
2617  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2618  *
2619  * Nasty bug: do_SAK is being called in interrupt context.  This can
2620  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2621  */
2622 void __do_SAK(struct tty_struct *tty)
2623 {
2624 #ifdef TTY_SOFT_SAK
2625         tty_hangup(tty);
2626 #else
2627         struct task_struct *g, *p;
2628         struct pid *session;
2629         int             i;
2630         struct file     *filp;
2631         struct fdtable *fdt;
2632
2633         if (!tty)
2634                 return;
2635         session = tty->session;
2636
2637         tty_ldisc_flush(tty);
2638
2639         tty_driver_flush_buffer(tty);
2640
2641         read_lock(&tasklist_lock);
2642         /* Kill the entire session */
2643         do_each_pid_task(session, PIDTYPE_SID, p) {
2644                 printk(KERN_NOTICE "SAK: killed process %d"
2645                         " (%s): task_session(p)==tty->session\n",
2646                         task_pid_nr(p), p->comm);
2647                 send_sig(SIGKILL, p, 1);
2648         } while_each_pid_task(session, PIDTYPE_SID, p);
2649         /* Now kill any processes that happen to have the
2650          * tty open.
2651          */
2652         do_each_thread(g, p) {
2653                 if (p->signal->tty == tty) {
2654                         printk(KERN_NOTICE "SAK: killed process %d"
2655                             " (%s): task_session(p)==tty->session\n",
2656                             task_pid_nr(p), p->comm);
2657                         send_sig(SIGKILL, p, 1);
2658                         continue;
2659                 }
2660                 task_lock(p);
2661                 if (p->files) {
2662                         /*
2663                          * We don't take a ref to the file, so we must
2664                          * hold ->file_lock instead.
2665                          */
2666                         spin_lock(&p->files->file_lock);
2667                         fdt = files_fdtable(p->files);
2668                         for (i = 0; i < fdt->max_fds; i++) {
2669                                 filp = fcheck_files(p->files, i);
2670                                 if (!filp)
2671                                         continue;
2672                                 if (filp->f_op->read == tty_read &&
2673                                     filp->private_data == tty) {
2674                                         printk(KERN_NOTICE "SAK: killed process %d"
2675                                             " (%s): fd#%d opened to the tty\n",
2676                                             task_pid_nr(p), p->comm, i);
2677                                         force_sig(SIGKILL, p);
2678                                         break;
2679                                 }
2680                         }
2681                         spin_unlock(&p->files->file_lock);
2682                 }
2683                 task_unlock(p);
2684         } while_each_thread(g, p);
2685         read_unlock(&tasklist_lock);
2686 #endif
2687 }
2688
2689 static void do_SAK_work(struct work_struct *work)
2690 {
2691         struct tty_struct *tty =
2692                 container_of(work, struct tty_struct, SAK_work);
2693         __do_SAK(tty);
2694 }
2695
2696 /*
2697  * The tq handling here is a little racy - tty->SAK_work may already be queued.
2698  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2699  * the values which we write to it will be identical to the values which it
2700  * already has. --akpm
2701  */
2702 void do_SAK(struct tty_struct *tty)
2703 {
2704         if (!tty)
2705                 return;
2706         schedule_work(&tty->SAK_work);
2707 }
2708
2709 EXPORT_SYMBOL(do_SAK);
2710
2711 /**
2712  *      initialize_tty_struct
2713  *      @tty: tty to initialize
2714  *
2715  *      This subroutine initializes a tty structure that has been newly
2716  *      allocated.
2717  *
2718  *      Locking: none - tty in question must not be exposed at this point
2719  */
2720
2721 void initialize_tty_struct(struct tty_struct *tty,
2722                 struct tty_driver *driver, int idx)
2723 {
2724         memset(tty, 0, sizeof(struct tty_struct));
2725         kref_init(&tty->kref);
2726         tty->magic = TTY_MAGIC;
2727         tty_ldisc_init(tty);
2728         tty->session = NULL;
2729         tty->pgrp = NULL;
2730         tty->overrun_time = jiffies;
2731         tty->buf.head = tty->buf.tail = NULL;
2732         tty_buffer_init(tty);
2733         mutex_init(&tty->termios_mutex);
2734         mutex_init(&tty->ldisc_mutex);
2735         init_waitqueue_head(&tty->write_wait);
2736         init_waitqueue_head(&tty->read_wait);
2737         INIT_WORK(&tty->hangup_work, do_tty_hangup);
2738         mutex_init(&tty->atomic_read_lock);
2739         mutex_init(&tty->atomic_write_lock);
2740         mutex_init(&tty->output_lock);
2741         mutex_init(&tty->echo_lock);
2742         spin_lock_init(&tty->read_lock);
2743         spin_lock_init(&tty->ctrl_lock);
2744         INIT_LIST_HEAD(&tty->tty_files);
2745         INIT_WORK(&tty->SAK_work, do_SAK_work);
2746
2747         tty->driver = driver;
2748         tty->ops = driver->ops;
2749         tty->index = idx;
2750         tty_line_name(driver, idx, tty->name);
2751 }
2752
2753 /**
2754  *      tty_put_char    -       write one character to a tty
2755  *      @tty: tty
2756  *      @ch: character
2757  *
2758  *      Write one byte to the tty using the provided put_char method
2759  *      if present. Returns the number of characters successfully output.
2760  *
2761  *      Note: the specific put_char operation in the driver layer may go
2762  *      away soon. Don't call it directly, use this method
2763  */
2764
2765 int tty_put_char(struct tty_struct *tty, unsigned char ch)
2766 {
2767         if (tty->ops->put_char)
2768                 return tty->ops->put_char(tty, ch);
2769         return tty->ops->write(tty, &ch, 1);
2770 }
2771 EXPORT_SYMBOL_GPL(tty_put_char);
2772
2773 struct class *tty_class;
2774
2775 /**
2776  *      tty_register_device - register a tty device
2777  *      @driver: the tty driver that describes the tty device
2778  *      @index: the index in the tty driver for this tty device
2779  *      @device: a struct device that is associated with this tty device.
2780  *              This field is optional, if there is no known struct device
2781  *              for this tty device it can be set to NULL safely.
2782  *
2783  *      Returns a pointer to the struct device for this tty device
2784  *      (or ERR_PTR(-EFOO) on error).
2785  *
2786  *      This call is required to be made to register an individual tty device
2787  *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
2788  *      that bit is not set, this function should not be called by a tty
2789  *      driver.
2790  *
2791  *      Locking: ??
2792  */
2793
2794 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
2795                                    struct device *device)
2796 {
2797         char name[64];
2798         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2799
2800         if (index >= driver->num) {
2801                 printk(KERN_ERR "Attempt to register invalid tty line number "
2802                        " (%d).\n", index);
2803                 return ERR_PTR(-EINVAL);
2804         }
2805
2806         if (driver->type == TTY_DRIVER_TYPE_PTY)
2807                 pty_line_name(driver, index, name);
2808         else
2809                 tty_line_name(driver, index, name);
2810
2811         return device_create(tty_class, device, dev, NULL, name);
2812 }
2813 EXPORT_SYMBOL(tty_register_device);
2814
2815 /**
2816  *      tty_unregister_device - unregister a tty device
2817  *      @driver: the tty driver that describes the tty device
2818  *      @index: the index in the tty driver for this tty device
2819  *
2820  *      If a tty device is registered with a call to tty_register_device() then
2821  *      this function must be called when the tty device is gone.
2822  *
2823  *      Locking: ??
2824  */
2825
2826 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2827 {
2828         device_destroy(tty_class,
2829                 MKDEV(driver->major, driver->minor_start) + index);
2830 }
2831 EXPORT_SYMBOL(tty_unregister_device);
2832
2833 struct tty_driver *alloc_tty_driver(int lines)
2834 {
2835         struct tty_driver *driver;
2836
2837         driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
2838         if (driver) {
2839                 kref_init(&driver->kref);
2840                 driver->magic = TTY_DRIVER_MAGIC;
2841                 driver->num = lines;
2842                 /* later we'll move allocation of tables here */
2843         }
2844         return driver;
2845 }
2846 EXPORT_SYMBOL(alloc_tty_driver);
2847
2848 static void destruct_tty_driver(struct kref *kref)
2849 {
2850         struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
2851         int i;
2852         struct ktermios *tp;
2853         void *p;
2854
2855         if (driver->flags & TTY_DRIVER_INSTALLED) {
2856                 /*
2857                  * Free the termios and termios_locked structures because
2858                  * we don't want to get memory leaks when modular tty
2859                  * drivers are removed from the kernel.
2860                  */
2861                 for (i = 0; i < driver->num; i++) {
2862                         tp = driver->termios[i];
2863                         if (tp) {
2864                                 driver->termios[i] = NULL;
2865                                 kfree(tp);
2866                         }
2867                         if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
2868                                 tty_unregister_device(driver, i);
2869                 }
2870                 p = driver->ttys;
2871                 proc_tty_unregister_driver(driver);
2872                 driver->ttys = NULL;
2873                 driver->termios = NULL;
2874                 kfree(p);
2875                 cdev_del(&driver->cdev);
2876         }
2877         kfree(driver);
2878 }
2879
2880 void tty_driver_kref_put(struct tty_driver *driver)
2881 {
2882         kref_put(&driver->kref, destruct_tty_driver);
2883 }
2884 EXPORT_SYMBOL(tty_driver_kref_put);
2885
2886 void tty_set_operations(struct tty_driver *driver,
2887                         const struct tty_operations *op)
2888 {
2889         driver->ops = op;
2890 };
2891 EXPORT_SYMBOL(tty_set_operations);
2892
2893 void put_tty_driver(struct tty_driver *d)
2894 {
2895         tty_driver_kref_put(d);
2896 }
2897 EXPORT_SYMBOL(put_tty_driver);
2898
2899 /*
2900  * Called by a tty driver to register itself.
2901  */
2902 int tty_register_driver(struct tty_driver *driver)
2903 {
2904         int error;
2905         int i;
2906         dev_t dev;
2907         void **p = NULL;
2908
2909         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
2910                 p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);
2911                 if (!p)
2912                         return -ENOMEM;
2913         }
2914
2915         if (!driver->major) {
2916                 error = alloc_chrdev_region(&dev, driver->minor_start,
2917                                                 driver->num, driver->name);
2918                 if (!error) {
2919                         driver->major = MAJOR(dev);
2920                         driver->minor_start = MINOR(dev);
2921                 }
2922         } else {
2923                 dev = MKDEV(driver->major, driver->minor_start);
2924                 error = register_chrdev_region(dev, driver->num, driver->name);
2925         }
2926         if (error < 0) {
2927                 kfree(p);
2928                 return error;
2929         }
2930
2931         if (p) {
2932                 driver->ttys = (struct tty_struct **)p;
2933                 driver->termios = (struct ktermios **)(p + driver->num);
2934         } else {
2935                 driver->ttys = NULL;
2936                 driver->termios = NULL;
2937         }
2938
2939         cdev_init(&driver->cdev, &tty_fops);
2940         driver->cdev.owner = driver->owner;
2941         error = cdev_add(&driver->cdev, dev, driver->num);
2942         if (error) {
2943                 unregister_chrdev_region(dev, driver->num);
2944                 driver->ttys = NULL;
2945                 driver->termios = NULL;
2946                 kfree(p);
2947                 return error;
2948         }
2949
2950         mutex_lock(&tty_mutex);
2951         list_add(&driver->tty_drivers, &tty_drivers);
2952         mutex_unlock(&tty_mutex);
2953
2954         if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
2955                 for (i = 0; i < driver->num; i++)
2956                     tty_register_device(driver, i, NULL);
2957         }
2958         proc_tty_register_driver(driver);
2959         driver->flags |= TTY_DRIVER_INSTALLED;
2960         return 0;
2961 }
2962
2963 EXPORT_SYMBOL(tty_register_driver);
2964
2965 /*
2966  * Called by a tty driver to unregister itself.
2967  */
2968 int tty_unregister_driver(struct tty_driver *driver)
2969 {
2970 #if 0
2971         /* FIXME */
2972         if (driver->refcount)
2973                 return -EBUSY;
2974 #endif
2975         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2976                                 driver->num);
2977         mutex_lock(&tty_mutex);
2978         list_del(&driver->tty_drivers);
2979         mutex_unlock(&tty_mutex);
2980         return 0;
2981 }
2982
2983 EXPORT_SYMBOL(tty_unregister_driver);
2984
2985 dev_t tty_devnum(struct tty_struct *tty)
2986 {
2987         return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
2988 }
2989 EXPORT_SYMBOL(tty_devnum);
2990
2991 void proc_clear_tty(struct task_struct *p)
2992 {
2993         unsigned long flags;
2994         struct tty_struct *tty;
2995         spin_lock_irqsave(&p->sighand->siglock, flags);
2996         tty = p->signal->tty;
2997         p->signal->tty = NULL;
2998         spin_unlock_irqrestore(&p->sighand->siglock, flags);
2999         tty_kref_put(tty);
3000 }
3001
3002 /* Called under the sighand lock */
3003
3004 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3005 {
3006         if (tty) {
3007                 unsigned long flags;
3008                 /* We should not have a session or pgrp to put here but.... */
3009                 spin_lock_irqsave(&tty->ctrl_lock, flags);
3010                 put_pid(tty->session);
3011                 put_pid(tty->pgrp);
3012                 tty->pgrp = get_pid(task_pgrp(tsk));
3013                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3014                 tty->session = get_pid(task_session(tsk));
3015                 if (tsk->signal->tty) {
3016                         printk(KERN_DEBUG "tty not NULL!!\n");
3017                         tty_kref_put(tsk->signal->tty);
3018                 }
3019         }
3020         put_pid(tsk->signal->tty_old_pgrp);
3021         tsk->signal->tty = tty_kref_get(tty);
3022         tsk->signal->tty_old_pgrp = NULL;
3023 }
3024
3025 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3026 {
3027         spin_lock_irq(&tsk->sighand->siglock);
3028         __proc_set_tty(tsk, tty);
3029         spin_unlock_irq(&tsk->sighand->siglock);
3030 }
3031
3032 struct tty_struct *get_current_tty(void)
3033 {
3034         struct tty_struct *tty;
3035         unsigned long flags;
3036
3037         spin_lock_irqsave(&current->sighand->siglock, flags);
3038         tty = tty_kref_get(current->signal->tty);
3039         spin_unlock_irqrestore(&current->sighand->siglock, flags);
3040         return tty;
3041 }
3042 EXPORT_SYMBOL_GPL(get_current_tty);
3043
3044 void tty_default_fops(struct file_operations *fops)
3045 {
3046         *fops = tty_fops;
3047 }
3048
3049 /*
3050  * Initialize the console device. This is called *early*, so
3051  * we can't necessarily depend on lots of kernel help here.
3052  * Just do some early initializations, and do the complex setup
3053  * later.
3054  */
3055 void __init console_init(void)
3056 {
3057         initcall_t *call;
3058
3059         /* Setup the default TTY line discipline. */
3060         tty_ldisc_begin();
3061
3062         /*
3063          * set up the console device so that later boot sequences can
3064          * inform about problems etc..
3065          */
3066         call = __con_initcall_start;
3067         while (call < __con_initcall_end) {
3068                 (*call)();
3069                 call++;
3070         }
3071 }
3072
3073 static char *tty_devnode(struct device *dev, mode_t *mode)
3074 {
3075         if (!mode)
3076                 return NULL;
3077         if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3078             dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3079                 *mode = 0666;
3080         return NULL;
3081 }
3082
3083 static int __init tty_class_init(void)
3084 {
3085         tty_class = class_create(THIS_MODULE, "tty");
3086         if (IS_ERR(tty_class))
3087                 return PTR_ERR(tty_class);
3088         tty_class->devnode = tty_devnode;
3089         return 0;
3090 }
3091
3092 postcore_initcall(tty_class_init);
3093
3094 /* 3/2004 jmc: why do these devices exist? */
3095
3096 static struct cdev tty_cdev, console_cdev;
3097
3098 /*
3099  * Ok, now we can initialize the rest of the tty devices and can count
3100  * on memory allocations, interrupts etc..
3101  */
3102 static int __init tty_init(void)
3103 {
3104         cdev_init(&tty_cdev, &tty_fops);
3105         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3106             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3107                 panic("Couldn't register /dev/tty driver\n");
3108         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
3109                               "tty");
3110
3111         cdev_init(&console_cdev, &console_fops);
3112         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3113             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3114                 panic("Couldn't register /dev/console driver\n");
3115         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3116                               "console");
3117
3118 #ifdef CONFIG_VT
3119         vty_init(&console_fops);
3120 #endif
3121         return 0;
3122 }
3123 module_init(tty_init);