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