Merge branch 'atmel'
[linux-2.6] / drivers / char / tty_io.c
1 /*
2  *  linux/drivers/char/tty_io.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 /*
8  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9  * or rs-channels. It also implements echoing, cooked mode etc.
10  *
11  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12  *
13  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14  * tty_struct and tty_queue structures.  Previously there was an array
15  * of 256 tty_struct's which was statically allocated, and the
16  * tty_queue structures were allocated at boot time.  Both are now
17  * dynamically allocated only when the tty is open.
18  *
19  * Also restructured routines so that there is more of a separation
20  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21  * the low-level tty routines (serial.c, pty.c, console.c).  This
22  * makes for cleaner and more compact code.  -TYT, 9/17/92 
23  *
24  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25  * which can be dynamically activated and de-activated by the line
26  * discipline handling modules (like SLIP).
27  *
28  * NOTE: pay no attention to the line discipline code (yet); its
29  * interface is still subject to change in this version...
30  * -- TYT, 1/31/92
31  *
32  * Added functionality to the OPOST tty handling.  No delays, but all
33  * other bits should be there.
34  *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35  *
36  * Rewrote canonical mode and added more termios flags.
37  *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38  *
39  * Reorganized FASYNC support so mouse code can share it.
40  *      -- ctm@ardi.com, 9Sep95
41  *
42  * New TIOCLINUX variants added.
43  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
44  * 
45  * Restrict vt switching via ioctl()
46  *      -- grif@cs.ucr.edu, 5-Dec-95
47  *
48  * Move console and virtual terminal code to more appropriate files,
49  * implement CONFIG_VT and generalize console device interface.
50  *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51  *
52  * Rewrote 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_u.fu_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         kfree(o_tp);
1420         if (o_tty)
1421                 free_tty_struct(o_tty);
1422         kfree(ltp);
1423         kfree(tp);
1424         free_tty_struct(tty);
1425
1426 fail_no_mem:
1427         module_put(driver->owner);
1428         retval = -ENOMEM;
1429         goto end_init;
1430
1431         /* call the tty release_mem routine to clean out this slot */
1432 release_mem_out:
1433         printk(KERN_INFO "init_dev: ldisc open failed, "
1434                          "clearing slot %d\n", idx);
1435         release_mem(tty, idx);
1436         goto end_init;
1437 }
1438
1439 /*
1440  * Releases memory associated with a tty structure, and clears out the
1441  * driver table slots.
1442  */
1443 static void release_mem(struct tty_struct *tty, int idx)
1444 {
1445         struct tty_struct *o_tty;
1446         struct termios *tp;
1447         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1448
1449         if ((o_tty = tty->link) != NULL) {
1450                 if (!devpts)
1451                         o_tty->driver->ttys[idx] = NULL;
1452                 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1453                         tp = o_tty->termios;
1454                         if (!devpts)
1455                                 o_tty->driver->termios[idx] = NULL;
1456                         kfree(tp);
1457
1458                         tp = o_tty->termios_locked;
1459                         if (!devpts)
1460                                 o_tty->driver->termios_locked[idx] = NULL;
1461                         kfree(tp);
1462                 }
1463                 o_tty->magic = 0;
1464                 o_tty->driver->refcount--;
1465                 file_list_lock();
1466                 list_del_init(&o_tty->tty_files);
1467                 file_list_unlock();
1468                 free_tty_struct(o_tty);
1469         }
1470
1471         if (!devpts)
1472                 tty->driver->ttys[idx] = NULL;
1473         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1474                 tp = tty->termios;
1475                 if (!devpts)
1476                         tty->driver->termios[idx] = NULL;
1477                 kfree(tp);
1478
1479                 tp = tty->termios_locked;
1480                 if (!devpts)
1481                         tty->driver->termios_locked[idx] = NULL;
1482                 kfree(tp);
1483         }
1484
1485         tty->magic = 0;
1486         tty->driver->refcount--;
1487         file_list_lock();
1488         list_del_init(&tty->tty_files);
1489         file_list_unlock();
1490         module_put(tty->driver->owner);
1491         free_tty_struct(tty);
1492 }
1493
1494 /*
1495  * Even releasing the tty structures is a tricky business.. We have
1496  * to be very careful that the structures are all released at the
1497  * same time, as interrupts might otherwise get the wrong pointers.
1498  *
1499  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1500  * lead to double frees or releasing memory still in use.
1501  */
1502 static void release_dev(struct file * filp)
1503 {
1504         struct tty_struct *tty, *o_tty;
1505         int     pty_master, tty_closing, o_tty_closing, do_sleep;
1506         int     devpts_master, devpts;
1507         int     idx;
1508         char    buf[64];
1509         unsigned long flags;
1510         
1511         tty = (struct tty_struct *)filp->private_data;
1512         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1513                 return;
1514
1515         check_tty_count(tty, "release_dev");
1516
1517         tty_fasync(-1, filp, 0);
1518
1519         idx = tty->index;
1520         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1521                       tty->driver->subtype == PTY_TYPE_MASTER);
1522         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1523         devpts_master = pty_master && devpts;
1524         o_tty = tty->link;
1525
1526 #ifdef TTY_PARANOIA_CHECK
1527         if (idx < 0 || idx >= tty->driver->num) {
1528                 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1529                                   "free (%s)\n", tty->name);
1530                 return;
1531         }
1532         if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1533                 if (tty != tty->driver->ttys[idx]) {
1534                         printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1535                                "for (%s)\n", idx, tty->name);
1536                         return;
1537                 }
1538                 if (tty->termios != tty->driver->termios[idx]) {
1539                         printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1540                                "for (%s)\n",
1541                                idx, tty->name);
1542                         return;
1543                 }
1544                 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1545                         printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1546                                "termios_locked for (%s)\n",
1547                                idx, tty->name);
1548                         return;
1549                 }
1550         }
1551 #endif
1552
1553 #ifdef TTY_DEBUG_HANGUP
1554         printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1555                tty_name(tty, buf), tty->count);
1556 #endif
1557
1558 #ifdef TTY_PARANOIA_CHECK
1559         if (tty->driver->other &&
1560              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1561                 if (o_tty != tty->driver->other->ttys[idx]) {
1562                         printk(KERN_DEBUG "release_dev: other->table[%d] "
1563                                           "not o_tty for (%s)\n",
1564                                idx, tty->name);
1565                         return;
1566                 }
1567                 if (o_tty->termios != tty->driver->other->termios[idx]) {
1568                         printk(KERN_DEBUG "release_dev: other->termios[%d] "
1569                                           "not o_termios for (%s)\n",
1570                                idx, tty->name);
1571                         return;
1572                 }
1573                 if (o_tty->termios_locked != 
1574                       tty->driver->other->termios_locked[idx]) {
1575                         printk(KERN_DEBUG "release_dev: other->termios_locked["
1576                                           "%d] not o_termios_locked for (%s)\n",
1577                                idx, tty->name);
1578                         return;
1579                 }
1580                 if (o_tty->link != tty) {
1581                         printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1582                         return;
1583                 }
1584         }
1585 #endif
1586         if (tty->driver->close)
1587                 tty->driver->close(tty, filp);
1588
1589         /*
1590          * Sanity check: if tty->count is going to zero, there shouldn't be
1591          * any waiters on tty->read_wait or tty->write_wait.  We test the
1592          * wait queues and kick everyone out _before_ actually starting to
1593          * close.  This ensures that we won't block while releasing the tty
1594          * structure.
1595          *
1596          * The test for the o_tty closing is necessary, since the master and
1597          * slave sides may close in any order.  If the slave side closes out
1598          * first, its count will be one, since the master side holds an open.
1599          * Thus this test wouldn't be triggered at the time the slave closes,
1600          * so we do it now.
1601          *
1602          * Note that it's possible for the tty to be opened again while we're
1603          * flushing out waiters.  By recalculating the closing flags before
1604          * each iteration we avoid any problems.
1605          */
1606         while (1) {
1607                 /* Guard against races with tty->count changes elsewhere and
1608                    opens on /dev/tty */
1609                    
1610                 down(&tty_sem);
1611                 tty_closing = tty->count <= 1;
1612                 o_tty_closing = o_tty &&
1613                         (o_tty->count <= (pty_master ? 1 : 0));
1614                 up(&tty_sem);
1615                 do_sleep = 0;
1616
1617                 if (tty_closing) {
1618                         if (waitqueue_active(&tty->read_wait)) {
1619                                 wake_up(&tty->read_wait);
1620                                 do_sleep++;
1621                         }
1622                         if (waitqueue_active(&tty->write_wait)) {
1623                                 wake_up(&tty->write_wait);
1624                                 do_sleep++;
1625                         }
1626                 }
1627                 if (o_tty_closing) {
1628                         if (waitqueue_active(&o_tty->read_wait)) {
1629                                 wake_up(&o_tty->read_wait);
1630                                 do_sleep++;
1631                         }
1632                         if (waitqueue_active(&o_tty->write_wait)) {
1633                                 wake_up(&o_tty->write_wait);
1634                                 do_sleep++;
1635                         }
1636                 }
1637                 if (!do_sleep)
1638                         break;
1639
1640                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1641                                     "active!\n", tty_name(tty, buf));
1642                 schedule();
1643         }       
1644
1645         /*
1646          * The closing flags are now consistent with the open counts on 
1647          * both sides, and we've completed the last operation that could 
1648          * block, so it's safe to proceed with closing.
1649          */
1650          
1651         down(&tty_sem);
1652         if (pty_master) {
1653                 if (--o_tty->count < 0) {
1654                         printk(KERN_WARNING "release_dev: bad pty slave count "
1655                                             "(%d) for %s\n",
1656                                o_tty->count, tty_name(o_tty, buf));
1657                         o_tty->count = 0;
1658                 }
1659         }
1660         if (--tty->count < 0) {
1661                 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1662                        tty->count, tty_name(tty, buf));
1663                 tty->count = 0;
1664         }
1665         up(&tty_sem);
1666         
1667         /*
1668          * We've decremented tty->count, so we need to remove this file
1669          * descriptor off the tty->tty_files list; this serves two
1670          * purposes:
1671          *  - check_tty_count sees the correct number of file descriptors
1672          *    associated with this tty.
1673          *  - do_tty_hangup no longer sees this file descriptor as
1674          *    something that needs to be handled for hangups.
1675          */
1676         file_kill(filp);
1677         filp->private_data = NULL;
1678
1679         /*
1680          * Perform some housekeeping before deciding whether to return.
1681          *
1682          * Set the TTY_CLOSING flag if this was the last open.  In the
1683          * case of a pty we may have to wait around for the other side
1684          * to close, and TTY_CLOSING makes sure we can't be reopened.
1685          */
1686         if(tty_closing)
1687                 set_bit(TTY_CLOSING, &tty->flags);
1688         if(o_tty_closing)
1689                 set_bit(TTY_CLOSING, &o_tty->flags);
1690
1691         /*
1692          * If _either_ side is closing, make sure there aren't any
1693          * processes that still think tty or o_tty is their controlling
1694          * tty.
1695          */
1696         if (tty_closing || o_tty_closing) {
1697                 struct task_struct *p;
1698
1699                 read_lock(&tasklist_lock);
1700                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1701                         p->signal->tty = NULL;
1702                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1703                 if (o_tty)
1704                         do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1705                                 p->signal->tty = NULL;
1706                         } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1707                 read_unlock(&tasklist_lock);
1708         }
1709
1710         /* check whether both sides are closing ... */
1711         if (!tty_closing || (o_tty && !o_tty_closing))
1712                 return;
1713         
1714 #ifdef TTY_DEBUG_HANGUP
1715         printk(KERN_DEBUG "freeing tty structure...");
1716 #endif
1717         /*
1718          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
1719          * kill any delayed work. As this is the final close it does not
1720          * race with the set_ldisc code path.
1721          */
1722         clear_bit(TTY_LDISC, &tty->flags);
1723         clear_bit(TTY_DONT_FLIP, &tty->flags);
1724         cancel_delayed_work(&tty->flip.work);
1725
1726         /*
1727          * Wait for ->hangup_work and ->flip.work handlers to terminate
1728          */
1729          
1730         flush_scheduled_work();
1731         
1732         /*
1733          * Wait for any short term users (we know they are just driver
1734          * side waiters as the file is closing so user count on the file
1735          * side is zero.
1736          */
1737         spin_lock_irqsave(&tty_ldisc_lock, flags);
1738         while(tty->ldisc.refcount)
1739         {
1740                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1741                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1742                 spin_lock_irqsave(&tty_ldisc_lock, flags);
1743         }
1744         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1745         /*
1746          * Shutdown the current line discipline, and reset it to N_TTY.
1747          * N.B. why reset ldisc when we're releasing the memory??
1748          *
1749          * FIXME: this MUST get fixed for the new reflocking
1750          */
1751         if (tty->ldisc.close)
1752                 (tty->ldisc.close)(tty);
1753         tty_ldisc_put(tty->ldisc.num);
1754         
1755         /*
1756          *      Switch the line discipline back
1757          */
1758         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1759         tty_set_termios_ldisc(tty,N_TTY); 
1760         if (o_tty) {
1761                 /* FIXME: could o_tty be in setldisc here ? */
1762                 clear_bit(TTY_LDISC, &o_tty->flags);
1763                 if (o_tty->ldisc.close)
1764                         (o_tty->ldisc.close)(o_tty);
1765                 tty_ldisc_put(o_tty->ldisc.num);
1766                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1767                 tty_set_termios_ldisc(o_tty,N_TTY); 
1768         }
1769         /*
1770          * The release_mem function takes care of the details of clearing
1771          * the slots and preserving the termios structure.
1772          */
1773         release_mem(tty, idx);
1774
1775 #ifdef CONFIG_UNIX98_PTYS
1776         /* Make this pty number available for reallocation */
1777         if (devpts) {
1778                 down(&allocated_ptys_lock);
1779                 idr_remove(&allocated_ptys, idx);
1780                 up(&allocated_ptys_lock);
1781         }
1782 #endif
1783
1784 }
1785
1786 /*
1787  * tty_open and tty_release keep up the tty count that contains the
1788  * number of opens done on a tty. We cannot use the inode-count, as
1789  * different inodes might point to the same tty.
1790  *
1791  * Open-counting is needed for pty masters, as well as for keeping
1792  * track of serial lines: DTR is dropped when the last close happens.
1793  * (This is not done solely through tty->count, now.  - Ted 1/27/92)
1794  *
1795  * The termios state of a pty is reset on first open so that
1796  * settings don't persist across reuse.
1797  */
1798 static int tty_open(struct inode * inode, struct file * filp)
1799 {
1800         struct tty_struct *tty;
1801         int noctty, retval;
1802         struct tty_driver *driver;
1803         int index;
1804         dev_t device = inode->i_rdev;
1805         unsigned short saved_flags = filp->f_flags;
1806
1807         nonseekable_open(inode, filp);
1808         
1809 retry_open:
1810         noctty = filp->f_flags & O_NOCTTY;
1811         index  = -1;
1812         retval = 0;
1813         
1814         down(&tty_sem);
1815
1816         if (device == MKDEV(TTYAUX_MAJOR,0)) {
1817                 if (!current->signal->tty) {
1818                         up(&tty_sem);
1819                         return -ENXIO;
1820                 }
1821                 driver = current->signal->tty->driver;
1822                 index = current->signal->tty->index;
1823                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1824                 /* noctty = 1; */
1825                 goto got_driver;
1826         }
1827 #ifdef CONFIG_VT
1828         if (device == MKDEV(TTY_MAJOR,0)) {
1829                 extern struct tty_driver *console_driver;
1830                 driver = console_driver;
1831                 index = fg_console;
1832                 noctty = 1;
1833                 goto got_driver;
1834         }
1835 #endif
1836         if (device == MKDEV(TTYAUX_MAJOR,1)) {
1837                 driver = console_device(&index);
1838                 if (driver) {
1839                         /* Don't let /dev/console block */
1840                         filp->f_flags |= O_NONBLOCK;
1841                         noctty = 1;
1842                         goto got_driver;
1843                 }
1844                 up(&tty_sem);
1845                 return -ENODEV;
1846         }
1847
1848         driver = get_tty_driver(device, &index);
1849         if (!driver) {
1850                 up(&tty_sem);
1851                 return -ENODEV;
1852         }
1853 got_driver:
1854         retval = init_dev(driver, index, &tty);
1855         up(&tty_sem);
1856         if (retval)
1857                 return retval;
1858
1859         filp->private_data = tty;
1860         file_move(filp, &tty->tty_files);
1861         check_tty_count(tty, "tty_open");
1862         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1863             tty->driver->subtype == PTY_TYPE_MASTER)
1864                 noctty = 1;
1865 #ifdef TTY_DEBUG_HANGUP
1866         printk(KERN_DEBUG "opening %s...", tty->name);
1867 #endif
1868         if (!retval) {
1869                 if (tty->driver->open)
1870                         retval = tty->driver->open(tty, filp);
1871                 else
1872                         retval = -ENODEV;
1873         }
1874         filp->f_flags = saved_flags;
1875
1876         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1877                 retval = -EBUSY;
1878
1879         if (retval) {
1880 #ifdef TTY_DEBUG_HANGUP
1881                 printk(KERN_DEBUG "error %d in opening %s...", retval,
1882                        tty->name);
1883 #endif
1884                 release_dev(filp);
1885                 if (retval != -ERESTARTSYS)
1886                         return retval;
1887                 if (signal_pending(current))
1888                         return retval;
1889                 schedule();
1890                 /*
1891                  * Need to reset f_op in case a hangup happened.
1892                  */
1893                 if (filp->f_op == &hung_up_tty_fops)
1894                         filp->f_op = &tty_fops;
1895                 goto retry_open;
1896         }
1897         if (!noctty &&
1898             current->signal->leader &&
1899             !current->signal->tty &&
1900             tty->session == 0) {
1901                 task_lock(current);
1902                 current->signal->tty = tty;
1903                 task_unlock(current);
1904                 current->signal->tty_old_pgrp = 0;
1905                 tty->session = current->signal->session;
1906                 tty->pgrp = process_group(current);
1907         }
1908         return 0;
1909 }
1910
1911 #ifdef CONFIG_UNIX98_PTYS
1912 static int ptmx_open(struct inode * inode, struct file * filp)
1913 {
1914         struct tty_struct *tty;
1915         int retval;
1916         int index;
1917         int idr_ret;
1918
1919         nonseekable_open(inode, filp);
1920
1921         /* find a device that is not in use. */
1922         down(&allocated_ptys_lock);
1923         if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1924                 up(&allocated_ptys_lock);
1925                 return -ENOMEM;
1926         }
1927         idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1928         if (idr_ret < 0) {
1929                 up(&allocated_ptys_lock);
1930                 if (idr_ret == -EAGAIN)
1931                         return -ENOMEM;
1932                 return -EIO;
1933         }
1934         if (index >= pty_limit) {
1935                 idr_remove(&allocated_ptys, index);
1936                 up(&allocated_ptys_lock);
1937                 return -EIO;
1938         }
1939         up(&allocated_ptys_lock);
1940
1941         down(&tty_sem);
1942         retval = init_dev(ptm_driver, index, &tty);
1943         up(&tty_sem);
1944         
1945         if (retval)
1946                 goto out;
1947
1948         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1949         filp->private_data = tty;
1950         file_move(filp, &tty->tty_files);
1951
1952         retval = -ENOMEM;
1953         if (devpts_pty_new(tty->link))
1954                 goto out1;
1955
1956         check_tty_count(tty, "tty_open");
1957         retval = ptm_driver->open(tty, filp);
1958         if (!retval)
1959                 return 0;
1960 out1:
1961         release_dev(filp);
1962 out:
1963         down(&allocated_ptys_lock);
1964         idr_remove(&allocated_ptys, index);
1965         up(&allocated_ptys_lock);
1966         return retval;
1967 }
1968 #endif
1969
1970 static int tty_release(struct inode * inode, struct file * filp)
1971 {
1972         lock_kernel();
1973         release_dev(filp);
1974         unlock_kernel();
1975         return 0;
1976 }
1977
1978 /* No kernel lock held - fine */
1979 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1980 {
1981         struct tty_struct * tty;
1982         struct tty_ldisc *ld;
1983         int ret = 0;
1984
1985         tty = (struct tty_struct *)filp->private_data;
1986         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1987                 return 0;
1988                 
1989         ld = tty_ldisc_ref_wait(tty);
1990         if (ld->poll)
1991                 ret = (ld->poll)(tty, filp, wait);
1992         tty_ldisc_deref(ld);
1993         return ret;
1994 }
1995
1996 static int tty_fasync(int fd, struct file * filp, int on)
1997 {
1998         struct tty_struct * tty;
1999         int retval;
2000
2001         tty = (struct tty_struct *)filp->private_data;
2002         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
2003                 return 0;
2004         
2005         retval = fasync_helper(fd, filp, on, &tty->fasync);
2006         if (retval <= 0)
2007                 return retval;
2008
2009         if (on) {
2010                 if (!waitqueue_active(&tty->read_wait))
2011                         tty->minimum_to_wake = 1;
2012                 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
2013                 if (retval)
2014                         return retval;
2015         } else {
2016                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2017                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
2018         }
2019         return 0;
2020 }
2021
2022 static int tiocsti(struct tty_struct *tty, char __user *p)
2023 {
2024         char ch, mbz = 0;
2025         struct tty_ldisc *ld;
2026         
2027         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2028                 return -EPERM;
2029         if (get_user(ch, p))
2030                 return -EFAULT;
2031         ld = tty_ldisc_ref_wait(tty);
2032         ld->receive_buf(tty, &ch, &mbz, 1);
2033         tty_ldisc_deref(ld);
2034         return 0;
2035 }
2036
2037 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2038 {
2039         if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2040                 return -EFAULT;
2041         return 0;
2042 }
2043
2044 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2045         struct winsize __user * arg)
2046 {
2047         struct winsize tmp_ws;
2048
2049         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2050                 return -EFAULT;
2051         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2052                 return 0;
2053 #ifdef CONFIG_VT
2054         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2055                 int rc;
2056
2057                 acquire_console_sem();
2058                 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2059                 release_console_sem();
2060                 if (rc)
2061                         return -ENXIO;
2062         }
2063 #endif
2064         if (tty->pgrp > 0)
2065                 kill_pg(tty->pgrp, SIGWINCH, 1);
2066         if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2067                 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2068         tty->winsize = tmp_ws;
2069         real_tty->winsize = tmp_ws;
2070         return 0;
2071 }
2072
2073 static int tioccons(struct file *file)
2074 {
2075         if (!capable(CAP_SYS_ADMIN))
2076                 return -EPERM;
2077         if (file->f_op->write == redirected_tty_write) {
2078                 struct file *f;
2079                 spin_lock(&redirect_lock);
2080                 f = redirect;
2081                 redirect = NULL;
2082                 spin_unlock(&redirect_lock);
2083                 if (f)
2084                         fput(f);
2085                 return 0;
2086         }
2087         spin_lock(&redirect_lock);
2088         if (redirect) {
2089                 spin_unlock(&redirect_lock);
2090                 return -EBUSY;
2091         }
2092         get_file(file);
2093         redirect = file;
2094         spin_unlock(&redirect_lock);
2095         return 0;
2096 }
2097
2098
2099 static int fionbio(struct file *file, int __user *p)
2100 {
2101         int nonblock;
2102
2103         if (get_user(nonblock, p))
2104                 return -EFAULT;
2105
2106         if (nonblock)
2107                 file->f_flags |= O_NONBLOCK;
2108         else
2109                 file->f_flags &= ~O_NONBLOCK;
2110         return 0;
2111 }
2112
2113 static int tiocsctty(struct tty_struct *tty, int arg)
2114 {
2115         task_t *p;
2116
2117         if (current->signal->leader &&
2118             (current->signal->session == tty->session))
2119                 return 0;
2120         /*
2121          * The process must be a session leader and
2122          * not have a controlling tty already.
2123          */
2124         if (!current->signal->leader || current->signal->tty)
2125                 return -EPERM;
2126         if (tty->session > 0) {
2127                 /*
2128                  * This tty is already the controlling
2129                  * tty for another session group!
2130                  */
2131                 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2132                         /*
2133                          * Steal it away
2134                          */
2135
2136                         read_lock(&tasklist_lock);
2137                         do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2138                                 p->signal->tty = NULL;
2139                         } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2140                         read_unlock(&tasklist_lock);
2141                 } else
2142                         return -EPERM;
2143         }
2144         task_lock(current);
2145         current->signal->tty = tty;
2146         task_unlock(current);
2147         current->signal->tty_old_pgrp = 0;
2148         tty->session = current->signal->session;
2149         tty->pgrp = process_group(current);
2150         return 0;
2151 }
2152
2153 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2154 {
2155         /*
2156          * (tty == real_tty) is a cheap way of
2157          * testing if the tty is NOT a master pty.
2158          */
2159         if (tty == real_tty && current->signal->tty != real_tty)
2160                 return -ENOTTY;
2161         return put_user(real_tty->pgrp, p);
2162 }
2163
2164 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2165 {
2166         pid_t pgrp;
2167         int retval = tty_check_change(real_tty);
2168
2169         if (retval == -EIO)
2170                 return -ENOTTY;
2171         if (retval)
2172                 return retval;
2173         if (!current->signal->tty ||
2174             (current->signal->tty != real_tty) ||
2175             (real_tty->session != current->signal->session))
2176                 return -ENOTTY;
2177         if (get_user(pgrp, p))
2178                 return -EFAULT;
2179         if (pgrp < 0)
2180                 return -EINVAL;
2181         if (session_of_pgrp(pgrp) != current->signal->session)
2182                 return -EPERM;
2183         real_tty->pgrp = pgrp;
2184         return 0;
2185 }
2186
2187 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2188 {
2189         /*
2190          * (tty == real_tty) is a cheap way of
2191          * testing if the tty is NOT a master pty.
2192         */
2193         if (tty == real_tty && current->signal->tty != real_tty)
2194                 return -ENOTTY;
2195         if (real_tty->session <= 0)
2196                 return -ENOTTY;
2197         return put_user(real_tty->session, p);
2198 }
2199
2200 static int tiocsetd(struct tty_struct *tty, int __user *p)
2201 {
2202         int ldisc;
2203
2204         if (get_user(ldisc, p))
2205                 return -EFAULT;
2206         return tty_set_ldisc(tty, ldisc);
2207 }
2208
2209 static int send_break(struct tty_struct *tty, unsigned int duration)
2210 {
2211         tty->driver->break_ctl(tty, -1);
2212         if (!signal_pending(current)) {
2213                 msleep_interruptible(duration);
2214         }
2215         tty->driver->break_ctl(tty, 0);
2216         if (signal_pending(current))
2217                 return -EINTR;
2218         return 0;
2219 }
2220
2221 static int
2222 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2223 {
2224         int retval = -EINVAL;
2225
2226         if (tty->driver->tiocmget) {
2227                 retval = tty->driver->tiocmget(tty, file);
2228
2229                 if (retval >= 0)
2230                         retval = put_user(retval, p);
2231         }
2232         return retval;
2233 }
2234
2235 static int
2236 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2237              unsigned __user *p)
2238 {
2239         int retval = -EINVAL;
2240
2241         if (tty->driver->tiocmset) {
2242                 unsigned int set, clear, val;
2243
2244                 retval = get_user(val, p);
2245                 if (retval)
2246                         return retval;
2247
2248                 set = clear = 0;
2249                 switch (cmd) {
2250                 case TIOCMBIS:
2251                         set = val;
2252                         break;
2253                 case TIOCMBIC:
2254                         clear = val;
2255                         break;
2256                 case TIOCMSET:
2257                         set = val;
2258                         clear = ~val;
2259                         break;
2260                 }
2261
2262                 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2263                 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2264
2265                 retval = tty->driver->tiocmset(tty, file, set, clear);
2266         }
2267         return retval;
2268 }
2269
2270 /*
2271  * Split this up, as gcc can choke on it otherwise..
2272  */
2273 int tty_ioctl(struct inode * inode, struct file * file,
2274               unsigned int cmd, unsigned long arg)
2275 {
2276         struct tty_struct *tty, *real_tty;
2277         void __user *p = (void __user *)arg;
2278         int retval;
2279         struct tty_ldisc *ld;
2280         
2281         tty = (struct tty_struct *)file->private_data;
2282         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2283                 return -EINVAL;
2284
2285         real_tty = tty;
2286         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2287             tty->driver->subtype == PTY_TYPE_MASTER)
2288                 real_tty = tty->link;
2289
2290         /*
2291          * Break handling by driver
2292          */
2293         if (!tty->driver->break_ctl) {
2294                 switch(cmd) {
2295                 case TIOCSBRK:
2296                 case TIOCCBRK:
2297                         if (tty->driver->ioctl)
2298                                 return tty->driver->ioctl(tty, file, cmd, arg);
2299                         return -EINVAL;
2300                         
2301                 /* These two ioctl's always return success; even if */
2302                 /* the driver doesn't support them. */
2303                 case TCSBRK:
2304                 case TCSBRKP:
2305                         if (!tty->driver->ioctl)
2306                                 return 0;
2307                         retval = tty->driver->ioctl(tty, file, cmd, arg);
2308                         if (retval == -ENOIOCTLCMD)
2309                                 retval = 0;
2310                         return retval;
2311                 }
2312         }
2313
2314         /*
2315          * Factor out some common prep work
2316          */
2317         switch (cmd) {
2318         case TIOCSETD:
2319         case TIOCSBRK:
2320         case TIOCCBRK:
2321         case TCSBRK:
2322         case TCSBRKP:                   
2323                 retval = tty_check_change(tty);
2324                 if (retval)
2325                         return retval;
2326                 if (cmd != TIOCCBRK) {
2327                         tty_wait_until_sent(tty, 0);
2328                         if (signal_pending(current))
2329                                 return -EINTR;
2330                 }
2331                 break;
2332         }
2333
2334         switch (cmd) {
2335                 case TIOCSTI:
2336                         return tiocsti(tty, p);
2337                 case TIOCGWINSZ:
2338                         return tiocgwinsz(tty, p);
2339                 case TIOCSWINSZ:
2340                         return tiocswinsz(tty, real_tty, p);
2341                 case TIOCCONS:
2342                         return real_tty!=tty ? -EINVAL : tioccons(file);
2343                 case FIONBIO:
2344                         return fionbio(file, p);
2345                 case TIOCEXCL:
2346                         set_bit(TTY_EXCLUSIVE, &tty->flags);
2347                         return 0;
2348                 case TIOCNXCL:
2349                         clear_bit(TTY_EXCLUSIVE, &tty->flags);
2350                         return 0;
2351                 case TIOCNOTTY:
2352                         if (current->signal->tty != tty)
2353                                 return -ENOTTY;
2354                         if (current->signal->leader)
2355                                 disassociate_ctty(0);
2356                         task_lock(current);
2357                         current->signal->tty = NULL;
2358                         task_unlock(current);
2359                         return 0;
2360                 case TIOCSCTTY:
2361                         return tiocsctty(tty, arg);
2362                 case TIOCGPGRP:
2363                         return tiocgpgrp(tty, real_tty, p);
2364                 case TIOCSPGRP:
2365                         return tiocspgrp(tty, real_tty, p);
2366                 case TIOCGSID:
2367                         return tiocgsid(tty, real_tty, p);
2368                 case TIOCGETD:
2369                         /* FIXME: check this is ok */
2370                         return put_user(tty->ldisc.num, (int __user *)p);
2371                 case TIOCSETD:
2372                         return tiocsetd(tty, p);
2373 #ifdef CONFIG_VT
2374                 case TIOCLINUX:
2375                         return tioclinux(tty, arg);
2376 #endif
2377                 /*
2378                  * Break handling
2379                  */
2380                 case TIOCSBRK:  /* Turn break on, unconditionally */
2381                         tty->driver->break_ctl(tty, -1);
2382                         return 0;
2383                         
2384                 case TIOCCBRK:  /* Turn break off, unconditionally */
2385                         tty->driver->break_ctl(tty, 0);
2386                         return 0;
2387                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
2388                         /*
2389                          * XXX is the above comment correct, or the
2390                          * code below correct?  Is this ioctl used at
2391                          * all by anyone?
2392                          */
2393                         if (!arg)
2394                                 return send_break(tty, 250);
2395                         return 0;
2396                 case TCSBRKP:   /* support for POSIX tcsendbreak() */   
2397                         return send_break(tty, arg ? arg*100 : 250);
2398
2399                 case TIOCMGET:
2400                         return tty_tiocmget(tty, file, p);
2401
2402                 case TIOCMSET:
2403                 case TIOCMBIC:
2404                 case TIOCMBIS:
2405                         return tty_tiocmset(tty, file, cmd, p);
2406         }
2407         if (tty->driver->ioctl) {
2408                 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2409                 if (retval != -ENOIOCTLCMD)
2410                         return retval;
2411         }
2412         ld = tty_ldisc_ref_wait(tty);
2413         retval = -EINVAL;
2414         if (ld->ioctl) {
2415                 retval = ld->ioctl(tty, file, cmd, arg);
2416                 if (retval == -ENOIOCTLCMD)
2417                         retval = -EINVAL;
2418         }
2419         tty_ldisc_deref(ld);
2420         return retval;
2421 }
2422
2423
2424 /*
2425  * This implements the "Secure Attention Key" ---  the idea is to
2426  * prevent trojan horses by killing all processes associated with this
2427  * tty when the user hits the "Secure Attention Key".  Required for
2428  * super-paranoid applications --- see the Orange Book for more details.
2429  * 
2430  * This code could be nicer; ideally it should send a HUP, wait a few
2431  * seconds, then send a INT, and then a KILL signal.  But you then
2432  * have to coordinate with the init process, since all processes associated
2433  * with the current tty must be dead before the new getty is allowed
2434  * to spawn.
2435  *
2436  * Now, if it would be correct ;-/ The current code has a nasty hole -
2437  * it doesn't catch files in flight. We may send the descriptor to ourselves
2438  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2439  *
2440  * Nasty bug: do_SAK is being called in interrupt context.  This can
2441  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2442  */
2443 static void __do_SAK(void *arg)
2444 {
2445 #ifdef TTY_SOFT_SAK
2446         tty_hangup(tty);
2447 #else
2448         struct tty_struct *tty = arg;
2449         struct task_struct *p;
2450         int session;
2451         int             i;
2452         struct file     *filp;
2453         struct tty_ldisc *disc;
2454         struct fdtable *fdt;
2455         
2456         if (!tty)
2457                 return;
2458         session  = tty->session;
2459         
2460         /* We don't want an ldisc switch during this */
2461         disc = tty_ldisc_ref(tty);
2462         if (disc && disc->flush_buffer)
2463                 disc->flush_buffer(tty);
2464         tty_ldisc_deref(disc);
2465
2466         if (tty->driver->flush_buffer)
2467                 tty->driver->flush_buffer(tty);
2468         
2469         read_lock(&tasklist_lock);
2470         do_each_task_pid(session, PIDTYPE_SID, p) {
2471                 if (p->signal->tty == tty || session > 0) {
2472                         printk(KERN_NOTICE "SAK: killed process %d"
2473                             " (%s): p->signal->session==tty->session\n",
2474                             p->pid, p->comm);
2475                         send_sig(SIGKILL, p, 1);
2476                         continue;
2477                 }
2478                 task_lock(p);
2479                 if (p->files) {
2480                         rcu_read_lock();
2481                         fdt = files_fdtable(p->files);
2482                         for (i=0; i < fdt->max_fds; i++) {
2483                                 filp = fcheck_files(p->files, i);
2484                                 if (!filp)
2485                                         continue;
2486                                 if (filp->f_op->read == tty_read &&
2487                                     filp->private_data == tty) {
2488                                         printk(KERN_NOTICE "SAK: killed process %d"
2489                                             " (%s): fd#%d opened to the tty\n",
2490                                             p->pid, p->comm, i);
2491                                         send_sig(SIGKILL, p, 1);
2492                                         break;
2493                                 }
2494                         }
2495                         rcu_read_unlock();
2496                 }
2497                 task_unlock(p);
2498         } while_each_task_pid(session, PIDTYPE_SID, p);
2499         read_unlock(&tasklist_lock);
2500 #endif
2501 }
2502
2503 /*
2504  * The tq handling here is a little racy - tty->SAK_work may already be queued.
2505  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2506  * the values which we write to it will be identical to the values which it
2507  * already has. --akpm
2508  */
2509 void do_SAK(struct tty_struct *tty)
2510 {
2511         if (!tty)
2512                 return;
2513         PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2514         schedule_work(&tty->SAK_work);
2515 }
2516
2517 EXPORT_SYMBOL(do_SAK);
2518
2519 /*
2520  * This routine is called out of the software interrupt to flush data
2521  * from the flip buffer to the line discipline. 
2522  */
2523  
2524 static void flush_to_ldisc(void *private_)
2525 {
2526         struct tty_struct *tty = (struct tty_struct *) private_;
2527         unsigned char   *cp;
2528         char            *fp;
2529         int             count;
2530         unsigned long   flags;
2531         struct tty_ldisc *disc;
2532
2533         disc = tty_ldisc_ref(tty);
2534         if (disc == NULL)       /*  !TTY_LDISC */
2535                 return;
2536
2537         if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2538                 /*
2539                  * Do it after the next timer tick:
2540                  */
2541                 schedule_delayed_work(&tty->flip.work, 1);
2542                 goto out;
2543         }
2544         spin_lock_irqsave(&tty->read_lock, flags);
2545         if (tty->flip.buf_num) {
2546                 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2547                 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2548                 tty->flip.buf_num = 0;
2549                 tty->flip.char_buf_ptr = tty->flip.char_buf;
2550                 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2551         } else {
2552                 cp = tty->flip.char_buf;
2553                 fp = tty->flip.flag_buf;
2554                 tty->flip.buf_num = 1;
2555                 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2556                 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2557         }
2558         count = tty->flip.count;
2559         tty->flip.count = 0;
2560         spin_unlock_irqrestore(&tty->read_lock, flags);
2561
2562         disc->receive_buf(tty, cp, fp, count);
2563 out:
2564         tty_ldisc_deref(disc);
2565 }
2566
2567 /*
2568  * Routine which returns the baud rate of the tty
2569  *
2570  * Note that the baud_table needs to be kept in sync with the
2571  * include/asm/termbits.h file.
2572  */
2573 static int baud_table[] = {
2574         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2575         9600, 19200, 38400, 57600, 115200, 230400, 460800,
2576 #ifdef __sparc__
2577         76800, 153600, 307200, 614400, 921600
2578 #else
2579         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2580         2500000, 3000000, 3500000, 4000000
2581 #endif
2582 };
2583
2584 static int n_baud_table = ARRAY_SIZE(baud_table);
2585
2586 /**
2587  *      tty_termios_baud_rate
2588  *      @termios: termios structure
2589  *
2590  *      Convert termios baud rate data into a speed. This should be called
2591  *      with the termios lock held if this termios is a terminal termios
2592  *      structure. May change the termios data.
2593  */
2594  
2595 int tty_termios_baud_rate(struct termios *termios)
2596 {
2597         unsigned int cbaud;
2598         
2599         cbaud = termios->c_cflag & CBAUD;
2600
2601         if (cbaud & CBAUDEX) {
2602                 cbaud &= ~CBAUDEX;
2603
2604                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2605                         termios->c_cflag &= ~CBAUDEX;
2606                 else
2607                         cbaud += 15;
2608         }
2609         return baud_table[cbaud];
2610 }
2611
2612 EXPORT_SYMBOL(tty_termios_baud_rate);
2613
2614 /**
2615  *      tty_get_baud_rate       -       get tty bit rates
2616  *      @tty: tty to query
2617  *
2618  *      Returns the baud rate as an integer for this terminal. The
2619  *      termios lock must be held by the caller and the terminal bit
2620  *      flags may be updated.
2621  */
2622  
2623 int tty_get_baud_rate(struct tty_struct *tty)
2624 {
2625         int baud = tty_termios_baud_rate(tty->termios);
2626
2627         if (baud == 38400 && tty->alt_speed) {
2628                 if (!tty->warned) {
2629                         printk(KERN_WARNING "Use of setserial/setrocket to "
2630                                             "set SPD_* flags is deprecated\n");
2631                         tty->warned = 1;
2632                 }
2633                 baud = tty->alt_speed;
2634         }
2635         
2636         return baud;
2637 }
2638
2639 EXPORT_SYMBOL(tty_get_baud_rate);
2640
2641 /**
2642  *      tty_flip_buffer_push    -       terminal
2643  *      @tty: tty to push
2644  *
2645  *      Queue a push of the terminal flip buffers to the line discipline. This
2646  *      function must not be called from IRQ context if tty->low_latency is set.
2647  *
2648  *      In the event of the queue being busy for flipping the work will be
2649  *      held off and retried later.
2650  */
2651
2652 void tty_flip_buffer_push(struct tty_struct *tty)
2653 {
2654         if (tty->low_latency)
2655                 flush_to_ldisc((void *) tty);
2656         else
2657                 schedule_delayed_work(&tty->flip.work, 1);
2658 }
2659
2660 EXPORT_SYMBOL(tty_flip_buffer_push);
2661
2662 /*
2663  * This subroutine initializes a tty structure.
2664  */
2665 static void initialize_tty_struct(struct tty_struct *tty)
2666 {
2667         memset(tty, 0, sizeof(struct tty_struct));
2668         tty->magic = TTY_MAGIC;
2669         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2670         tty->pgrp = -1;
2671         tty->overrun_time = jiffies;
2672         tty->flip.char_buf_ptr = tty->flip.char_buf;
2673         tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2674         INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2675         init_MUTEX(&tty->flip.pty_sem);
2676         init_MUTEX(&tty->termios_sem);
2677         init_waitqueue_head(&tty->write_wait);
2678         init_waitqueue_head(&tty->read_wait);
2679         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2680         sema_init(&tty->atomic_read, 1);
2681         sema_init(&tty->atomic_write, 1);
2682         spin_lock_init(&tty->read_lock);
2683         INIT_LIST_HEAD(&tty->tty_files);
2684         INIT_WORK(&tty->SAK_work, NULL, NULL);
2685 }
2686
2687 /*
2688  * The default put_char routine if the driver did not define one.
2689  */
2690 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2691 {
2692         tty->driver->write(tty, &ch, 1);
2693 }
2694
2695 static struct class *tty_class;
2696
2697 /**
2698  * tty_register_device - register a tty device
2699  * @driver: the tty driver that describes the tty device
2700  * @index: the index in the tty driver for this tty device
2701  * @device: a struct device that is associated with this tty device.
2702  *      This field is optional, if there is no known struct device for this
2703  *      tty device it can be set to NULL safely.
2704  *
2705  * This call is required to be made to register an individual tty device if
2706  * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set.  If that
2707  * bit is not set, this function should not be called.
2708  */
2709 void tty_register_device(struct tty_driver *driver, unsigned index,
2710                          struct device *device)
2711 {
2712         char name[64];
2713         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2714
2715         if (index >= driver->num) {
2716                 printk(KERN_ERR "Attempt to register invalid tty line number "
2717                        " (%d).\n", index);
2718                 return;
2719         }
2720
2721         devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2722                         "%s%d", driver->devfs_name, index + driver->name_base);
2723
2724         if (driver->type == TTY_DRIVER_TYPE_PTY)
2725                 pty_line_name(driver, index, name);
2726         else
2727                 tty_line_name(driver, index, name);
2728         class_device_create(tty_class, NULL, dev, device, "%s", name);
2729 }
2730
2731 /**
2732  * tty_unregister_device - unregister a tty device
2733  * @driver: the tty driver that describes the tty device
2734  * @index: the index in the tty driver for this tty device
2735  *
2736  * If a tty device is registered with a call to tty_register_device() then
2737  * this function must be made when the tty device is gone.
2738  */
2739 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2740 {
2741         devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2742         class_device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
2743 }
2744
2745 EXPORT_SYMBOL(tty_register_device);
2746 EXPORT_SYMBOL(tty_unregister_device);
2747
2748 struct tty_driver *alloc_tty_driver(int lines)
2749 {
2750         struct tty_driver *driver;
2751
2752         driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2753         if (driver) {
2754                 memset(driver, 0, sizeof(struct tty_driver));
2755                 driver->magic = TTY_DRIVER_MAGIC;
2756                 driver->num = lines;
2757                 /* later we'll move allocation of tables here */
2758         }
2759         return driver;
2760 }
2761
2762 void put_tty_driver(struct tty_driver *driver)
2763 {
2764         kfree(driver);
2765 }
2766
2767 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2768 {
2769         driver->open = op->open;
2770         driver->close = op->close;
2771         driver->write = op->write;
2772         driver->put_char = op->put_char;
2773         driver->flush_chars = op->flush_chars;
2774         driver->write_room = op->write_room;
2775         driver->chars_in_buffer = op->chars_in_buffer;
2776         driver->ioctl = op->ioctl;
2777         driver->set_termios = op->set_termios;
2778         driver->throttle = op->throttle;
2779         driver->unthrottle = op->unthrottle;
2780         driver->stop = op->stop;
2781         driver->start = op->start;
2782         driver->hangup = op->hangup;
2783         driver->break_ctl = op->break_ctl;
2784         driver->flush_buffer = op->flush_buffer;
2785         driver->set_ldisc = op->set_ldisc;
2786         driver->wait_until_sent = op->wait_until_sent;
2787         driver->send_xchar = op->send_xchar;
2788         driver->read_proc = op->read_proc;
2789         driver->write_proc = op->write_proc;
2790         driver->tiocmget = op->tiocmget;
2791         driver->tiocmset = op->tiocmset;
2792 }
2793
2794
2795 EXPORT_SYMBOL(alloc_tty_driver);
2796 EXPORT_SYMBOL(put_tty_driver);
2797 EXPORT_SYMBOL(tty_set_operations);
2798
2799 /*
2800  * Called by a tty driver to register itself.
2801  */
2802 int tty_register_driver(struct tty_driver *driver)
2803 {
2804         int error;
2805         int i;
2806         dev_t dev;
2807         void **p = NULL;
2808
2809         if (driver->flags & TTY_DRIVER_INSTALLED)
2810                 return 0;
2811
2812         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2813                 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2814                 if (!p)
2815                         return -ENOMEM;
2816                 memset(p, 0, driver->num * 3 * sizeof(void *));
2817         }
2818
2819         if (!driver->major) {
2820                 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2821                                                 (char*)driver->name);
2822                 if (!error) {
2823                         driver->major = MAJOR(dev);
2824                         driver->minor_start = MINOR(dev);
2825                 }
2826         } else {
2827                 dev = MKDEV(driver->major, driver->minor_start);
2828                 error = register_chrdev_region(dev, driver->num,
2829                                                 (char*)driver->name);
2830         }
2831         if (error < 0) {
2832                 kfree(p);
2833                 return error;
2834         }
2835
2836         if (p) {
2837                 driver->ttys = (struct tty_struct **)p;
2838                 driver->termios = (struct termios **)(p + driver->num);
2839                 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2840         } else {
2841                 driver->ttys = NULL;
2842                 driver->termios = NULL;
2843                 driver->termios_locked = NULL;
2844         }
2845
2846         cdev_init(&driver->cdev, &tty_fops);
2847         driver->cdev.owner = driver->owner;
2848         error = cdev_add(&driver->cdev, dev, driver->num);
2849         if (error) {
2850                 cdev_del(&driver->cdev);
2851                 unregister_chrdev_region(dev, driver->num);
2852                 driver->ttys = NULL;
2853                 driver->termios = driver->termios_locked = NULL;
2854                 kfree(p);
2855                 return error;
2856         }
2857
2858         if (!driver->put_char)
2859                 driver->put_char = tty_default_put_char;
2860         
2861         list_add(&driver->tty_drivers, &tty_drivers);
2862         
2863         if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2864                 for(i = 0; i < driver->num; i++)
2865                     tty_register_device(driver, i, NULL);
2866         }
2867         proc_tty_register_driver(driver);
2868         return 0;
2869 }
2870
2871 EXPORT_SYMBOL(tty_register_driver);
2872
2873 /*
2874  * Called by a tty driver to unregister itself.
2875  */
2876 int tty_unregister_driver(struct tty_driver *driver)
2877 {
2878         int i;
2879         struct termios *tp;
2880         void *p;
2881
2882         if (driver->refcount)
2883                 return -EBUSY;
2884
2885         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2886                                 driver->num);
2887
2888         list_del(&driver->tty_drivers);
2889
2890         /*
2891          * Free the termios and termios_locked structures because
2892          * we don't want to get memory leaks when modular tty
2893          * drivers are removed from the kernel.
2894          */
2895         for (i = 0; i < driver->num; i++) {
2896                 tp = driver->termios[i];
2897                 if (tp) {
2898                         driver->termios[i] = NULL;
2899                         kfree(tp);
2900                 }
2901                 tp = driver->termios_locked[i];
2902                 if (tp) {
2903                         driver->termios_locked[i] = NULL;
2904                         kfree(tp);
2905                 }
2906                 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2907                         tty_unregister_device(driver, i);
2908         }
2909         p = driver->ttys;
2910         proc_tty_unregister_driver(driver);
2911         driver->ttys = NULL;
2912         driver->termios = driver->termios_locked = NULL;
2913         kfree(p);
2914         cdev_del(&driver->cdev);
2915         return 0;
2916 }
2917
2918 EXPORT_SYMBOL(tty_unregister_driver);
2919
2920
2921 /*
2922  * Initialize the console device. This is called *early*, so
2923  * we can't necessarily depend on lots of kernel help here.
2924  * Just do some early initializations, and do the complex setup
2925  * later.
2926  */
2927 void __init console_init(void)
2928 {
2929         initcall_t *call;
2930
2931         /* Setup the default TTY line discipline. */
2932         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2933
2934         /*
2935          * set up the console device so that later boot sequences can 
2936          * inform about problems etc..
2937          */
2938 #ifdef CONFIG_EARLY_PRINTK
2939         disable_early_printk();
2940 #endif
2941         call = __con_initcall_start;
2942         while (call < __con_initcall_end) {
2943                 (*call)();
2944                 call++;
2945         }
2946 }
2947
2948 #ifdef CONFIG_VT
2949 extern int vty_init(void);
2950 #endif
2951
2952 static int __init tty_class_init(void)
2953 {
2954         tty_class = class_create(THIS_MODULE, "tty");
2955         if (IS_ERR(tty_class))
2956                 return PTR_ERR(tty_class);
2957         return 0;
2958 }
2959
2960 postcore_initcall(tty_class_init);
2961
2962 /* 3/2004 jmc: why do these devices exist? */
2963
2964 static struct cdev tty_cdev, console_cdev;
2965 #ifdef CONFIG_UNIX98_PTYS
2966 static struct cdev ptmx_cdev;
2967 #endif
2968 #ifdef CONFIG_VT
2969 static struct cdev vc0_cdev;
2970 #endif
2971
2972 /*
2973  * Ok, now we can initialize the rest of the tty devices and can count
2974  * on memory allocations, interrupts etc..
2975  */
2976 static int __init tty_init(void)
2977 {
2978         cdev_init(&tty_cdev, &tty_fops);
2979         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2980             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2981                 panic("Couldn't register /dev/tty driver\n");
2982         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2983         class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2984
2985         cdev_init(&console_cdev, &console_fops);
2986         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2987             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2988                 panic("Couldn't register /dev/console driver\n");
2989         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2990         class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2991
2992 #ifdef CONFIG_UNIX98_PTYS
2993         cdev_init(&ptmx_cdev, &ptmx_fops);
2994         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2995             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2996                 panic("Couldn't register /dev/ptmx driver\n");
2997         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2998         class_device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2999 #endif
3000
3001 #ifdef CONFIG_VT
3002         cdev_init(&vc0_cdev, &console_fops);
3003         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
3004             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
3005                 panic("Couldn't register /dev/tty0 driver\n");
3006         devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
3007         class_device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
3008
3009         vty_init();
3010 #endif
3011         return 0;
3012 }
3013 module_init(tty_init);