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