[PATCH] files: lock-free fd look-up
[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 init_dev and 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() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
66  */
67
68 #include <linux/config.h>
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/console.h>
82 #include <linux/timer.h>
83 #include <linux/ctype.h>
84 #include <linux/kd.h>
85 #include <linux/mm.h>
86 #include <linux/string.h>
87 #include <linux/slab.h>
88 #include <linux/poll.h>
89 #include <linux/proc_fs.h>
90 #include <linux/init.h>
91 #include <linux/module.h>
92 #include <linux/smp_lock.h>
93 #include <linux/device.h>
94 #include <linux/idr.h>
95 #include <linux/wait.h>
96 #include <linux/bitops.h>
97 #include <linux/delay.h>
98
99 #include <asm/uaccess.h>
100 #include <asm/system.h>
101
102 #include <linux/kbd_kern.h>
103 #include <linux/vt_kern.h>
104 #include <linux/selection.h>
105 #include <linux/devfs_fs_kernel.h>
106
107 #include <linux/kmod.h>
108
109 #undef TTY_DEBUG_HANGUP
110
111 #define TTY_PARANOIA_CHECK 1
112 #define CHECK_TTY_COUNT 1
113
114 struct termios tty_std_termios = {      /* for the benefit of tty drivers  */
115         .c_iflag = ICRNL | IXON,
116         .c_oflag = OPOST | ONLCR,
117         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
118         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
119                    ECHOCTL | ECHOKE | IEXTEN,
120         .c_cc = INIT_C_CC
121 };
122
123 EXPORT_SYMBOL(tty_std_termios);
124
125 /* This list gets poked at by procfs and various bits of boot up code. This
126    could do with some rationalisation such as pulling the tty proc function
127    into this file */
128    
129 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
130
131 /* Semaphore to protect creating and releasing a tty. This is shared with
132    vt.c for deeply disgusting hack reasons */
133 DECLARE_MUTEX(tty_sem);
134
135 #ifdef CONFIG_UNIX98_PTYS
136 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
137 extern int pty_limit;           /* Config limit on Unix98 ptys */
138 static DEFINE_IDR(allocated_ptys);
139 static DECLARE_MUTEX(allocated_ptys_lock);
140 static int ptmx_open(struct inode *, struct file *);
141 #endif
142
143 extern void disable_early_printk(void);
144
145 static void initialize_tty_struct(struct tty_struct *tty);
146
147 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
148 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
149 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
150 static unsigned int tty_poll(struct file *, poll_table *);
151 static int tty_open(struct inode *, struct file *);
152 static int tty_release(struct inode *, struct file *);
153 int tty_ioctl(struct inode * inode, struct file * file,
154               unsigned int cmd, unsigned long arg);
155 static int tty_fasync(int fd, struct file * filp, int on);
156 static void release_mem(struct tty_struct *tty, int idx);
157
158
159 static struct tty_struct *alloc_tty_struct(void)
160 {
161         struct tty_struct *tty;
162
163         tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
164         if (tty)
165                 memset(tty, 0, sizeof(struct tty_struct));
166         return tty;
167 }
168
169 static inline void free_tty_struct(struct tty_struct *tty)
170 {
171         kfree(tty->write_buf);
172         kfree(tty);
173 }
174
175 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
176
177 char *tty_name(struct tty_struct *tty, char *buf)
178 {
179         if (!tty) /* Hmm.  NULL pointer.  That's fun. */
180                 strcpy(buf, "NULL tty");
181         else
182                 strcpy(buf, tty->name);
183         return buf;
184 }
185
186 EXPORT_SYMBOL(tty_name);
187
188 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
189                               const char *routine)
190 {
191 #ifdef TTY_PARANOIA_CHECK
192         if (!tty) {
193                 printk(KERN_WARNING
194                         "null TTY for (%d:%d) in %s\n",
195                         imajor(inode), iminor(inode), routine);
196                 return 1;
197         }
198         if (tty->magic != TTY_MAGIC) {
199                 printk(KERN_WARNING
200                         "bad magic number for tty struct (%d:%d) in %s\n",
201                         imajor(inode), iminor(inode), routine);
202                 return 1;
203         }
204 #endif
205         return 0;
206 }
207
208 static int check_tty_count(struct tty_struct *tty, const char *routine)
209 {
210 #ifdef CHECK_TTY_COUNT
211         struct list_head *p;
212         int count = 0;
213         
214         file_list_lock();
215         list_for_each(p, &tty->tty_files) {
216                 count++;
217         }
218         file_list_unlock();
219         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
220             tty->driver->subtype == PTY_TYPE_SLAVE &&
221             tty->link && tty->link->count)
222                 count++;
223         if (tty->count != count) {
224                 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
225                                     "!= #fd's(%d) in %s\n",
226                        tty->name, tty->count, count, routine);
227                 return count;
228        }        
229 #endif
230         return 0;
231 }
232
233 /*
234  *      This is probably overkill for real world processors but
235  *      they are not on hot paths so a little discipline won't do 
236  *      any harm.
237  */
238  
239 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
240 {
241         down(&tty->termios_sem);
242         tty->termios->c_line = num;
243         up(&tty->termios_sem);
244 }
245
246 /*
247  *      This guards the refcounted line discipline lists. The lock
248  *      must be taken with irqs off because there are hangup path
249  *      callers who will do ldisc lookups and cannot sleep.
250  */
251  
252 static DEFINE_SPINLOCK(tty_ldisc_lock);
253 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
254 static struct tty_ldisc tty_ldiscs[NR_LDISCS];  /* line disc dispatch table */
255
256 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
257 {
258         unsigned long flags;
259         int ret = 0;
260         
261         if (disc < N_TTY || disc >= NR_LDISCS)
262                 return -EINVAL;
263         
264         spin_lock_irqsave(&tty_ldisc_lock, flags);
265         tty_ldiscs[disc] = *new_ldisc;
266         tty_ldiscs[disc].num = disc;
267         tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
268         tty_ldiscs[disc].refcount = 0;
269         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
270         
271         return ret;
272 }
273 EXPORT_SYMBOL(tty_register_ldisc);
274
275 int tty_unregister_ldisc(int disc)
276 {
277         unsigned long flags;
278         int ret = 0;
279
280         if (disc < N_TTY || disc >= NR_LDISCS)
281                 return -EINVAL;
282
283         spin_lock_irqsave(&tty_ldisc_lock, flags);
284         if (tty_ldiscs[disc].refcount)
285                 ret = -EBUSY;
286         else
287                 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
288         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
289
290         return ret;
291 }
292 EXPORT_SYMBOL(tty_unregister_ldisc);
293
294 struct tty_ldisc *tty_ldisc_get(int disc)
295 {
296         unsigned long flags;
297         struct tty_ldisc *ld;
298
299         if (disc < N_TTY || disc >= NR_LDISCS)
300                 return NULL;
301         
302         spin_lock_irqsave(&tty_ldisc_lock, flags);
303
304         ld = &tty_ldiscs[disc];
305         /* Check the entry is defined */
306         if(ld->flags & LDISC_FLAG_DEFINED)
307         {
308                 /* If the module is being unloaded we can't use it */
309                 if (!try_module_get(ld->owner))
310                         ld = NULL;
311                 else /* lock it */
312                         ld->refcount++;
313         }
314         else
315                 ld = NULL;
316         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
317         return ld;
318 }
319
320 EXPORT_SYMBOL_GPL(tty_ldisc_get);
321
322 void tty_ldisc_put(int disc)
323 {
324         struct tty_ldisc *ld;
325         unsigned long flags;
326         
327         if (disc < N_TTY || disc >= NR_LDISCS)
328                 BUG();
329                 
330         spin_lock_irqsave(&tty_ldisc_lock, flags);
331         ld = &tty_ldiscs[disc];
332         if(ld->refcount == 0)
333                 BUG();
334         ld->refcount --;
335         module_put(ld->owner);
336         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
337 }
338         
339 EXPORT_SYMBOL_GPL(tty_ldisc_put);
340
341 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
342 {
343         tty->ldisc = *ld;
344         tty->ldisc.refcount = 0;
345 }
346
347 /**
348  *      tty_ldisc_try           -       internal helper
349  *      @tty: the tty
350  *
351  *      Make a single attempt to grab and bump the refcount on
352  *      the tty ldisc. Return 0 on failure or 1 on success. This is
353  *      used to implement both the waiting and non waiting versions
354  *      of tty_ldisc_ref
355  */
356
357 static int tty_ldisc_try(struct tty_struct *tty)
358 {
359         unsigned long flags;
360         struct tty_ldisc *ld;
361         int ret = 0;
362         
363         spin_lock_irqsave(&tty_ldisc_lock, flags);
364         ld = &tty->ldisc;
365         if(test_bit(TTY_LDISC, &tty->flags))
366         {
367                 ld->refcount++;
368                 ret = 1;
369         }
370         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
371         return ret;
372 }
373
374 /**
375  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
376  *      @tty: tty device
377  *
378  *      Dereference the line discipline for the terminal and take a 
379  *      reference to it. If the line discipline is in flux then 
380  *      wait patiently until it changes.
381  *
382  *      Note: Must not be called from an IRQ/timer context. The caller
383  *      must also be careful not to hold other locks that will deadlock
384  *      against a discipline change, such as an existing ldisc reference
385  *      (which we check for)
386  */
387  
388 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
389 {
390         /* wait_event is a macro */
391         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
392         if(tty->ldisc.refcount == 0)
393                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
394         return &tty->ldisc;
395 }
396
397 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
398
399 /**
400  *      tty_ldisc_ref           -       get the tty ldisc
401  *      @tty: tty device
402  *
403  *      Dereference the line discipline for the terminal and take a 
404  *      reference to it. If the line discipline is in flux then 
405  *      return NULL. Can be called from IRQ and timer functions.
406  */
407  
408 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
409 {
410         if(tty_ldisc_try(tty))
411                 return &tty->ldisc;
412         return NULL;
413 }
414
415 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
416
417 /**
418  *      tty_ldisc_deref         -       free a tty ldisc reference
419  *      @ld: reference to free up
420  *
421  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
422  *      be called in IRQ context.
423  */
424  
425 void tty_ldisc_deref(struct tty_ldisc *ld)
426 {
427         unsigned long flags;
428
429         if(ld == NULL)
430                 BUG();
431                 
432         spin_lock_irqsave(&tty_ldisc_lock, flags);
433         if(ld->refcount == 0)
434                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
435         else
436                 ld->refcount--;
437         if(ld->refcount == 0)
438                 wake_up(&tty_ldisc_wait);
439         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
440 }
441
442 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
443
444 /**
445  *      tty_ldisc_enable        -       allow ldisc use
446  *      @tty: terminal to activate ldisc on
447  *
448  *      Set the TTY_LDISC flag when the line discipline can be called
449  *      again. Do neccessary wakeups for existing sleepers.
450  *
451  *      Note: nobody should set this bit except via this function. Clearing
452  *      directly is allowed.
453  */
454
455 static void tty_ldisc_enable(struct tty_struct *tty)
456 {
457         set_bit(TTY_LDISC, &tty->flags);
458         wake_up(&tty_ldisc_wait);
459 }
460         
461 /**
462  *      tty_set_ldisc           -       set line discipline
463  *      @tty: the terminal to set
464  *      @ldisc: the line discipline
465  *
466  *      Set the discipline of a tty line. Must be called from a process
467  *      context.
468  */
469  
470 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
471 {
472         int retval = 0;
473         struct tty_ldisc o_ldisc;
474         char buf[64];
475         int work;
476         unsigned long flags;
477         struct tty_ldisc *ld;
478         struct tty_struct *o_tty;
479
480         if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
481                 return -EINVAL;
482
483 restart:
484
485         ld = tty_ldisc_get(ldisc);
486         /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
487         /* Cyrus Durgin <cider@speakeasy.org> */
488         if (ld == NULL) {
489                 request_module("tty-ldisc-%d", ldisc);
490                 ld = tty_ldisc_get(ldisc);
491         }
492         if (ld == NULL)
493                 return -EINVAL;
494
495         tty_wait_until_sent(tty, 0);
496
497         if (tty->ldisc.num == ldisc) {
498                 tty_ldisc_put(ldisc);
499                 return 0;
500         }
501
502         o_ldisc = tty->ldisc;
503         o_tty = tty->link;
504
505         /*
506          *      Make sure we don't change while someone holds a
507          *      reference to the line discipline. The TTY_LDISC bit
508          *      prevents anyone taking a reference once it is clear.
509          *      We need the lock to avoid racing reference takers.
510          */
511
512         spin_lock_irqsave(&tty_ldisc_lock, flags);
513         if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
514                 if(tty->ldisc.refcount) {
515                         /* Free the new ldisc we grabbed. Must drop the lock
516                            first. */
517                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
518                         tty_ldisc_put(ldisc);
519                         /*
520                          * There are several reasons we may be busy, including
521                          * random momentary I/O traffic. We must therefore
522                          * retry. We could distinguish between blocking ops
523                          * and retries if we made tty_ldisc_wait() smarter. That
524                          * is up for discussion.
525                          */
526                         if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
527                                 return -ERESTARTSYS;
528                         goto restart;
529                 }
530                 if(o_tty && o_tty->ldisc.refcount) {
531                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
532                         tty_ldisc_put(ldisc);
533                         if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
534                                 return -ERESTARTSYS;
535                         goto restart;
536                 }
537         }
538
539         /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
540
541         if (!test_bit(TTY_LDISC, &tty->flags)) {
542                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
543                 tty_ldisc_put(ldisc);
544                 ld = tty_ldisc_ref_wait(tty);
545                 tty_ldisc_deref(ld);
546                 goto restart;
547         }
548
549         clear_bit(TTY_LDISC, &tty->flags);
550         clear_bit(TTY_DONT_FLIP, &tty->flags);
551         if (o_tty) {
552                 clear_bit(TTY_LDISC, &o_tty->flags);
553                 clear_bit(TTY_DONT_FLIP, &o_tty->flags);
554         }
555         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
556
557         /*
558          *      From this point on we know nobody has an ldisc
559          *      usage reference, nor can they obtain one until
560          *      we say so later on.
561          */
562
563         work = cancel_delayed_work(&tty->flip.work);
564         /*
565          * Wait for ->hangup_work and ->flip.work handlers to terminate
566          */
567          
568         flush_scheduled_work();
569         /* Shutdown the current discipline. */
570         if (tty->ldisc.close)
571                 (tty->ldisc.close)(tty);
572
573         /* Now set up the new line discipline. */
574         tty_ldisc_assign(tty, ld);
575         tty_set_termios_ldisc(tty, ldisc);
576         if (tty->ldisc.open)
577                 retval = (tty->ldisc.open)(tty);
578         if (retval < 0) {
579                 tty_ldisc_put(ldisc);
580                 /* There is an outstanding reference here so this is safe */
581                 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
582                 tty_set_termios_ldisc(tty, tty->ldisc.num);
583                 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
584                         tty_ldisc_put(o_ldisc.num);
585                         /* This driver is always present */
586                         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
587                         tty_set_termios_ldisc(tty, N_TTY);
588                         if (tty->ldisc.open) {
589                                 int r = tty->ldisc.open(tty);
590
591                                 if (r < 0)
592                                         panic("Couldn't open N_TTY ldisc for "
593                                               "%s --- error %d.",
594                                               tty_name(tty, buf), r);
595                         }
596                 }
597         }
598         /* At this point we hold a reference to the new ldisc and a
599            a reference to the old ldisc. If we ended up flipping back
600            to the existing ldisc we have two references to it */
601         
602         if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
603                 tty->driver->set_ldisc(tty);
604                 
605         tty_ldisc_put(o_ldisc.num);
606         
607         /*
608          *      Allow ldisc referencing to occur as soon as the driver
609          *      ldisc callback completes.
610          */
611          
612         tty_ldisc_enable(tty);
613         if (o_tty)
614                 tty_ldisc_enable(o_tty);
615         
616         /* Restart it in case no characters kick it off. Safe if
617            already running */
618         if (work)
619                 schedule_delayed_work(&tty->flip.work, 1);
620         return retval;
621 }
622
623 /*
624  * This routine returns a tty driver structure, given a device number
625  */
626 static struct tty_driver *get_tty_driver(dev_t device, int *index)
627 {
628         struct tty_driver *p;
629
630         list_for_each_entry(p, &tty_drivers, tty_drivers) {
631                 dev_t base = MKDEV(p->major, p->minor_start);
632                 if (device < base || device >= base + p->num)
633                         continue;
634                 *index = device - base;
635                 return p;
636         }
637         return NULL;
638 }
639
640 /*
641  * If we try to write to, or set the state of, a terminal and we're
642  * not in the foreground, send a SIGTTOU.  If the signal is blocked or
643  * ignored, go ahead and perform the operation.  (POSIX 7.2)
644  */
645 int tty_check_change(struct tty_struct * tty)
646 {
647         if (current->signal->tty != tty)
648                 return 0;
649         if (tty->pgrp <= 0) {
650                 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
651                 return 0;
652         }
653         if (process_group(current) == tty->pgrp)
654                 return 0;
655         if (is_ignored(SIGTTOU))
656                 return 0;
657         if (is_orphaned_pgrp(process_group(current)))
658                 return -EIO;
659         (void) kill_pg(process_group(current), SIGTTOU, 1);
660         return -ERESTARTSYS;
661 }
662
663 EXPORT_SYMBOL(tty_check_change);
664
665 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
666                                 size_t count, loff_t *ppos)
667 {
668         return 0;
669 }
670
671 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
672                                  size_t count, loff_t *ppos)
673 {
674         return -EIO;
675 }
676
677 /* No kernel lock held - none needed ;) */
678 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
679 {
680         return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
681 }
682
683 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
684                              unsigned int cmd, unsigned long arg)
685 {
686         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
687 }
688
689 static struct file_operations tty_fops = {
690         .llseek         = no_llseek,
691         .read           = tty_read,
692         .write          = tty_write,
693         .poll           = tty_poll,
694         .ioctl          = tty_ioctl,
695         .open           = tty_open,
696         .release        = tty_release,
697         .fasync         = tty_fasync,
698 };
699
700 #ifdef CONFIG_UNIX98_PTYS
701 static struct file_operations ptmx_fops = {
702         .llseek         = no_llseek,
703         .read           = tty_read,
704         .write          = tty_write,
705         .poll           = tty_poll,
706         .ioctl          = tty_ioctl,
707         .open           = ptmx_open,
708         .release        = tty_release,
709         .fasync         = tty_fasync,
710 };
711 #endif
712
713 static struct file_operations console_fops = {
714         .llseek         = no_llseek,
715         .read           = tty_read,
716         .write          = redirected_tty_write,
717         .poll           = tty_poll,
718         .ioctl          = tty_ioctl,
719         .open           = tty_open,
720         .release        = tty_release,
721         .fasync         = tty_fasync,
722 };
723
724 static struct file_operations hung_up_tty_fops = {
725         .llseek         = no_llseek,
726         .read           = hung_up_tty_read,
727         .write          = hung_up_tty_write,
728         .poll           = hung_up_tty_poll,
729         .ioctl          = hung_up_tty_ioctl,
730         .release        = tty_release,
731 };
732
733 static DEFINE_SPINLOCK(redirect_lock);
734 static struct file *redirect;
735
736 /**
737  *      tty_wakeup      -       request more data
738  *      @tty: terminal
739  *
740  *      Internal and external helper for wakeups of tty. This function
741  *      informs the line discipline if present that the driver is ready
742  *      to receive more output data.
743  */
744  
745 void tty_wakeup(struct tty_struct *tty)
746 {
747         struct tty_ldisc *ld;
748         
749         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
750                 ld = tty_ldisc_ref(tty);
751                 if(ld) {
752                         if(ld->write_wakeup)
753                                 ld->write_wakeup(tty);
754                         tty_ldisc_deref(ld);
755                 }
756         }
757         wake_up_interruptible(&tty->write_wait);
758 }
759
760 EXPORT_SYMBOL_GPL(tty_wakeup);
761
762 /**
763  *      tty_ldisc_flush -       flush line discipline queue
764  *      @tty: tty
765  *
766  *      Flush the line discipline queue (if any) for this tty. If there
767  *      is no line discipline active this is a no-op.
768  */
769  
770 void tty_ldisc_flush(struct tty_struct *tty)
771 {
772         struct tty_ldisc *ld = tty_ldisc_ref(tty);
773         if(ld) {
774                 if(ld->flush_buffer)
775                         ld->flush_buffer(tty);
776                 tty_ldisc_deref(ld);
777         }
778 }
779
780 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
781         
782 /*
783  * This can be called by the "eventd" kernel thread.  That is process synchronous,
784  * but doesn't hold any locks, so we need to make sure we have the appropriate
785  * locks for what we're doing..
786  */
787 static void do_tty_hangup(void *data)
788 {
789         struct tty_struct *tty = (struct tty_struct *) data;
790         struct file * cons_filp = NULL;
791         struct file *filp, *f = NULL;
792         struct task_struct *p;
793         struct tty_ldisc *ld;
794         int    closecount = 0, n;
795
796         if (!tty)
797                 return;
798
799         /* inuse_filps is protected by the single kernel lock */
800         lock_kernel();
801
802         spin_lock(&redirect_lock);
803         if (redirect && redirect->private_data == tty) {
804                 f = redirect;
805                 redirect = NULL;
806         }
807         spin_unlock(&redirect_lock);
808         
809         check_tty_count(tty, "do_tty_hangup");
810         file_list_lock();
811         /* This breaks for file handles being sent over AF_UNIX sockets ? */
812         list_for_each_entry(filp, &tty->tty_files, f_list) {
813                 if (filp->f_op->write == redirected_tty_write)
814                         cons_filp = filp;
815                 if (filp->f_op->write != tty_write)
816                         continue;
817                 closecount++;
818                 tty_fasync(-1, filp, 0);        /* can't block */
819                 filp->f_op = &hung_up_tty_fops;
820         }
821         file_list_unlock();
822         
823         /* FIXME! What are the locking issues here? This may me overdoing things..
824          * this question is especially important now that we've removed the irqlock. */
825
826         ld = tty_ldisc_ref(tty);
827         if(ld != NULL)  /* We may have no line discipline at this point */
828         {
829                 if (ld->flush_buffer)
830                         ld->flush_buffer(tty);
831                 if (tty->driver->flush_buffer)
832                         tty->driver->flush_buffer(tty);
833                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
834                     ld->write_wakeup)
835                         ld->write_wakeup(tty);
836                 if (ld->hangup)
837                         ld->hangup(tty);
838         }
839
840         /* FIXME: Once we trust the LDISC code better we can wait here for
841            ldisc completion and fix the driver call race */
842            
843         wake_up_interruptible(&tty->write_wait);
844         wake_up_interruptible(&tty->read_wait);
845
846         /*
847          * Shutdown the current line discipline, and reset it to
848          * N_TTY.
849          */
850         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
851         {
852                 down(&tty->termios_sem);
853                 *tty->termios = tty->driver->init_termios;
854                 up(&tty->termios_sem);
855         }
856         
857         /* Defer ldisc switch */
858         /* tty_deferred_ldisc_switch(N_TTY);
859         
860           This should get done automatically when the port closes and
861           tty_release is called */
862         
863         read_lock(&tasklist_lock);
864         if (tty->session > 0) {
865                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
866                         if (p->signal->tty == tty)
867                                 p->signal->tty = NULL;
868                         if (!p->signal->leader)
869                                 continue;
870                         send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
871                         send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
872                         if (tty->pgrp > 0)
873                                 p->signal->tty_old_pgrp = tty->pgrp;
874                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
875         }
876         read_unlock(&tasklist_lock);
877
878         tty->flags = 0;
879         tty->session = 0;
880         tty->pgrp = -1;
881         tty->ctrl_status = 0;
882         /*
883          *      If one of the devices matches a console pointer, we
884          *      cannot just call hangup() because that will cause
885          *      tty->count and state->count to go out of sync.
886          *      So we just call close() the right number of times.
887          */
888         if (cons_filp) {
889                 if (tty->driver->close)
890                         for (n = 0; n < closecount; n++)
891                                 tty->driver->close(tty, cons_filp);
892         } else if (tty->driver->hangup)
893                 (tty->driver->hangup)(tty);
894                 
895         /* We don't want to have driver/ldisc interactions beyond
896            the ones we did here. The driver layer expects no
897            calls after ->hangup() from the ldisc side. However we
898            can't yet guarantee all that */
899
900         set_bit(TTY_HUPPED, &tty->flags);
901         if (ld) {
902                 tty_ldisc_enable(tty);
903                 tty_ldisc_deref(ld);
904         }
905         unlock_kernel();
906         if (f)
907                 fput(f);
908 }
909
910 void tty_hangup(struct tty_struct * tty)
911 {
912 #ifdef TTY_DEBUG_HANGUP
913         char    buf[64];
914         
915         printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
916 #endif
917         schedule_work(&tty->hangup_work);
918 }
919
920 EXPORT_SYMBOL(tty_hangup);
921
922 void tty_vhangup(struct tty_struct * tty)
923 {
924 #ifdef TTY_DEBUG_HANGUP
925         char    buf[64];
926
927         printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
928 #endif
929         do_tty_hangup((void *) tty);
930 }
931 EXPORT_SYMBOL(tty_vhangup);
932
933 int tty_hung_up_p(struct file * filp)
934 {
935         return (filp->f_op == &hung_up_tty_fops);
936 }
937
938 EXPORT_SYMBOL(tty_hung_up_p);
939
940 /*
941  * This function is typically called only by the session leader, when
942  * it wants to disassociate itself from its controlling tty.
943  *
944  * It performs the following functions:
945  *      (1)  Sends a SIGHUP and SIGCONT to the foreground process group
946  *      (2)  Clears the tty from being controlling the session
947  *      (3)  Clears the controlling tty for all processes in the
948  *              session group.
949  *
950  * The argument on_exit is set to 1 if called when a process is
951  * exiting; it is 0 if called by the ioctl TIOCNOTTY.
952  */
953 void disassociate_ctty(int on_exit)
954 {
955         struct tty_struct *tty;
956         struct task_struct *p;
957         int tty_pgrp = -1;
958
959         lock_kernel();
960
961         down(&tty_sem);
962         tty = current->signal->tty;
963         if (tty) {
964                 tty_pgrp = tty->pgrp;
965                 up(&tty_sem);
966                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
967                         tty_vhangup(tty);
968         } else {
969                 if (current->signal->tty_old_pgrp) {
970                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
971                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
972                 }
973                 up(&tty_sem);
974                 unlock_kernel();        
975                 return;
976         }
977         if (tty_pgrp > 0) {
978                 kill_pg(tty_pgrp, SIGHUP, on_exit);
979                 if (!on_exit)
980                         kill_pg(tty_pgrp, SIGCONT, on_exit);
981         }
982
983         /* Must lock changes to tty_old_pgrp */
984         down(&tty_sem);
985         current->signal->tty_old_pgrp = 0;
986         tty->session = 0;
987         tty->pgrp = -1;
988
989         /* Now clear signal->tty under the lock */
990         read_lock(&tasklist_lock);
991         do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
992                 p->signal->tty = NULL;
993         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
994         read_unlock(&tasklist_lock);
995         up(&tty_sem);
996         unlock_kernel();
997 }
998
999 void stop_tty(struct tty_struct *tty)
1000 {
1001         if (tty->stopped)
1002                 return;
1003         tty->stopped = 1;
1004         if (tty->link && tty->link->packet) {
1005                 tty->ctrl_status &= ~TIOCPKT_START;
1006                 tty->ctrl_status |= TIOCPKT_STOP;
1007                 wake_up_interruptible(&tty->link->read_wait);
1008         }
1009         if (tty->driver->stop)
1010                 (tty->driver->stop)(tty);
1011 }
1012
1013 EXPORT_SYMBOL(stop_tty);
1014
1015 void start_tty(struct tty_struct *tty)
1016 {
1017         if (!tty->stopped || tty->flow_stopped)
1018                 return;
1019         tty->stopped = 0;
1020         if (tty->link && tty->link->packet) {
1021                 tty->ctrl_status &= ~TIOCPKT_STOP;
1022                 tty->ctrl_status |= TIOCPKT_START;
1023                 wake_up_interruptible(&tty->link->read_wait);
1024         }
1025         if (tty->driver->start)
1026                 (tty->driver->start)(tty);
1027
1028         /* If we have a running line discipline it may need kicking */
1029         tty_wakeup(tty);
1030         wake_up_interruptible(&tty->write_wait);
1031 }
1032
1033 EXPORT_SYMBOL(start_tty);
1034
1035 static ssize_t tty_read(struct file * file, char __user * buf, size_t count, 
1036                         loff_t *ppos)
1037 {
1038         int i;
1039         struct tty_struct * tty;
1040         struct inode *inode;
1041         struct tty_ldisc *ld;
1042
1043         tty = (struct tty_struct *)file->private_data;
1044         inode = file->f_dentry->d_inode;
1045         if (tty_paranoia_check(tty, inode, "tty_read"))
1046                 return -EIO;
1047         if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1048                 return -EIO;
1049
1050         /* We want to wait for the line discipline to sort out in this
1051            situation */
1052         ld = tty_ldisc_ref_wait(tty);
1053         lock_kernel();
1054         if (ld->read)
1055                 i = (ld->read)(tty,file,buf,count);
1056         else
1057                 i = -EIO;
1058         tty_ldisc_deref(ld);
1059         unlock_kernel();
1060         if (i > 0)
1061                 inode->i_atime = current_fs_time(inode->i_sb);
1062         return i;
1063 }
1064
1065 /*
1066  * Split writes up in sane blocksizes to avoid
1067  * denial-of-service type attacks
1068  */
1069 static inline ssize_t do_tty_write(
1070         ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1071         struct tty_struct *tty,
1072         struct file *file,
1073         const char __user *buf,
1074         size_t count)
1075 {
1076         ssize_t ret = 0, written = 0;
1077         unsigned int chunk;
1078         
1079         if (down_interruptible(&tty->atomic_write)) {
1080                 return -ERESTARTSYS;
1081         }
1082
1083         /*
1084          * We chunk up writes into a temporary buffer. This
1085          * simplifies low-level drivers immensely, since they
1086          * don't have locking issues and user mode accesses.
1087          *
1088          * But if TTY_NO_WRITE_SPLIT is set, we should use a
1089          * big chunk-size..
1090          *
1091          * The default chunk-size is 2kB, because the NTTY
1092          * layer has problems with bigger chunks. It will
1093          * claim to be able to handle more characters than
1094          * it actually does.
1095          */
1096         chunk = 2048;
1097         if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1098                 chunk = 65536;
1099         if (count < chunk)
1100                 chunk = count;
1101
1102         /* write_buf/write_cnt is protected by the atomic_write semaphore */
1103         if (tty->write_cnt < chunk) {
1104                 unsigned char *buf;
1105
1106                 if (chunk < 1024)
1107                         chunk = 1024;
1108
1109                 buf = kmalloc(chunk, GFP_KERNEL);
1110                 if (!buf) {
1111                         up(&tty->atomic_write);
1112                         return -ENOMEM;
1113                 }
1114                 kfree(tty->write_buf);
1115                 tty->write_cnt = chunk;
1116                 tty->write_buf = buf;
1117         }
1118
1119         /* Do the write .. */
1120         for (;;) {
1121                 size_t size = count;
1122                 if (size > chunk)
1123                         size = chunk;
1124                 ret = -EFAULT;
1125                 if (copy_from_user(tty->write_buf, buf, size))
1126                         break;
1127                 lock_kernel();
1128                 ret = write(tty, file, tty->write_buf, size);
1129                 unlock_kernel();
1130                 if (ret <= 0)
1131                         break;
1132                 written += ret;
1133                 buf += ret;
1134                 count -= ret;
1135                 if (!count)
1136                         break;
1137                 ret = -ERESTARTSYS;
1138                 if (signal_pending(current))
1139                         break;
1140                 cond_resched();
1141         }
1142         if (written) {
1143                 struct inode *inode = file->f_dentry->d_inode;
1144                 inode->i_mtime = current_fs_time(inode->i_sb);
1145                 ret = written;
1146         }
1147         up(&tty->atomic_write);
1148         return ret;
1149 }
1150
1151
1152 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1153                          loff_t *ppos)
1154 {
1155         struct tty_struct * tty;
1156         struct inode *inode = file->f_dentry->d_inode;
1157         ssize_t ret;
1158         struct tty_ldisc *ld;
1159         
1160         tty = (struct tty_struct *)file->private_data;
1161         if (tty_paranoia_check(tty, inode, "tty_write"))
1162                 return -EIO;
1163         if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1164                 return -EIO;
1165
1166         ld = tty_ldisc_ref_wait(tty);           
1167         if (!ld->write)
1168                 ret = -EIO;
1169         else
1170                 ret = do_tty_write(ld->write, tty, file, buf, count);
1171         tty_ldisc_deref(ld);
1172         return ret;
1173 }
1174
1175 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1176                          loff_t *ppos)
1177 {
1178         struct file *p = NULL;
1179
1180         spin_lock(&redirect_lock);
1181         if (redirect) {
1182                 get_file(redirect);
1183                 p = redirect;
1184         }
1185         spin_unlock(&redirect_lock);
1186
1187         if (p) {
1188                 ssize_t res;
1189                 res = vfs_write(p, buf, count, &p->f_pos);
1190                 fput(p);
1191                 return res;
1192         }
1193
1194         return tty_write(file, buf, count, ppos);
1195 }
1196
1197 static char ptychar[] = "pqrstuvwxyzabcde";
1198
1199 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1200 {
1201         int i = index + driver->name_base;
1202         /* ->name is initialized to "ttyp", but "tty" is expected */
1203         sprintf(p, "%s%c%x",
1204                         driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1205                         ptychar[i >> 4 & 0xf], i & 0xf);
1206 }
1207
1208 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1209 {
1210         sprintf(p, "%s%d", driver->name, index + driver->name_base);
1211 }
1212
1213 /*
1214  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1215  * failed open.  The new code protects the open with a semaphore, so it's
1216  * really quite straightforward.  The semaphore locking can probably be
1217  * relaxed for the (most common) case of reopening a tty.
1218  */
1219 static int init_dev(struct tty_driver *driver, int idx,
1220         struct tty_struct **ret_tty)
1221 {
1222         struct tty_struct *tty, *o_tty;
1223         struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1224         struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1225         int retval=0;
1226
1227         /* check whether we're reopening an existing tty */
1228         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1229                 tty = devpts_get_tty(idx);
1230                 if (tty && driver->subtype == PTY_TYPE_MASTER)
1231                         tty = tty->link;
1232         } else {
1233                 tty = driver->ttys[idx];
1234         }
1235         if (tty) goto fast_track;
1236
1237         /*
1238          * First time open is complex, especially for PTY devices.
1239          * This code guarantees that either everything succeeds and the
1240          * TTY is ready for operation, or else the table slots are vacated
1241          * and the allocated memory released.  (Except that the termios 
1242          * and locked termios may be retained.)
1243          */
1244
1245         if (!try_module_get(driver->owner)) {
1246                 retval = -ENODEV;
1247                 goto end_init;
1248         }
1249
1250         o_tty = NULL;
1251         tp = o_tp = NULL;
1252         ltp = o_ltp = NULL;
1253
1254         tty = alloc_tty_struct();
1255         if(!tty)
1256                 goto fail_no_mem;
1257         initialize_tty_struct(tty);
1258         tty->driver = driver;
1259         tty->index = idx;
1260         tty_line_name(driver, idx, tty->name);
1261
1262         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1263                 tp_loc = &tty->termios;
1264                 ltp_loc = &tty->termios_locked;
1265         } else {
1266                 tp_loc = &driver->termios[idx];
1267                 ltp_loc = &driver->termios_locked[idx];
1268         }
1269
1270         if (!*tp_loc) {
1271                 tp = (struct termios *) kmalloc(sizeof(struct termios),
1272                                                 GFP_KERNEL);
1273                 if (!tp)
1274                         goto free_mem_out;
1275                 *tp = driver->init_termios;
1276         }
1277
1278         if (!*ltp_loc) {
1279                 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1280                                                  GFP_KERNEL);
1281                 if (!ltp)
1282                         goto free_mem_out;
1283                 memset(ltp, 0, sizeof(struct termios));
1284         }
1285
1286         if (driver->type == TTY_DRIVER_TYPE_PTY) {
1287                 o_tty = alloc_tty_struct();
1288                 if (!o_tty)
1289                         goto free_mem_out;
1290                 initialize_tty_struct(o_tty);
1291                 o_tty->driver = driver->other;
1292                 o_tty->index = idx;
1293                 tty_line_name(driver->other, idx, o_tty->name);
1294
1295                 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1296                         o_tp_loc = &o_tty->termios;
1297                         o_ltp_loc = &o_tty->termios_locked;
1298                 } else {
1299                         o_tp_loc = &driver->other->termios[idx];
1300                         o_ltp_loc = &driver->other->termios_locked[idx];
1301                 }
1302
1303                 if (!*o_tp_loc) {
1304                         o_tp = (struct termios *)
1305                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1306                         if (!o_tp)
1307                                 goto free_mem_out;
1308                         *o_tp = driver->other->init_termios;
1309                 }
1310
1311                 if (!*o_ltp_loc) {
1312                         o_ltp = (struct termios *)
1313                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1314                         if (!o_ltp)
1315                                 goto free_mem_out;
1316                         memset(o_ltp, 0, sizeof(struct termios));
1317                 }
1318
1319                 /*
1320                  * Everything allocated ... set up the o_tty structure.
1321                  */
1322                 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1323                         driver->other->ttys[idx] = o_tty;
1324                 }
1325                 if (!*o_tp_loc)
1326                         *o_tp_loc = o_tp;
1327                 if (!*o_ltp_loc)
1328                         *o_ltp_loc = o_ltp;
1329                 o_tty->termios = *o_tp_loc;
1330                 o_tty->termios_locked = *o_ltp_loc;
1331                 driver->other->refcount++;
1332                 if (driver->subtype == PTY_TYPE_MASTER)
1333                         o_tty->count++;
1334
1335                 /* Establish the links in both directions */
1336                 tty->link   = o_tty;
1337                 o_tty->link = tty;
1338         }
1339
1340         /* 
1341          * All structures have been allocated, so now we install them.
1342          * Failures after this point use release_mem to clean up, so 
1343          * there's no need to null out the local pointers.
1344          */
1345         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1346                 driver->ttys[idx] = tty;
1347         }
1348         
1349         if (!*tp_loc)
1350                 *tp_loc = tp;
1351         if (!*ltp_loc)
1352                 *ltp_loc = ltp;
1353         tty->termios = *tp_loc;
1354         tty->termios_locked = *ltp_loc;
1355         driver->refcount++;
1356         tty->count++;
1357
1358         /* 
1359          * Structures all installed ... call the ldisc open routines.
1360          * If we fail here just call release_mem to clean up.  No need
1361          * to decrement the use counts, as release_mem doesn't care.
1362          */
1363
1364         if (tty->ldisc.open) {
1365                 retval = (tty->ldisc.open)(tty);
1366                 if (retval)
1367                         goto release_mem_out;
1368         }
1369         if (o_tty && o_tty->ldisc.open) {
1370                 retval = (o_tty->ldisc.open)(o_tty);
1371                 if (retval) {
1372                         if (tty->ldisc.close)
1373                                 (tty->ldisc.close)(tty);
1374                         goto release_mem_out;
1375                 }
1376                 tty_ldisc_enable(o_tty);
1377         }
1378         tty_ldisc_enable(tty);
1379         goto success;
1380
1381         /*
1382          * This fast open can be used if the tty is already open.
1383          * No memory is allocated, and the only failures are from
1384          * attempting to open a closing tty or attempting multiple
1385          * opens on a pty master.
1386          */
1387 fast_track:
1388         if (test_bit(TTY_CLOSING, &tty->flags)) {
1389                 retval = -EIO;
1390                 goto end_init;
1391         }
1392         if (driver->type == TTY_DRIVER_TYPE_PTY &&
1393             driver->subtype == PTY_TYPE_MASTER) {
1394                 /*
1395                  * special case for PTY masters: only one open permitted, 
1396                  * and the slave side open count is incremented as well.
1397                  */
1398                 if (tty->count) {
1399                         retval = -EIO;
1400                         goto end_init;
1401                 }
1402                 tty->link->count++;
1403         }
1404         tty->count++;
1405         tty->driver = driver; /* N.B. why do this every time?? */
1406
1407         /* FIXME */
1408         if(!test_bit(TTY_LDISC, &tty->flags))
1409                 printk(KERN_ERR "init_dev but no ldisc\n");
1410 success:
1411         *ret_tty = tty;
1412         
1413         /* All paths come through here to release the semaphore */
1414 end_init:
1415         return retval;
1416
1417         /* Release locally allocated memory ... nothing placed in slots */
1418 free_mem_out:
1419         if (o_tp)
1420                 kfree(o_tp);
1421         if (o_tty)
1422                 free_tty_struct(o_tty);
1423         if (ltp)
1424                 kfree(ltp);
1425         if (tp)
1426                 kfree(tp);
1427         free_tty_struct(tty);
1428
1429 fail_no_mem:
1430         module_put(driver->owner);
1431         retval = -ENOMEM;
1432         goto end_init;
1433
1434         /* call the tty release_mem routine to clean out this slot */
1435 release_mem_out:
1436         printk(KERN_INFO "init_dev: ldisc open failed, "
1437                          "clearing slot %d\n", idx);
1438         release_mem(tty, idx);
1439         goto end_init;
1440 }
1441
1442 /*
1443  * Releases memory associated with a tty structure, and clears out the
1444  * driver table slots.
1445  */
1446 static void release_mem(struct tty_struct *tty, int idx)
1447 {
1448         struct tty_struct *o_tty;
1449         struct termios *tp;
1450         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1451
1452         if ((o_tty = tty->link) != NULL) {
1453                 if (!devpts)
1454                         o_tty->driver->ttys[idx] = NULL;
1455                 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1456                         tp = o_tty->termios;
1457                         if (!devpts)
1458                                 o_tty->driver->termios[idx] = NULL;
1459                         kfree(tp);
1460
1461                         tp = o_tty->termios_locked;
1462                         if (!devpts)
1463                                 o_tty->driver->termios_locked[idx] = NULL;
1464                         kfree(tp);
1465                 }
1466                 o_tty->magic = 0;
1467                 o_tty->driver->refcount--;
1468                 file_list_lock();
1469                 list_del_init(&o_tty->tty_files);
1470                 file_list_unlock();
1471                 free_tty_struct(o_tty);
1472         }
1473
1474         if (!devpts)
1475                 tty->driver->ttys[idx] = NULL;
1476         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1477                 tp = tty->termios;
1478                 if (!devpts)
1479                         tty->driver->termios[idx] = NULL;
1480                 kfree(tp);
1481
1482                 tp = tty->termios_locked;
1483                 if (!devpts)
1484                         tty->driver->termios_locked[idx] = NULL;
1485                 kfree(tp);
1486         }
1487
1488         tty->magic = 0;
1489         tty->driver->refcount--;
1490         file_list_lock();
1491         list_del_init(&tty->tty_files);
1492         file_list_unlock();
1493         module_put(tty->driver->owner);
1494         free_tty_struct(tty);
1495 }
1496
1497 /*
1498  * Even releasing the tty structures is a tricky business.. We have
1499  * to be very careful that the structures are all released at the
1500  * same time, as interrupts might otherwise get the wrong pointers.
1501  *
1502  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1503  * lead to double frees or releasing memory still in use.
1504  */
1505 static void release_dev(struct file * filp)
1506 {
1507         struct tty_struct *tty, *o_tty;
1508         int     pty_master, tty_closing, o_tty_closing, do_sleep;
1509         int     devpts_master, devpts;
1510         int     idx;
1511         char    buf[64];
1512         unsigned long flags;
1513         
1514         tty = (struct tty_struct *)filp->private_data;
1515         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1516                 return;
1517
1518         check_tty_count(tty, "release_dev");
1519
1520         tty_fasync(-1, filp, 0);
1521
1522         idx = tty->index;
1523         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1524                       tty->driver->subtype == PTY_TYPE_MASTER);
1525         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1526         devpts_master = pty_master && devpts;
1527         o_tty = tty->link;
1528
1529 #ifdef TTY_PARANOIA_CHECK
1530         if (idx < 0 || idx >= tty->driver->num) {
1531                 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1532                                   "free (%s)\n", tty->name);
1533                 return;
1534         }
1535         if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1536                 if (tty != tty->driver->ttys[idx]) {
1537                         printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1538                                "for (%s)\n", idx, tty->name);
1539                         return;
1540                 }
1541                 if (tty->termios != tty->driver->termios[idx]) {
1542                         printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1543                                "for (%s)\n",
1544                                idx, tty->name);
1545                         return;
1546                 }
1547                 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1548                         printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1549                                "termios_locked for (%s)\n",
1550                                idx, tty->name);
1551                         return;
1552                 }
1553         }
1554 #endif
1555
1556 #ifdef TTY_DEBUG_HANGUP
1557         printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1558                tty_name(tty, buf), tty->count);
1559 #endif
1560
1561 #ifdef TTY_PARANOIA_CHECK
1562         if (tty->driver->other &&
1563              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1564                 if (o_tty != tty->driver->other->ttys[idx]) {
1565                         printk(KERN_DEBUG "release_dev: other->table[%d] "
1566                                           "not o_tty for (%s)\n",
1567                                idx, tty->name);
1568                         return;
1569                 }
1570                 if (o_tty->termios != tty->driver->other->termios[idx]) {
1571                         printk(KERN_DEBUG "release_dev: other->termios[%d] "
1572                                           "not o_termios for (%s)\n",
1573                                idx, tty->name);
1574                         return;
1575                 }
1576                 if (o_tty->termios_locked != 
1577                       tty->driver->other->termios_locked[idx]) {
1578                         printk(KERN_DEBUG "release_dev: other->termios_locked["
1579                                           "%d] not o_termios_locked for (%s)\n",
1580                                idx, tty->name);
1581                         return;
1582                 }
1583                 if (o_tty->link != tty) {
1584                         printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1585                         return;
1586                 }
1587         }
1588 #endif
1589         if (tty->driver->close)
1590                 tty->driver->close(tty, filp);
1591
1592         /*
1593          * Sanity check: if tty->count is going to zero, there shouldn't be
1594          * any waiters on tty->read_wait or tty->write_wait.  We test the
1595          * wait queues and kick everyone out _before_ actually starting to
1596          * close.  This ensures that we won't block while releasing the tty
1597          * structure.
1598          *
1599          * The test for the o_tty closing is necessary, since the master and
1600          * slave sides may close in any order.  If the slave side closes out
1601          * first, its count will be one, since the master side holds an open.
1602          * Thus this test wouldn't be triggered at the time the slave closes,
1603          * so we do it now.
1604          *
1605          * Note that it's possible for the tty to be opened again while we're
1606          * flushing out waiters.  By recalculating the closing flags before
1607          * each iteration we avoid any problems.
1608          */
1609         while (1) {
1610                 /* Guard against races with tty->count changes elsewhere and
1611                    opens on /dev/tty */
1612                    
1613                 down(&tty_sem);
1614                 tty_closing = tty->count <= 1;
1615                 o_tty_closing = o_tty &&
1616                         (o_tty->count <= (pty_master ? 1 : 0));
1617                 up(&tty_sem);
1618                 do_sleep = 0;
1619
1620                 if (tty_closing) {
1621                         if (waitqueue_active(&tty->read_wait)) {
1622                                 wake_up(&tty->read_wait);
1623                                 do_sleep++;
1624                         }
1625                         if (waitqueue_active(&tty->write_wait)) {
1626                                 wake_up(&tty->write_wait);
1627                                 do_sleep++;
1628                         }
1629                 }
1630                 if (o_tty_closing) {
1631                         if (waitqueue_active(&o_tty->read_wait)) {
1632                                 wake_up(&o_tty->read_wait);
1633                                 do_sleep++;
1634                         }
1635                         if (waitqueue_active(&o_tty->write_wait)) {
1636                                 wake_up(&o_tty->write_wait);
1637                                 do_sleep++;
1638                         }
1639                 }
1640                 if (!do_sleep)
1641                         break;
1642
1643                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1644                                     "active!\n", tty_name(tty, buf));
1645                 schedule();
1646         }       
1647
1648         /*
1649          * The closing flags are now consistent with the open counts on 
1650          * both sides, and we've completed the last operation that could 
1651          * block, so it's safe to proceed with closing.
1652          */
1653          
1654         down(&tty_sem);
1655         if (pty_master) {
1656                 if (--o_tty->count < 0) {
1657                         printk(KERN_WARNING "release_dev: bad pty slave count "
1658                                             "(%d) for %s\n",
1659                                o_tty->count, tty_name(o_tty, buf));
1660                         o_tty->count = 0;
1661                 }
1662         }
1663         if (--tty->count < 0) {
1664                 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1665                        tty->count, tty_name(tty, buf));
1666                 tty->count = 0;
1667         }
1668         up(&tty_sem);
1669         
1670         /*
1671          * We've decremented tty->count, so we need to remove this file
1672          * descriptor off the tty->tty_files list; this serves two
1673          * purposes:
1674          *  - check_tty_count sees the correct number of file descriptors
1675          *    associated with this tty.
1676          *  - do_tty_hangup no longer sees this file descriptor as
1677          *    something that needs to be handled for hangups.
1678          */
1679         file_kill(filp);
1680         filp->private_data = NULL;
1681
1682         /*
1683          * Perform some housekeeping before deciding whether to return.
1684          *
1685          * Set the TTY_CLOSING flag if this was the last open.  In the
1686          * case of a pty we may have to wait around for the other side
1687          * to close, and TTY_CLOSING makes sure we can't be reopened.
1688          */
1689         if(tty_closing)
1690                 set_bit(TTY_CLOSING, &tty->flags);
1691         if(o_tty_closing)
1692                 set_bit(TTY_CLOSING, &o_tty->flags);
1693
1694         /*
1695          * If _either_ side is closing, make sure there aren't any
1696          * processes that still think tty or o_tty is their controlling
1697          * tty.
1698          */
1699         if (tty_closing || o_tty_closing) {
1700                 struct task_struct *p;
1701
1702                 read_lock(&tasklist_lock);
1703                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1704                         p->signal->tty = NULL;
1705                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1706                 if (o_tty)
1707                         do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1708                                 p->signal->tty = NULL;
1709                         } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1710                 read_unlock(&tasklist_lock);
1711         }
1712
1713         /* check whether both sides are closing ... */
1714         if (!tty_closing || (o_tty && !o_tty_closing))
1715                 return;
1716         
1717 #ifdef TTY_DEBUG_HANGUP
1718         printk(KERN_DEBUG "freeing tty structure...");
1719 #endif
1720         /*
1721          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
1722          * kill any delayed work. As this is the final close it does not
1723          * race with the set_ldisc code path.
1724          */
1725         clear_bit(TTY_LDISC, &tty->flags);
1726         clear_bit(TTY_DONT_FLIP, &tty->flags);
1727         cancel_delayed_work(&tty->flip.work);
1728
1729         /*
1730          * Wait for ->hangup_work and ->flip.work handlers to terminate
1731          */
1732          
1733         flush_scheduled_work();
1734         
1735         /*
1736          * Wait for any short term users (we know they are just driver
1737          * side waiters as the file is closing so user count on the file
1738          * side is zero.
1739          */
1740         spin_lock_irqsave(&tty_ldisc_lock, flags);
1741         while(tty->ldisc.refcount)
1742         {
1743                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1744                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1745                 spin_lock_irqsave(&tty_ldisc_lock, flags);
1746         }
1747         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1748         /*
1749          * Shutdown the current line discipline, and reset it to N_TTY.
1750          * N.B. why reset ldisc when we're releasing the memory??
1751          *
1752          * FIXME: this MUST get fixed for the new reflocking
1753          */
1754         if (tty->ldisc.close)
1755                 (tty->ldisc.close)(tty);
1756         tty_ldisc_put(tty->ldisc.num);
1757         
1758         /*
1759          *      Switch the line discipline back
1760          */
1761         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1762         tty_set_termios_ldisc(tty,N_TTY); 
1763         if (o_tty) {
1764                 /* FIXME: could o_tty be in setldisc here ? */
1765                 clear_bit(TTY_LDISC, &o_tty->flags);
1766                 if (o_tty->ldisc.close)
1767                         (o_tty->ldisc.close)(o_tty);
1768                 tty_ldisc_put(o_tty->ldisc.num);
1769                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1770                 tty_set_termios_ldisc(o_tty,N_TTY); 
1771         }
1772         /*
1773          * The release_mem function takes care of the details of clearing
1774          * the slots and preserving the termios structure.
1775          */
1776         release_mem(tty, idx);
1777
1778 #ifdef CONFIG_UNIX98_PTYS
1779         /* Make this pty number available for reallocation */
1780         if (devpts) {
1781                 down(&allocated_ptys_lock);
1782                 idr_remove(&allocated_ptys, idx);
1783                 up(&allocated_ptys_lock);
1784         }
1785 #endif
1786
1787 }
1788
1789 /*
1790  * tty_open and tty_release keep up the tty count that contains the
1791  * number of opens done on a tty. We cannot use the inode-count, as
1792  * different inodes might point to the same tty.
1793  *
1794  * Open-counting is needed for pty masters, as well as for keeping
1795  * track of serial lines: DTR is dropped when the last close happens.
1796  * (This is not done solely through tty->count, now.  - Ted 1/27/92)
1797  *
1798  * The termios state of a pty is reset on first open so that
1799  * settings don't persist across reuse.
1800  */
1801 static int tty_open(struct inode * inode, struct file * filp)
1802 {
1803         struct tty_struct *tty;
1804         int noctty, retval;
1805         struct tty_driver *driver;
1806         int index;
1807         dev_t device = inode->i_rdev;
1808         unsigned short saved_flags = filp->f_flags;
1809
1810         nonseekable_open(inode, filp);
1811         
1812 retry_open:
1813         noctty = filp->f_flags & O_NOCTTY;
1814         index  = -1;
1815         retval = 0;
1816         
1817         down(&tty_sem);
1818
1819         if (device == MKDEV(TTYAUX_MAJOR,0)) {
1820                 if (!current->signal->tty) {
1821                         up(&tty_sem);
1822                         return -ENXIO;
1823                 }
1824                 driver = current->signal->tty->driver;
1825                 index = current->signal->tty->index;
1826                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1827                 /* noctty = 1; */
1828                 goto got_driver;
1829         }
1830 #ifdef CONFIG_VT
1831         if (device == MKDEV(TTY_MAJOR,0)) {
1832                 extern struct tty_driver *console_driver;
1833                 driver = console_driver;
1834                 index = fg_console;
1835                 noctty = 1;
1836                 goto got_driver;
1837         }
1838 #endif
1839         if (device == MKDEV(TTYAUX_MAJOR,1)) {
1840                 driver = console_device(&index);
1841                 if (driver) {
1842                         /* Don't let /dev/console block */
1843                         filp->f_flags |= O_NONBLOCK;
1844                         noctty = 1;
1845                         goto got_driver;
1846                 }
1847                 up(&tty_sem);
1848                 return -ENODEV;
1849         }
1850
1851         driver = get_tty_driver(device, &index);
1852         if (!driver) {
1853                 up(&tty_sem);
1854                 return -ENODEV;
1855         }
1856 got_driver:
1857         retval = init_dev(driver, index, &tty);
1858         up(&tty_sem);
1859         if (retval)
1860                 return retval;
1861
1862         filp->private_data = tty;
1863         file_move(filp, &tty->tty_files);
1864         check_tty_count(tty, "tty_open");
1865         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1866             tty->driver->subtype == PTY_TYPE_MASTER)
1867                 noctty = 1;
1868 #ifdef TTY_DEBUG_HANGUP
1869         printk(KERN_DEBUG "opening %s...", tty->name);
1870 #endif
1871         if (!retval) {
1872                 if (tty->driver->open)
1873                         retval = tty->driver->open(tty, filp);
1874                 else
1875                         retval = -ENODEV;
1876         }
1877         filp->f_flags = saved_flags;
1878
1879         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1880                 retval = -EBUSY;
1881
1882         if (retval) {
1883 #ifdef TTY_DEBUG_HANGUP
1884                 printk(KERN_DEBUG "error %d in opening %s...", retval,
1885                        tty->name);
1886 #endif
1887                 release_dev(filp);
1888                 if (retval != -ERESTARTSYS)
1889                         return retval;
1890                 if (signal_pending(current))
1891                         return retval;
1892                 schedule();
1893                 /*
1894                  * Need to reset f_op in case a hangup happened.
1895                  */
1896                 if (filp->f_op == &hung_up_tty_fops)
1897                         filp->f_op = &tty_fops;
1898                 goto retry_open;
1899         }
1900         if (!noctty &&
1901             current->signal->leader &&
1902             !current->signal->tty &&
1903             tty->session == 0) {
1904                 task_lock(current);
1905                 current->signal->tty = tty;
1906                 task_unlock(current);
1907                 current->signal->tty_old_pgrp = 0;
1908                 tty->session = current->signal->session;
1909                 tty->pgrp = process_group(current);
1910         }
1911         return 0;
1912 }
1913
1914 #ifdef CONFIG_UNIX98_PTYS
1915 static int ptmx_open(struct inode * inode, struct file * filp)
1916 {
1917         struct tty_struct *tty;
1918         int retval;
1919         int index;
1920         int idr_ret;
1921
1922         nonseekable_open(inode, filp);
1923
1924         /* find a device that is not in use. */
1925         down(&allocated_ptys_lock);
1926         if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1927                 up(&allocated_ptys_lock);
1928                 return -ENOMEM;
1929         }
1930         idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1931         if (idr_ret < 0) {
1932                 up(&allocated_ptys_lock);
1933                 if (idr_ret == -EAGAIN)
1934                         return -ENOMEM;
1935                 return -EIO;
1936         }
1937         if (index >= pty_limit) {
1938                 idr_remove(&allocated_ptys, index);
1939                 up(&allocated_ptys_lock);
1940                 return -EIO;
1941         }
1942         up(&allocated_ptys_lock);
1943
1944         down(&tty_sem);
1945         retval = init_dev(ptm_driver, index, &tty);
1946         up(&tty_sem);
1947         
1948         if (retval)
1949                 goto out;
1950
1951         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1952         filp->private_data = tty;
1953         file_move(filp, &tty->tty_files);
1954
1955         retval = -ENOMEM;
1956         if (devpts_pty_new(tty->link))
1957                 goto out1;
1958
1959         check_tty_count(tty, "tty_open");
1960         retval = ptm_driver->open(tty, filp);
1961         if (!retval)
1962                 return 0;
1963 out1:
1964         release_dev(filp);
1965 out:
1966         down(&allocated_ptys_lock);
1967         idr_remove(&allocated_ptys, index);
1968         up(&allocated_ptys_lock);
1969         return retval;
1970 }
1971 #endif
1972
1973 static int tty_release(struct inode * inode, struct file * filp)
1974 {
1975         lock_kernel();
1976         release_dev(filp);
1977         unlock_kernel();
1978         return 0;
1979 }
1980
1981 /* No kernel lock held - fine */
1982 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1983 {
1984         struct tty_struct * tty;
1985         struct tty_ldisc *ld;
1986         int ret = 0;
1987
1988         tty = (struct tty_struct *)filp->private_data;
1989         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1990                 return 0;
1991                 
1992         ld = tty_ldisc_ref_wait(tty);
1993         if (ld->poll)
1994                 ret = (ld->poll)(tty, filp, wait);
1995         tty_ldisc_deref(ld);
1996         return ret;
1997 }
1998
1999 static int tty_fasync(int fd, struct file * filp, int on)
2000 {
2001         struct tty_struct * tty;
2002         int retval;
2003
2004         tty = (struct tty_struct *)filp->private_data;
2005         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2006                 return 0;
2007         
2008         retval = fasync_helper(fd, filp, on, &tty->fasync);
2009         if (retval <= 0)
2010                 return retval;
2011
2012         if (on) {
2013                 if (!waitqueue_active(&tty->read_wait))
2014                         tty->minimum_to_wake = 1;
2015                 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2016                 if (retval)
2017                         return retval;
2018         } else {
2019                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2020                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
2021         }
2022         return 0;
2023 }
2024
2025 static int tiocsti(struct tty_struct *tty, char __user *p)
2026 {
2027         char ch, mbz = 0;
2028         struct tty_ldisc *ld;
2029         
2030         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2031                 return -EPERM;
2032         if (get_user(ch, p))
2033                 return -EFAULT;
2034         ld = tty_ldisc_ref_wait(tty);
2035         ld->receive_buf(tty, &ch, &mbz, 1);
2036         tty_ldisc_deref(ld);
2037         return 0;
2038 }
2039
2040 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2041 {
2042         if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2043                 return -EFAULT;
2044         return 0;
2045 }
2046
2047 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2048         struct winsize __user * arg)
2049 {
2050         struct winsize tmp_ws;
2051
2052         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2053                 return -EFAULT;
2054         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2055                 return 0;
2056 #ifdef CONFIG_VT
2057         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2058                 int rc;
2059
2060                 acquire_console_sem();
2061                 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2062                 release_console_sem();
2063                 if (rc)
2064                         return -ENXIO;
2065         }
2066 #endif
2067         if (tty->pgrp > 0)
2068                 kill_pg(tty->pgrp, SIGWINCH, 1);
2069         if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2070                 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2071         tty->winsize = tmp_ws;
2072         real_tty->winsize = tmp_ws;
2073         return 0;
2074 }
2075
2076 static int tioccons(struct file *file)
2077 {
2078         if (!capable(CAP_SYS_ADMIN))
2079                 return -EPERM;
2080         if (file->f_op->write == redirected_tty_write) {
2081                 struct file *f;
2082                 spin_lock(&redirect_lock);
2083                 f = redirect;
2084                 redirect = NULL;
2085                 spin_unlock(&redirect_lock);
2086                 if (f)
2087                         fput(f);
2088                 return 0;
2089         }
2090         spin_lock(&redirect_lock);
2091         if (redirect) {
2092                 spin_unlock(&redirect_lock);
2093                 return -EBUSY;
2094         }
2095         get_file(file);
2096         redirect = file;
2097         spin_unlock(&redirect_lock);
2098         return 0;
2099 }
2100
2101
2102 static int fionbio(struct file *file, int __user *p)
2103 {
2104         int nonblock;
2105
2106         if (get_user(nonblock, p))
2107                 return -EFAULT;
2108
2109         if (nonblock)
2110                 file->f_flags |= O_NONBLOCK;
2111         else
2112                 file->f_flags &= ~O_NONBLOCK;
2113         return 0;
2114 }
2115
2116 static int tiocsctty(struct tty_struct *tty, int arg)
2117 {
2118         task_t *p;
2119
2120         if (current->signal->leader &&
2121             (current->signal->session == tty->session))
2122                 return 0;
2123         /*
2124          * The process must be a session leader and
2125          * not have a controlling tty already.
2126          */
2127         if (!current->signal->leader || current->signal->tty)
2128                 return -EPERM;
2129         if (tty->session > 0) {
2130                 /*
2131                  * This tty is already the controlling
2132                  * tty for another session group!
2133                  */
2134                 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2135                         /*
2136                          * Steal it away
2137                          */
2138
2139                         read_lock(&tasklist_lock);
2140                         do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2141                                 p->signal->tty = NULL;
2142                         } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2143                         read_unlock(&tasklist_lock);
2144                 } else
2145                         return -EPERM;
2146         }
2147         task_lock(current);
2148         current->signal->tty = tty;
2149         task_unlock(current);
2150         current->signal->tty_old_pgrp = 0;
2151         tty->session = current->signal->session;
2152         tty->pgrp = process_group(current);
2153         return 0;
2154 }
2155
2156 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2157 {
2158         /*
2159          * (tty == real_tty) is a cheap way of
2160          * testing if the tty is NOT a master pty.
2161          */
2162         if (tty == real_tty && current->signal->tty != real_tty)
2163                 return -ENOTTY;
2164         return put_user(real_tty->pgrp, p);
2165 }
2166
2167 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2168 {
2169         pid_t pgrp;
2170         int retval = tty_check_change(real_tty);
2171
2172         if (retval == -EIO)
2173                 return -ENOTTY;
2174         if (retval)
2175                 return retval;
2176         if (!current->signal->tty ||
2177             (current->signal->tty != real_tty) ||
2178             (real_tty->session != current->signal->session))
2179                 return -ENOTTY;
2180         if (get_user(pgrp, p))
2181                 return -EFAULT;
2182         if (pgrp < 0)
2183                 return -EINVAL;
2184         if (session_of_pgrp(pgrp) != current->signal->session)
2185                 return -EPERM;
2186         real_tty->pgrp = pgrp;
2187         return 0;
2188 }
2189
2190 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2191 {
2192         /*
2193          * (tty == real_tty) is a cheap way of
2194          * testing if the tty is NOT a master pty.
2195         */
2196         if (tty == real_tty && current->signal->tty != real_tty)
2197                 return -ENOTTY;
2198         if (real_tty->session <= 0)
2199                 return -ENOTTY;
2200         return put_user(real_tty->session, p);
2201 }
2202
2203 static int tiocsetd(struct tty_struct *tty, int __user *p)
2204 {
2205         int ldisc;
2206
2207         if (get_user(ldisc, p))
2208                 return -EFAULT;
2209         return tty_set_ldisc(tty, ldisc);
2210 }
2211
2212 static int send_break(struct tty_struct *tty, unsigned int duration)
2213 {
2214         tty->driver->break_ctl(tty, -1);
2215         if (!signal_pending(current)) {
2216                 msleep_interruptible(duration);
2217         }
2218         tty->driver->break_ctl(tty, 0);
2219         if (signal_pending(current))
2220                 return -EINTR;
2221         return 0;
2222 }
2223
2224 static int
2225 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2226 {
2227         int retval = -EINVAL;
2228
2229         if (tty->driver->tiocmget) {
2230                 retval = tty->driver->tiocmget(tty, file);
2231
2232                 if (retval >= 0)
2233                         retval = put_user(retval, p);
2234         }
2235         return retval;
2236 }
2237
2238 static int
2239 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2240              unsigned __user *p)
2241 {
2242         int retval = -EINVAL;
2243
2244         if (tty->driver->tiocmset) {
2245                 unsigned int set, clear, val;
2246
2247                 retval = get_user(val, p);
2248                 if (retval)
2249                         return retval;
2250
2251                 set = clear = 0;
2252                 switch (cmd) {
2253                 case TIOCMBIS:
2254                         set = val;
2255                         break;
2256                 case TIOCMBIC:
2257                         clear = val;
2258                         break;
2259                 case TIOCMSET:
2260                         set = val;
2261                         clear = ~val;
2262                         break;
2263                 }
2264
2265                 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2266                 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2267
2268                 retval = tty->driver->tiocmset(tty, file, set, clear);
2269         }
2270         return retval;
2271 }
2272
2273 /*
2274  * Split this up, as gcc can choke on it otherwise..
2275  */
2276 int tty_ioctl(struct inode * inode, struct file * file,
2277               unsigned int cmd, unsigned long arg)
2278 {
2279         struct tty_struct *tty, *real_tty;
2280         void __user *p = (void __user *)arg;
2281         int retval;
2282         struct tty_ldisc *ld;
2283         
2284         tty = (struct tty_struct *)file->private_data;
2285         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2286                 return -EINVAL;
2287
2288         real_tty = tty;
2289         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2290             tty->driver->subtype == PTY_TYPE_MASTER)
2291                 real_tty = tty->link;
2292
2293         /*
2294          * Break handling by driver
2295          */
2296         if (!tty->driver->break_ctl) {
2297                 switch(cmd) {
2298                 case TIOCSBRK:
2299                 case TIOCCBRK:
2300                         if (tty->driver->ioctl)
2301                                 return tty->driver->ioctl(tty, file, cmd, arg);
2302                         return -EINVAL;
2303                         
2304                 /* These two ioctl's always return success; even if */
2305                 /* the driver doesn't support them. */
2306                 case TCSBRK:
2307                 case TCSBRKP:
2308                         if (!tty->driver->ioctl)
2309                                 return 0;
2310                         retval = tty->driver->ioctl(tty, file, cmd, arg);
2311                         if (retval == -ENOIOCTLCMD)
2312                                 retval = 0;
2313                         return retval;
2314                 }
2315         }
2316
2317         /*
2318          * Factor out some common prep work
2319          */
2320         switch (cmd) {
2321         case TIOCSETD:
2322         case TIOCSBRK:
2323         case TIOCCBRK:
2324         case TCSBRK:
2325         case TCSBRKP:                   
2326                 retval = tty_check_change(tty);
2327                 if (retval)
2328                         return retval;
2329                 if (cmd != TIOCCBRK) {
2330                         tty_wait_until_sent(tty, 0);
2331                         if (signal_pending(current))
2332                                 return -EINTR;
2333                 }
2334                 break;
2335         }
2336
2337         switch (cmd) {
2338                 case TIOCSTI:
2339                         return tiocsti(tty, p);
2340                 case TIOCGWINSZ:
2341                         return tiocgwinsz(tty, p);
2342                 case TIOCSWINSZ:
2343                         return tiocswinsz(tty, real_tty, p);
2344                 case TIOCCONS:
2345                         return real_tty!=tty ? -EINVAL : tioccons(file);
2346                 case FIONBIO:
2347                         return fionbio(file, p);
2348                 case TIOCEXCL:
2349                         set_bit(TTY_EXCLUSIVE, &tty->flags);
2350                         return 0;
2351                 case TIOCNXCL:
2352                         clear_bit(TTY_EXCLUSIVE, &tty->flags);
2353                         return 0;
2354                 case TIOCNOTTY:
2355                         if (current->signal->tty != tty)
2356                                 return -ENOTTY;
2357                         if (current->signal->leader)
2358                                 disassociate_ctty(0);
2359                         task_lock(current);
2360                         current->signal->tty = NULL;
2361                         task_unlock(current);
2362                         return 0;
2363                 case TIOCSCTTY:
2364                         return tiocsctty(tty, arg);
2365                 case TIOCGPGRP:
2366                         return tiocgpgrp(tty, real_tty, p);
2367                 case TIOCSPGRP:
2368                         return tiocspgrp(tty, real_tty, p);
2369                 case TIOCGSID:
2370                         return tiocgsid(tty, real_tty, p);
2371                 case TIOCGETD:
2372                         /* FIXME: check this is ok */
2373                         return put_user(tty->ldisc.num, (int __user *)p);
2374                 case TIOCSETD:
2375                         return tiocsetd(tty, p);
2376 #ifdef CONFIG_VT
2377                 case TIOCLINUX:
2378                         return tioclinux(tty, arg);
2379 #endif
2380                 /*
2381                  * Break handling
2382                  */
2383                 case TIOCSBRK:  /* Turn break on, unconditionally */
2384                         tty->driver->break_ctl(tty, -1);
2385                         return 0;
2386                         
2387                 case TIOCCBRK:  /* Turn break off, unconditionally */
2388                         tty->driver->break_ctl(tty, 0);
2389                         return 0;
2390                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
2391                         /*
2392                          * XXX is the above comment correct, or the
2393                          * code below correct?  Is this ioctl used at
2394                          * all by anyone?
2395                          */
2396                         if (!arg)
2397                                 return send_break(tty, 250);
2398                         return 0;
2399                 case TCSBRKP:   /* support for POSIX tcsendbreak() */   
2400                         return send_break(tty, arg ? arg*100 : 250);
2401
2402                 case TIOCMGET:
2403                         return tty_tiocmget(tty, file, p);
2404
2405                 case TIOCMSET:
2406                 case TIOCMBIC:
2407                 case TIOCMBIS:
2408                         return tty_tiocmset(tty, file, cmd, p);
2409         }
2410         if (tty->driver->ioctl) {
2411                 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2412                 if (retval != -ENOIOCTLCMD)
2413                         return retval;
2414         }
2415         ld = tty_ldisc_ref_wait(tty);
2416         retval = -EINVAL;
2417         if (ld->ioctl) {
2418                 retval = ld->ioctl(tty, file, cmd, arg);
2419                 if (retval == -ENOIOCTLCMD)
2420                         retval = -EINVAL;
2421         }
2422         tty_ldisc_deref(ld);
2423         return retval;
2424 }
2425
2426
2427 /*
2428  * This implements the "Secure Attention Key" ---  the idea is to
2429  * prevent trojan horses by killing all processes associated with this
2430  * tty when the user hits the "Secure Attention Key".  Required for
2431  * super-paranoid applications --- see the Orange Book for more details.
2432  * 
2433  * This code could be nicer; ideally it should send a HUP, wait a few
2434  * seconds, then send a INT, and then a KILL signal.  But you then
2435  * have to coordinate with the init process, since all processes associated
2436  * with the current tty must be dead before the new getty is allowed
2437  * to spawn.
2438  *
2439  * Now, if it would be correct ;-/ The current code has a nasty hole -
2440  * it doesn't catch files in flight. We may send the descriptor to ourselves
2441  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2442  *
2443  * Nasty bug: do_SAK is being called in interrupt context.  This can
2444  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2445  */
2446 static void __do_SAK(void *arg)
2447 {
2448 #ifdef TTY_SOFT_SAK
2449         tty_hangup(tty);
2450 #else
2451         struct tty_struct *tty = arg;
2452         struct task_struct *p;
2453         int session;
2454         int             i;
2455         struct file     *filp;
2456         struct tty_ldisc *disc;
2457         struct fdtable *fdt;
2458         
2459         if (!tty)
2460                 return;
2461         session  = tty->session;
2462         
2463         /* We don't want an ldisc switch during this */
2464         disc = tty_ldisc_ref(tty);
2465         if (disc && disc->flush_buffer)
2466                 disc->flush_buffer(tty);
2467         tty_ldisc_deref(disc);
2468
2469         if (tty->driver->flush_buffer)
2470                 tty->driver->flush_buffer(tty);
2471         
2472         read_lock(&tasklist_lock);
2473         do_each_task_pid(session, PIDTYPE_SID, p) {
2474                 if (p->signal->tty == tty || session > 0) {
2475                         printk(KERN_NOTICE "SAK: killed process %d"
2476                             " (%s): p->signal->session==tty->session\n",
2477                             p->pid, p->comm);
2478                         send_sig(SIGKILL, p, 1);
2479                         continue;
2480                 }
2481                 task_lock(p);
2482                 if (p->files) {
2483                         rcu_read_lock();
2484                         fdt = files_fdtable(p->files);
2485                         for (i=0; i < fdt->max_fds; i++) {
2486                                 filp = fcheck_files(p->files, i);
2487                                 if (!filp)
2488                                         continue;
2489                                 if (filp->f_op->read == tty_read &&
2490                                     filp->private_data == tty) {
2491                                         printk(KERN_NOTICE "SAK: killed process %d"
2492                                             " (%s): fd#%d opened to the tty\n",
2493                                             p->pid, p->comm, i);
2494                                         send_sig(SIGKILL, p, 1);
2495                                         break;
2496                                 }
2497                         }
2498                         rcu_read_unlock();
2499                 }
2500                 task_unlock(p);
2501         } while_each_task_pid(session, PIDTYPE_SID, p);
2502         read_unlock(&tasklist_lock);
2503 #endif
2504 }
2505
2506 /*
2507  * The tq handling here is a little racy - tty->SAK_work may already be queued.
2508  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2509  * the values which we write to it will be identical to the values which it
2510  * already has. --akpm
2511  */
2512 void do_SAK(struct tty_struct *tty)
2513 {
2514         if (!tty)
2515                 return;
2516         PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2517         schedule_work(&tty->SAK_work);
2518 }
2519
2520 EXPORT_SYMBOL(do_SAK);
2521
2522 /*
2523  * This routine is called out of the software interrupt to flush data
2524  * from the flip buffer to the line discipline. 
2525  */
2526  
2527 static void flush_to_ldisc(void *private_)
2528 {
2529         struct tty_struct *tty = (struct tty_struct *) private_;
2530         unsigned char   *cp;
2531         char            *fp;
2532         int             count;
2533         unsigned long   flags;
2534         struct tty_ldisc *disc;
2535
2536         disc = tty_ldisc_ref(tty);
2537         if (disc == NULL)       /*  !TTY_LDISC */
2538                 return;
2539
2540         if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2541                 /*
2542                  * Do it after the next timer tick:
2543                  */
2544                 schedule_delayed_work(&tty->flip.work, 1);
2545                 goto out;
2546         }
2547         spin_lock_irqsave(&tty->read_lock, flags);
2548         if (tty->flip.buf_num) {
2549                 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2550                 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2551                 tty->flip.buf_num = 0;
2552                 tty->flip.char_buf_ptr = tty->flip.char_buf;
2553                 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2554         } else {
2555                 cp = tty->flip.char_buf;
2556                 fp = tty->flip.flag_buf;
2557                 tty->flip.buf_num = 1;
2558                 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2559                 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2560         }
2561         count = tty->flip.count;
2562         tty->flip.count = 0;
2563         spin_unlock_irqrestore(&tty->read_lock, flags);
2564
2565         disc->receive_buf(tty, cp, fp, count);
2566 out:
2567         tty_ldisc_deref(disc);
2568 }
2569
2570 /*
2571  * Routine which returns the baud rate of the tty
2572  *
2573  * Note that the baud_table needs to be kept in sync with the
2574  * include/asm/termbits.h file.
2575  */
2576 static int baud_table[] = {
2577         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2578         9600, 19200, 38400, 57600, 115200, 230400, 460800,
2579 #ifdef __sparc__
2580         76800, 153600, 307200, 614400, 921600
2581 #else
2582         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2583         2500000, 3000000, 3500000, 4000000
2584 #endif
2585 };
2586
2587 static int n_baud_table = ARRAY_SIZE(baud_table);
2588
2589 /**
2590  *      tty_termios_baud_rate
2591  *      @termios: termios structure
2592  *
2593  *      Convert termios baud rate data into a speed. This should be called
2594  *      with the termios lock held if this termios is a terminal termios
2595  *      structure. May change the termios data.
2596  */
2597  
2598 int tty_termios_baud_rate(struct termios *termios)
2599 {
2600         unsigned int cbaud;
2601         
2602         cbaud = termios->c_cflag & CBAUD;
2603
2604         if (cbaud & CBAUDEX) {
2605                 cbaud &= ~CBAUDEX;
2606
2607                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2608                         termios->c_cflag &= ~CBAUDEX;
2609                 else
2610                         cbaud += 15;
2611         }
2612         return baud_table[cbaud];
2613 }
2614
2615 EXPORT_SYMBOL(tty_termios_baud_rate);
2616
2617 /**
2618  *      tty_get_baud_rate       -       get tty bit rates
2619  *      @tty: tty to query
2620  *
2621  *      Returns the baud rate as an integer for this terminal. The
2622  *      termios lock must be held by the caller and the terminal bit
2623  *      flags may be updated.
2624  */
2625  
2626 int tty_get_baud_rate(struct tty_struct *tty)
2627 {
2628         int baud = tty_termios_baud_rate(tty->termios);
2629
2630         if (baud == 38400 && tty->alt_speed) {
2631                 if (!tty->warned) {
2632                         printk(KERN_WARNING "Use of setserial/setrocket to "
2633                                             "set SPD_* flags is deprecated\n");
2634                         tty->warned = 1;
2635                 }
2636                 baud = tty->alt_speed;
2637         }
2638         
2639         return baud;
2640 }
2641
2642 EXPORT_SYMBOL(tty_get_baud_rate);
2643
2644 /**
2645  *      tty_flip_buffer_push    -       terminal
2646  *      @tty: tty to push
2647  *
2648  *      Queue a push of the terminal flip buffers to the line discipline. This
2649  *      function must not be called from IRQ context if tty->low_latency is set.
2650  *
2651  *      In the event of the queue being busy for flipping the work will be
2652  *      held off and retried later.
2653  */
2654
2655 void tty_flip_buffer_push(struct tty_struct *tty)
2656 {
2657         if (tty->low_latency)
2658                 flush_to_ldisc((void *) tty);
2659         else
2660                 schedule_delayed_work(&tty->flip.work, 1);
2661 }
2662
2663 EXPORT_SYMBOL(tty_flip_buffer_push);
2664
2665 /*
2666  * This subroutine initializes a tty structure.
2667  */
2668 static void initialize_tty_struct(struct tty_struct *tty)
2669 {
2670         memset(tty, 0, sizeof(struct tty_struct));
2671         tty->magic = TTY_MAGIC;
2672         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2673         tty->pgrp = -1;
2674         tty->overrun_time = jiffies;
2675         tty->flip.char_buf_ptr = tty->flip.char_buf;
2676         tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2677         INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2678         init_MUTEX(&tty->flip.pty_sem);
2679         init_MUTEX(&tty->termios_sem);
2680         init_waitqueue_head(&tty->write_wait);
2681         init_waitqueue_head(&tty->read_wait);
2682         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2683         sema_init(&tty->atomic_read, 1);
2684         sema_init(&tty->atomic_write, 1);
2685         spin_lock_init(&tty->read_lock);
2686         INIT_LIST_HEAD(&tty->tty_files);
2687         INIT_WORK(&tty->SAK_work, NULL, NULL);
2688 }
2689
2690 /*
2691  * The default put_char routine if the driver did not define one.
2692  */
2693 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2694 {
2695         tty->driver->write(tty, &ch, 1);
2696 }
2697
2698 static struct class *tty_class;
2699
2700 /**
2701  * tty_register_device - register a tty device
2702  * @driver: the tty driver that describes the tty device
2703  * @index: the index in the tty driver for this tty device
2704  * @device: a struct device that is associated with this tty device.
2705  *      This field is optional, if there is no known struct device for this
2706  *      tty device it can be set to NULL safely.
2707  *
2708  * This call is required to be made to register an individual tty device if
2709  * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set.  If that
2710  * bit is not set, this function should not be called.
2711  */
2712 void tty_register_device(struct tty_driver *driver, unsigned index,
2713                          struct device *device)
2714 {
2715         char name[64];
2716         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2717
2718         if (index >= driver->num) {
2719                 printk(KERN_ERR "Attempt to register invalid tty line number "
2720                        " (%d).\n", index);
2721                 return;
2722         }
2723
2724         devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2725                         "%s%d", driver->devfs_name, index + driver->name_base);
2726
2727         if (driver->type == TTY_DRIVER_TYPE_PTY)
2728                 pty_line_name(driver, index, name);
2729         else
2730                 tty_line_name(driver, index, name);
2731         class_device_create(tty_class, dev, device, name);
2732 }
2733
2734 /**
2735  * tty_unregister_device - unregister a tty device
2736  * @driver: the tty driver that describes the tty device
2737  * @index: the index in the tty driver for this tty device
2738  *
2739  * If a tty device is registered with a call to tty_register_device() then
2740  * this function must be made when the tty device is gone.
2741  */
2742 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2743 {
2744         devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2745         class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2746 }
2747
2748 EXPORT_SYMBOL(tty_register_device);
2749 EXPORT_SYMBOL(tty_unregister_device);
2750
2751 struct tty_driver *alloc_tty_driver(int lines)
2752 {
2753         struct tty_driver *driver;
2754
2755         driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2756         if (driver) {
2757                 memset(driver, 0, sizeof(struct tty_driver));
2758                 driver->magic = TTY_DRIVER_MAGIC;
2759                 driver->num = lines;
2760                 /* later we'll move allocation of tables here */
2761         }
2762         return driver;
2763 }
2764
2765 void put_tty_driver(struct tty_driver *driver)
2766 {
2767         kfree(driver);
2768 }
2769
2770 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2771 {
2772         driver->open = op->open;
2773         driver->close = op->close;
2774         driver->write = op->write;
2775         driver->put_char = op->put_char;
2776         driver->flush_chars = op->flush_chars;
2777         driver->write_room = op->write_room;
2778         driver->chars_in_buffer = op->chars_in_buffer;
2779         driver->ioctl = op->ioctl;
2780         driver->set_termios = op->set_termios;
2781         driver->throttle = op->throttle;
2782         driver->unthrottle = op->unthrottle;
2783         driver->stop = op->stop;
2784         driver->start = op->start;
2785         driver->hangup = op->hangup;
2786         driver->break_ctl = op->break_ctl;
2787         driver->flush_buffer = op->flush_buffer;
2788         driver->set_ldisc = op->set_ldisc;
2789         driver->wait_until_sent = op->wait_until_sent;
2790         driver->send_xchar = op->send_xchar;
2791         driver->read_proc = op->read_proc;
2792         driver->write_proc = op->write_proc;
2793         driver->tiocmget = op->tiocmget;
2794         driver->tiocmset = op->tiocmset;
2795 }
2796
2797
2798 EXPORT_SYMBOL(alloc_tty_driver);
2799 EXPORT_SYMBOL(put_tty_driver);
2800 EXPORT_SYMBOL(tty_set_operations);
2801
2802 /*
2803  * Called by a tty driver to register itself.
2804  */
2805 int tty_register_driver(struct tty_driver *driver)
2806 {
2807         int error;
2808         int i;
2809         dev_t dev;
2810         void **p = NULL;
2811
2812         if (driver->flags & TTY_DRIVER_INSTALLED)
2813                 return 0;
2814
2815         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2816                 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2817                 if (!p)
2818                         return -ENOMEM;
2819                 memset(p, 0, driver->num * 3 * sizeof(void *));
2820         }
2821
2822         if (!driver->major) {
2823                 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2824                                                 (char*)driver->name);
2825                 if (!error) {
2826                         driver->major = MAJOR(dev);
2827                         driver->minor_start = MINOR(dev);
2828                 }
2829         } else {
2830                 dev = MKDEV(driver->major, driver->minor_start);
2831                 error = register_chrdev_region(dev, driver->num,
2832                                                 (char*)driver->name);
2833         }
2834         if (error < 0) {
2835                 kfree(p);
2836                 return error;
2837         }
2838
2839         if (p) {
2840                 driver->ttys = (struct tty_struct **)p;
2841                 driver->termios = (struct termios **)(p + driver->num);
2842                 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2843         } else {
2844                 driver->ttys = NULL;
2845                 driver->termios = NULL;
2846                 driver->termios_locked = NULL;
2847         }
2848
2849         cdev_init(&driver->cdev, &tty_fops);
2850         driver->cdev.owner = driver->owner;
2851         error = cdev_add(&driver->cdev, dev, driver->num);
2852         if (error) {
2853                 cdev_del(&driver->cdev);
2854                 unregister_chrdev_region(dev, driver->num);
2855                 driver->ttys = NULL;
2856                 driver->termios = driver->termios_locked = NULL;
2857                 kfree(p);
2858                 return error;
2859         }
2860
2861         if (!driver->put_char)
2862                 driver->put_char = tty_default_put_char;
2863         
2864         list_add(&driver->tty_drivers, &tty_drivers);
2865         
2866         if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2867                 for(i = 0; i < driver->num; i++)
2868                     tty_register_device(driver, i, NULL);
2869         }
2870         proc_tty_register_driver(driver);
2871         return 0;
2872 }
2873
2874 EXPORT_SYMBOL(tty_register_driver);
2875
2876 /*
2877  * Called by a tty driver to unregister itself.
2878  */
2879 int tty_unregister_driver(struct tty_driver *driver)
2880 {
2881         int i;
2882         struct termios *tp;
2883         void *p;
2884
2885         if (driver->refcount)
2886                 return -EBUSY;
2887
2888         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2889                                 driver->num);
2890
2891         list_del(&driver->tty_drivers);
2892
2893         /*
2894          * Free the termios and termios_locked structures because
2895          * we don't want to get memory leaks when modular tty
2896          * drivers are removed from the kernel.
2897          */
2898         for (i = 0; i < driver->num; i++) {
2899                 tp = driver->termios[i];
2900                 if (tp) {
2901                         driver->termios[i] = NULL;
2902                         kfree(tp);
2903                 }
2904                 tp = driver->termios_locked[i];
2905                 if (tp) {
2906                         driver->termios_locked[i] = NULL;
2907                         kfree(tp);
2908                 }
2909                 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2910                         tty_unregister_device(driver, i);
2911         }
2912         p = driver->ttys;
2913         proc_tty_unregister_driver(driver);
2914         driver->ttys = NULL;
2915         driver->termios = driver->termios_locked = NULL;
2916         kfree(p);
2917         cdev_del(&driver->cdev);
2918         return 0;
2919 }
2920
2921 EXPORT_SYMBOL(tty_unregister_driver);
2922
2923
2924 /*
2925  * Initialize the console device. This is called *early*, so
2926  * we can't necessarily depend on lots of kernel help here.
2927  * Just do some early initializations, and do the complex setup
2928  * later.
2929  */
2930 void __init console_init(void)
2931 {
2932         initcall_t *call;
2933
2934         /* Setup the default TTY line discipline. */
2935         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2936
2937         /*
2938          * set up the console device so that later boot sequences can 
2939          * inform about problems etc..
2940          */
2941 #ifdef CONFIG_EARLY_PRINTK
2942         disable_early_printk();
2943 #endif
2944         call = __con_initcall_start;
2945         while (call < __con_initcall_end) {
2946                 (*call)();
2947                 call++;
2948         }
2949 }
2950
2951 #ifdef CONFIG_VT
2952 extern int vty_init(void);
2953 #endif
2954
2955 static int __init tty_class_init(void)
2956 {
2957         tty_class = class_create(THIS_MODULE, "tty");
2958         if (IS_ERR(tty_class))
2959                 return PTR_ERR(tty_class);
2960         return 0;
2961 }
2962
2963 postcore_initcall(tty_class_init);
2964
2965 /* 3/2004 jmc: why do these devices exist? */
2966
2967 static struct cdev tty_cdev, console_cdev;
2968 #ifdef CONFIG_UNIX98_PTYS
2969 static struct cdev ptmx_cdev;
2970 #endif
2971 #ifdef CONFIG_VT
2972 static struct cdev vc0_cdev;
2973 #endif
2974
2975 /*
2976  * Ok, now we can initialize the rest of the tty devices and can count
2977  * on memory allocations, interrupts etc..
2978  */
2979 static int __init tty_init(void)
2980 {
2981         cdev_init(&tty_cdev, &tty_fops);
2982         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2983             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2984                 panic("Couldn't register /dev/tty driver\n");
2985         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2986         class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2987
2988         cdev_init(&console_cdev, &console_fops);
2989         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2990             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2991                 panic("Couldn't register /dev/console driver\n");
2992         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2993         class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2994
2995 #ifdef CONFIG_UNIX98_PTYS
2996         cdev_init(&ptmx_cdev, &ptmx_fops);
2997         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2998             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2999                 panic("Couldn't register /dev/ptmx driver\n");
3000         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
3001         class_device_create(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
3002 #endif
3003
3004 #ifdef CONFIG_VT
3005         cdev_init(&vc0_cdev, &console_fops);
3006         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3007             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3008                 panic("Couldn't register /dev/tty0 driver\n");
3009         devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3010         class_device_create(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3011
3012         vty_init();
3013 #endif
3014         return 0;
3015 }
3016 module_init(tty_init);