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