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