cc4b43bad703c1da6aaf444f0ee3acbca3d4d7c3
[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
98 #include <asm/uaccess.h>
99 #include <asm/system.h>
100
101 #include <linux/kbd_kern.h>
102 #include <linux/vt_kern.h>
103 #include <linux/selection.h>
104 #include <linux/devfs_fs_kernel.h>
105
106 #include <linux/kmod.h>
107
108 #undef TTY_DEBUG_HANGUP
109
110 #define TTY_PARANOIA_CHECK 1
111 #define CHECK_TTY_COUNT 1
112
113 struct termios tty_std_termios = {      /* for the benefit of tty drivers  */
114         .c_iflag = ICRNL | IXON,
115         .c_oflag = OPOST | ONLCR,
116         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
117         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
118                    ECHOCTL | ECHOKE | IEXTEN,
119         .c_cc = INIT_C_CC
120 };
121
122 EXPORT_SYMBOL(tty_std_termios);
123
124 /* This list gets poked at by procfs and various bits of boot up code. This
125    could do with some rationalisation such as pulling the tty proc function
126    into this file */
127    
128 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
129
130 /* Semaphore to protect creating and releasing a tty. This is shared with
131    vt.c for deeply disgusting hack reasons */
132 DECLARE_MUTEX(tty_sem);
133
134 #ifdef CONFIG_UNIX98_PTYS
135 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
136 extern int pty_limit;           /* Config limit on Unix98 ptys */
137 static DEFINE_IDR(allocated_ptys);
138 static DECLARE_MUTEX(allocated_ptys_lock);
139 static int ptmx_open(struct inode *, struct file *);
140 #endif
141
142 extern void disable_early_printk(void);
143
144 static void initialize_tty_struct(struct tty_struct *tty);
145
146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
149 static unsigned int tty_poll(struct file *, poll_table *);
150 static int tty_open(struct inode *, struct file *);
151 static int tty_release(struct inode *, struct file *);
152 int tty_ioctl(struct inode * inode, struct file * file,
153               unsigned int cmd, unsigned long arg);
154 static int tty_fasync(int fd, struct file * filp, int on);
155 extern void rs_360_init(void);
156 static void release_mem(struct tty_struct *tty, int idx);
157
158
159 static struct tty_struct *alloc_tty_struct(void)
160 {
161         struct tty_struct *tty;
162
163         tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
164         if (tty)
165                 memset(tty, 0, sizeof(struct tty_struct));
166         return tty;
167 }
168
169 static inline void free_tty_struct(struct tty_struct *tty)
170 {
171         kfree(tty->write_buf);
172         kfree(tty);
173 }
174
175 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
176
177 char *tty_name(struct tty_struct *tty, char *buf)
178 {
179         if (!tty) /* Hmm.  NULL pointer.  That's fun. */
180                 strcpy(buf, "NULL tty");
181         else
182                 strcpy(buf, tty->name);
183         return buf;
184 }
185
186 EXPORT_SYMBOL(tty_name);
187
188 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
189                               const char *routine)
190 {
191 #ifdef TTY_PARANOIA_CHECK
192         if (!tty) {
193                 printk(KERN_WARNING
194                         "null TTY for (%d:%d) in %s\n",
195                         imajor(inode), iminor(inode), routine);
196                 return 1;
197         }
198         if (tty->magic != TTY_MAGIC) {
199                 printk(KERN_WARNING
200                         "bad magic number for tty struct (%d:%d) in %s\n",
201                         imajor(inode), iminor(inode), routine);
202                 return 1;
203         }
204 #endif
205         return 0;
206 }
207
208 static int check_tty_count(struct tty_struct *tty, const char *routine)
209 {
210 #ifdef CHECK_TTY_COUNT
211         struct list_head *p;
212         int count = 0;
213         
214         file_list_lock();
215         list_for_each(p, &tty->tty_files) {
216                 count++;
217         }
218         file_list_unlock();
219         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
220             tty->driver->subtype == PTY_TYPE_SLAVE &&
221             tty->link && tty->link->count)
222                 count++;
223         if (tty->count != count) {
224                 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
225                                     "!= #fd's(%d) in %s\n",
226                        tty->name, tty->count, count, routine);
227                 return count;
228        }        
229 #endif
230         return 0;
231 }
232
233 /*
234  *      This is probably overkill for real world processors but
235  *      they are not on hot paths so a little discipline won't do 
236  *      any harm.
237  */
238  
239 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
240 {
241         down(&tty->termios_sem);
242         tty->termios->c_line = num;
243         up(&tty->termios_sem);
244 }
245
246 /*
247  *      This guards the refcounted line discipline lists. The lock
248  *      must be taken with irqs off because there are hangup path
249  *      callers who will do ldisc lookups and cannot sleep.
250  */
251  
252 static DEFINE_SPINLOCK(tty_ldisc_lock);
253 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
254 static struct tty_ldisc tty_ldiscs[NR_LDISCS];  /* line disc dispatch table */
255
256 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
257 {
258         unsigned long flags;
259         int ret = 0;
260         
261         if (disc < N_TTY || disc >= NR_LDISCS)
262                 return -EINVAL;
263         
264         spin_lock_irqsave(&tty_ldisc_lock, flags);
265         tty_ldiscs[disc] = *new_ldisc;
266         tty_ldiscs[disc].num = disc;
267         tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
268         tty_ldiscs[disc].refcount = 0;
269         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
270         
271         return ret;
272 }
273 EXPORT_SYMBOL(tty_register_ldisc);
274
275 int tty_unregister_ldisc(int disc)
276 {
277         unsigned long flags;
278         int ret = 0;
279
280         if (disc < N_TTY || disc >= NR_LDISCS)
281                 return -EINVAL;
282
283         spin_lock_irqsave(&tty_ldisc_lock, flags);
284         if (tty_ldiscs[disc].refcount)
285                 ret = -EBUSY;
286         else
287                 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
288         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
289
290         return ret;
291 }
292 EXPORT_SYMBOL(tty_unregister_ldisc);
293
294 struct tty_ldisc *tty_ldisc_get(int disc)
295 {
296         unsigned long flags;
297         struct tty_ldisc *ld;
298
299         if (disc < N_TTY || disc >= NR_LDISCS)
300                 return NULL;
301         
302         spin_lock_irqsave(&tty_ldisc_lock, flags);
303
304         ld = &tty_ldiscs[disc];
305         /* Check the entry is defined */
306         if(ld->flags & LDISC_FLAG_DEFINED)
307         {
308                 /* If the module is being unloaded we can't use it */
309                 if (!try_module_get(ld->owner))
310                         ld = NULL;
311                 else /* lock it */
312                         ld->refcount++;
313         }
314         else
315                 ld = NULL;
316         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
317         return ld;
318 }
319
320 EXPORT_SYMBOL_GPL(tty_ldisc_get);
321
322 void tty_ldisc_put(int disc)
323 {
324         struct tty_ldisc *ld;
325         unsigned long flags;
326         
327         if (disc < N_TTY || disc >= NR_LDISCS)
328                 BUG();
329                 
330         spin_lock_irqsave(&tty_ldisc_lock, flags);
331         ld = &tty_ldiscs[disc];
332         if(ld->refcount == 0)
333                 BUG();
334         ld->refcount --;
335         module_put(ld->owner);
336         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
337 }
338         
339 EXPORT_SYMBOL_GPL(tty_ldisc_put);
340
341 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
342 {
343         tty->ldisc = *ld;
344         tty->ldisc.refcount = 0;
345 }
346
347 /**
348  *      tty_ldisc_try           -       internal helper
349  *      @tty: the tty
350  *
351  *      Make a single attempt to grab and bump the refcount on
352  *      the tty ldisc. Return 0 on failure or 1 on success. This is
353  *      used to implement both the waiting and non waiting versions
354  *      of tty_ldisc_ref
355  */
356
357 static int tty_ldisc_try(struct tty_struct *tty)
358 {
359         unsigned long flags;
360         struct tty_ldisc *ld;
361         int ret = 0;
362         
363         spin_lock_irqsave(&tty_ldisc_lock, flags);
364         ld = &tty->ldisc;
365         if(test_bit(TTY_LDISC, &tty->flags))
366         {
367                 ld->refcount++;
368                 ret = 1;
369         }
370         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
371         return ret;
372 }
373
374 /**
375  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
376  *      @tty: tty device
377  *
378  *      Dereference the line discipline for the terminal and take a 
379  *      reference to it. If the line discipline is in flux then 
380  *      wait patiently until it changes.
381  *
382  *      Note: Must not be called from an IRQ/timer context. The caller
383  *      must also be careful not to hold other locks that will deadlock
384  *      against a discipline change, such as an existing ldisc reference
385  *      (which we check for)
386  */
387  
388 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
389 {
390         /* wait_event is a macro */
391         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
392         if(tty->ldisc.refcount == 0)
393                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
394         return &tty->ldisc;
395 }
396
397 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
398
399 /**
400  *      tty_ldisc_ref           -       get the tty ldisc
401  *      @tty: tty device
402  *
403  *      Dereference the line discipline for the terminal and take a 
404  *      reference to it. If the line discipline is in flux then 
405  *      return NULL. Can be called from IRQ and timer functions.
406  */
407  
408 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
409 {
410         if(tty_ldisc_try(tty))
411                 return &tty->ldisc;
412         return NULL;
413 }
414
415 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
416
417 /**
418  *      tty_ldisc_deref         -       free a tty ldisc reference
419  *      @ld: reference to free up
420  *
421  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
422  *      be called in IRQ context.
423  */
424  
425 void tty_ldisc_deref(struct tty_ldisc *ld)
426 {
427         unsigned long flags;
428
429         if(ld == NULL)
430                 BUG();
431                 
432         spin_lock_irqsave(&tty_ldisc_lock, flags);
433         if(ld->refcount == 0)
434                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
435         else
436                 ld->refcount--;
437         if(ld->refcount == 0)
438                 wake_up(&tty_ldisc_wait);
439         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
440 }
441
442 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
443
444 /**
445  *      tty_ldisc_enable        -       allow ldisc use
446  *      @tty: terminal to activate ldisc on
447  *
448  *      Set the TTY_LDISC flag when the line discipline can be called
449  *      again. Do neccessary wakeups for existing sleepers.
450  *
451  *      Note: nobody should set this bit except via this function. Clearing
452  *      directly is allowed.
453  */
454
455 static void tty_ldisc_enable(struct tty_struct *tty)
456 {
457         set_bit(TTY_LDISC, &tty->flags);
458         wake_up(&tty_ldisc_wait);
459 }
460         
461 /**
462  *      tty_set_ldisc           -       set line discipline
463  *      @tty: the terminal to set
464  *      @ldisc: the line discipline
465  *
466  *      Set the discipline of a tty line. Must be called from a process
467  *      context.
468  */
469  
470 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
471 {
472         int     retval = 0;
473         struct  tty_ldisc o_ldisc;
474         char buf[64];
475         int work;
476         unsigned long flags;
477         struct tty_ldisc *ld;
478
479         if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
480                 return -EINVAL;
481
482 restart:
483
484         if (tty->ldisc.num == ldisc)
485                 return 0;       /* We are already in the desired discipline */
486         
487         ld = tty_ldisc_get(ldisc);
488         /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
489         /* Cyrus Durgin <cider@speakeasy.org> */
490         if (ld == NULL) {
491                 request_module("tty-ldisc-%d", ldisc);
492                 ld = tty_ldisc_get(ldisc);
493         }
494         if (ld == NULL)
495                 return -EINVAL;
496
497         o_ldisc = tty->ldisc;
498
499         tty_wait_until_sent(tty, 0);
500
501         /*
502          *      Make sure we don't change while someone holds a
503          *      reference to the line discipline. The TTY_LDISC bit
504          *      prevents anyone taking a reference once it is clear.
505          *      We need the lock to avoid racing reference takers.
506          */
507          
508         spin_lock_irqsave(&tty_ldisc_lock, flags);
509         if(tty->ldisc.refcount)
510         {
511                 /* Free the new ldisc we grabbed. Must drop the lock
512                    first. */
513                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
514                 tty_ldisc_put(ldisc);
515                 /*
516                  * There are several reasons we may be busy, including
517                  * random momentary I/O traffic. We must therefore
518                  * retry. We could distinguish between blocking ops
519                  * and retries if we made tty_ldisc_wait() smarter. That
520                  * is up for discussion.
521                  */
522                 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
523                         return -ERESTARTSYS;                    
524                 goto restart;
525         }
526         clear_bit(TTY_LDISC, &tty->flags);      
527         clear_bit(TTY_DONT_FLIP, &tty->flags);
528         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
529         
530         /*
531          *      From this point on we know nobody has an ldisc
532          *      usage reference, nor can they obtain one until
533          *      we say so later on.
534          */
535          
536         work = cancel_delayed_work(&tty->flip.work);
537         /*
538          * Wait for ->hangup_work and ->flip.work handlers to terminate
539          */
540          
541         flush_scheduled_work();
542         /* Shutdown the current discipline. */
543         if (tty->ldisc.close)
544                 (tty->ldisc.close)(tty);
545
546         /* Now set up the new line discipline. */
547         tty_ldisc_assign(tty, ld);
548         tty_set_termios_ldisc(tty, ldisc);
549         if (tty->ldisc.open)
550                 retval = (tty->ldisc.open)(tty);
551         if (retval < 0) {
552                 tty_ldisc_put(ldisc);
553                 /* There is an outstanding reference here so this is safe */
554                 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
555                 tty_set_termios_ldisc(tty, tty->ldisc.num);
556                 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
557                         tty_ldisc_put(o_ldisc.num);
558                         /* This driver is always present */
559                         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
560                         tty_set_termios_ldisc(tty, N_TTY);
561                         if (tty->ldisc.open) {
562                                 int r = tty->ldisc.open(tty);
563
564                                 if (r < 0)
565                                         panic("Couldn't open N_TTY ldisc for "
566                                               "%s --- error %d.",
567                                               tty_name(tty, buf), r);
568                         }
569                 }
570         }
571         /* At this point we hold a reference to the new ldisc and a
572            a reference to the old ldisc. If we ended up flipping back
573            to the existing ldisc we have two references to it */
574         
575         if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
576                 tty->driver->set_ldisc(tty);
577                 
578         tty_ldisc_put(o_ldisc.num);
579         
580         /*
581          *      Allow ldisc referencing to occur as soon as the driver
582          *      ldisc callback completes.
583          */
584          
585         tty_ldisc_enable(tty);
586         
587         /* Restart it in case no characters kick it off. Safe if
588            already running */
589         if(work)
590                 schedule_delayed_work(&tty->flip.work, 1);
591         return retval;
592 }
593
594 /*
595  * This routine returns a tty driver structure, given a device number
596  */
597 static struct tty_driver *get_tty_driver(dev_t device, int *index)
598 {
599         struct tty_driver *p;
600
601         list_for_each_entry(p, &tty_drivers, tty_drivers) {
602                 dev_t base = MKDEV(p->major, p->minor_start);
603                 if (device < base || device >= base + p->num)
604                         continue;
605                 *index = device - base;
606                 return p;
607         }
608         return NULL;
609 }
610
611 /*
612  * If we try to write to, or set the state of, a terminal and we're
613  * not in the foreground, send a SIGTTOU.  If the signal is blocked or
614  * ignored, go ahead and perform the operation.  (POSIX 7.2)
615  */
616 int tty_check_change(struct tty_struct * tty)
617 {
618         if (current->signal->tty != tty)
619                 return 0;
620         if (tty->pgrp <= 0) {
621                 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
622                 return 0;
623         }
624         if (process_group(current) == tty->pgrp)
625                 return 0;
626         if (is_ignored(SIGTTOU))
627                 return 0;
628         if (is_orphaned_pgrp(process_group(current)))
629                 return -EIO;
630         (void) kill_pg(process_group(current), SIGTTOU, 1);
631         return -ERESTARTSYS;
632 }
633
634 EXPORT_SYMBOL(tty_check_change);
635
636 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
637                                 size_t count, loff_t *ppos)
638 {
639         return 0;
640 }
641
642 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
643                                  size_t count, loff_t *ppos)
644 {
645         return -EIO;
646 }
647
648 /* No kernel lock held - none needed ;) */
649 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
650 {
651         return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
652 }
653
654 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
655                              unsigned int cmd, unsigned long arg)
656 {
657         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
658 }
659
660 static struct file_operations tty_fops = {
661         .llseek         = no_llseek,
662         .read           = tty_read,
663         .write          = tty_write,
664         .poll           = tty_poll,
665         .ioctl          = tty_ioctl,
666         .open           = tty_open,
667         .release        = tty_release,
668         .fasync         = tty_fasync,
669 };
670
671 #ifdef CONFIG_UNIX98_PTYS
672 static struct file_operations ptmx_fops = {
673         .llseek         = no_llseek,
674         .read           = tty_read,
675         .write          = tty_write,
676         .poll           = tty_poll,
677         .ioctl          = tty_ioctl,
678         .open           = ptmx_open,
679         .release        = tty_release,
680         .fasync         = tty_fasync,
681 };
682 #endif
683
684 static struct file_operations console_fops = {
685         .llseek         = no_llseek,
686         .read           = tty_read,
687         .write          = redirected_tty_write,
688         .poll           = tty_poll,
689         .ioctl          = tty_ioctl,
690         .open           = tty_open,
691         .release        = tty_release,
692         .fasync         = tty_fasync,
693 };
694
695 static struct file_operations hung_up_tty_fops = {
696         .llseek         = no_llseek,
697         .read           = hung_up_tty_read,
698         .write          = hung_up_tty_write,
699         .poll           = hung_up_tty_poll,
700         .ioctl          = hung_up_tty_ioctl,
701         .release        = tty_release,
702 };
703
704 static DEFINE_SPINLOCK(redirect_lock);
705 static struct file *redirect;
706
707 /**
708  *      tty_wakeup      -       request more data
709  *      @tty: terminal
710  *
711  *      Internal and external helper for wakeups of tty. This function
712  *      informs the line discipline if present that the driver is ready
713  *      to receive more output data.
714  */
715  
716 void tty_wakeup(struct tty_struct *tty)
717 {
718         struct tty_ldisc *ld;
719         
720         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
721                 ld = tty_ldisc_ref(tty);
722                 if(ld) {
723                         if(ld->write_wakeup)
724                                 ld->write_wakeup(tty);
725                         tty_ldisc_deref(ld);
726                 }
727         }
728         wake_up_interruptible(&tty->write_wait);
729 }
730
731 EXPORT_SYMBOL_GPL(tty_wakeup);
732
733 /**
734  *      tty_ldisc_flush -       flush line discipline queue
735  *      @tty: tty
736  *
737  *      Flush the line discipline queue (if any) for this tty. If there
738  *      is no line discipline active this is a no-op.
739  */
740  
741 void tty_ldisc_flush(struct tty_struct *tty)
742 {
743         struct tty_ldisc *ld = tty_ldisc_ref(tty);
744         if(ld) {
745                 if(ld->flush_buffer)
746                         ld->flush_buffer(tty);
747                 tty_ldisc_deref(ld);
748         }
749 }
750
751 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
752         
753 /*
754  * This can be called by the "eventd" kernel thread.  That is process synchronous,
755  * but doesn't hold any locks, so we need to make sure we have the appropriate
756  * locks for what we're doing..
757  */
758 static void do_tty_hangup(void *data)
759 {
760         struct tty_struct *tty = (struct tty_struct *) data;
761         struct file * cons_filp = NULL;
762         struct file *filp, *f = NULL;
763         struct task_struct *p;
764         struct tty_ldisc *ld;
765         int    closecount = 0, n;
766
767         if (!tty)
768                 return;
769
770         /* inuse_filps is protected by the single kernel lock */
771         lock_kernel();
772
773         spin_lock(&redirect_lock);
774         if (redirect && redirect->private_data == tty) {
775                 f = redirect;
776                 redirect = NULL;
777         }
778         spin_unlock(&redirect_lock);
779         
780         check_tty_count(tty, "do_tty_hangup");
781         file_list_lock();
782         /* This breaks for file handles being sent over AF_UNIX sockets ? */
783         list_for_each_entry(filp, &tty->tty_files, f_list) {
784                 if (filp->f_op->write == redirected_tty_write)
785                         cons_filp = filp;
786                 if (filp->f_op->write != tty_write)
787                         continue;
788                 closecount++;
789                 tty_fasync(-1, filp, 0);        /* can't block */
790                 filp->f_op = &hung_up_tty_fops;
791         }
792         file_list_unlock();
793         
794         /* FIXME! What are the locking issues here? This may me overdoing things..
795          * this question is especially important now that we've removed the irqlock. */
796
797         ld = tty_ldisc_ref(tty);
798         if(ld != NULL)  /* We may have no line discipline at this point */
799         {
800                 if (ld->flush_buffer)
801                         ld->flush_buffer(tty);
802                 if (tty->driver->flush_buffer)
803                         tty->driver->flush_buffer(tty);
804                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
805                     ld->write_wakeup)
806                         ld->write_wakeup(tty);
807                 if (ld->hangup)
808                         ld->hangup(tty);
809         }
810
811         /* FIXME: Once we trust the LDISC code better we can wait here for
812            ldisc completion and fix the driver call race */
813            
814         wake_up_interruptible(&tty->write_wait);
815         wake_up_interruptible(&tty->read_wait);
816
817         /*
818          * Shutdown the current line discipline, and reset it to
819          * N_TTY.
820          */
821         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
822         {
823                 down(&tty->termios_sem);
824                 *tty->termios = tty->driver->init_termios;
825                 up(&tty->termios_sem);
826         }
827         
828         /* Defer ldisc switch */
829         /* tty_deferred_ldisc_switch(N_TTY);
830         
831           This should get done automatically when the port closes and
832           tty_release is called */
833         
834         read_lock(&tasklist_lock);
835         if (tty->session > 0) {
836                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
837                         if (p->signal->tty == tty)
838                                 p->signal->tty = NULL;
839                         if (!p->signal->leader)
840                                 continue;
841                         send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
842                         send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
843                         if (tty->pgrp > 0)
844                                 p->signal->tty_old_pgrp = tty->pgrp;
845                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
846         }
847         read_unlock(&tasklist_lock);
848
849         tty->flags = 0;
850         tty->session = 0;
851         tty->pgrp = -1;
852         tty->ctrl_status = 0;
853         /*
854          *      If one of the devices matches a console pointer, we
855          *      cannot just call hangup() because that will cause
856          *      tty->count and state->count to go out of sync.
857          *      So we just call close() the right number of times.
858          */
859         if (cons_filp) {
860                 if (tty->driver->close)
861                         for (n = 0; n < closecount; n++)
862                                 tty->driver->close(tty, cons_filp);
863         } else if (tty->driver->hangup)
864                 (tty->driver->hangup)(tty);
865                 
866         /* We don't want to have driver/ldisc interactions beyond
867            the ones we did here. The driver layer expects no
868            calls after ->hangup() from the ldisc side. However we
869            can't yet guarantee all that */
870
871         set_bit(TTY_HUPPED, &tty->flags);
872         if (ld) {
873                 tty_ldisc_enable(tty);
874                 tty_ldisc_deref(ld);
875         }
876         unlock_kernel();
877         if (f)
878                 fput(f);
879 }
880
881 void tty_hangup(struct tty_struct * tty)
882 {
883 #ifdef TTY_DEBUG_HANGUP
884         char    buf[64];
885         
886         printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
887 #endif
888         schedule_work(&tty->hangup_work);
889 }
890
891 EXPORT_SYMBOL(tty_hangup);
892
893 void tty_vhangup(struct tty_struct * tty)
894 {
895 #ifdef TTY_DEBUG_HANGUP
896         char    buf[64];
897
898         printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
899 #endif
900         do_tty_hangup((void *) tty);
901 }
902 EXPORT_SYMBOL(tty_vhangup);
903
904 int tty_hung_up_p(struct file * filp)
905 {
906         return (filp->f_op == &hung_up_tty_fops);
907 }
908
909 EXPORT_SYMBOL(tty_hung_up_p);
910
911 /*
912  * This function is typically called only by the session leader, when
913  * it wants to disassociate itself from its controlling tty.
914  *
915  * It performs the following functions:
916  *      (1)  Sends a SIGHUP and SIGCONT to the foreground process group
917  *      (2)  Clears the tty from being controlling the session
918  *      (3)  Clears the controlling tty for all processes in the
919  *              session group.
920  *
921  * The argument on_exit is set to 1 if called when a process is
922  * exiting; it is 0 if called by the ioctl TIOCNOTTY.
923  */
924 void disassociate_ctty(int on_exit)
925 {
926         struct tty_struct *tty;
927         struct task_struct *p;
928         int tty_pgrp = -1;
929
930         lock_kernel();
931
932         down(&tty_sem);
933         tty = current->signal->tty;
934         if (tty) {
935                 tty_pgrp = tty->pgrp;
936                 up(&tty_sem);
937                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
938                         tty_vhangup(tty);
939         } else {
940                 if (current->signal->tty_old_pgrp) {
941                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
942                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
943                 }
944                 up(&tty_sem);
945                 unlock_kernel();        
946                 return;
947         }
948         if (tty_pgrp > 0) {
949                 kill_pg(tty_pgrp, SIGHUP, on_exit);
950                 if (!on_exit)
951                         kill_pg(tty_pgrp, SIGCONT, on_exit);
952         }
953
954         /* Must lock changes to tty_old_pgrp */
955         down(&tty_sem);
956         current->signal->tty_old_pgrp = 0;
957         tty->session = 0;
958         tty->pgrp = -1;
959
960         /* Now clear signal->tty under the lock */
961         read_lock(&tasklist_lock);
962         do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
963                 p->signal->tty = NULL;
964         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
965         read_unlock(&tasklist_lock);
966         up(&tty_sem);
967         unlock_kernel();
968 }
969
970 void stop_tty(struct tty_struct *tty)
971 {
972         if (tty->stopped)
973                 return;
974         tty->stopped = 1;
975         if (tty->link && tty->link->packet) {
976                 tty->ctrl_status &= ~TIOCPKT_START;
977                 tty->ctrl_status |= TIOCPKT_STOP;
978                 wake_up_interruptible(&tty->link->read_wait);
979         }
980         if (tty->driver->stop)
981                 (tty->driver->stop)(tty);
982 }
983
984 EXPORT_SYMBOL(stop_tty);
985
986 void start_tty(struct tty_struct *tty)
987 {
988         if (!tty->stopped || tty->flow_stopped)
989                 return;
990         tty->stopped = 0;
991         if (tty->link && tty->link->packet) {
992                 tty->ctrl_status &= ~TIOCPKT_STOP;
993                 tty->ctrl_status |= TIOCPKT_START;
994                 wake_up_interruptible(&tty->link->read_wait);
995         }
996         if (tty->driver->start)
997                 (tty->driver->start)(tty);
998
999         /* If we have a running line discipline it may need kicking */
1000         tty_wakeup(tty);
1001         wake_up_interruptible(&tty->write_wait);
1002 }
1003
1004 EXPORT_SYMBOL(start_tty);
1005
1006 static ssize_t tty_read(struct file * file, char __user * buf, size_t count, 
1007                         loff_t *ppos)
1008 {
1009         int i;
1010         struct tty_struct * tty;
1011         struct inode *inode;
1012         struct tty_ldisc *ld;
1013
1014         tty = (struct tty_struct *)file->private_data;
1015         inode = file->f_dentry->d_inode;
1016         if (tty_paranoia_check(tty, inode, "tty_read"))
1017                 return -EIO;
1018         if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1019                 return -EIO;
1020
1021         /* We want to wait for the line discipline to sort out in this
1022            situation */
1023         ld = tty_ldisc_ref_wait(tty);
1024         lock_kernel();
1025         if (ld->read)
1026                 i = (ld->read)(tty,file,buf,count);
1027         else
1028                 i = -EIO;
1029         tty_ldisc_deref(ld);
1030         unlock_kernel();
1031         if (i > 0)
1032                 inode->i_atime = current_fs_time(inode->i_sb);
1033         return i;
1034 }
1035
1036 /*
1037  * Split writes up in sane blocksizes to avoid
1038  * denial-of-service type attacks
1039  */
1040 static inline ssize_t do_tty_write(
1041         ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1042         struct tty_struct *tty,
1043         struct file *file,
1044         const char __user *buf,
1045         size_t count)
1046 {
1047         ssize_t ret = 0, written = 0;
1048         unsigned int chunk;
1049         
1050         if (down_interruptible(&tty->atomic_write)) {
1051                 return -ERESTARTSYS;
1052         }
1053
1054         /*
1055          * We chunk up writes into a temporary buffer. This
1056          * simplifies low-level drivers immensely, since they
1057          * don't have locking issues and user mode accesses.
1058          *
1059          * But if TTY_NO_WRITE_SPLIT is set, we should use a
1060          * big chunk-size..
1061          *
1062          * The default chunk-size is 2kB, because the NTTY
1063          * layer has problems with bigger chunks. It will
1064          * claim to be able to handle more characters than
1065          * it actually does.
1066          */
1067         chunk = 2048;
1068         if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1069                 chunk = 65536;
1070         if (count < chunk)
1071                 chunk = count;
1072
1073         /* write_buf/write_cnt is protected by the atomic_write semaphore */
1074         if (tty->write_cnt < chunk) {
1075                 unsigned char *buf;
1076
1077                 if (chunk < 1024)
1078                         chunk = 1024;
1079
1080                 buf = kmalloc(chunk, GFP_KERNEL);
1081                 if (!buf) {
1082                         up(&tty->atomic_write);
1083                         return -ENOMEM;
1084                 }
1085                 kfree(tty->write_buf);
1086                 tty->write_cnt = chunk;
1087                 tty->write_buf = buf;
1088         }
1089
1090         /* Do the write .. */
1091         for (;;) {
1092                 size_t size = count;
1093                 if (size > chunk)
1094                         size = chunk;
1095                 ret = -EFAULT;
1096                 if (copy_from_user(tty->write_buf, buf, size))
1097                         break;
1098                 lock_kernel();
1099                 ret = write(tty, file, tty->write_buf, size);
1100                 unlock_kernel();
1101                 if (ret <= 0)
1102                         break;
1103                 written += ret;
1104                 buf += ret;
1105                 count -= ret;
1106                 if (!count)
1107                         break;
1108                 ret = -ERESTARTSYS;
1109                 if (signal_pending(current))
1110                         break;
1111                 cond_resched();
1112         }
1113         if (written) {
1114                 struct inode *inode = file->f_dentry->d_inode;
1115                 inode->i_mtime = current_fs_time(inode->i_sb);
1116                 ret = written;
1117         }
1118         up(&tty->atomic_write);
1119         return ret;
1120 }
1121
1122
1123 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1124                          loff_t *ppos)
1125 {
1126         struct tty_struct * tty;
1127         struct inode *inode = file->f_dentry->d_inode;
1128         ssize_t ret;
1129         struct tty_ldisc *ld;
1130         
1131         tty = (struct tty_struct *)file->private_data;
1132         if (tty_paranoia_check(tty, inode, "tty_write"))
1133                 return -EIO;
1134         if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1135                 return -EIO;
1136
1137         ld = tty_ldisc_ref_wait(tty);           
1138         if (!ld->write)
1139                 ret = -EIO;
1140         else
1141                 ret = do_tty_write(ld->write, tty, file, buf, count);
1142         tty_ldisc_deref(ld);
1143         return ret;
1144 }
1145
1146 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1147                          loff_t *ppos)
1148 {
1149         struct file *p = NULL;
1150
1151         spin_lock(&redirect_lock);
1152         if (redirect) {
1153                 get_file(redirect);
1154                 p = redirect;
1155         }
1156         spin_unlock(&redirect_lock);
1157
1158         if (p) {
1159                 ssize_t res;
1160                 res = vfs_write(p, buf, count, &p->f_pos);
1161                 fput(p);
1162                 return res;
1163         }
1164
1165         return tty_write(file, buf, count, ppos);
1166 }
1167
1168 static char ptychar[] = "pqrstuvwxyzabcde";
1169
1170 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1171 {
1172         int i = index + driver->name_base;
1173         /* ->name is initialized to "ttyp", but "tty" is expected */
1174         sprintf(p, "%s%c%x",
1175                         driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1176                         ptychar[i >> 4 & 0xf], i & 0xf);
1177 }
1178
1179 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1180 {
1181         sprintf(p, "%s%d", driver->name, index + driver->name_base);
1182 }
1183
1184 /*
1185  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1186  * failed open.  The new code protects the open with a semaphore, so it's
1187  * really quite straightforward.  The semaphore locking can probably be
1188  * relaxed for the (most common) case of reopening a tty.
1189  */
1190 static int init_dev(struct tty_driver *driver, int idx,
1191         struct tty_struct **ret_tty)
1192 {
1193         struct tty_struct *tty, *o_tty;
1194         struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1195         struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1196         int retval=0;
1197
1198         /* check whether we're reopening an existing tty */
1199         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1200                 tty = devpts_get_tty(idx);
1201                 if (tty && driver->subtype == PTY_TYPE_MASTER)
1202                         tty = tty->link;
1203         } else {
1204                 tty = driver->ttys[idx];
1205         }
1206         if (tty) goto fast_track;
1207
1208         /*
1209          * First time open is complex, especially for PTY devices.
1210          * This code guarantees that either everything succeeds and the
1211          * TTY is ready for operation, or else the table slots are vacated
1212          * and the allocated memory released.  (Except that the termios 
1213          * and locked termios may be retained.)
1214          */
1215
1216         if (!try_module_get(driver->owner)) {
1217                 retval = -ENODEV;
1218                 goto end_init;
1219         }
1220
1221         o_tty = NULL;
1222         tp = o_tp = NULL;
1223         ltp = o_ltp = NULL;
1224
1225         tty = alloc_tty_struct();
1226         if(!tty)
1227                 goto fail_no_mem;
1228         initialize_tty_struct(tty);
1229         tty->driver = driver;
1230         tty->index = idx;
1231         tty_line_name(driver, idx, tty->name);
1232
1233         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1234                 tp_loc = &tty->termios;
1235                 ltp_loc = &tty->termios_locked;
1236         } else {
1237                 tp_loc = &driver->termios[idx];
1238                 ltp_loc = &driver->termios_locked[idx];
1239         }
1240
1241         if (!*tp_loc) {
1242                 tp = (struct termios *) kmalloc(sizeof(struct termios),
1243                                                 GFP_KERNEL);
1244                 if (!tp)
1245                         goto free_mem_out;
1246                 *tp = driver->init_termios;
1247         }
1248
1249         if (!*ltp_loc) {
1250                 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1251                                                  GFP_KERNEL);
1252                 if (!ltp)
1253                         goto free_mem_out;
1254                 memset(ltp, 0, sizeof(struct termios));
1255         }
1256
1257         if (driver->type == TTY_DRIVER_TYPE_PTY) {
1258                 o_tty = alloc_tty_struct();
1259                 if (!o_tty)
1260                         goto free_mem_out;
1261                 initialize_tty_struct(o_tty);
1262                 o_tty->driver = driver->other;
1263                 o_tty->index = idx;
1264                 tty_line_name(driver->other, idx, o_tty->name);
1265
1266                 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1267                         o_tp_loc = &o_tty->termios;
1268                         o_ltp_loc = &o_tty->termios_locked;
1269                 } else {
1270                         o_tp_loc = &driver->other->termios[idx];
1271                         o_ltp_loc = &driver->other->termios_locked[idx];
1272                 }
1273
1274                 if (!*o_tp_loc) {
1275                         o_tp = (struct termios *)
1276                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1277                         if (!o_tp)
1278                                 goto free_mem_out;
1279                         *o_tp = driver->other->init_termios;
1280                 }
1281
1282                 if (!*o_ltp_loc) {
1283                         o_ltp = (struct termios *)
1284                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1285                         if (!o_ltp)
1286                                 goto free_mem_out;
1287                         memset(o_ltp, 0, sizeof(struct termios));
1288                 }
1289
1290                 /*
1291                  * Everything allocated ... set up the o_tty structure.
1292                  */
1293                 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1294                         driver->other->ttys[idx] = o_tty;
1295                 }
1296                 if (!*o_tp_loc)
1297                         *o_tp_loc = o_tp;
1298                 if (!*o_ltp_loc)
1299                         *o_ltp_loc = o_ltp;
1300                 o_tty->termios = *o_tp_loc;
1301                 o_tty->termios_locked = *o_ltp_loc;
1302                 driver->other->refcount++;
1303                 if (driver->subtype == PTY_TYPE_MASTER)
1304                         o_tty->count++;
1305
1306                 /* Establish the links in both directions */
1307                 tty->link   = o_tty;
1308                 o_tty->link = tty;
1309         }
1310
1311         /* 
1312          * All structures have been allocated, so now we install them.
1313          * Failures after this point use release_mem to clean up, so 
1314          * there's no need to null out the local pointers.
1315          */
1316         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1317                 driver->ttys[idx] = tty;
1318         }
1319         
1320         if (!*tp_loc)
1321                 *tp_loc = tp;
1322         if (!*ltp_loc)
1323                 *ltp_loc = ltp;
1324         tty->termios = *tp_loc;
1325         tty->termios_locked = *ltp_loc;
1326         driver->refcount++;
1327         tty->count++;
1328
1329         /* 
1330          * Structures all installed ... call the ldisc open routines.
1331          * If we fail here just call release_mem to clean up.  No need
1332          * to decrement the use counts, as release_mem doesn't care.
1333          */
1334
1335         if (tty->ldisc.open) {
1336                 retval = (tty->ldisc.open)(tty);
1337                 if (retval)
1338                         goto release_mem_out;
1339         }
1340         if (o_tty && o_tty->ldisc.open) {
1341                 retval = (o_tty->ldisc.open)(o_tty);
1342                 if (retval) {
1343                         if (tty->ldisc.close)
1344                                 (tty->ldisc.close)(tty);
1345                         goto release_mem_out;
1346                 }
1347                 tty_ldisc_enable(o_tty);
1348         }
1349         tty_ldisc_enable(tty);
1350         goto success;
1351
1352         /*
1353          * This fast open can be used if the tty is already open.
1354          * No memory is allocated, and the only failures are from
1355          * attempting to open a closing tty or attempting multiple
1356          * opens on a pty master.
1357          */
1358 fast_track:
1359         if (test_bit(TTY_CLOSING, &tty->flags)) {
1360                 retval = -EIO;
1361                 goto end_init;
1362         }
1363         if (driver->type == TTY_DRIVER_TYPE_PTY &&
1364             driver->subtype == PTY_TYPE_MASTER) {
1365                 /*
1366                  * special case for PTY masters: only one open permitted, 
1367                  * and the slave side open count is incremented as well.
1368                  */
1369                 if (tty->count) {
1370                         retval = -EIO;
1371                         goto end_init;
1372                 }
1373                 tty->link->count++;
1374         }
1375         tty->count++;
1376         tty->driver = driver; /* N.B. why do this every time?? */
1377
1378         /* FIXME */
1379         if(!test_bit(TTY_LDISC, &tty->flags))
1380                 printk(KERN_ERR "init_dev but no ldisc\n");
1381 success:
1382         *ret_tty = tty;
1383         
1384         /* All paths come through here to release the semaphore */
1385 end_init:
1386         return retval;
1387
1388         /* Release locally allocated memory ... nothing placed in slots */
1389 free_mem_out:
1390         if (o_tp)
1391                 kfree(o_tp);
1392         if (o_tty)
1393                 free_tty_struct(o_tty);
1394         if (ltp)
1395                 kfree(ltp);
1396         if (tp)
1397                 kfree(tp);
1398         free_tty_struct(tty);
1399
1400 fail_no_mem:
1401         module_put(driver->owner);
1402         retval = -ENOMEM;
1403         goto end_init;
1404
1405         /* call the tty release_mem routine to clean out this slot */
1406 release_mem_out:
1407         printk(KERN_INFO "init_dev: ldisc open failed, "
1408                          "clearing slot %d\n", idx);
1409         release_mem(tty, idx);
1410         goto end_init;
1411 }
1412
1413 /*
1414  * Releases memory associated with a tty structure, and clears out the
1415  * driver table slots.
1416  */
1417 static void release_mem(struct tty_struct *tty, int idx)
1418 {
1419         struct tty_struct *o_tty;
1420         struct termios *tp;
1421         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1422
1423         if ((o_tty = tty->link) != NULL) {
1424                 if (!devpts)
1425                         o_tty->driver->ttys[idx] = NULL;
1426                 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1427                         tp = o_tty->termios;
1428                         if (!devpts)
1429                                 o_tty->driver->termios[idx] = NULL;
1430                         kfree(tp);
1431
1432                         tp = o_tty->termios_locked;
1433                         if (!devpts)
1434                                 o_tty->driver->termios_locked[idx] = NULL;
1435                         kfree(tp);
1436                 }
1437                 o_tty->magic = 0;
1438                 o_tty->driver->refcount--;
1439                 file_list_lock();
1440                 list_del_init(&o_tty->tty_files);
1441                 file_list_unlock();
1442                 free_tty_struct(o_tty);
1443         }
1444
1445         if (!devpts)
1446                 tty->driver->ttys[idx] = NULL;
1447         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1448                 tp = tty->termios;
1449                 if (!devpts)
1450                         tty->driver->termios[idx] = NULL;
1451                 kfree(tp);
1452
1453                 tp = tty->termios_locked;
1454                 if (!devpts)
1455                         tty->driver->termios_locked[idx] = NULL;
1456                 kfree(tp);
1457         }
1458
1459         tty->magic = 0;
1460         tty->driver->refcount--;
1461         file_list_lock();
1462         list_del_init(&tty->tty_files);
1463         file_list_unlock();
1464         module_put(tty->driver->owner);
1465         free_tty_struct(tty);
1466 }
1467
1468 /*
1469  * Even releasing the tty structures is a tricky business.. We have
1470  * to be very careful that the structures are all released at the
1471  * same time, as interrupts might otherwise get the wrong pointers.
1472  *
1473  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1474  * lead to double frees or releasing memory still in use.
1475  */
1476 static void release_dev(struct file * filp)
1477 {
1478         struct tty_struct *tty, *o_tty;
1479         int     pty_master, tty_closing, o_tty_closing, do_sleep;
1480         int     devpts_master, devpts;
1481         int     idx;
1482         char    buf[64];
1483         unsigned long flags;
1484         
1485         tty = (struct tty_struct *)filp->private_data;
1486         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1487                 return;
1488
1489         check_tty_count(tty, "release_dev");
1490
1491         tty_fasync(-1, filp, 0);
1492
1493         idx = tty->index;
1494         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1495                       tty->driver->subtype == PTY_TYPE_MASTER);
1496         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1497         devpts_master = pty_master && devpts;
1498         o_tty = tty->link;
1499
1500 #ifdef TTY_PARANOIA_CHECK
1501         if (idx < 0 || idx >= tty->driver->num) {
1502                 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1503                                   "free (%s)\n", tty->name);
1504                 return;
1505         }
1506         if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1507                 if (tty != tty->driver->ttys[idx]) {
1508                         printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1509                                "for (%s)\n", idx, tty->name);
1510                         return;
1511                 }
1512                 if (tty->termios != tty->driver->termios[idx]) {
1513                         printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1514                                "for (%s)\n",
1515                                idx, tty->name);
1516                         return;
1517                 }
1518                 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1519                         printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1520                                "termios_locked for (%s)\n",
1521                                idx, tty->name);
1522                         return;
1523                 }
1524         }
1525 #endif
1526
1527 #ifdef TTY_DEBUG_HANGUP
1528         printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1529                tty_name(tty, buf), tty->count);
1530 #endif
1531
1532 #ifdef TTY_PARANOIA_CHECK
1533         if (tty->driver->other &&
1534              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1535                 if (o_tty != tty->driver->other->ttys[idx]) {
1536                         printk(KERN_DEBUG "release_dev: other->table[%d] "
1537                                           "not o_tty for (%s)\n",
1538                                idx, tty->name);
1539                         return;
1540                 }
1541                 if (o_tty->termios != tty->driver->other->termios[idx]) {
1542                         printk(KERN_DEBUG "release_dev: other->termios[%d] "
1543                                           "not o_termios for (%s)\n",
1544                                idx, tty->name);
1545                         return;
1546                 }
1547                 if (o_tty->termios_locked != 
1548                       tty->driver->other->termios_locked[idx]) {
1549                         printk(KERN_DEBUG "release_dev: other->termios_locked["
1550                                           "%d] not o_termios_locked for (%s)\n",
1551                                idx, tty->name);
1552                         return;
1553                 }
1554                 if (o_tty->link != tty) {
1555                         printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1556                         return;
1557                 }
1558         }
1559 #endif
1560         if (tty->driver->close)
1561                 tty->driver->close(tty, filp);
1562
1563         /*
1564          * Sanity check: if tty->count is going to zero, there shouldn't be
1565          * any waiters on tty->read_wait or tty->write_wait.  We test the
1566          * wait queues and kick everyone out _before_ actually starting to
1567          * close.  This ensures that we won't block while releasing the tty
1568          * structure.
1569          *
1570          * The test for the o_tty closing is necessary, since the master and
1571          * slave sides may close in any order.  If the slave side closes out
1572          * first, its count will be one, since the master side holds an open.
1573          * Thus this test wouldn't be triggered at the time the slave closes,
1574          * so we do it now.
1575          *
1576          * Note that it's possible for the tty to be opened again while we're
1577          * flushing out waiters.  By recalculating the closing flags before
1578          * each iteration we avoid any problems.
1579          */
1580         while (1) {
1581                 /* Guard against races with tty->count changes elsewhere and
1582                    opens on /dev/tty */
1583                    
1584                 down(&tty_sem);
1585                 tty_closing = tty->count <= 1;
1586                 o_tty_closing = o_tty &&
1587                         (o_tty->count <= (pty_master ? 1 : 0));
1588                 up(&tty_sem);
1589                 do_sleep = 0;
1590
1591                 if (tty_closing) {
1592                         if (waitqueue_active(&tty->read_wait)) {
1593                                 wake_up(&tty->read_wait);
1594                                 do_sleep++;
1595                         }
1596                         if (waitqueue_active(&tty->write_wait)) {
1597                                 wake_up(&tty->write_wait);
1598                                 do_sleep++;
1599                         }
1600                 }
1601                 if (o_tty_closing) {
1602                         if (waitqueue_active(&o_tty->read_wait)) {
1603                                 wake_up(&o_tty->read_wait);
1604                                 do_sleep++;
1605                         }
1606                         if (waitqueue_active(&o_tty->write_wait)) {
1607                                 wake_up(&o_tty->write_wait);
1608                                 do_sleep++;
1609                         }
1610                 }
1611                 if (!do_sleep)
1612                         break;
1613
1614                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1615                                     "active!\n", tty_name(tty, buf));
1616                 schedule();
1617         }       
1618
1619         /*
1620          * The closing flags are now consistent with the open counts on 
1621          * both sides, and we've completed the last operation that could 
1622          * block, so it's safe to proceed with closing.
1623          */
1624          
1625         down(&tty_sem);
1626         if (pty_master) {
1627                 if (--o_tty->count < 0) {
1628                         printk(KERN_WARNING "release_dev: bad pty slave count "
1629                                             "(%d) for %s\n",
1630                                o_tty->count, tty_name(o_tty, buf));
1631                         o_tty->count = 0;
1632                 }
1633         }
1634         if (--tty->count < 0) {
1635                 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1636                        tty->count, tty_name(tty, buf));
1637                 tty->count = 0;
1638         }
1639         up(&tty_sem);
1640         
1641         /*
1642          * We've decremented tty->count, so we need to remove this file
1643          * descriptor off the tty->tty_files list; this serves two
1644          * purposes:
1645          *  - check_tty_count sees the correct number of file descriptors
1646          *    associated with this tty.
1647          *  - do_tty_hangup no longer sees this file descriptor as
1648          *    something that needs to be handled for hangups.
1649          */
1650         file_kill(filp);
1651         filp->private_data = NULL;
1652
1653         /*
1654          * Perform some housekeeping before deciding whether to return.
1655          *
1656          * Set the TTY_CLOSING flag if this was the last open.  In the
1657          * case of a pty we may have to wait around for the other side
1658          * to close, and TTY_CLOSING makes sure we can't be reopened.
1659          */
1660         if(tty_closing)
1661                 set_bit(TTY_CLOSING, &tty->flags);
1662         if(o_tty_closing)
1663                 set_bit(TTY_CLOSING, &o_tty->flags);
1664
1665         /*
1666          * If _either_ side is closing, make sure there aren't any
1667          * processes that still think tty or o_tty is their controlling
1668          * tty.
1669          */
1670         if (tty_closing || o_tty_closing) {
1671                 struct task_struct *p;
1672
1673                 read_lock(&tasklist_lock);
1674                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1675                         p->signal->tty = NULL;
1676                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1677                 if (o_tty)
1678                         do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1679                                 p->signal->tty = NULL;
1680                         } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1681                 read_unlock(&tasklist_lock);
1682         }
1683
1684         /* check whether both sides are closing ... */
1685         if (!tty_closing || (o_tty && !o_tty_closing))
1686                 return;
1687         
1688 #ifdef TTY_DEBUG_HANGUP
1689         printk(KERN_DEBUG "freeing tty structure...");
1690 #endif
1691         /*
1692          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
1693          * kill any delayed work. As this is the final close it does not
1694          * race with the set_ldisc code path.
1695          */
1696         clear_bit(TTY_LDISC, &tty->flags);
1697         clear_bit(TTY_DONT_FLIP, &tty->flags);
1698         cancel_delayed_work(&tty->flip.work);
1699
1700         /*
1701          * Wait for ->hangup_work and ->flip.work handlers to terminate
1702          */
1703          
1704         flush_scheduled_work();
1705         
1706         /*
1707          * Wait for any short term users (we know they are just driver
1708          * side waiters as the file is closing so user count on the file
1709          * side is zero.
1710          */
1711         spin_lock_irqsave(&tty_ldisc_lock, flags);
1712         while(tty->ldisc.refcount)
1713         {
1714                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1715                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1716                 spin_lock_irqsave(&tty_ldisc_lock, flags);
1717         }
1718         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1719         /*
1720          * Shutdown the current line discipline, and reset it to N_TTY.
1721          * N.B. why reset ldisc when we're releasing the memory??
1722          *
1723          * FIXME: this MUST get fixed for the new reflocking
1724          */
1725         if (tty->ldisc.close)
1726                 (tty->ldisc.close)(tty);
1727         tty_ldisc_put(tty->ldisc.num);
1728         
1729         /*
1730          *      Switch the line discipline back
1731          */
1732         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1733         tty_set_termios_ldisc(tty,N_TTY); 
1734         if (o_tty) {
1735                 /* FIXME: could o_tty be in setldisc here ? */
1736                 clear_bit(TTY_LDISC, &o_tty->flags);
1737                 if (o_tty->ldisc.close)
1738                         (o_tty->ldisc.close)(o_tty);
1739                 tty_ldisc_put(o_tty->ldisc.num);
1740                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1741                 tty_set_termios_ldisc(o_tty,N_TTY); 
1742         }
1743         /*
1744          * The release_mem function takes care of the details of clearing
1745          * the slots and preserving the termios structure.
1746          */
1747         release_mem(tty, idx);
1748
1749 #ifdef CONFIG_UNIX98_PTYS
1750         /* Make this pty number available for reallocation */
1751         if (devpts) {
1752                 down(&allocated_ptys_lock);
1753                 idr_remove(&allocated_ptys, idx);
1754                 up(&allocated_ptys_lock);
1755         }
1756 #endif
1757
1758 }
1759
1760 /*
1761  * tty_open and tty_release keep up the tty count that contains the
1762  * number of opens done on a tty. We cannot use the inode-count, as
1763  * different inodes might point to the same tty.
1764  *
1765  * Open-counting is needed for pty masters, as well as for keeping
1766  * track of serial lines: DTR is dropped when the last close happens.
1767  * (This is not done solely through tty->count, now.  - Ted 1/27/92)
1768  *
1769  * The termios state of a pty is reset on first open so that
1770  * settings don't persist across reuse.
1771  */
1772 static int tty_open(struct inode * inode, struct file * filp)
1773 {
1774         struct tty_struct *tty;
1775         int noctty, retval;
1776         struct tty_driver *driver;
1777         int index;
1778         dev_t device = inode->i_rdev;
1779         unsigned short saved_flags = filp->f_flags;
1780
1781         nonseekable_open(inode, filp);
1782         
1783 retry_open:
1784         noctty = filp->f_flags & O_NOCTTY;
1785         index  = -1;
1786         retval = 0;
1787         
1788         down(&tty_sem);
1789
1790         if (device == MKDEV(TTYAUX_MAJOR,0)) {
1791                 if (!current->signal->tty) {
1792                         up(&tty_sem);
1793                         return -ENXIO;
1794                 }
1795                 driver = current->signal->tty->driver;
1796                 index = current->signal->tty->index;
1797                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1798                 /* noctty = 1; */
1799                 goto got_driver;
1800         }
1801 #ifdef CONFIG_VT
1802         if (device == MKDEV(TTY_MAJOR,0)) {
1803                 extern struct tty_driver *console_driver;
1804                 driver = console_driver;
1805                 index = fg_console;
1806                 noctty = 1;
1807                 goto got_driver;
1808         }
1809 #endif
1810         if (device == MKDEV(TTYAUX_MAJOR,1)) {
1811                 driver = console_device(&index);
1812                 if (driver) {
1813                         /* Don't let /dev/console block */
1814                         filp->f_flags |= O_NONBLOCK;
1815                         noctty = 1;
1816                         goto got_driver;
1817                 }
1818                 up(&tty_sem);
1819                 return -ENODEV;
1820         }
1821
1822         driver = get_tty_driver(device, &index);
1823         if (!driver) {
1824                 up(&tty_sem);
1825                 return -ENODEV;
1826         }
1827 got_driver:
1828         retval = init_dev(driver, index, &tty);
1829         up(&tty_sem);
1830         if (retval)
1831                 return retval;
1832
1833         filp->private_data = tty;
1834         file_move(filp, &tty->tty_files);
1835         check_tty_count(tty, "tty_open");
1836         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1837             tty->driver->subtype == PTY_TYPE_MASTER)
1838                 noctty = 1;
1839 #ifdef TTY_DEBUG_HANGUP
1840         printk(KERN_DEBUG "opening %s...", tty->name);
1841 #endif
1842         if (!retval) {
1843                 if (tty->driver->open)
1844                         retval = tty->driver->open(tty, filp);
1845                 else
1846                         retval = -ENODEV;
1847         }
1848         filp->f_flags = saved_flags;
1849
1850         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1851                 retval = -EBUSY;
1852
1853         if (retval) {
1854 #ifdef TTY_DEBUG_HANGUP
1855                 printk(KERN_DEBUG "error %d in opening %s...", retval,
1856                        tty->name);
1857 #endif
1858                 release_dev(filp);
1859                 if (retval != -ERESTARTSYS)
1860                         return retval;
1861                 if (signal_pending(current))
1862                         return retval;
1863                 schedule();
1864                 /*
1865                  * Need to reset f_op in case a hangup happened.
1866                  */
1867                 if (filp->f_op == &hung_up_tty_fops)
1868                         filp->f_op = &tty_fops;
1869                 goto retry_open;
1870         }
1871         if (!noctty &&
1872             current->signal->leader &&
1873             !current->signal->tty &&
1874             tty->session == 0) {
1875                 task_lock(current);
1876                 current->signal->tty = tty;
1877                 task_unlock(current);
1878                 current->signal->tty_old_pgrp = 0;
1879                 tty->session = current->signal->session;
1880                 tty->pgrp = process_group(current);
1881         }
1882         return 0;
1883 }
1884
1885 #ifdef CONFIG_UNIX98_PTYS
1886 static int ptmx_open(struct inode * inode, struct file * filp)
1887 {
1888         struct tty_struct *tty;
1889         int retval;
1890         int index;
1891         int idr_ret;
1892
1893         nonseekable_open(inode, filp);
1894
1895         /* find a device that is not in use. */
1896         down(&allocated_ptys_lock);
1897         if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1898                 up(&allocated_ptys_lock);
1899                 return -ENOMEM;
1900         }
1901         idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1902         if (idr_ret < 0) {
1903                 up(&allocated_ptys_lock);
1904                 if (idr_ret == -EAGAIN)
1905                         return -ENOMEM;
1906                 return -EIO;
1907         }
1908         if (index >= pty_limit) {
1909                 idr_remove(&allocated_ptys, index);
1910                 up(&allocated_ptys_lock);
1911                 return -EIO;
1912         }
1913         up(&allocated_ptys_lock);
1914
1915         down(&tty_sem);
1916         retval = init_dev(ptm_driver, index, &tty);
1917         up(&tty_sem);
1918         
1919         if (retval)
1920                 goto out;
1921
1922         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1923         filp->private_data = tty;
1924         file_move(filp, &tty->tty_files);
1925
1926         retval = -ENOMEM;
1927         if (devpts_pty_new(tty->link))
1928                 goto out1;
1929
1930         check_tty_count(tty, "tty_open");
1931         retval = ptm_driver->open(tty, filp);
1932         if (!retval)
1933                 return 0;
1934 out1:
1935         release_dev(filp);
1936 out:
1937         down(&allocated_ptys_lock);
1938         idr_remove(&allocated_ptys, index);
1939         up(&allocated_ptys_lock);
1940         return retval;
1941 }
1942 #endif
1943
1944 static int tty_release(struct inode * inode, struct file * filp)
1945 {
1946         lock_kernel();
1947         release_dev(filp);
1948         unlock_kernel();
1949         return 0;
1950 }
1951
1952 /* No kernel lock held - fine */
1953 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1954 {
1955         struct tty_struct * tty;
1956         struct tty_ldisc *ld;
1957         int ret = 0;
1958
1959         tty = (struct tty_struct *)filp->private_data;
1960         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1961                 return 0;
1962                 
1963         ld = tty_ldisc_ref_wait(tty);
1964         if (ld->poll)
1965                 ret = (ld->poll)(tty, filp, wait);
1966         tty_ldisc_deref(ld);
1967         return ret;
1968 }
1969
1970 static int tty_fasync(int fd, struct file * filp, int on)
1971 {
1972         struct tty_struct * tty;
1973         int retval;
1974
1975         tty = (struct tty_struct *)filp->private_data;
1976         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1977                 return 0;
1978         
1979         retval = fasync_helper(fd, filp, on, &tty->fasync);
1980         if (retval <= 0)
1981                 return retval;
1982
1983         if (on) {
1984                 if (!waitqueue_active(&tty->read_wait))
1985                         tty->minimum_to_wake = 1;
1986                 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1987                 if (retval)
1988                         return retval;
1989         } else {
1990                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1991                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
1992         }
1993         return 0;
1994 }
1995
1996 static int tiocsti(struct tty_struct *tty, char __user *p)
1997 {
1998         char ch, mbz = 0;
1999         struct tty_ldisc *ld;
2000         
2001         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2002                 return -EPERM;
2003         if (get_user(ch, p))
2004                 return -EFAULT;
2005         ld = tty_ldisc_ref_wait(tty);
2006         ld->receive_buf(tty, &ch, &mbz, 1);
2007         tty_ldisc_deref(ld);
2008         return 0;
2009 }
2010
2011 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2012 {
2013         if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
2014                 return -EFAULT;
2015         return 0;
2016 }
2017
2018 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2019         struct winsize __user * arg)
2020 {
2021         struct winsize tmp_ws;
2022
2023         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2024                 return -EFAULT;
2025         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2026                 return 0;
2027 #ifdef CONFIG_VT
2028         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2029                 int rc;
2030
2031                 acquire_console_sem();
2032                 rc = vc_resize(tty->driver_data, tmp_ws.ws_col, tmp_ws.ws_row);
2033                 release_console_sem();
2034                 if (rc)
2035                         return -ENXIO;
2036         }
2037 #endif
2038         if (tty->pgrp > 0)
2039                 kill_pg(tty->pgrp, SIGWINCH, 1);
2040         if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
2041                 kill_pg(real_tty->pgrp, SIGWINCH, 1);
2042         tty->winsize = tmp_ws;
2043         real_tty->winsize = tmp_ws;
2044         return 0;
2045 }
2046
2047 static int tioccons(struct file *file)
2048 {
2049         if (!capable(CAP_SYS_ADMIN))
2050                 return -EPERM;
2051         if (file->f_op->write == redirected_tty_write) {
2052                 struct file *f;
2053                 spin_lock(&redirect_lock);
2054                 f = redirect;
2055                 redirect = NULL;
2056                 spin_unlock(&redirect_lock);
2057                 if (f)
2058                         fput(f);
2059                 return 0;
2060         }
2061         spin_lock(&redirect_lock);
2062         if (redirect) {
2063                 spin_unlock(&redirect_lock);
2064                 return -EBUSY;
2065         }
2066         get_file(file);
2067         redirect = file;
2068         spin_unlock(&redirect_lock);
2069         return 0;
2070 }
2071
2072
2073 static int fionbio(struct file *file, int __user *p)
2074 {
2075         int nonblock;
2076
2077         if (get_user(nonblock, p))
2078                 return -EFAULT;
2079
2080         if (nonblock)
2081                 file->f_flags |= O_NONBLOCK;
2082         else
2083                 file->f_flags &= ~O_NONBLOCK;
2084         return 0;
2085 }
2086
2087 static int tiocsctty(struct tty_struct *tty, int arg)
2088 {
2089         task_t *p;
2090
2091         if (current->signal->leader &&
2092             (current->signal->session == tty->session))
2093                 return 0;
2094         /*
2095          * The process must be a session leader and
2096          * not have a controlling tty already.
2097          */
2098         if (!current->signal->leader || current->signal->tty)
2099                 return -EPERM;
2100         if (tty->session > 0) {
2101                 /*
2102                  * This tty is already the controlling
2103                  * tty for another session group!
2104                  */
2105                 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2106                         /*
2107                          * Steal it away
2108                          */
2109
2110                         read_lock(&tasklist_lock);
2111                         do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2112                                 p->signal->tty = NULL;
2113                         } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2114                         read_unlock(&tasklist_lock);
2115                 } else
2116                         return -EPERM;
2117         }
2118         task_lock(current);
2119         current->signal->tty = tty;
2120         task_unlock(current);
2121         current->signal->tty_old_pgrp = 0;
2122         tty->session = current->signal->session;
2123         tty->pgrp = process_group(current);
2124         return 0;
2125 }
2126
2127 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2128 {
2129         /*
2130          * (tty == real_tty) is a cheap way of
2131          * testing if the tty is NOT a master pty.
2132          */
2133         if (tty == real_tty && current->signal->tty != real_tty)
2134                 return -ENOTTY;
2135         return put_user(real_tty->pgrp, p);
2136 }
2137
2138 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2139 {
2140         pid_t pgrp;
2141         int retval = tty_check_change(real_tty);
2142
2143         if (retval == -EIO)
2144                 return -ENOTTY;
2145         if (retval)
2146                 return retval;
2147         if (!current->signal->tty ||
2148             (current->signal->tty != real_tty) ||
2149             (real_tty->session != current->signal->session))
2150                 return -ENOTTY;
2151         if (get_user(pgrp, p))
2152                 return -EFAULT;
2153         if (pgrp < 0)
2154                 return -EINVAL;
2155         if (session_of_pgrp(pgrp) != current->signal->session)
2156                 return -EPERM;
2157         real_tty->pgrp = pgrp;
2158         return 0;
2159 }
2160
2161 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2162 {
2163         /*
2164          * (tty == real_tty) is a cheap way of
2165          * testing if the tty is NOT a master pty.
2166         */
2167         if (tty == real_tty && current->signal->tty != real_tty)
2168                 return -ENOTTY;
2169         if (real_tty->session <= 0)
2170                 return -ENOTTY;
2171         return put_user(real_tty->session, p);
2172 }
2173
2174 static int tiocsetd(struct tty_struct *tty, int __user *p)
2175 {
2176         int ldisc;
2177
2178         if (get_user(ldisc, p))
2179                 return -EFAULT;
2180         return tty_set_ldisc(tty, ldisc);
2181 }
2182
2183 static int send_break(struct tty_struct *tty, int duration)
2184 {
2185         tty->driver->break_ctl(tty, -1);
2186         if (!signal_pending(current)) {
2187                 set_current_state(TASK_INTERRUPTIBLE);
2188                 schedule_timeout(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, HZ/4);
2370                         return 0;
2371                 case TCSBRKP:   /* support for POSIX tcsendbreak() */   
2372                         return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
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);