KVM: Emulate hlt in the kernel
[linux-2.6] / drivers / char / tty_io.c
1 /*
2  *  linux/drivers/char/tty_io.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6
7 /*
8  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
9  * or rs-channels. It also implements echoing, cooked mode etc.
10  *
11  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
12  *
13  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
14  * tty_struct and tty_queue structures.  Previously there was an array
15  * of 256 tty_struct's which was statically allocated, and the
16  * tty_queue structures were allocated at boot time.  Both are now
17  * dynamically allocated only when the tty is open.
18  *
19  * Also restructured routines so that there is more of a separation
20  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
21  * the low-level tty routines (serial.c, pty.c, console.c).  This
22  * makes for cleaner and more compact code.  -TYT, 9/17/92 
23  *
24  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
25  * which can be dynamically activated and de-activated by the line
26  * discipline handling modules (like SLIP).
27  *
28  * NOTE: pay no attention to the line discipline code (yet); its
29  * interface is still subject to change in this version...
30  * -- TYT, 1/31/92
31  *
32  * Added functionality to the OPOST tty handling.  No delays, but all
33  * other bits should be there.
34  *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
35  *
36  * Rewrote canonical mode and added more termios flags.
37  *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
38  *
39  * Reorganized FASYNC support so mouse code can share it.
40  *      -- ctm@ardi.com, 9Sep95
41  *
42  * New TIOCLINUX variants added.
43  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
44  * 
45  * Restrict vt switching via ioctl()
46  *      -- grif@cs.ucr.edu, 5-Dec-95
47  *
48  * Move console and virtual terminal code to more appropriate files,
49  * implement CONFIG_VT and generalize console device interface.
50  *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
51  *
52  * Rewrote init_dev and release_dev to eliminate races.
53  *      -- Bill Hawes <whawes@star.net>, June 97
54  *
55  * Added devfs support.
56  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
57  *
58  * Added support for a Unix98-style ptmx device.
59  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
60  *
61  * Reduced memory usage for older ARM systems
62  *      -- Russell King <rmk@arm.linux.org.uk>
63  *
64  * Move do_SAK() into process context.  Less stack use in devfs functions.
65  * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
66  */
67
68 #include <linux/types.h>
69 #include <linux/major.h>
70 #include <linux/errno.h>
71 #include <linux/signal.h>
72 #include <linux/fcntl.h>
73 #include <linux/sched.h>
74 #include <linux/interrupt.h>
75 #include <linux/tty.h>
76 #include <linux/tty_driver.h>
77 #include <linux/tty_flip.h>
78 #include <linux/devpts_fs.h>
79 #include <linux/file.h>
80 #include <linux/console.h>
81 #include <linux/timer.h>
82 #include <linux/ctype.h>
83 #include <linux/kd.h>
84 #include <linux/mm.h>
85 #include <linux/string.h>
86 #include <linux/slab.h>
87 #include <linux/poll.h>
88 #include <linux/proc_fs.h>
89 #include <linux/init.h>
90 #include <linux/module.h>
91 #include <linux/smp_lock.h>
92 #include <linux/device.h>
93 #include <linux/idr.h>
94 #include <linux/wait.h>
95 #include <linux/bitops.h>
96 #include <linux/delay.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
105 #include <linux/kmod.h>
106
107 #undef TTY_DEBUG_HANGUP
108
109 #define TTY_PARANOIA_CHECK 1
110 #define CHECK_TTY_COUNT 1
111
112 struct ktermios tty_std_termios = {     /* for the benefit of tty drivers  */
113         .c_iflag = ICRNL | IXON,
114         .c_oflag = OPOST | ONLCR,
115         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
116         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
117                    ECHOCTL | ECHOKE | IEXTEN,
118         .c_cc = INIT_C_CC,
119         .c_ispeed = 38400,
120         .c_ospeed = 38400
121 };
122
123 EXPORT_SYMBOL(tty_std_termios);
124
125 /* This list gets poked at by procfs and various bits of boot up code. This
126    could do with some rationalisation such as pulling the tty proc function
127    into this file */
128    
129 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
130
131 /* Mutex to protect creating and releasing a tty. This is shared with
132    vt.c for deeply disgusting hack reasons */
133 DEFINE_MUTEX(tty_mutex);
134 EXPORT_SYMBOL(tty_mutex);
135
136 #ifdef CONFIG_UNIX98_PTYS
137 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
138 extern int pty_limit;           /* Config limit on Unix98 ptys */
139 static DEFINE_IDR(allocated_ptys);
140 static DECLARE_MUTEX(allocated_ptys_lock);
141 static int ptmx_open(struct inode *, struct file *);
142 #endif
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 #ifdef CONFIG_COMPAT
155 static long tty_compat_ioctl(struct file * file, unsigned int cmd,
156                                 unsigned long arg);
157 #else
158 #define tty_compat_ioctl NULL
159 #endif
160 static int tty_fasync(int fd, struct file * filp, int on);
161 static void release_tty(struct tty_struct *tty, int idx);
162 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
163 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
164
165 /**
166  *      alloc_tty_struct        -       allocate a tty object
167  *
168  *      Return a new empty tty structure. The data fields have not
169  *      been initialized in any way but has been zeroed
170  *
171  *      Locking: none
172  */
173
174 static struct tty_struct *alloc_tty_struct(void)
175 {
176         return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
177 }
178
179 static void tty_buffer_free_all(struct tty_struct *);
180
181 /**
182  *      free_tty_struct         -       free a disused tty
183  *      @tty: tty struct to free
184  *
185  *      Free the write buffers, tty queue and tty memory itself.
186  *
187  *      Locking: none. Must be called after tty is definitely unused
188  */
189
190 static inline void free_tty_struct(struct tty_struct *tty)
191 {
192         kfree(tty->write_buf);
193         tty_buffer_free_all(tty);
194         kfree(tty);
195 }
196
197 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
198
199 /**
200  *      tty_name        -       return tty naming
201  *      @tty: tty structure
202  *      @buf: buffer for output
203  *
204  *      Convert a tty structure into a name. The name reflects the kernel
205  *      naming policy and if udev is in use may not reflect user space
206  *
207  *      Locking: none
208  */
209
210 char *tty_name(struct tty_struct *tty, char *buf)
211 {
212         if (!tty) /* Hmm.  NULL pointer.  That's fun. */
213                 strcpy(buf, "NULL tty");
214         else
215                 strcpy(buf, tty->name);
216         return buf;
217 }
218
219 EXPORT_SYMBOL(tty_name);
220
221 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
222                               const char *routine)
223 {
224 #ifdef TTY_PARANOIA_CHECK
225         if (!tty) {
226                 printk(KERN_WARNING
227                         "null TTY for (%d:%d) in %s\n",
228                         imajor(inode), iminor(inode), routine);
229                 return 1;
230         }
231         if (tty->magic != TTY_MAGIC) {
232                 printk(KERN_WARNING
233                         "bad magic number for tty struct (%d:%d) in %s\n",
234                         imajor(inode), iminor(inode), routine);
235                 return 1;
236         }
237 #endif
238         return 0;
239 }
240
241 static int check_tty_count(struct tty_struct *tty, const char *routine)
242 {
243 #ifdef CHECK_TTY_COUNT
244         struct list_head *p;
245         int count = 0;
246         
247         file_list_lock();
248         list_for_each(p, &tty->tty_files) {
249                 count++;
250         }
251         file_list_unlock();
252         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
253             tty->driver->subtype == PTY_TYPE_SLAVE &&
254             tty->link && tty->link->count)
255                 count++;
256         if (tty->count != count) {
257                 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
258                                     "!= #fd's(%d) in %s\n",
259                        tty->name, tty->count, count, routine);
260                 return count;
261         }
262 #endif
263         return 0;
264 }
265
266 /*
267  * Tty buffer allocation management
268  */
269
270 /**
271  *      tty_buffer_free_all             -       free buffers used by a tty
272  *      @tty: tty to free from
273  *
274  *      Remove all the buffers pending on a tty whether queued with data
275  *      or in the free ring. Must be called when the tty is no longer in use
276  *
277  *      Locking: none
278  */
279
280 static void tty_buffer_free_all(struct tty_struct *tty)
281 {
282         struct tty_buffer *thead;
283         while((thead = tty->buf.head) != NULL) {
284                 tty->buf.head = thead->next;
285                 kfree(thead);
286         }
287         while((thead = tty->buf.free) != NULL) {
288                 tty->buf.free = thead->next;
289                 kfree(thead);
290         }
291         tty->buf.tail = NULL;
292         tty->buf.memory_used = 0;
293 }
294
295 /**
296  *      tty_buffer_init         -       prepare a tty buffer structure
297  *      @tty: tty to initialise
298  *
299  *      Set up the initial state of the buffer management for a tty device.
300  *      Must be called before the other tty buffer functions are used.
301  *
302  *      Locking: none
303  */
304
305 static void tty_buffer_init(struct tty_struct *tty)
306 {
307         spin_lock_init(&tty->buf.lock);
308         tty->buf.head = NULL;
309         tty->buf.tail = NULL;
310         tty->buf.free = NULL;
311         tty->buf.memory_used = 0;
312 }
313
314 /**
315  *      tty_buffer_alloc        -       allocate a tty buffer
316  *      @tty: tty device
317  *      @size: desired size (characters)
318  *
319  *      Allocate a new tty buffer to hold the desired number of characters.
320  *      Return NULL if out of memory or the allocation would exceed the
321  *      per device queue
322  *
323  *      Locking: Caller must hold tty->buf.lock
324  */
325
326 static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
327 {
328         struct tty_buffer *p;
329
330         if (tty->buf.memory_used + size > 65536)
331                 return NULL;
332         p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
333         if(p == NULL)
334                 return NULL;
335         p->used = 0;
336         p->size = size;
337         p->next = NULL;
338         p->commit = 0;
339         p->read = 0;
340         p->char_buf_ptr = (char *)(p->data);
341         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
342         tty->buf.memory_used += size;
343         return p;
344 }
345
346 /**
347  *      tty_buffer_free         -       free a tty buffer
348  *      @tty: tty owning the buffer
349  *      @b: the buffer to free
350  *
351  *      Free a tty buffer, or add it to the free list according to our
352  *      internal strategy
353  *
354  *      Locking: Caller must hold tty->buf.lock
355  */
356
357 static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
358 {
359         /* Dumb strategy for now - should keep some stats */
360         tty->buf.memory_used -= b->size;
361         WARN_ON(tty->buf.memory_used < 0);
362
363         if(b->size >= 512)
364                 kfree(b);
365         else {
366                 b->next = tty->buf.free;
367                 tty->buf.free = b;
368         }
369 }
370
371 /**
372  *      __tty_buffer_flush              -       flush full tty buffers
373  *      @tty: tty to flush
374  *
375  *      flush all the buffers containing receive data. Caller must
376  *      hold the buffer lock and must have ensured no parallel flush to
377  *      ldisc is running.
378  *
379  *      Locking: Caller must hold tty->buf.lock
380  */
381
382 static void __tty_buffer_flush(struct tty_struct *tty)
383 {
384         struct tty_buffer *thead;
385
386         while((thead = tty->buf.head) != NULL) {
387                 tty->buf.head = thead->next;
388                 tty_buffer_free(tty, thead);
389         }
390         tty->buf.tail = NULL;
391 }
392
393 /**
394  *      tty_buffer_flush                -       flush full tty buffers
395  *      @tty: tty to flush
396  *
397  *      flush all the buffers containing receive data. If the buffer is
398  *      being processed by flush_to_ldisc then we defer the processing
399  *      to that function
400  *
401  *      Locking: none
402  */
403
404 static void tty_buffer_flush(struct tty_struct *tty)
405 {
406         unsigned long flags;
407         spin_lock_irqsave(&tty->buf.lock, flags);
408
409         /* If the data is being pushed to the tty layer then we can't
410            process it here. Instead set a flag and the flush_to_ldisc
411            path will process the flush request before it exits */
412         if (test_bit(TTY_FLUSHING, &tty->flags)) {
413                 set_bit(TTY_FLUSHPENDING, &tty->flags);
414                 spin_unlock_irqrestore(&tty->buf.lock, flags);
415                 wait_event(tty->read_wait,
416                                 test_bit(TTY_FLUSHPENDING, &tty->flags) == 0);
417                 return;
418         } else
419                 __tty_buffer_flush(tty);
420         spin_unlock_irqrestore(&tty->buf.lock, flags);
421 }
422
423 /**
424  *      tty_buffer_find         -       find a free tty buffer
425  *      @tty: tty owning the buffer
426  *      @size: characters wanted
427  *
428  *      Locate an existing suitable tty buffer or if we are lacking one then
429  *      allocate a new one. We round our buffers off in 256 character chunks
430  *      to get better allocation behaviour.
431  *
432  *      Locking: Caller must hold tty->buf.lock
433  */
434
435 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
436 {
437         struct tty_buffer **tbh = &tty->buf.free;
438         while((*tbh) != NULL) {
439                 struct tty_buffer *t = *tbh;
440                 if(t->size >= size) {
441                         *tbh = t->next;
442                         t->next = NULL;
443                         t->used = 0;
444                         t->commit = 0;
445                         t->read = 0;
446                         tty->buf.memory_used += t->size;
447                         return t;
448                 }
449                 tbh = &((*tbh)->next);
450         }
451         /* Round the buffer size out */
452         size = (size + 0xFF) & ~ 0xFF;
453         return tty_buffer_alloc(tty, size);
454         /* Should possibly check if this fails for the largest buffer we
455            have queued and recycle that ? */
456 }
457
458 /**
459  *      tty_buffer_request_room         -       grow tty buffer if needed
460  *      @tty: tty structure
461  *      @size: size desired
462  *
463  *      Make at least size bytes of linear space available for the tty
464  *      buffer. If we fail return the size we managed to find.
465  *
466  *      Locking: Takes tty->buf.lock
467  */
468 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
469 {
470         struct tty_buffer *b, *n;
471         int left;
472         unsigned long flags;
473
474         spin_lock_irqsave(&tty->buf.lock, flags);
475
476         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
477            remove this conditional if its worth it. This would be invisible
478            to the callers */
479         if ((b = tty->buf.tail) != NULL)
480                 left = b->size - b->used;
481         else
482                 left = 0;
483
484         if (left < size) {
485                 /* This is the slow path - looking for new buffers to use */
486                 if ((n = tty_buffer_find(tty, size)) != NULL) {
487                         if (b != NULL) {
488                                 b->next = n;
489                                 b->commit = b->used;
490                         } else
491                                 tty->buf.head = n;
492                         tty->buf.tail = n;
493                 } else
494                         size = left;
495         }
496
497         spin_unlock_irqrestore(&tty->buf.lock, flags);
498         return size;
499 }
500 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
501
502 /**
503  *      tty_insert_flip_string  -       Add characters to the tty buffer
504  *      @tty: tty structure
505  *      @chars: characters
506  *      @size: size
507  *
508  *      Queue a series of bytes to the tty buffering. All the characters
509  *      passed are marked as without error. Returns the number added.
510  *
511  *      Locking: Called functions may take tty->buf.lock
512  */
513
514 int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
515                                 size_t size)
516 {
517         int copied = 0;
518         do {
519                 int space = tty_buffer_request_room(tty, size - copied);
520                 struct tty_buffer *tb = tty->buf.tail;
521                 /* If there is no space then tb may be NULL */
522                 if(unlikely(space == 0))
523                         break;
524                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
525                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
526                 tb->used += space;
527                 copied += space;
528                 chars += space;
529                 /* There is a small chance that we need to split the data over
530                    several buffers. If this is the case we must loop */
531         } while (unlikely(size > copied));
532         return copied;
533 }
534 EXPORT_SYMBOL(tty_insert_flip_string);
535
536 /**
537  *      tty_insert_flip_string_flags    -       Add characters to the tty buffer
538  *      @tty: tty structure
539  *      @chars: characters
540  *      @flags: flag bytes
541  *      @size: size
542  *
543  *      Queue a series of bytes to the tty buffering. For each character
544  *      the flags array indicates the status of the character. Returns the
545  *      number added.
546  *
547  *      Locking: Called functions may take tty->buf.lock
548  */
549
550 int tty_insert_flip_string_flags(struct tty_struct *tty,
551                 const unsigned char *chars, const char *flags, size_t size)
552 {
553         int copied = 0;
554         do {
555                 int space = tty_buffer_request_room(tty, size - copied);
556                 struct tty_buffer *tb = tty->buf.tail;
557                 /* If there is no space then tb may be NULL */
558                 if(unlikely(space == 0))
559                         break;
560                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
561                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
562                 tb->used += space;
563                 copied += space;
564                 chars += space;
565                 flags += space;
566                 /* There is a small chance that we need to split the data over
567                    several buffers. If this is the case we must loop */
568         } while (unlikely(size > copied));
569         return copied;
570 }
571 EXPORT_SYMBOL(tty_insert_flip_string_flags);
572
573 /**
574  *      tty_schedule_flip       -       push characters to ldisc
575  *      @tty: tty to push from
576  *
577  *      Takes any pending buffers and transfers their ownership to the
578  *      ldisc side of the queue. It then schedules those characters for
579  *      processing by the line discipline.
580  *
581  *      Locking: Takes tty->buf.lock
582  */
583
584 void tty_schedule_flip(struct tty_struct *tty)
585 {
586         unsigned long flags;
587         spin_lock_irqsave(&tty->buf.lock, flags);
588         if (tty->buf.tail != NULL)
589                 tty->buf.tail->commit = tty->buf.tail->used;
590         spin_unlock_irqrestore(&tty->buf.lock, flags);
591         schedule_delayed_work(&tty->buf.work, 1);
592 }
593 EXPORT_SYMBOL(tty_schedule_flip);
594
595 /**
596  *      tty_prepare_flip_string         -       make room for characters
597  *      @tty: tty
598  *      @chars: return pointer for character write area
599  *      @size: desired size
600  *
601  *      Prepare a block of space in the buffer for data. Returns the length
602  *      available and buffer pointer to the space which is now allocated and
603  *      accounted for as ready for normal characters. This is used for drivers
604  *      that need their own block copy routines into the buffer. There is no
605  *      guarantee the buffer is a DMA target!
606  *
607  *      Locking: May call functions taking tty->buf.lock
608  */
609
610 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
611 {
612         int space = tty_buffer_request_room(tty, size);
613         if (likely(space)) {
614                 struct tty_buffer *tb = tty->buf.tail;
615                 *chars = tb->char_buf_ptr + tb->used;
616                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
617                 tb->used += space;
618         }
619         return space;
620 }
621
622 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
623
624 /**
625  *      tty_prepare_flip_string_flags   -       make room for characters
626  *      @tty: tty
627  *      @chars: return pointer for character write area
628  *      @flags: return pointer for status flag write area
629  *      @size: desired size
630  *
631  *      Prepare a block of space in the buffer for data. Returns the length
632  *      available and buffer pointer to the space which is now allocated and
633  *      accounted for as ready for characters. This is used for drivers
634  *      that need their own block copy routines into the buffer. There is no
635  *      guarantee the buffer is a DMA target!
636  *
637  *      Locking: May call functions taking tty->buf.lock
638  */
639
640 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
641 {
642         int space = tty_buffer_request_room(tty, size);
643         if (likely(space)) {
644                 struct tty_buffer *tb = tty->buf.tail;
645                 *chars = tb->char_buf_ptr + tb->used;
646                 *flags = tb->flag_buf_ptr + tb->used;
647                 tb->used += space;
648         }
649         return space;
650 }
651
652 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
653
654
655
656 /**
657  *      tty_set_termios_ldisc           -       set ldisc field
658  *      @tty: tty structure
659  *      @num: line discipline number
660  *
661  *      This is probably overkill for real world processors but
662  *      they are not on hot paths so a little discipline won't do 
663  *      any harm.
664  *
665  *      Locking: takes termios_mutex
666  */
667  
668 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
669 {
670         mutex_lock(&tty->termios_mutex);
671         tty->termios->c_line = num;
672         mutex_unlock(&tty->termios_mutex);
673 }
674
675 /*
676  *      This guards the refcounted line discipline lists. The lock
677  *      must be taken with irqs off because there are hangup path
678  *      callers who will do ldisc lookups and cannot sleep.
679  */
680  
681 static DEFINE_SPINLOCK(tty_ldisc_lock);
682 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
683 static struct tty_ldisc tty_ldiscs[NR_LDISCS];  /* line disc dispatch table */
684
685 /**
686  *      tty_register_ldisc      -       install a line discipline
687  *      @disc: ldisc number
688  *      @new_ldisc: pointer to the ldisc object
689  *
690  *      Installs a new line discipline into the kernel. The discipline
691  *      is set up as unreferenced and then made available to the kernel
692  *      from this point onwards.
693  *
694  *      Locking:
695  *              takes tty_ldisc_lock to guard against ldisc races
696  */
697
698 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
699 {
700         unsigned long flags;
701         int ret = 0;
702         
703         if (disc < N_TTY || disc >= NR_LDISCS)
704                 return -EINVAL;
705         
706         spin_lock_irqsave(&tty_ldisc_lock, flags);
707         tty_ldiscs[disc] = *new_ldisc;
708         tty_ldiscs[disc].num = disc;
709         tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
710         tty_ldiscs[disc].refcount = 0;
711         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
712         
713         return ret;
714 }
715 EXPORT_SYMBOL(tty_register_ldisc);
716
717 /**
718  *      tty_unregister_ldisc    -       unload a line discipline
719  *      @disc: ldisc number
720  *      @new_ldisc: pointer to the ldisc object
721  *
722  *      Remove a line discipline from the kernel providing it is not
723  *      currently in use.
724  *
725  *      Locking:
726  *              takes tty_ldisc_lock to guard against ldisc races
727  */
728
729 int tty_unregister_ldisc(int disc)
730 {
731         unsigned long flags;
732         int ret = 0;
733
734         if (disc < N_TTY || disc >= NR_LDISCS)
735                 return -EINVAL;
736
737         spin_lock_irqsave(&tty_ldisc_lock, flags);
738         if (tty_ldiscs[disc].refcount)
739                 ret = -EBUSY;
740         else
741                 tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
742         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
743
744         return ret;
745 }
746 EXPORT_SYMBOL(tty_unregister_ldisc);
747
748 /**
749  *      tty_ldisc_get           -       take a reference to an ldisc
750  *      @disc: ldisc number
751  *
752  *      Takes a reference to a line discipline. Deals with refcounts and
753  *      module locking counts. Returns NULL if the discipline is not available.
754  *      Returns a pointer to the discipline and bumps the ref count if it is
755  *      available
756  *
757  *      Locking:
758  *              takes tty_ldisc_lock to guard against ldisc races
759  */
760
761 struct tty_ldisc *tty_ldisc_get(int disc)
762 {
763         unsigned long flags;
764         struct tty_ldisc *ld;
765
766         if (disc < N_TTY || disc >= NR_LDISCS)
767                 return NULL;
768         
769         spin_lock_irqsave(&tty_ldisc_lock, flags);
770
771         ld = &tty_ldiscs[disc];
772         /* Check the entry is defined */
773         if(ld->flags & LDISC_FLAG_DEFINED)
774         {
775                 /* If the module is being unloaded we can't use it */
776                 if (!try_module_get(ld->owner))
777                         ld = NULL;
778                 else /* lock it */
779                         ld->refcount++;
780         }
781         else
782                 ld = NULL;
783         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
784         return ld;
785 }
786
787 EXPORT_SYMBOL_GPL(tty_ldisc_get);
788
789 /**
790  *      tty_ldisc_put           -       drop ldisc reference
791  *      @disc: ldisc number
792  *
793  *      Drop a reference to a line discipline. Manage refcounts and
794  *      module usage counts
795  *
796  *      Locking:
797  *              takes tty_ldisc_lock to guard against ldisc races
798  */
799
800 void tty_ldisc_put(int disc)
801 {
802         struct tty_ldisc *ld;
803         unsigned long flags;
804         
805         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
806                 
807         spin_lock_irqsave(&tty_ldisc_lock, flags);
808         ld = &tty_ldiscs[disc];
809         BUG_ON(ld->refcount == 0);
810         ld->refcount--;
811         module_put(ld->owner);
812         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
813 }
814         
815 EXPORT_SYMBOL_GPL(tty_ldisc_put);
816
817 /**
818  *      tty_ldisc_assign        -       set ldisc on a tty
819  *      @tty: tty to assign
820  *      @ld: line discipline
821  *
822  *      Install an instance of a line discipline into a tty structure. The
823  *      ldisc must have a reference count above zero to ensure it remains/
824  *      The tty instance refcount starts at zero.
825  *
826  *      Locking:
827  *              Caller must hold references
828  */
829
830 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
831 {
832         tty->ldisc = *ld;
833         tty->ldisc.refcount = 0;
834 }
835
836 /**
837  *      tty_ldisc_try           -       internal helper
838  *      @tty: the tty
839  *
840  *      Make a single attempt to grab and bump the refcount on
841  *      the tty ldisc. Return 0 on failure or 1 on success. This is
842  *      used to implement both the waiting and non waiting versions
843  *      of tty_ldisc_ref
844  *
845  *      Locking: takes tty_ldisc_lock
846  */
847
848 static int tty_ldisc_try(struct tty_struct *tty)
849 {
850         unsigned long flags;
851         struct tty_ldisc *ld;
852         int ret = 0;
853         
854         spin_lock_irqsave(&tty_ldisc_lock, flags);
855         ld = &tty->ldisc;
856         if(test_bit(TTY_LDISC, &tty->flags))
857         {
858                 ld->refcount++;
859                 ret = 1;
860         }
861         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
862         return ret;
863 }
864
865 /**
866  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
867  *      @tty: tty device
868  *
869  *      Dereference the line discipline for the terminal and take a 
870  *      reference to it. If the line discipline is in flux then 
871  *      wait patiently until it changes.
872  *
873  *      Note: Must not be called from an IRQ/timer context. The caller
874  *      must also be careful not to hold other locks that will deadlock
875  *      against a discipline change, such as an existing ldisc reference
876  *      (which we check for)
877  *
878  *      Locking: call functions take tty_ldisc_lock
879  */
880  
881 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
882 {
883         /* wait_event is a macro */
884         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
885         if(tty->ldisc.refcount == 0)
886                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
887         return &tty->ldisc;
888 }
889
890 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
891
892 /**
893  *      tty_ldisc_ref           -       get the tty ldisc
894  *      @tty: tty device
895  *
896  *      Dereference the line discipline for the terminal and take a 
897  *      reference to it. If the line discipline is in flux then 
898  *      return NULL. Can be called from IRQ and timer functions.
899  *
900  *      Locking: called functions take tty_ldisc_lock
901  */
902  
903 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
904 {
905         if(tty_ldisc_try(tty))
906                 return &tty->ldisc;
907         return NULL;
908 }
909
910 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
911
912 /**
913  *      tty_ldisc_deref         -       free a tty ldisc reference
914  *      @ld: reference to free up
915  *
916  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
917  *      be called in IRQ context.
918  *
919  *      Locking: takes tty_ldisc_lock
920  */
921  
922 void tty_ldisc_deref(struct tty_ldisc *ld)
923 {
924         unsigned long flags;
925
926         BUG_ON(ld == NULL);
927                 
928         spin_lock_irqsave(&tty_ldisc_lock, flags);
929         if(ld->refcount == 0)
930                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
931         else
932                 ld->refcount--;
933         if(ld->refcount == 0)
934                 wake_up(&tty_ldisc_wait);
935         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
936 }
937
938 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
939
940 /**
941  *      tty_ldisc_enable        -       allow ldisc use
942  *      @tty: terminal to activate ldisc on
943  *
944  *      Set the TTY_LDISC flag when the line discipline can be called
945  *      again. Do neccessary wakeups for existing sleepers.
946  *
947  *      Note: nobody should set this bit except via this function. Clearing
948  *      directly is allowed.
949  */
950
951 static void tty_ldisc_enable(struct tty_struct *tty)
952 {
953         set_bit(TTY_LDISC, &tty->flags);
954         wake_up(&tty_ldisc_wait);
955 }
956         
957 /**
958  *      tty_set_ldisc           -       set line discipline
959  *      @tty: the terminal to set
960  *      @ldisc: the line discipline
961  *
962  *      Set the discipline of a tty line. Must be called from a process
963  *      context.
964  *
965  *      Locking: takes tty_ldisc_lock.
966  *               called functions take termios_mutex
967  */
968  
969 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
970 {
971         int retval = 0;
972         struct tty_ldisc o_ldisc;
973         char buf[64];
974         int work;
975         unsigned long flags;
976         struct tty_ldisc *ld;
977         struct tty_struct *o_tty;
978
979         if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
980                 return -EINVAL;
981
982 restart:
983
984         ld = tty_ldisc_get(ldisc);
985         /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
986         /* Cyrus Durgin <cider@speakeasy.org> */
987         if (ld == NULL) {
988                 request_module("tty-ldisc-%d", ldisc);
989                 ld = tty_ldisc_get(ldisc);
990         }
991         if (ld == NULL)
992                 return -EINVAL;
993
994         /*
995          *      Problem: What do we do if this blocks ?
996          */
997
998         tty_wait_until_sent(tty, 0);
999
1000         if (tty->ldisc.num == ldisc) {
1001                 tty_ldisc_put(ldisc);
1002                 return 0;
1003         }
1004
1005         /*
1006          *      No more input please, we are switching. The new ldisc
1007          *      will update this value in the ldisc open function
1008          */
1009
1010         tty->receive_room = 0;
1011
1012         o_ldisc = tty->ldisc;
1013         o_tty = tty->link;
1014
1015         /*
1016          *      Make sure we don't change while someone holds a
1017          *      reference to the line discipline. The TTY_LDISC bit
1018          *      prevents anyone taking a reference once it is clear.
1019          *      We need the lock to avoid racing reference takers.
1020          */
1021
1022         spin_lock_irqsave(&tty_ldisc_lock, flags);
1023         if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
1024                 if(tty->ldisc.refcount) {
1025                         /* Free the new ldisc we grabbed. Must drop the lock
1026                            first. */
1027                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1028                         tty_ldisc_put(ldisc);
1029                         /*
1030                          * There are several reasons we may be busy, including
1031                          * random momentary I/O traffic. We must therefore
1032                          * retry. We could distinguish between blocking ops
1033                          * and retries if we made tty_ldisc_wait() smarter. That
1034                          * is up for discussion.
1035                          */
1036                         if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
1037                                 return -ERESTARTSYS;
1038                         goto restart;
1039                 }
1040                 if(o_tty && o_tty->ldisc.refcount) {
1041                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1042                         tty_ldisc_put(ldisc);
1043                         if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
1044                                 return -ERESTARTSYS;
1045                         goto restart;
1046                 }
1047         }
1048
1049         /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
1050
1051         if (!test_bit(TTY_LDISC, &tty->flags)) {
1052                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1053                 tty_ldisc_put(ldisc);
1054                 ld = tty_ldisc_ref_wait(tty);
1055                 tty_ldisc_deref(ld);
1056                 goto restart;
1057         }
1058
1059         clear_bit(TTY_LDISC, &tty->flags);
1060         if (o_tty)
1061                 clear_bit(TTY_LDISC, &o_tty->flags);
1062         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1063
1064         /*
1065          *      From this point on we know nobody has an ldisc
1066          *      usage reference, nor can they obtain one until
1067          *      we say so later on.
1068          */
1069
1070         work = cancel_delayed_work(&tty->buf.work);
1071         /*
1072          * Wait for ->hangup_work and ->buf.work handlers to terminate
1073          */
1074          
1075         flush_scheduled_work();
1076         /* Shutdown the current discipline. */
1077         if (tty->ldisc.close)
1078                 (tty->ldisc.close)(tty);
1079
1080         /* Now set up the new line discipline. */
1081         tty_ldisc_assign(tty, ld);
1082         tty_set_termios_ldisc(tty, ldisc);
1083         if (tty->ldisc.open)
1084                 retval = (tty->ldisc.open)(tty);
1085         if (retval < 0) {
1086                 tty_ldisc_put(ldisc);
1087                 /* There is an outstanding reference here so this is safe */
1088                 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
1089                 tty_set_termios_ldisc(tty, tty->ldisc.num);
1090                 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
1091                         tty_ldisc_put(o_ldisc.num);
1092                         /* This driver is always present */
1093                         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1094                         tty_set_termios_ldisc(tty, N_TTY);
1095                         if (tty->ldisc.open) {
1096                                 int r = tty->ldisc.open(tty);
1097
1098                                 if (r < 0)
1099                                         panic("Couldn't open N_TTY ldisc for "
1100                                               "%s --- error %d.",
1101                                               tty_name(tty, buf), r);
1102                         }
1103                 }
1104         }
1105         /* At this point we hold a reference to the new ldisc and a
1106            a reference to the old ldisc. If we ended up flipping back
1107            to the existing ldisc we have two references to it */
1108         
1109         if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
1110                 tty->driver->set_ldisc(tty);
1111                 
1112         tty_ldisc_put(o_ldisc.num);
1113         
1114         /*
1115          *      Allow ldisc referencing to occur as soon as the driver
1116          *      ldisc callback completes.
1117          */
1118          
1119         tty_ldisc_enable(tty);
1120         if (o_tty)
1121                 tty_ldisc_enable(o_tty);
1122         
1123         /* Restart it in case no characters kick it off. Safe if
1124            already running */
1125         if (work)
1126                 schedule_delayed_work(&tty->buf.work, 1);
1127         return retval;
1128 }
1129
1130 /**
1131  *      get_tty_driver          -       find device of a tty
1132  *      @dev_t: device identifier
1133  *      @index: returns the index of the tty
1134  *
1135  *      This routine returns a tty driver structure, given a device number
1136  *      and also passes back the index number.
1137  *
1138  *      Locking: caller must hold tty_mutex
1139  */
1140
1141 static struct tty_driver *get_tty_driver(dev_t device, int *index)
1142 {
1143         struct tty_driver *p;
1144
1145         list_for_each_entry(p, &tty_drivers, tty_drivers) {
1146                 dev_t base = MKDEV(p->major, p->minor_start);
1147                 if (device < base || device >= base + p->num)
1148                         continue;
1149                 *index = device - base;
1150                 return p;
1151         }
1152         return NULL;
1153 }
1154
1155 /**
1156  *      tty_check_change        -       check for POSIX terminal changes
1157  *      @tty: tty to check
1158  *
1159  *      If we try to write to, or set the state of, a terminal and we're
1160  *      not in the foreground, send a SIGTTOU.  If the signal is blocked or
1161  *      ignored, go ahead and perform the operation.  (POSIX 7.2)
1162  *
1163  *      Locking: none
1164  */
1165
1166 int tty_check_change(struct tty_struct * tty)
1167 {
1168         if (current->signal->tty != tty)
1169                 return 0;
1170         if (!tty->pgrp) {
1171                 printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
1172                 return 0;
1173         }
1174         if (task_pgrp(current) == tty->pgrp)
1175                 return 0;
1176         if (is_ignored(SIGTTOU))
1177                 return 0;
1178         if (is_current_pgrp_orphaned())
1179                 return -EIO;
1180         kill_pgrp(task_pgrp(current), SIGTTOU, 1);
1181         set_thread_flag(TIF_SIGPENDING);
1182         return -ERESTARTSYS;
1183 }
1184
1185 EXPORT_SYMBOL(tty_check_change);
1186
1187 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
1188                                 size_t count, loff_t *ppos)
1189 {
1190         return 0;
1191 }
1192
1193 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
1194                                  size_t count, loff_t *ppos)
1195 {
1196         return -EIO;
1197 }
1198
1199 /* No kernel lock held - none needed ;) */
1200 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
1201 {
1202         return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
1203 }
1204
1205 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
1206                              unsigned int cmd, unsigned long arg)
1207 {
1208         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1209 }
1210
1211 static long hung_up_tty_compat_ioctl(struct file * file,
1212                                      unsigned int cmd, unsigned long arg)
1213 {
1214         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
1215 }
1216
1217 static const struct file_operations tty_fops = {
1218         .llseek         = no_llseek,
1219         .read           = tty_read,
1220         .write          = tty_write,
1221         .poll           = tty_poll,
1222         .ioctl          = tty_ioctl,
1223         .compat_ioctl   = tty_compat_ioctl,
1224         .open           = tty_open,
1225         .release        = tty_release,
1226         .fasync         = tty_fasync,
1227 };
1228
1229 #ifdef CONFIG_UNIX98_PTYS
1230 static const struct file_operations ptmx_fops = {
1231         .llseek         = no_llseek,
1232         .read           = tty_read,
1233         .write          = tty_write,
1234         .poll           = tty_poll,
1235         .ioctl          = tty_ioctl,
1236         .compat_ioctl   = tty_compat_ioctl,
1237         .open           = ptmx_open,
1238         .release        = tty_release,
1239         .fasync         = tty_fasync,
1240 };
1241 #endif
1242
1243 static const struct file_operations console_fops = {
1244         .llseek         = no_llseek,
1245         .read           = tty_read,
1246         .write          = redirected_tty_write,
1247         .poll           = tty_poll,
1248         .ioctl          = tty_ioctl,
1249         .compat_ioctl   = tty_compat_ioctl,
1250         .open           = tty_open,
1251         .release        = tty_release,
1252         .fasync         = tty_fasync,
1253 };
1254
1255 static const struct file_operations hung_up_tty_fops = {
1256         .llseek         = no_llseek,
1257         .read           = hung_up_tty_read,
1258         .write          = hung_up_tty_write,
1259         .poll           = hung_up_tty_poll,
1260         .ioctl          = hung_up_tty_ioctl,
1261         .compat_ioctl   = hung_up_tty_compat_ioctl,
1262         .release        = tty_release,
1263 };
1264
1265 static DEFINE_SPINLOCK(redirect_lock);
1266 static struct file *redirect;
1267
1268 /**
1269  *      tty_wakeup      -       request more data
1270  *      @tty: terminal
1271  *
1272  *      Internal and external helper for wakeups of tty. This function
1273  *      informs the line discipline if present that the driver is ready
1274  *      to receive more output data.
1275  */
1276  
1277 void tty_wakeup(struct tty_struct *tty)
1278 {
1279         struct tty_ldisc *ld;
1280         
1281         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
1282                 ld = tty_ldisc_ref(tty);
1283                 if(ld) {
1284                         if(ld->write_wakeup)
1285                                 ld->write_wakeup(tty);
1286                         tty_ldisc_deref(ld);
1287                 }
1288         }
1289         wake_up_interruptible(&tty->write_wait);
1290 }
1291
1292 EXPORT_SYMBOL_GPL(tty_wakeup);
1293
1294 /**
1295  *      tty_ldisc_flush -       flush line discipline queue
1296  *      @tty: tty
1297  *
1298  *      Flush the line discipline queue (if any) for this tty. If there
1299  *      is no line discipline active this is a no-op.
1300  */
1301  
1302 void tty_ldisc_flush(struct tty_struct *tty)
1303 {
1304         struct tty_ldisc *ld = tty_ldisc_ref(tty);
1305         if(ld) {
1306                 if(ld->flush_buffer)
1307                         ld->flush_buffer(tty);
1308                 tty_ldisc_deref(ld);
1309         }
1310         tty_buffer_flush(tty);
1311 }
1312
1313 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
1314
1315 /**
1316  *      tty_reset_termios       -       reset terminal state
1317  *      @tty: tty to reset
1318  *
1319  *      Restore a terminal to the driver default state
1320  */
1321
1322 static void tty_reset_termios(struct tty_struct *tty)
1323 {
1324         mutex_lock(&tty->termios_mutex);
1325         *tty->termios = tty->driver->init_termios;
1326         tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
1327         tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1328         mutex_unlock(&tty->termios_mutex);
1329 }
1330         
1331 /**
1332  *      do_tty_hangup           -       actual handler for hangup events
1333  *      @work: tty device
1334  *
1335  *      This can be called by the "eventd" kernel thread.  That is process
1336  *      synchronous but doesn't hold any locks, so we need to make sure we
1337  *      have the appropriate locks for what we're doing.
1338  *
1339  *      The hangup event clears any pending redirections onto the hung up
1340  *      device. It ensures future writes will error and it does the needed
1341  *      line discipline hangup and signal delivery. The tty object itself
1342  *      remains intact.
1343  *
1344  *      Locking:
1345  *              BKL
1346  *                redirect lock for undoing redirection
1347  *                file list lock for manipulating list of ttys
1348  *                tty_ldisc_lock from called functions
1349  *                termios_mutex resetting termios data
1350  *                tasklist_lock to walk task list for hangup event
1351  *                  ->siglock to protect ->signal/->sighand
1352  */
1353 static void do_tty_hangup(struct work_struct *work)
1354 {
1355         struct tty_struct *tty =
1356                 container_of(work, struct tty_struct, hangup_work);
1357         struct file * cons_filp = NULL;
1358         struct file *filp, *f = NULL;
1359         struct task_struct *p;
1360         struct tty_ldisc *ld;
1361         int    closecount = 0, n;
1362
1363         if (!tty)
1364                 return;
1365
1366         /* inuse_filps is protected by the single kernel lock */
1367         lock_kernel();
1368
1369         spin_lock(&redirect_lock);
1370         if (redirect && redirect->private_data == tty) {
1371                 f = redirect;
1372                 redirect = NULL;
1373         }
1374         spin_unlock(&redirect_lock);
1375         
1376         check_tty_count(tty, "do_tty_hangup");
1377         file_list_lock();
1378         /* This breaks for file handles being sent over AF_UNIX sockets ? */
1379         list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
1380                 if (filp->f_op->write == redirected_tty_write)
1381                         cons_filp = filp;
1382                 if (filp->f_op->write != tty_write)
1383                         continue;
1384                 closecount++;
1385                 tty_fasync(-1, filp, 0);        /* can't block */
1386                 filp->f_op = &hung_up_tty_fops;
1387         }
1388         file_list_unlock();
1389         
1390         /* FIXME! What are the locking issues here? This may me overdoing things..
1391          * this question is especially important now that we've removed the irqlock. */
1392
1393         ld = tty_ldisc_ref(tty);
1394         if(ld != NULL)  /* We may have no line discipline at this point */
1395         {
1396                 if (ld->flush_buffer)
1397                         ld->flush_buffer(tty);
1398                 if (tty->driver->flush_buffer)
1399                         tty->driver->flush_buffer(tty);
1400                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
1401                     ld->write_wakeup)
1402                         ld->write_wakeup(tty);
1403                 if (ld->hangup)
1404                         ld->hangup(tty);
1405         }
1406
1407         /* FIXME: Once we trust the LDISC code better we can wait here for
1408            ldisc completion and fix the driver call race */
1409            
1410         wake_up_interruptible(&tty->write_wait);
1411         wake_up_interruptible(&tty->read_wait);
1412
1413         /*
1414          * Shutdown the current line discipline, and reset it to
1415          * N_TTY.
1416          */
1417         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1418                 tty_reset_termios(tty);
1419         
1420         /* Defer ldisc switch */
1421         /* tty_deferred_ldisc_switch(N_TTY);
1422         
1423           This should get done automatically when the port closes and
1424           tty_release is called */
1425         
1426         read_lock(&tasklist_lock);
1427         if (tty->session) {
1428                 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
1429                         spin_lock_irq(&p->sighand->siglock);
1430                         if (p->signal->tty == tty)
1431                                 p->signal->tty = NULL;
1432                         if (!p->signal->leader) {
1433                                 spin_unlock_irq(&p->sighand->siglock);
1434                                 continue;
1435                         }
1436                         __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
1437                         __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
1438                         put_pid(p->signal->tty_old_pgrp);  /* A noop */
1439                         if (tty->pgrp)
1440                                 p->signal->tty_old_pgrp = get_pid(tty->pgrp);
1441                         spin_unlock_irq(&p->sighand->siglock);
1442                 } while_each_pid_task(tty->session, PIDTYPE_SID, p);
1443         }
1444         read_unlock(&tasklist_lock);
1445
1446         tty->flags = 0;
1447         put_pid(tty->session);
1448         put_pid(tty->pgrp);
1449         tty->session = NULL;
1450         tty->pgrp = NULL;
1451         tty->ctrl_status = 0;
1452         /*
1453          *      If one of the devices matches a console pointer, we
1454          *      cannot just call hangup() because that will cause
1455          *      tty->count and state->count to go out of sync.
1456          *      So we just call close() the right number of times.
1457          */
1458         if (cons_filp) {
1459                 if (tty->driver->close)
1460                         for (n = 0; n < closecount; n++)
1461                                 tty->driver->close(tty, cons_filp);
1462         } else if (tty->driver->hangup)
1463                 (tty->driver->hangup)(tty);
1464                 
1465         /* We don't want to have driver/ldisc interactions beyond
1466            the ones we did here. The driver layer expects no
1467            calls after ->hangup() from the ldisc side. However we
1468            can't yet guarantee all that */
1469
1470         set_bit(TTY_HUPPED, &tty->flags);
1471         if (ld) {
1472                 tty_ldisc_enable(tty);
1473                 tty_ldisc_deref(ld);
1474         }
1475         unlock_kernel();
1476         if (f)
1477                 fput(f);
1478 }
1479
1480 /**
1481  *      tty_hangup              -       trigger a hangup event
1482  *      @tty: tty to hangup
1483  *
1484  *      A carrier loss (virtual or otherwise) has occurred on this like
1485  *      schedule a hangup sequence to run after this event.
1486  */
1487
1488 void tty_hangup(struct tty_struct * tty)
1489 {
1490 #ifdef TTY_DEBUG_HANGUP
1491         char    buf[64];
1492         
1493         printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
1494 #endif
1495         schedule_work(&tty->hangup_work);
1496 }
1497
1498 EXPORT_SYMBOL(tty_hangup);
1499
1500 /**
1501  *      tty_vhangup             -       process vhangup
1502  *      @tty: tty to hangup
1503  *
1504  *      The user has asked via system call for the terminal to be hung up.
1505  *      We do this synchronously so that when the syscall returns the process
1506  *      is complete. That guarantee is neccessary for security reasons.
1507  */
1508
1509 void tty_vhangup(struct tty_struct * tty)
1510 {
1511 #ifdef TTY_DEBUG_HANGUP
1512         char    buf[64];
1513
1514         printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
1515 #endif
1516         do_tty_hangup(&tty->hangup_work);
1517 }
1518 EXPORT_SYMBOL(tty_vhangup);
1519
1520 /**
1521  *      tty_hung_up_p           -       was tty hung up
1522  *      @filp: file pointer of tty
1523  *
1524  *      Return true if the tty has been subject to a vhangup or a carrier
1525  *      loss
1526  */
1527
1528 int tty_hung_up_p(struct file * filp)
1529 {
1530         return (filp->f_op == &hung_up_tty_fops);
1531 }
1532
1533 EXPORT_SYMBOL(tty_hung_up_p);
1534
1535 /**
1536  * is_tty       -       checker whether file is a TTY
1537  */
1538 int is_tty(struct file *filp)
1539 {
1540         return filp->f_op->read == tty_read
1541                 || filp->f_op->read == hung_up_tty_read;
1542 }
1543
1544 static void session_clear_tty(struct pid *session)
1545 {
1546         struct task_struct *p;
1547         do_each_pid_task(session, PIDTYPE_SID, p) {
1548                 proc_clear_tty(p);
1549         } while_each_pid_task(session, PIDTYPE_SID, p);
1550 }
1551
1552 /**
1553  *      disassociate_ctty       -       disconnect controlling tty
1554  *      @on_exit: true if exiting so need to "hang up" the session
1555  *
1556  *      This function is typically called only by the session leader, when
1557  *      it wants to disassociate itself from its controlling tty.
1558  *
1559  *      It performs the following functions:
1560  *      (1)  Sends a SIGHUP and SIGCONT to the foreground process group
1561  *      (2)  Clears the tty from being controlling the session
1562  *      (3)  Clears the controlling tty for all processes in the
1563  *              session group.
1564  *
1565  *      The argument on_exit is set to 1 if called when a process is
1566  *      exiting; it is 0 if called by the ioctl TIOCNOTTY.
1567  *
1568  *      Locking:
1569  *              BKL is taken for hysterical raisins
1570  *                tty_mutex is taken to protect tty
1571  *                ->siglock is taken to protect ->signal/->sighand
1572  *                tasklist_lock is taken to walk process list for sessions
1573  *                  ->siglock is taken to protect ->signal/->sighand
1574  */
1575
1576 void disassociate_ctty(int on_exit)
1577 {
1578         struct tty_struct *tty;
1579         struct pid *tty_pgrp = NULL;
1580
1581         lock_kernel();
1582
1583         mutex_lock(&tty_mutex);
1584         tty = get_current_tty();
1585         if (tty) {
1586                 tty_pgrp = get_pid(tty->pgrp);
1587                 mutex_unlock(&tty_mutex);
1588                 /* XXX: here we race, there is nothing protecting tty */
1589                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
1590                         tty_vhangup(tty);
1591         } else if (on_exit) {
1592                 struct pid *old_pgrp;
1593                 spin_lock_irq(&current->sighand->siglock);
1594                 old_pgrp = current->signal->tty_old_pgrp;
1595                 current->signal->tty_old_pgrp = NULL;
1596                 spin_unlock_irq(&current->sighand->siglock);
1597                 if (old_pgrp) {
1598                         kill_pgrp(old_pgrp, SIGHUP, on_exit);
1599                         kill_pgrp(old_pgrp, SIGCONT, on_exit);
1600                         put_pid(old_pgrp);
1601                 }
1602                 mutex_unlock(&tty_mutex);
1603                 unlock_kernel();        
1604                 return;
1605         }
1606         if (tty_pgrp) {
1607                 kill_pgrp(tty_pgrp, SIGHUP, on_exit);
1608                 if (!on_exit)
1609                         kill_pgrp(tty_pgrp, SIGCONT, on_exit);
1610                 put_pid(tty_pgrp);
1611         }
1612
1613         spin_lock_irq(&current->sighand->siglock);
1614         put_pid(current->signal->tty_old_pgrp);
1615         current->signal->tty_old_pgrp = NULL;
1616         spin_unlock_irq(&current->sighand->siglock);
1617
1618         mutex_lock(&tty_mutex);
1619         /* It is possible that do_tty_hangup has free'd this tty */
1620         tty = get_current_tty();
1621         if (tty) {
1622                 put_pid(tty->session);
1623                 put_pid(tty->pgrp);
1624                 tty->session = NULL;
1625                 tty->pgrp = NULL;
1626         } else {
1627 #ifdef TTY_DEBUG_HANGUP
1628                 printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
1629                        " = NULL", tty);
1630 #endif
1631         }
1632         mutex_unlock(&tty_mutex);
1633
1634         /* Now clear signal->tty under the lock */
1635         read_lock(&tasklist_lock);
1636         session_clear_tty(task_session(current));
1637         read_unlock(&tasklist_lock);
1638         unlock_kernel();
1639 }
1640
1641 /**
1642  *
1643  *      no_tty  - Ensure the current process does not have a controlling tty
1644  */
1645 void no_tty(void)
1646 {
1647         struct task_struct *tsk = current;
1648         if (tsk->signal->leader)
1649                 disassociate_ctty(0);
1650         proc_clear_tty(tsk);
1651 }
1652
1653
1654 /**
1655  *      stop_tty        -       propagate flow control
1656  *      @tty: tty to stop
1657  *
1658  *      Perform flow control to the driver. For PTY/TTY pairs we
1659  *      must also propagate the TIOCKPKT status. May be called
1660  *      on an already stopped device and will not re-call the driver
1661  *      method.
1662  *
1663  *      This functionality is used by both the line disciplines for
1664  *      halting incoming flow and by the driver. It may therefore be
1665  *      called from any context, may be under the tty atomic_write_lock
1666  *      but not always.
1667  *
1668  *      Locking:
1669  *              Broken. Relies on BKL which is unsafe here.
1670  */
1671
1672 void stop_tty(struct tty_struct *tty)
1673 {
1674         if (tty->stopped)
1675                 return;
1676         tty->stopped = 1;
1677         if (tty->link && tty->link->packet) {
1678                 tty->ctrl_status &= ~TIOCPKT_START;
1679                 tty->ctrl_status |= TIOCPKT_STOP;
1680                 wake_up_interruptible(&tty->link->read_wait);
1681         }
1682         if (tty->driver->stop)
1683                 (tty->driver->stop)(tty);
1684 }
1685
1686 EXPORT_SYMBOL(stop_tty);
1687
1688 /**
1689  *      start_tty       -       propagate flow control
1690  *      @tty: tty to start
1691  *
1692  *      Start a tty that has been stopped if at all possible. Perform
1693  *      any neccessary wakeups and propagate the TIOCPKT status. If this
1694  *      is the tty was previous stopped and is being started then the
1695  *      driver start method is invoked and the line discipline woken.
1696  *
1697  *      Locking:
1698  *              Broken. Relies on BKL which is unsafe here.
1699  */
1700
1701 void start_tty(struct tty_struct *tty)
1702 {
1703         if (!tty->stopped || tty->flow_stopped)
1704                 return;
1705         tty->stopped = 0;
1706         if (tty->link && tty->link->packet) {
1707                 tty->ctrl_status &= ~TIOCPKT_STOP;
1708                 tty->ctrl_status |= TIOCPKT_START;
1709                 wake_up_interruptible(&tty->link->read_wait);
1710         }
1711         if (tty->driver->start)
1712                 (tty->driver->start)(tty);
1713
1714         /* If we have a running line discipline it may need kicking */
1715         tty_wakeup(tty);
1716 }
1717
1718 EXPORT_SYMBOL(start_tty);
1719
1720 /**
1721  *      tty_read        -       read method for tty device files
1722  *      @file: pointer to tty file
1723  *      @buf: user buffer
1724  *      @count: size of user buffer
1725  *      @ppos: unused
1726  *
1727  *      Perform the read system call function on this terminal device. Checks
1728  *      for hung up devices before calling the line discipline method.
1729  *
1730  *      Locking:
1731  *              Locks the line discipline internally while needed
1732  *              For historical reasons the line discipline read method is
1733  *      invoked under the BKL. This will go away in time so do not rely on it
1734  *      in new code. Multiple read calls may be outstanding in parallel.
1735  */
1736
1737 static ssize_t tty_read(struct file * file, char __user * buf, size_t count, 
1738                         loff_t *ppos)
1739 {
1740         int i;
1741         struct tty_struct * tty;
1742         struct inode *inode;
1743         struct tty_ldisc *ld;
1744
1745         tty = (struct tty_struct *)file->private_data;
1746         inode = file->f_path.dentry->d_inode;
1747         if (tty_paranoia_check(tty, inode, "tty_read"))
1748                 return -EIO;
1749         if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1750                 return -EIO;
1751
1752         /* We want to wait for the line discipline to sort out in this
1753            situation */
1754         ld = tty_ldisc_ref_wait(tty);
1755         lock_kernel();
1756         if (ld->read)
1757                 i = (ld->read)(tty,file,buf,count);
1758         else
1759                 i = -EIO;
1760         tty_ldisc_deref(ld);
1761         unlock_kernel();
1762         if (i > 0)
1763                 inode->i_atime = current_fs_time(inode->i_sb);
1764         return i;
1765 }
1766
1767 void tty_write_unlock(struct tty_struct *tty)
1768 {
1769         mutex_unlock(&tty->atomic_write_lock);
1770         wake_up_interruptible(&tty->write_wait);
1771 }
1772
1773 int tty_write_lock(struct tty_struct *tty, int ndelay)
1774 {
1775         if (!mutex_trylock(&tty->atomic_write_lock)) {
1776                 if (ndelay)
1777                         return -EAGAIN;
1778                 if (mutex_lock_interruptible(&tty->atomic_write_lock))
1779                         return -ERESTARTSYS;
1780         }
1781         return 0;
1782 }
1783
1784 /*
1785  * Split writes up in sane blocksizes to avoid
1786  * denial-of-service type attacks
1787  */
1788 static inline ssize_t do_tty_write(
1789         ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1790         struct tty_struct *tty,
1791         struct file *file,
1792         const char __user *buf,
1793         size_t count)
1794 {
1795         ssize_t ret, written = 0;
1796         unsigned int chunk;
1797         
1798         ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1799         if (ret < 0)
1800                 return ret;
1801
1802         /*
1803          * We chunk up writes into a temporary buffer. This
1804          * simplifies low-level drivers immensely, since they
1805          * don't have locking issues and user mode accesses.
1806          *
1807          * But if TTY_NO_WRITE_SPLIT is set, we should use a
1808          * big chunk-size..
1809          *
1810          * The default chunk-size is 2kB, because the NTTY
1811          * layer has problems with bigger chunks. It will
1812          * claim to be able to handle more characters than
1813          * it actually does.
1814          *
1815          * FIXME: This can probably go away now except that 64K chunks
1816          * are too likely to fail unless switched to vmalloc...
1817          */
1818         chunk = 2048;
1819         if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1820                 chunk = 65536;
1821         if (count < chunk)
1822                 chunk = count;
1823
1824         /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1825         if (tty->write_cnt < chunk) {
1826                 unsigned char *buf;
1827
1828                 if (chunk < 1024)
1829                         chunk = 1024;
1830
1831                 buf = kmalloc(chunk, GFP_KERNEL);
1832                 if (!buf) {
1833                         ret = -ENOMEM;
1834                         goto out;
1835                 }
1836                 kfree(tty->write_buf);
1837                 tty->write_cnt = chunk;
1838                 tty->write_buf = buf;
1839         }
1840
1841         /* Do the write .. */
1842         for (;;) {
1843                 size_t size = count;
1844                 if (size > chunk)
1845                         size = chunk;
1846                 ret = -EFAULT;
1847                 if (copy_from_user(tty->write_buf, buf, size))
1848                         break;
1849                 lock_kernel();
1850                 ret = write(tty, file, tty->write_buf, size);
1851                 unlock_kernel();
1852                 if (ret <= 0)
1853                         break;
1854                 written += ret;
1855                 buf += ret;
1856                 count -= ret;
1857                 if (!count)
1858                         break;
1859                 ret = -ERESTARTSYS;
1860                 if (signal_pending(current))
1861                         break;
1862                 cond_resched();
1863         }
1864         if (written) {
1865                 struct inode *inode = file->f_path.dentry->d_inode;
1866                 inode->i_mtime = current_fs_time(inode->i_sb);
1867                 ret = written;
1868         }
1869 out:
1870         tty_write_unlock(tty);
1871         return ret;
1872 }
1873
1874
1875 /**
1876  *      tty_write               -       write method for tty device file
1877  *      @file: tty file pointer
1878  *      @buf: user data to write
1879  *      @count: bytes to write
1880  *      @ppos: unused
1881  *
1882  *      Write data to a tty device via the line discipline.
1883  *
1884  *      Locking:
1885  *              Locks the line discipline as required
1886  *              Writes to the tty driver are serialized by the atomic_write_lock
1887  *      and are then processed in chunks to the device. The line discipline
1888  *      write method will not be involked in parallel for each device
1889  *              The line discipline write method is called under the big
1890  *      kernel lock for historical reasons. New code should not rely on this.
1891  */
1892
1893 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1894                          loff_t *ppos)
1895 {
1896         struct tty_struct * tty;
1897         struct inode *inode = file->f_path.dentry->d_inode;
1898         ssize_t ret;
1899         struct tty_ldisc *ld;
1900         
1901         tty = (struct tty_struct *)file->private_data;
1902         if (tty_paranoia_check(tty, inode, "tty_write"))
1903                 return -EIO;
1904         if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1905                 return -EIO;
1906
1907         ld = tty_ldisc_ref_wait(tty);           
1908         if (!ld->write)
1909                 ret = -EIO;
1910         else
1911                 ret = do_tty_write(ld->write, tty, file, buf, count);
1912         tty_ldisc_deref(ld);
1913         return ret;
1914 }
1915
1916 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1917                          loff_t *ppos)
1918 {
1919         struct file *p = NULL;
1920
1921         spin_lock(&redirect_lock);
1922         if (redirect) {
1923                 get_file(redirect);
1924                 p = redirect;
1925         }
1926         spin_unlock(&redirect_lock);
1927
1928         if (p) {
1929                 ssize_t res;
1930                 res = vfs_write(p, buf, count, &p->f_pos);
1931                 fput(p);
1932                 return res;
1933         }
1934
1935         return tty_write(file, buf, count, ppos);
1936 }
1937
1938 static char ptychar[] = "pqrstuvwxyzabcde";
1939
1940 /**
1941  *      pty_line_name   -       generate name for a pty
1942  *      @driver: the tty driver in use
1943  *      @index: the minor number
1944  *      @p: output buffer of at least 6 bytes
1945  *
1946  *      Generate a name from a driver reference and write it to the output
1947  *      buffer.
1948  *
1949  *      Locking: None
1950  */
1951 static void pty_line_name(struct tty_driver *driver, int index, char *p)
1952 {
1953         int i = index + driver->name_base;
1954         /* ->name is initialized to "ttyp", but "tty" is expected */
1955         sprintf(p, "%s%c%x",
1956                         driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1957                         ptychar[i >> 4 & 0xf], i & 0xf);
1958 }
1959
1960 /**
1961  *      pty_line_name   -       generate name for a tty
1962  *      @driver: the tty driver in use
1963  *      @index: the minor number
1964  *      @p: output buffer of at least 7 bytes
1965  *
1966  *      Generate a name from a driver reference and write it to the output
1967  *      buffer.
1968  *
1969  *      Locking: None
1970  */
1971 static void tty_line_name(struct tty_driver *driver, int index, char *p)
1972 {
1973         sprintf(p, "%s%d", driver->name, index + driver->name_base);
1974 }
1975
1976 /**
1977  *      init_dev                -       initialise a tty device
1978  *      @driver: tty driver we are opening a device on
1979  *      @idx: device index
1980  *      @tty: returned tty structure
1981  *
1982  *      Prepare a tty device. This may not be a "new" clean device but
1983  *      could also be an active device. The pty drivers require special
1984  *      handling because of this.
1985  *
1986  *      Locking:
1987  *              The function is called under the tty_mutex, which
1988  *      protects us from the tty struct or driver itself going away.
1989  *
1990  *      On exit the tty device has the line discipline attached and
1991  *      a reference count of 1. If a pair was created for pty/tty use
1992  *      and the other was a pty master then it too has a reference count of 1.
1993  *
1994  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1995  * failed open.  The new code protects the open with a mutex, so it's
1996  * really quite straightforward.  The mutex locking can probably be
1997  * relaxed for the (most common) case of reopening a tty.
1998  */
1999
2000 static int init_dev(struct tty_driver *driver, int idx,
2001         struct tty_struct **ret_tty)
2002 {
2003         struct tty_struct *tty, *o_tty;
2004         struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
2005         struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
2006         int retval = 0;
2007
2008         /* check whether we're reopening an existing tty */
2009         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2010                 tty = devpts_get_tty(idx);
2011                 /*
2012                  * If we don't have a tty here on a slave open, it's because
2013                  * the master already started the close process and there's
2014                  * no relation between devpts file and tty anymore.
2015                  */
2016                 if (!tty && driver->subtype == PTY_TYPE_SLAVE) {
2017                         retval = -EIO;
2018                         goto end_init;
2019                 }
2020                 /*
2021                  * It's safe from now on because init_dev() is called with
2022                  * tty_mutex held and release_dev() won't change tty->count
2023                  * or tty->flags without having to grab tty_mutex
2024                  */
2025                 if (tty && driver->subtype == PTY_TYPE_MASTER)
2026                         tty = tty->link;
2027         } else {
2028                 tty = driver->ttys[idx];
2029         }
2030         if (tty) goto fast_track;
2031
2032         /*
2033          * First time open is complex, especially for PTY devices.
2034          * This code guarantees that either everything succeeds and the
2035          * TTY is ready for operation, or else the table slots are vacated
2036          * and the allocated memory released.  (Except that the termios 
2037          * and locked termios may be retained.)
2038          */
2039
2040         if (!try_module_get(driver->owner)) {
2041                 retval = -ENODEV;
2042                 goto end_init;
2043         }
2044
2045         o_tty = NULL;
2046         tp = o_tp = NULL;
2047         ltp = o_ltp = NULL;
2048
2049         tty = alloc_tty_struct();
2050         if(!tty)
2051                 goto fail_no_mem;
2052         initialize_tty_struct(tty);
2053         tty->driver = driver;
2054         tty->index = idx;
2055         tty_line_name(driver, idx, tty->name);
2056
2057         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2058                 tp_loc = &tty->termios;
2059                 ltp_loc = &tty->termios_locked;
2060         } else {
2061                 tp_loc = &driver->termios[idx];
2062                 ltp_loc = &driver->termios_locked[idx];
2063         }
2064
2065         if (!*tp_loc) {
2066                 tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
2067                 if (!tp)
2068                         goto free_mem_out;
2069                 *tp = driver->init_termios;
2070         }
2071
2072         if (!*ltp_loc) {
2073                 ltp = kzalloc(sizeof(struct ktermios), GFP_KERNEL);
2074                 if (!ltp)
2075                         goto free_mem_out;
2076         }
2077
2078         if (driver->type == TTY_DRIVER_TYPE_PTY) {
2079                 o_tty = alloc_tty_struct();
2080                 if (!o_tty)
2081                         goto free_mem_out;
2082                 initialize_tty_struct(o_tty);
2083                 o_tty->driver = driver->other;
2084                 o_tty->index = idx;
2085                 tty_line_name(driver->other, idx, o_tty->name);
2086
2087                 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
2088                         o_tp_loc = &o_tty->termios;
2089                         o_ltp_loc = &o_tty->termios_locked;
2090                 } else {
2091                         o_tp_loc = &driver->other->termios[idx];
2092                         o_ltp_loc = &driver->other->termios_locked[idx];
2093                 }
2094
2095                 if (!*o_tp_loc) {
2096                         o_tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
2097                         if (!o_tp)
2098                                 goto free_mem_out;
2099                         *o_tp = driver->other->init_termios;
2100                 }
2101
2102                 if (!*o_ltp_loc) {
2103                         o_ltp = kzalloc(sizeof(struct ktermios), GFP_KERNEL);
2104                         if (!o_ltp)
2105                                 goto free_mem_out;
2106                 }
2107
2108                 /*
2109                  * Everything allocated ... set up the o_tty structure.
2110                  */
2111                 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
2112                         driver->other->ttys[idx] = o_tty;
2113                 }
2114                 if (!*o_tp_loc)
2115                         *o_tp_loc = o_tp;
2116                 if (!*o_ltp_loc)
2117                         *o_ltp_loc = o_ltp;
2118                 o_tty->termios = *o_tp_loc;
2119                 o_tty->termios_locked = *o_ltp_loc;
2120                 driver->other->refcount++;
2121                 if (driver->subtype == PTY_TYPE_MASTER)
2122                         o_tty->count++;
2123
2124                 /* Establish the links in both directions */
2125                 tty->link   = o_tty;
2126                 o_tty->link = tty;
2127         }
2128
2129         /* 
2130          * All structures have been allocated, so now we install them.
2131          * Failures after this point use release_tty to clean up, so
2132          * there's no need to null out the local pointers.
2133          */
2134         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2135                 driver->ttys[idx] = tty;
2136         }
2137         
2138         if (!*tp_loc)
2139                 *tp_loc = tp;
2140         if (!*ltp_loc)
2141                 *ltp_loc = ltp;
2142         tty->termios = *tp_loc;
2143         tty->termios_locked = *ltp_loc;
2144         /* Compatibility until drivers always set this */
2145         tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
2146         tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
2147         driver->refcount++;
2148         tty->count++;
2149
2150         /* 
2151          * Structures all installed ... call the ldisc open routines.
2152          * If we fail here just call release_tty to clean up.  No need
2153          * to decrement the use counts, as release_tty doesn't care.
2154          */
2155
2156         if (tty->ldisc.open) {
2157                 retval = (tty->ldisc.open)(tty);
2158                 if (retval)
2159                         goto release_mem_out;
2160         }
2161         if (o_tty && o_tty->ldisc.open) {
2162                 retval = (o_tty->ldisc.open)(o_tty);
2163                 if (retval) {
2164                         if (tty->ldisc.close)
2165                                 (tty->ldisc.close)(tty);
2166                         goto release_mem_out;
2167                 }
2168                 tty_ldisc_enable(o_tty);
2169         }
2170         tty_ldisc_enable(tty);
2171         goto success;
2172
2173         /*
2174          * This fast open can be used if the tty is already open.
2175          * No memory is allocated, and the only failures are from
2176          * attempting to open a closing tty or attempting multiple
2177          * opens on a pty master.
2178          */
2179 fast_track:
2180         if (test_bit(TTY_CLOSING, &tty->flags)) {
2181                 retval = -EIO;
2182                 goto end_init;
2183         }
2184         if (driver->type == TTY_DRIVER_TYPE_PTY &&
2185             driver->subtype == PTY_TYPE_MASTER) {
2186                 /*
2187                  * special case for PTY masters: only one open permitted, 
2188                  * and the slave side open count is incremented as well.
2189                  */
2190                 if (tty->count) {
2191                         retval = -EIO;
2192                         goto end_init;
2193                 }
2194                 tty->link->count++;
2195         }
2196         tty->count++;
2197         tty->driver = driver; /* N.B. why do this every time?? */
2198
2199         /* FIXME */
2200         if(!test_bit(TTY_LDISC, &tty->flags))
2201                 printk(KERN_ERR "init_dev but no ldisc\n");
2202 success:
2203         *ret_tty = tty;
2204         
2205         /* All paths come through here to release the mutex */
2206 end_init:
2207         return retval;
2208
2209         /* Release locally allocated memory ... nothing placed in slots */
2210 free_mem_out:
2211         kfree(o_tp);
2212         if (o_tty)
2213                 free_tty_struct(o_tty);
2214         kfree(ltp);
2215         kfree(tp);
2216         free_tty_struct(tty);
2217
2218 fail_no_mem:
2219         module_put(driver->owner);
2220         retval = -ENOMEM;
2221         goto end_init;
2222
2223         /* call the tty release_tty routine to clean out this slot */
2224 release_mem_out:
2225         if (printk_ratelimit())
2226                 printk(KERN_INFO "init_dev: ldisc open failed, "
2227                                  "clearing slot %d\n", idx);
2228         release_tty(tty, idx);
2229         goto end_init;
2230 }
2231
2232 /**
2233  *      release_one_tty         -       release tty structure memory
2234  *
2235  *      Releases memory associated with a tty structure, and clears out the
2236  *      driver table slots. This function is called when a device is no longer
2237  *      in use. It also gets called when setup of a device fails.
2238  *
2239  *      Locking:
2240  *              tty_mutex - sometimes only
2241  *              takes the file list lock internally when working on the list
2242  *      of ttys that the driver keeps.
2243  *              FIXME: should we require tty_mutex is held here ??
2244  */
2245 static void release_one_tty(struct tty_struct *tty, int idx)
2246 {
2247         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
2248         struct ktermios *tp;
2249
2250         if (!devpts)
2251                 tty->driver->ttys[idx] = NULL;
2252
2253         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
2254                 tp = tty->termios;
2255                 if (!devpts)
2256                         tty->driver->termios[idx] = NULL;
2257                 kfree(tp);
2258
2259                 tp = tty->termios_locked;
2260                 if (!devpts)
2261                         tty->driver->termios_locked[idx] = NULL;
2262                 kfree(tp);
2263         }
2264
2265
2266         tty->magic = 0;
2267         tty->driver->refcount--;
2268
2269         file_list_lock();
2270         list_del_init(&tty->tty_files);
2271         file_list_unlock();
2272
2273         free_tty_struct(tty);
2274 }
2275
2276 /**
2277  *      release_tty             -       release tty structure memory
2278  *
2279  *      Release both @tty and a possible linked partner (think pty pair),
2280  *      and decrement the refcount of the backing module.
2281  *
2282  *      Locking:
2283  *              tty_mutex - sometimes only
2284  *              takes the file list lock internally when working on the list
2285  *      of ttys that the driver keeps.
2286  *              FIXME: should we require tty_mutex is held here ??
2287  */
2288 static void release_tty(struct tty_struct *tty, int idx)
2289 {
2290         struct tty_driver *driver = tty->driver;
2291
2292         if (tty->link)
2293                 release_one_tty(tty->link, idx);
2294         release_one_tty(tty, idx);
2295         module_put(driver->owner);
2296 }
2297
2298 /*
2299  * Even releasing the tty structures is a tricky business.. We have
2300  * to be very careful that the structures are all released at the
2301  * same time, as interrupts might otherwise get the wrong pointers.
2302  *
2303  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
2304  * lead to double frees or releasing memory still in use.
2305  */
2306 static void release_dev(struct file * filp)
2307 {
2308         struct tty_struct *tty, *o_tty;
2309         int     pty_master, tty_closing, o_tty_closing, do_sleep;
2310         int     devpts;
2311         int     idx;
2312         char    buf[64];
2313         unsigned long flags;
2314         
2315         tty = (struct tty_struct *)filp->private_data;
2316         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))
2317                 return;
2318
2319         check_tty_count(tty, "release_dev");
2320
2321         tty_fasync(-1, filp, 0);
2322
2323         idx = tty->index;
2324         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2325                       tty->driver->subtype == PTY_TYPE_MASTER);
2326         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
2327         o_tty = tty->link;
2328
2329 #ifdef TTY_PARANOIA_CHECK
2330         if (idx < 0 || idx >= tty->driver->num) {
2331                 printk(KERN_DEBUG "release_dev: bad idx when trying to "
2332                                   "free (%s)\n", tty->name);
2333                 return;
2334         }
2335         if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2336                 if (tty != tty->driver->ttys[idx]) {
2337                         printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
2338                                "for (%s)\n", idx, tty->name);
2339                         return;
2340                 }
2341                 if (tty->termios != tty->driver->termios[idx]) {
2342                         printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
2343                                "for (%s)\n",
2344                                idx, tty->name);
2345                         return;
2346                 }
2347                 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
2348                         printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
2349                                "termios_locked for (%s)\n",
2350                                idx, tty->name);
2351                         return;
2352                 }
2353         }
2354 #endif
2355
2356 #ifdef TTY_DEBUG_HANGUP
2357         printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
2358                tty_name(tty, buf), tty->count);
2359 #endif
2360
2361 #ifdef TTY_PARANOIA_CHECK
2362         if (tty->driver->other &&
2363              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2364                 if (o_tty != tty->driver->other->ttys[idx]) {
2365                         printk(KERN_DEBUG "release_dev: other->table[%d] "
2366                                           "not o_tty for (%s)\n",
2367                                idx, tty->name);
2368                         return;
2369                 }
2370                 if (o_tty->termios != tty->driver->other->termios[idx]) {
2371                         printk(KERN_DEBUG "release_dev: other->termios[%d] "
2372                                           "not o_termios for (%s)\n",
2373                                idx, tty->name);
2374                         return;
2375                 }
2376                 if (o_tty->termios_locked != 
2377                       tty->driver->other->termios_locked[idx]) {
2378                         printk(KERN_DEBUG "release_dev: other->termios_locked["
2379                                           "%d] not o_termios_locked for (%s)\n",
2380                                idx, tty->name);
2381                         return;
2382                 }
2383                 if (o_tty->link != tty) {
2384                         printk(KERN_DEBUG "release_dev: bad pty pointers\n");
2385                         return;
2386                 }
2387         }
2388 #endif
2389         if (tty->driver->close)
2390                 tty->driver->close(tty, filp);
2391
2392         /*
2393          * Sanity check: if tty->count is going to zero, there shouldn't be
2394          * any waiters on tty->read_wait or tty->write_wait.  We test the
2395          * wait queues and kick everyone out _before_ actually starting to
2396          * close.  This ensures that we won't block while releasing the tty
2397          * structure.
2398          *
2399          * The test for the o_tty closing is necessary, since the master and
2400          * slave sides may close in any order.  If the slave side closes out
2401          * first, its count will be one, since the master side holds an open.
2402          * Thus this test wouldn't be triggered at the time the slave closes,
2403          * so we do it now.
2404          *
2405          * Note that it's possible for the tty to be opened again while we're
2406          * flushing out waiters.  By recalculating the closing flags before
2407          * each iteration we avoid any problems.
2408          */
2409         while (1) {
2410                 /* Guard against races with tty->count changes elsewhere and
2411                    opens on /dev/tty */
2412                    
2413                 mutex_lock(&tty_mutex);
2414                 tty_closing = tty->count <= 1;
2415                 o_tty_closing = o_tty &&
2416                         (o_tty->count <= (pty_master ? 1 : 0));
2417                 do_sleep = 0;
2418
2419                 if (tty_closing) {
2420                         if (waitqueue_active(&tty->read_wait)) {
2421                                 wake_up(&tty->read_wait);
2422                                 do_sleep++;
2423                         }
2424                         if (waitqueue_active(&tty->write_wait)) {
2425                                 wake_up(&tty->write_wait);
2426                                 do_sleep++;
2427                         }
2428                 }
2429                 if (o_tty_closing) {
2430                         if (waitqueue_active(&o_tty->read_wait)) {
2431                                 wake_up(&o_tty->read_wait);
2432                                 do_sleep++;
2433                         }
2434                         if (waitqueue_active(&o_tty->write_wait)) {
2435                                 wake_up(&o_tty->write_wait);
2436                                 do_sleep++;
2437                         }
2438                 }
2439                 if (!do_sleep)
2440                         break;
2441
2442                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
2443                                     "active!\n", tty_name(tty, buf));
2444                 mutex_unlock(&tty_mutex);
2445                 schedule();
2446         }       
2447
2448         /*
2449          * The closing flags are now consistent with the open counts on 
2450          * both sides, and we've completed the last operation that could 
2451          * block, so it's safe to proceed with closing.
2452          */
2453         if (pty_master) {
2454                 if (--o_tty->count < 0) {
2455                         printk(KERN_WARNING "release_dev: bad pty slave count "
2456                                             "(%d) for %s\n",
2457                                o_tty->count, tty_name(o_tty, buf));
2458                         o_tty->count = 0;
2459                 }
2460         }
2461         if (--tty->count < 0) {
2462                 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
2463                        tty->count, tty_name(tty, buf));
2464                 tty->count = 0;
2465         }
2466         
2467         /*
2468          * We've decremented tty->count, so we need to remove this file
2469          * descriptor off the tty->tty_files list; this serves two
2470          * purposes:
2471          *  - check_tty_count sees the correct number of file descriptors
2472          *    associated with this tty.
2473          *  - do_tty_hangup no longer sees this file descriptor as
2474          *    something that needs to be handled for hangups.
2475          */
2476         file_kill(filp);
2477         filp->private_data = NULL;
2478
2479         /*
2480          * Perform some housekeeping before deciding whether to return.
2481          *
2482          * Set the TTY_CLOSING flag if this was the last open.  In the
2483          * case of a pty we may have to wait around for the other side
2484          * to close, and TTY_CLOSING makes sure we can't be reopened.
2485          */
2486         if(tty_closing)
2487                 set_bit(TTY_CLOSING, &tty->flags);
2488         if(o_tty_closing)
2489                 set_bit(TTY_CLOSING, &o_tty->flags);
2490
2491         /*
2492          * If _either_ side is closing, make sure there aren't any
2493          * processes that still think tty or o_tty is their controlling
2494          * tty.
2495          */
2496         if (tty_closing || o_tty_closing) {
2497                 read_lock(&tasklist_lock);
2498                 session_clear_tty(tty->session);
2499                 if (o_tty)
2500                         session_clear_tty(o_tty->session);
2501                 read_unlock(&tasklist_lock);
2502         }
2503
2504         mutex_unlock(&tty_mutex);
2505
2506         /* check whether both sides are closing ... */
2507         if (!tty_closing || (o_tty && !o_tty_closing))
2508                 return;
2509         
2510 #ifdef TTY_DEBUG_HANGUP
2511         printk(KERN_DEBUG "freeing tty structure...");
2512 #endif
2513         /*
2514          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
2515          * kill any delayed work. As this is the final close it does not
2516          * race with the set_ldisc code path.
2517          */
2518         clear_bit(TTY_LDISC, &tty->flags);
2519         cancel_delayed_work(&tty->buf.work);
2520
2521         /*
2522          * Wait for ->hangup_work and ->buf.work handlers to terminate
2523          */
2524          
2525         flush_scheduled_work();
2526         
2527         /*
2528          * Wait for any short term users (we know they are just driver
2529          * side waiters as the file is closing so user count on the file
2530          * side is zero.
2531          */
2532         spin_lock_irqsave(&tty_ldisc_lock, flags);
2533         while(tty->ldisc.refcount)
2534         {
2535                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2536                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
2537                 spin_lock_irqsave(&tty_ldisc_lock, flags);
2538         }
2539         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
2540         /*
2541          * Shutdown the current line discipline, and reset it to N_TTY.
2542          * N.B. why reset ldisc when we're releasing the memory??
2543          *
2544          * FIXME: this MUST get fixed for the new reflocking
2545          */
2546         if (tty->ldisc.close)
2547                 (tty->ldisc.close)(tty);
2548         tty_ldisc_put(tty->ldisc.num);
2549         
2550         /*
2551          *      Switch the line discipline back
2552          */
2553         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2554         tty_set_termios_ldisc(tty,N_TTY); 
2555         if (o_tty) {
2556                 /* FIXME: could o_tty be in setldisc here ? */
2557                 clear_bit(TTY_LDISC, &o_tty->flags);
2558                 if (o_tty->ldisc.close)
2559                         (o_tty->ldisc.close)(o_tty);
2560                 tty_ldisc_put(o_tty->ldisc.num);
2561                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
2562                 tty_set_termios_ldisc(o_tty,N_TTY); 
2563         }
2564         /*
2565          * The release_tty function takes care of the details of clearing
2566          * the slots and preserving the termios structure.
2567          */
2568         release_tty(tty, idx);
2569
2570 #ifdef CONFIG_UNIX98_PTYS
2571         /* Make this pty number available for reallocation */
2572         if (devpts) {
2573                 down(&allocated_ptys_lock);
2574                 idr_remove(&allocated_ptys, idx);
2575                 up(&allocated_ptys_lock);
2576         }
2577 #endif
2578
2579 }
2580
2581 /**
2582  *      tty_open                -       open a tty device
2583  *      @inode: inode of device file
2584  *      @filp: file pointer to tty
2585  *
2586  *      tty_open and tty_release keep up the tty count that contains the
2587  *      number of opens done on a tty. We cannot use the inode-count, as
2588  *      different inodes might point to the same tty.
2589  *
2590  *      Open-counting is needed for pty masters, as well as for keeping
2591  *      track of serial lines: DTR is dropped when the last close happens.
2592  *      (This is not done solely through tty->count, now.  - Ted 1/27/92)
2593  *
2594  *      The termios state of a pty is reset on first open so that
2595  *      settings don't persist across reuse.
2596  *
2597  *      Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
2598  *               tty->count should protect the rest.
2599  *               ->siglock protects ->signal/->sighand
2600  */
2601
2602 static int tty_open(struct inode * inode, struct file * filp)
2603 {
2604         struct tty_struct *tty;
2605         int noctty, retval;
2606         struct tty_driver *driver;
2607         int index;
2608         dev_t device = inode->i_rdev;
2609         unsigned short saved_flags = filp->f_flags;
2610
2611         nonseekable_open(inode, filp);
2612         
2613 retry_open:
2614         noctty = filp->f_flags & O_NOCTTY;
2615         index  = -1;
2616         retval = 0;
2617         
2618         mutex_lock(&tty_mutex);
2619
2620         if (device == MKDEV(TTYAUX_MAJOR,0)) {
2621                 tty = get_current_tty();
2622                 if (!tty) {
2623                         mutex_unlock(&tty_mutex);
2624                         return -ENXIO;
2625                 }
2626                 driver = tty->driver;
2627                 index = tty->index;
2628                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
2629                 /* noctty = 1; */
2630                 goto got_driver;
2631         }
2632 #ifdef CONFIG_VT
2633         if (device == MKDEV(TTY_MAJOR,0)) {
2634                 extern struct tty_driver *console_driver;
2635                 driver = console_driver;
2636                 index = fg_console;
2637                 noctty = 1;
2638                 goto got_driver;
2639         }
2640 #endif
2641         if (device == MKDEV(TTYAUX_MAJOR,1)) {
2642                 driver = console_device(&index);
2643                 if (driver) {
2644                         /* Don't let /dev/console block */
2645                         filp->f_flags |= O_NONBLOCK;
2646                         noctty = 1;
2647                         goto got_driver;
2648                 }
2649                 mutex_unlock(&tty_mutex);
2650                 return -ENODEV;
2651         }
2652
2653         driver = get_tty_driver(device, &index);
2654         if (!driver) {
2655                 mutex_unlock(&tty_mutex);
2656                 return -ENODEV;
2657         }
2658 got_driver:
2659         retval = init_dev(driver, index, &tty);
2660         mutex_unlock(&tty_mutex);
2661         if (retval)
2662                 return retval;
2663
2664         filp->private_data = tty;
2665         file_move(filp, &tty->tty_files);
2666         check_tty_count(tty, "tty_open");
2667         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2668             tty->driver->subtype == PTY_TYPE_MASTER)
2669                 noctty = 1;
2670 #ifdef TTY_DEBUG_HANGUP
2671         printk(KERN_DEBUG "opening %s...", tty->name);
2672 #endif
2673         if (!retval) {
2674                 if (tty->driver->open)
2675                         retval = tty->driver->open(tty, filp);
2676                 else
2677                         retval = -ENODEV;
2678         }
2679         filp->f_flags = saved_flags;
2680
2681         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
2682                 retval = -EBUSY;
2683
2684         if (retval) {
2685 #ifdef TTY_DEBUG_HANGUP
2686                 printk(KERN_DEBUG "error %d in opening %s...", retval,
2687                        tty->name);
2688 #endif
2689                 release_dev(filp);
2690                 if (retval != -ERESTARTSYS)
2691                         return retval;
2692                 if (signal_pending(current))
2693                         return retval;
2694                 schedule();
2695                 /*
2696                  * Need to reset f_op in case a hangup happened.
2697                  */
2698                 if (filp->f_op == &hung_up_tty_fops)
2699                         filp->f_op = &tty_fops;
2700                 goto retry_open;
2701         }
2702
2703         mutex_lock(&tty_mutex);
2704         spin_lock_irq(&current->sighand->siglock);
2705         if (!noctty &&
2706             current->signal->leader &&
2707             !current->signal->tty &&
2708             tty->session == NULL)
2709                 __proc_set_tty(current, tty);
2710         spin_unlock_irq(&current->sighand->siglock);
2711         mutex_unlock(&tty_mutex);
2712         tty_audit_opening();
2713         return 0;
2714 }
2715
2716 #ifdef CONFIG_UNIX98_PTYS
2717 /**
2718  *      ptmx_open               -       open a unix 98 pty master
2719  *      @inode: inode of device file
2720  *      @filp: file pointer to tty
2721  *
2722  *      Allocate a unix98 pty master device from the ptmx driver.
2723  *
2724  *      Locking: tty_mutex protects theinit_dev work. tty->count should
2725                 protect the rest.
2726  *              allocated_ptys_lock handles the list of free pty numbers
2727  */
2728
2729 static int ptmx_open(struct inode * inode, struct file * filp)
2730 {
2731         struct tty_struct *tty;
2732         int retval;
2733         int index;
2734         int idr_ret;
2735
2736         nonseekable_open(inode, filp);
2737
2738         /* find a device that is not in use. */
2739         down(&allocated_ptys_lock);
2740         if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
2741                 up(&allocated_ptys_lock);
2742                 return -ENOMEM;
2743         }
2744         idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
2745         if (idr_ret < 0) {
2746                 up(&allocated_ptys_lock);
2747                 if (idr_ret == -EAGAIN)
2748                         return -ENOMEM;
2749                 return -EIO;
2750         }
2751         if (index >= pty_limit) {
2752                 idr_remove(&allocated_ptys, index);
2753                 up(&allocated_ptys_lock);
2754                 return -EIO;
2755         }
2756         up(&allocated_ptys_lock);
2757
2758         mutex_lock(&tty_mutex);
2759         retval = init_dev(ptm_driver, index, &tty);
2760         mutex_unlock(&tty_mutex);
2761         
2762         if (retval)
2763                 goto out;
2764
2765         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
2766         filp->private_data = tty;
2767         file_move(filp, &tty->tty_files);
2768
2769         retval = -ENOMEM;
2770         if (devpts_pty_new(tty->link))
2771                 goto out1;
2772
2773         check_tty_count(tty, "tty_open");
2774         retval = ptm_driver->open(tty, filp);
2775         if (!retval) {
2776                 tty_audit_opening();
2777                 return 0;
2778         }
2779 out1:
2780         release_dev(filp);
2781         return retval;
2782 out:
2783         down(&allocated_ptys_lock);
2784         idr_remove(&allocated_ptys, index);
2785         up(&allocated_ptys_lock);
2786         return retval;
2787 }
2788 #endif
2789
2790 /**
2791  *      tty_release             -       vfs callback for close
2792  *      @inode: inode of tty
2793  *      @filp: file pointer for handle to tty
2794  *
2795  *      Called the last time each file handle is closed that references
2796  *      this tty. There may however be several such references.
2797  *
2798  *      Locking:
2799  *              Takes bkl. See release_dev
2800  */
2801
2802 static int tty_release(struct inode * inode, struct file * filp)
2803 {
2804         lock_kernel();
2805         release_dev(filp);
2806         unlock_kernel();
2807         return 0;
2808 }
2809
2810 /**
2811  *      tty_poll        -       check tty status
2812  *      @filp: file being polled
2813  *      @wait: poll wait structures to update
2814  *
2815  *      Call the line discipline polling method to obtain the poll
2816  *      status of the device.
2817  *
2818  *      Locking: locks called line discipline but ldisc poll method
2819  *      may be re-entered freely by other callers.
2820  */
2821
2822 static unsigned int tty_poll(struct file * filp, poll_table * wait)
2823 {
2824         struct tty_struct * tty;
2825         struct tty_ldisc *ld;
2826         int ret = 0;
2827
2828         tty = (struct tty_struct *)filp->private_data;
2829         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
2830                 return 0;
2831                 
2832         ld = tty_ldisc_ref_wait(tty);
2833         if (ld->poll)
2834                 ret = (ld->poll)(tty, filp, wait);
2835         tty_ldisc_deref(ld);
2836         return ret;
2837 }
2838
2839 static int tty_fasync(int fd, struct file * filp, int on)
2840 {
2841         struct tty_struct * tty;
2842         int retval;
2843
2844         tty = (struct tty_struct *)filp->private_data;
2845         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
2846                 return 0;
2847         
2848         retval = fasync_helper(fd, filp, on, &tty->fasync);
2849         if (retval <= 0)
2850                 return retval;
2851
2852         if (on) {
2853                 enum pid_type type;
2854                 struct pid *pid;
2855                 if (!waitqueue_active(&tty->read_wait))
2856                         tty->minimum_to_wake = 1;
2857                 if (tty->pgrp) {
2858                         pid = tty->pgrp;
2859                         type = PIDTYPE_PGID;
2860                 } else {
2861                         pid = task_pid(current);
2862                         type = PIDTYPE_PID;
2863                 }
2864                 retval = __f_setown(filp, pid, type, 0);
2865                 if (retval)
2866                         return retval;
2867         } else {
2868                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2869                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
2870         }
2871         return 0;
2872 }
2873
2874 /**
2875  *      tiocsti                 -       fake input character
2876  *      @tty: tty to fake input into
2877  *      @p: pointer to character
2878  *
2879  *      Fake input to a tty device. Does the neccessary locking and
2880  *      input management.
2881  *
2882  *      FIXME: does not honour flow control ??
2883  *
2884  *      Locking:
2885  *              Called functions take tty_ldisc_lock
2886  *              current->signal->tty check is safe without locks
2887  *
2888  *      FIXME: may race normal receive processing
2889  */
2890
2891 static int tiocsti(struct tty_struct *tty, char __user *p)
2892 {
2893         char ch, mbz = 0;
2894         struct tty_ldisc *ld;
2895         
2896         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2897                 return -EPERM;
2898         if (get_user(ch, p))
2899                 return -EFAULT;
2900         ld = tty_ldisc_ref_wait(tty);
2901         ld->receive_buf(tty, &ch, &mbz, 1);
2902         tty_ldisc_deref(ld);
2903         return 0;
2904 }
2905
2906 /**
2907  *      tiocgwinsz              -       implement window query ioctl
2908  *      @tty; tty
2909  *      @arg: user buffer for result
2910  *
2911  *      Copies the kernel idea of the window size into the user buffer.
2912  *
2913  *      Locking: tty->termios_mutex is taken to ensure the winsize data
2914  *              is consistent.
2915  */
2916
2917 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
2918 {
2919         int err;
2920
2921         mutex_lock(&tty->termios_mutex);
2922         err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2923         mutex_unlock(&tty->termios_mutex);
2924
2925         return err ? -EFAULT: 0;
2926 }
2927
2928 /**
2929  *      tiocswinsz              -       implement window size set ioctl
2930  *      @tty; tty
2931  *      @arg: user buffer for result
2932  *
2933  *      Copies the user idea of the window size to the kernel. Traditionally
2934  *      this is just advisory information but for the Linux console it
2935  *      actually has driver level meaning and triggers a VC resize.
2936  *
2937  *      Locking:
2938  *              Called function use the console_sem is used to ensure we do
2939  *      not try and resize the console twice at once.
2940  *              The tty->termios_mutex is used to ensure we don't double
2941  *      resize and get confused. Lock order - tty->termios_mutex before
2942  *      console sem
2943  */
2944
2945 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
2946         struct winsize __user * arg)
2947 {
2948         struct winsize tmp_ws;
2949
2950         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2951                 return -EFAULT;
2952
2953         mutex_lock(&tty->termios_mutex);
2954         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
2955                 goto done;
2956
2957 #ifdef CONFIG_VT
2958         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
2959                 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
2960                                         tmp_ws.ws_row)) {
2961                         mutex_unlock(&tty->termios_mutex);
2962                         return -ENXIO;
2963                 }
2964         }
2965 #endif
2966         if (tty->pgrp)
2967                 kill_pgrp(tty->pgrp, SIGWINCH, 1);
2968         if ((real_tty->pgrp != tty->pgrp) && real_tty->pgrp)
2969                 kill_pgrp(real_tty->pgrp, SIGWINCH, 1);
2970         tty->winsize = tmp_ws;
2971         real_tty->winsize = tmp_ws;
2972 done:
2973         mutex_unlock(&tty->termios_mutex);
2974         return 0;
2975 }
2976
2977 /**
2978  *      tioccons        -       allow admin to move logical console
2979  *      @file: the file to become console
2980  *
2981  *      Allow the adminstrator to move the redirected console device
2982  *
2983  *      Locking: uses redirect_lock to guard the redirect information
2984  */
2985
2986 static int tioccons(struct file *file)
2987 {
2988         if (!capable(CAP_SYS_ADMIN))
2989                 return -EPERM;
2990         if (file->f_op->write == redirected_tty_write) {
2991                 struct file *f;
2992                 spin_lock(&redirect_lock);
2993                 f = redirect;
2994                 redirect = NULL;
2995                 spin_unlock(&redirect_lock);
2996                 if (f)
2997                         fput(f);
2998                 return 0;
2999         }
3000         spin_lock(&redirect_lock);
3001         if (redirect) {
3002                 spin_unlock(&redirect_lock);
3003                 return -EBUSY;
3004         }
3005         get_file(file);
3006         redirect = file;
3007         spin_unlock(&redirect_lock);
3008         return 0;
3009 }
3010
3011 /**
3012  *      fionbio         -       non blocking ioctl
3013  *      @file: file to set blocking value
3014  *      @p: user parameter
3015  *
3016  *      Historical tty interfaces had a blocking control ioctl before
3017  *      the generic functionality existed. This piece of history is preserved
3018  *      in the expected tty API of posix OS's.
3019  *
3020  *      Locking: none, the open fle handle ensures it won't go away.
3021  */
3022
3023 static int fionbio(struct file *file, int __user *p)
3024 {
3025         int nonblock;
3026
3027         if (get_user(nonblock, p))
3028                 return -EFAULT;
3029
3030         if (nonblock)
3031                 file->f_flags |= O_NONBLOCK;
3032         else
3033                 file->f_flags &= ~O_NONBLOCK;
3034         return 0;
3035 }
3036
3037 /**
3038  *      tiocsctty       -       set controlling tty
3039  *      @tty: tty structure
3040  *      @arg: user argument
3041  *
3042  *      This ioctl is used to manage job control. It permits a session
3043  *      leader to set this tty as the controlling tty for the session.
3044  *
3045  *      Locking:
3046  *              Takes tty_mutex() to protect tty instance
3047  *              Takes tasklist_lock internally to walk sessions
3048  *              Takes ->siglock() when updating signal->tty
3049  */
3050
3051 static int tiocsctty(struct tty_struct *tty, int arg)
3052 {
3053         int ret = 0;
3054         if (current->signal->leader && (task_session(current) == tty->session))
3055                 return ret;
3056
3057         mutex_lock(&tty_mutex);
3058         /*
3059          * The process must be a session leader and
3060          * not have a controlling tty already.
3061          */
3062         if (!current->signal->leader || current->signal->tty) {
3063                 ret = -EPERM;
3064                 goto unlock;
3065         }
3066
3067         if (tty->session) {
3068                 /*
3069                  * This tty is already the controlling
3070                  * tty for another session group!
3071                  */
3072                 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
3073                         /*
3074                          * Steal it away
3075                          */
3076                         read_lock(&tasklist_lock);
3077                         session_clear_tty(tty->session);
3078                         read_unlock(&tasklist_lock);
3079                 } else {
3080                         ret = -EPERM;
3081                         goto unlock;
3082                 }
3083         }
3084         proc_set_tty(current, tty);
3085 unlock:
3086         mutex_unlock(&tty_mutex);
3087         return ret;
3088 }
3089
3090 /**
3091  *      tiocgpgrp               -       get process group
3092  *      @tty: tty passed by user
3093  *      @real_tty: tty side of the tty pased by the user if a pty else the tty
3094  *      @p: returned pid
3095  *
3096  *      Obtain the process group of the tty. If there is no process group
3097  *      return an error.
3098  *
3099  *      Locking: none. Reference to current->signal->tty is safe.
3100  */
3101
3102 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3103 {
3104         /*
3105          * (tty == real_tty) is a cheap way of
3106          * testing if the tty is NOT a master pty.
3107          */
3108         if (tty == real_tty && current->signal->tty != real_tty)
3109                 return -ENOTTY;
3110         return put_user(pid_nr(real_tty->pgrp), p);
3111 }
3112
3113 /**
3114  *      tiocspgrp               -       attempt to set process group
3115  *      @tty: tty passed by user
3116  *      @real_tty: tty side device matching tty passed by user
3117  *      @p: pid pointer
3118  *
3119  *      Set the process group of the tty to the session passed. Only
3120  *      permitted where the tty session is our session.
3121  *
3122  *      Locking: None
3123  */
3124
3125 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3126 {
3127         struct pid *pgrp;
3128         pid_t pgrp_nr;
3129         int retval = tty_check_change(real_tty);
3130
3131         if (retval == -EIO)
3132                 return -ENOTTY;
3133         if (retval)
3134                 return retval;
3135         if (!current->signal->tty ||
3136             (current->signal->tty != real_tty) ||
3137             (real_tty->session != task_session(current)))
3138                 return -ENOTTY;
3139         if (get_user(pgrp_nr, p))
3140                 return -EFAULT;
3141         if (pgrp_nr < 0)
3142                 return -EINVAL;
3143         rcu_read_lock();
3144         pgrp = find_pid(pgrp_nr);
3145         retval = -ESRCH;
3146         if (!pgrp)
3147                 goto out_unlock;
3148         retval = -EPERM;
3149         if (session_of_pgrp(pgrp) != task_session(current))
3150                 goto out_unlock;
3151         retval = 0;
3152         put_pid(real_tty->pgrp);
3153         real_tty->pgrp = get_pid(pgrp);
3154 out_unlock:
3155         rcu_read_unlock();
3156         return retval;
3157 }
3158
3159 /**
3160  *      tiocgsid                -       get session id
3161  *      @tty: tty passed by user
3162  *      @real_tty: tty side of the tty pased by the user if a pty else the tty
3163  *      @p: pointer to returned session id
3164  *
3165  *      Obtain the session id of the tty. If there is no session
3166  *      return an error.
3167  *
3168  *      Locking: none. Reference to current->signal->tty is safe.
3169  */
3170
3171 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
3172 {
3173         /*
3174          * (tty == real_tty) is a cheap way of
3175          * testing if the tty is NOT a master pty.
3176         */
3177         if (tty == real_tty && current->signal->tty != real_tty)
3178                 return -ENOTTY;
3179         if (!real_tty->session)
3180                 return -ENOTTY;
3181         return put_user(pid_nr(real_tty->session), p);
3182 }
3183
3184 /**
3185  *      tiocsetd        -       set line discipline
3186  *      @tty: tty device
3187  *      @p: pointer to user data
3188  *
3189  *      Set the line discipline according to user request.
3190  *
3191  *      Locking: see tty_set_ldisc, this function is just a helper
3192  */
3193
3194 static int tiocsetd(struct tty_struct *tty, int __user *p)
3195 {
3196         int ldisc;
3197
3198         if (get_user(ldisc, p))
3199                 return -EFAULT;
3200         return tty_set_ldisc(tty, ldisc);
3201 }
3202
3203 /**
3204  *      send_break      -       performed time break
3205  *      @tty: device to break on
3206  *      @duration: timeout in mS
3207  *
3208  *      Perform a timed break on hardware that lacks its own driver level
3209  *      timed break functionality.
3210  *
3211  *      Locking:
3212  *              atomic_write_lock serializes
3213  *
3214  */
3215
3216 static int send_break(struct tty_struct *tty, unsigned int duration)
3217 {
3218         if (tty_write_lock(tty, 0) < 0)
3219                 return -EINTR;
3220         tty->driver->break_ctl(tty, -1);
3221         if (!signal_pending(current))
3222                 msleep_interruptible(duration);
3223         tty->driver->break_ctl(tty, 0);
3224         tty_write_unlock(tty);
3225         if (signal_pending(current))
3226                 return -EINTR;
3227         return 0;
3228 }
3229
3230 /**
3231  *      tiocmget                -       get modem status
3232  *      @tty: tty device
3233  *      @file: user file pointer
3234  *      @p: pointer to result
3235  *
3236  *      Obtain the modem status bits from the tty driver if the feature
3237  *      is supported. Return -EINVAL if it is not available.
3238  *
3239  *      Locking: none (up to the driver)
3240  */
3241
3242 static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
3243 {
3244         int retval = -EINVAL;
3245
3246         if (tty->driver->tiocmget) {
3247                 retval = tty->driver->tiocmget(tty, file);
3248
3249                 if (retval >= 0)
3250                         retval = put_user(retval, p);
3251         }
3252         return retval;
3253 }
3254
3255 /**
3256  *      tiocmset                -       set modem status
3257  *      @tty: tty device
3258  *      @file: user file pointer
3259  *      @cmd: command - clear bits, set bits or set all
3260  *      @p: pointer to desired bits
3261  *
3262  *      Set the modem status bits from the tty driver if the feature
3263  *      is supported. Return -EINVAL if it is not available.
3264  *
3265  *      Locking: none (up to the driver)
3266  */
3267
3268 static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
3269              unsigned __user *p)
3270 {
3271         int retval = -EINVAL;
3272
3273         if (tty->driver->tiocmset) {
3274                 unsigned int set, clear, val;
3275
3276                 retval = get_user(val, p);
3277                 if (retval)
3278                         return retval;
3279
3280                 set = clear = 0;
3281                 switch (cmd) {
3282                 case TIOCMBIS:
3283                         set = val;
3284                         break;
3285                 case TIOCMBIC:
3286                         clear = val;
3287                         break;
3288                 case TIOCMSET:
3289                         set = val;
3290                         clear = ~val;
3291                         break;
3292                 }
3293
3294                 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3295                 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
3296
3297                 retval = tty->driver->tiocmset(tty, file, set, clear);
3298         }
3299         return retval;
3300 }
3301
3302 /*
3303  * Split this up, as gcc can choke on it otherwise..
3304  */
3305 int tty_ioctl(struct inode * inode, struct file * file,
3306               unsigned int cmd, unsigned long arg)
3307 {
3308         struct tty_struct *tty, *real_tty;
3309         void __user *p = (void __user *)arg;
3310         int retval;
3311         struct tty_ldisc *ld;
3312         
3313         tty = (struct tty_struct *)file->private_data;
3314         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3315                 return -EINVAL;
3316
3317         /* CHECKME: is this safe as one end closes ? */
3318
3319         real_tty = tty;
3320         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
3321             tty->driver->subtype == PTY_TYPE_MASTER)
3322                 real_tty = tty->link;
3323
3324         /*
3325          * Break handling by driver
3326          */
3327         if (!tty->driver->break_ctl) {
3328                 switch(cmd) {
3329                 case TIOCSBRK:
3330                 case TIOCCBRK:
3331                         if (tty->driver->ioctl)
3332                                 return tty->driver->ioctl(tty, file, cmd, arg);
3333                         return -EINVAL;
3334                         
3335                 /* These two ioctl's always return success; even if */
3336                 /* the driver doesn't support them. */
3337                 case TCSBRK:
3338                 case TCSBRKP:
3339                         if (!tty->driver->ioctl)
3340                                 return 0;
3341                         retval = tty->driver->ioctl(tty, file, cmd, arg);
3342                         if (retval == -ENOIOCTLCMD)
3343                                 retval = 0;
3344                         return retval;
3345                 }
3346         }
3347
3348         /*
3349          * Factor out some common prep work
3350          */
3351         switch (cmd) {
3352         case TIOCSETD:
3353         case TIOCSBRK:
3354         case TIOCCBRK:
3355         case TCSBRK:
3356         case TCSBRKP:                   
3357                 retval = tty_check_change(tty);
3358                 if (retval)
3359                         return retval;
3360                 if (cmd != TIOCCBRK) {
3361                         tty_wait_until_sent(tty, 0);
3362                         if (signal_pending(current))
3363                                 return -EINTR;
3364                 }
3365                 break;
3366         }
3367
3368         switch (cmd) {
3369                 case TIOCSTI:
3370                         return tiocsti(tty, p);
3371                 case TIOCGWINSZ:
3372                         return tiocgwinsz(tty, p);
3373                 case TIOCSWINSZ:
3374                         return tiocswinsz(tty, real_tty, p);
3375                 case TIOCCONS:
3376                         return real_tty!=tty ? -EINVAL : tioccons(file);
3377                 case FIONBIO:
3378                         return fionbio(file, p);
3379                 case TIOCEXCL:
3380                         set_bit(TTY_EXCLUSIVE, &tty->flags);
3381                         return 0;
3382                 case TIOCNXCL:
3383                         clear_bit(TTY_EXCLUSIVE, &tty->flags);
3384                         return 0;
3385                 case TIOCNOTTY:
3386                         if (current->signal->tty != tty)
3387                                 return -ENOTTY;
3388                         no_tty();
3389                         return 0;
3390                 case TIOCSCTTY:
3391                         return tiocsctty(tty, arg);
3392                 case TIOCGPGRP:
3393                         return tiocgpgrp(tty, real_tty, p);
3394                 case TIOCSPGRP:
3395                         return tiocspgrp(tty, real_tty, p);
3396                 case TIOCGSID:
3397                         return tiocgsid(tty, real_tty, p);
3398                 case TIOCGETD:
3399                         /* FIXME: check this is ok */
3400                         return put_user(tty->ldisc.num, (int __user *)p);
3401                 case TIOCSETD:
3402                         return tiocsetd(tty, p);
3403 #ifdef CONFIG_VT
3404                 case TIOCLINUX:
3405                         return tioclinux(tty, arg);
3406 #endif
3407                 /*
3408                  * Break handling
3409                  */
3410                 case TIOCSBRK:  /* Turn break on, unconditionally */
3411                         tty->driver->break_ctl(tty, -1);
3412                         return 0;
3413                         
3414                 case TIOCCBRK:  /* Turn break off, unconditionally */
3415                         tty->driver->break_ctl(tty, 0);
3416                         return 0;
3417                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
3418                         /* non-zero arg means wait for all output data
3419                          * to be sent (performed above) but don't send break.
3420                          * This is used by the tcdrain() termios function.
3421                          */
3422                         if (!arg)
3423                                 return send_break(tty, 250);
3424                         return 0;
3425                 case TCSBRKP:   /* support for POSIX tcsendbreak() */   
3426                         return send_break(tty, arg ? arg*100 : 250);
3427
3428                 case TIOCMGET:
3429                         return tty_tiocmget(tty, file, p);
3430
3431                 case TIOCMSET:
3432                 case TIOCMBIC:
3433                 case TIOCMBIS:
3434                         return tty_tiocmset(tty, file, cmd, p);
3435                 case TCFLSH:
3436                         switch (arg) {
3437                         case TCIFLUSH:
3438                         case TCIOFLUSH:
3439                                 /* flush tty buffer and allow ldisc to process ioctl */
3440                                 tty_buffer_flush(tty);
3441                                 break;
3442                         }
3443                         break;
3444         }
3445         if (tty->driver->ioctl) {
3446                 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
3447                 if (retval != -ENOIOCTLCMD)
3448                         return retval;
3449         }
3450         ld = tty_ldisc_ref_wait(tty);
3451         retval = -EINVAL;
3452         if (ld->ioctl) {
3453                 retval = ld->ioctl(tty, file, cmd, arg);
3454                 if (retval == -ENOIOCTLCMD)
3455                         retval = -EINVAL;
3456         }
3457         tty_ldisc_deref(ld);
3458         return retval;
3459 }
3460
3461 #ifdef CONFIG_COMPAT
3462 static long tty_compat_ioctl(struct file * file, unsigned int cmd,
3463                                 unsigned long arg)
3464 {
3465         struct inode *inode = file->f_dentry->d_inode;
3466         struct tty_struct *tty = file->private_data;
3467         struct tty_ldisc *ld;
3468         int retval = -ENOIOCTLCMD;
3469
3470         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
3471                 return -EINVAL;
3472
3473         if (tty->driver->compat_ioctl) {
3474                 retval = (tty->driver->compat_ioctl)(tty, file, cmd, arg);
3475                 if (retval != -ENOIOCTLCMD)
3476                         return retval;
3477         }
3478
3479         ld = tty_ldisc_ref_wait(tty);
3480         if (ld->compat_ioctl)
3481                 retval = ld->compat_ioctl(tty, file, cmd, arg);
3482         tty_ldisc_deref(ld);
3483
3484         return retval;
3485 }
3486 #endif
3487
3488 /*
3489  * This implements the "Secure Attention Key" ---  the idea is to
3490  * prevent trojan horses by killing all processes associated with this
3491  * tty when the user hits the "Secure Attention Key".  Required for
3492  * super-paranoid applications --- see the Orange Book for more details.
3493  * 
3494  * This code could be nicer; ideally it should send a HUP, wait a few
3495  * seconds, then send a INT, and then a KILL signal.  But you then
3496  * have to coordinate with the init process, since all processes associated
3497  * with the current tty must be dead before the new getty is allowed
3498  * to spawn.
3499  *
3500  * Now, if it would be correct ;-/ The current code has a nasty hole -
3501  * it doesn't catch files in flight. We may send the descriptor to ourselves
3502  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
3503  *
3504  * Nasty bug: do_SAK is being called in interrupt context.  This can
3505  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
3506  */
3507 void __do_SAK(struct tty_struct *tty)
3508 {
3509 #ifdef TTY_SOFT_SAK
3510         tty_hangup(tty);
3511 #else
3512         struct task_struct *g, *p;
3513         struct pid *session;
3514         int             i;
3515         struct file     *filp;
3516         struct fdtable *fdt;
3517         
3518         if (!tty)
3519                 return;
3520         session = tty->session;
3521         
3522         tty_ldisc_flush(tty);
3523
3524         if (tty->driver->flush_buffer)
3525                 tty->driver->flush_buffer(tty);
3526         
3527         read_lock(&tasklist_lock);
3528         /* Kill the entire session */
3529         do_each_pid_task(session, PIDTYPE_SID, p) {
3530                 printk(KERN_NOTICE "SAK: killed process %d"
3531                         " (%s): process_session(p)==tty->session\n",
3532                         p->pid, p->comm);
3533                 send_sig(SIGKILL, p, 1);
3534         } while_each_pid_task(session, PIDTYPE_SID, p);
3535         /* Now kill any processes that happen to have the
3536          * tty open.
3537          */
3538         do_each_thread(g, p) {
3539                 if (p->signal->tty == tty) {
3540                         printk(KERN_NOTICE "SAK: killed process %d"
3541                             " (%s): process_session(p)==tty->session\n",
3542                             p->pid, p->comm);
3543                         send_sig(SIGKILL, p, 1);
3544                         continue;
3545                 }
3546                 task_lock(p);
3547                 if (p->files) {
3548                         /*
3549                          * We don't take a ref to the file, so we must
3550                          * hold ->file_lock instead.
3551                          */
3552                         spin_lock(&p->files->file_lock);
3553                         fdt = files_fdtable(p->files);
3554                         for (i=0; i < fdt->max_fds; i++) {
3555                                 filp = fcheck_files(p->files, i);
3556                                 if (!filp)
3557                                         continue;
3558                                 if (filp->f_op->read == tty_read &&
3559                                     filp->private_data == tty) {
3560                                         printk(KERN_NOTICE "SAK: killed process %d"
3561                                             " (%s): fd#%d opened to the tty\n",
3562                                             p->pid, p->comm, i);
3563                                         force_sig(SIGKILL, p);
3564                                         break;
3565                                 }
3566                         }
3567                         spin_unlock(&p->files->file_lock);
3568                 }
3569                 task_unlock(p);
3570         } while_each_thread(g, p);
3571         read_unlock(&tasklist_lock);
3572 #endif
3573 }
3574
3575 static void do_SAK_work(struct work_struct *work)
3576 {
3577         struct tty_struct *tty =
3578                 container_of(work, struct tty_struct, SAK_work);
3579         __do_SAK(tty);
3580 }
3581
3582 /*
3583  * The tq handling here is a little racy - tty->SAK_work may already be queued.
3584  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
3585  * the values which we write to it will be identical to the values which it
3586  * already has. --akpm
3587  */
3588 void do_SAK(struct tty_struct *tty)
3589 {
3590         if (!tty)
3591                 return;
3592         schedule_work(&tty->SAK_work);
3593 }
3594
3595 EXPORT_SYMBOL(do_SAK);
3596
3597 /**
3598  *      flush_to_ldisc
3599  *      @work: tty structure passed from work queue.
3600  *
3601  *      This routine is called out of the software interrupt to flush data
3602  *      from the buffer chain to the line discipline.
3603  *
3604  *      Locking: holds tty->buf.lock to guard buffer list. Drops the lock
3605  *      while invoking the line discipline receive_buf method. The
3606  *      receive_buf method is single threaded for each tty instance.
3607  */
3608  
3609 static void flush_to_ldisc(struct work_struct *work)
3610 {
3611         struct tty_struct *tty =
3612                 container_of(work, struct tty_struct, buf.work.work);
3613         unsigned long   flags;
3614         struct tty_ldisc *disc;
3615         struct tty_buffer *tbuf, *head;
3616         char *char_buf;
3617         unsigned char *flag_buf;
3618
3619         disc = tty_ldisc_ref(tty);
3620         if (disc == NULL)       /*  !TTY_LDISC */
3621                 return;
3622
3623         spin_lock_irqsave(&tty->buf.lock, flags);
3624         set_bit(TTY_FLUSHING, &tty->flags);     /* So we know a flush is running */
3625         head = tty->buf.head;
3626         if (head != NULL) {
3627                 tty->buf.head = NULL;
3628                 for (;;) {
3629                         int count = head->commit - head->read;
3630                         if (!count) {
3631                                 if (head->next == NULL)
3632                                         break;
3633                                 tbuf = head;
3634                                 head = head->next;
3635                                 tty_buffer_free(tty, tbuf);
3636                                 continue;
3637                         }
3638                         /* Ldisc or user is trying to flush the buffers
3639                            we are feeding to the ldisc, stop feeding the
3640                            line discipline as we want to empty the queue */
3641                         if (test_bit(TTY_FLUSHPENDING, &tty->flags))
3642                                 break;
3643                         if (!tty->receive_room) {
3644                                 schedule_delayed_work(&tty->buf.work, 1);
3645                                 break;
3646                         }
3647                         if (count > tty->receive_room)
3648                                 count = tty->receive_room;
3649                         char_buf = head->char_buf_ptr + head->read;
3650                         flag_buf = head->flag_buf_ptr + head->read;
3651                         head->read += count;
3652                         spin_unlock_irqrestore(&tty->buf.lock, flags);
3653                         disc->receive_buf(tty, char_buf, flag_buf, count);
3654                         spin_lock_irqsave(&tty->buf.lock, flags);
3655                 }
3656                 /* Restore the queue head */
3657                 tty->buf.head = head;
3658         }
3659         /* We may have a deferred request to flush the input buffer,
3660            if so pull the chain under the lock and empty the queue */
3661         if (test_bit(TTY_FLUSHPENDING, &tty->flags)) {
3662                 __tty_buffer_flush(tty);
3663                 clear_bit(TTY_FLUSHPENDING, &tty->flags);
3664                 wake_up(&tty->read_wait);
3665         }
3666         clear_bit(TTY_FLUSHING, &tty->flags);
3667         spin_unlock_irqrestore(&tty->buf.lock, flags);
3668
3669         tty_ldisc_deref(disc);
3670 }
3671
3672 /**
3673  *      tty_flip_buffer_push    -       terminal
3674  *      @tty: tty to push
3675  *
3676  *      Queue a push of the terminal flip buffers to the line discipline. This
3677  *      function must not be called from IRQ context if tty->low_latency is set.
3678  *
3679  *      In the event of the queue being busy for flipping the work will be
3680  *      held off and retried later.
3681  *
3682  *      Locking: tty buffer lock. Driver locks in low latency mode.
3683  */
3684
3685 void tty_flip_buffer_push(struct tty_struct *tty)
3686 {
3687         unsigned long flags;
3688         spin_lock_irqsave(&tty->buf.lock, flags);
3689         if (tty->buf.tail != NULL)
3690                 tty->buf.tail->commit = tty->buf.tail->used;
3691         spin_unlock_irqrestore(&tty->buf.lock, flags);
3692
3693         if (tty->low_latency)
3694                 flush_to_ldisc(&tty->buf.work.work);
3695         else
3696                 schedule_delayed_work(&tty->buf.work, 1);
3697 }
3698
3699 EXPORT_SYMBOL(tty_flip_buffer_push);
3700
3701
3702 /**
3703  *      initialize_tty_struct
3704  *      @tty: tty to initialize
3705  *
3706  *      This subroutine initializes a tty structure that has been newly
3707  *      allocated.
3708  *
3709  *      Locking: none - tty in question must not be exposed at this point
3710  */
3711
3712 static void initialize_tty_struct(struct tty_struct *tty)
3713 {
3714         memset(tty, 0, sizeof(struct tty_struct));
3715         tty->magic = TTY_MAGIC;
3716         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
3717         tty->session = NULL;
3718         tty->pgrp = NULL;
3719         tty->overrun_time = jiffies;
3720         tty->buf.head = tty->buf.tail = NULL;
3721         tty_buffer_init(tty);
3722         INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
3723         init_MUTEX(&tty->buf.pty_sem);
3724         mutex_init(&tty->termios_mutex);
3725         init_waitqueue_head(&tty->write_wait);
3726         init_waitqueue_head(&tty->read_wait);
3727         INIT_WORK(&tty->hangup_work, do_tty_hangup);
3728         mutex_init(&tty->atomic_read_lock);
3729         mutex_init(&tty->atomic_write_lock);
3730         spin_lock_init(&tty->read_lock);
3731         INIT_LIST_HEAD(&tty->tty_files);
3732         INIT_WORK(&tty->SAK_work, do_SAK_work);
3733 }
3734
3735 /*
3736  * The default put_char routine if the driver did not define one.
3737  */
3738
3739 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
3740 {
3741         tty->driver->write(tty, &ch, 1);
3742 }
3743
3744 static struct class *tty_class;
3745
3746 /**
3747  *      tty_register_device - register a tty device
3748  *      @driver: the tty driver that describes the tty device
3749  *      @index: the index in the tty driver for this tty device
3750  *      @device: a struct device that is associated with this tty device.
3751  *              This field is optional, if there is no known struct device
3752  *              for this tty device it can be set to NULL safely.
3753  *
3754  *      Returns a pointer to the struct device for this tty device
3755  *      (or ERR_PTR(-EFOO) on error).
3756  *
3757  *      This call is required to be made to register an individual tty device
3758  *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
3759  *      that bit is not set, this function should not be called by a tty
3760  *      driver.
3761  *
3762  *      Locking: ??
3763  */
3764
3765 struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3766                                    struct device *device)
3767 {
3768         char name[64];
3769         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
3770
3771         if (index >= driver->num) {
3772                 printk(KERN_ERR "Attempt to register invalid tty line number "
3773                        " (%d).\n", index);
3774                 return ERR_PTR(-EINVAL);
3775         }
3776
3777         if (driver->type == TTY_DRIVER_TYPE_PTY)
3778                 pty_line_name(driver, index, name);
3779         else
3780                 tty_line_name(driver, index, name);
3781
3782         return device_create(tty_class, device, dev, name);
3783 }
3784
3785 /**
3786  *      tty_unregister_device - unregister a tty device
3787  *      @driver: the tty driver that describes the tty device
3788  *      @index: the index in the tty driver for this tty device
3789  *
3790  *      If a tty device is registered with a call to tty_register_device() then
3791  *      this function must be called when the tty device is gone.
3792  *
3793  *      Locking: ??
3794  */
3795
3796 void tty_unregister_device(struct tty_driver *driver, unsigned index)
3797 {
3798         device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
3799 }
3800
3801 EXPORT_SYMBOL(tty_register_device);
3802 EXPORT_SYMBOL(tty_unregister_device);
3803
3804 struct tty_driver *alloc_tty_driver(int lines)
3805 {
3806         struct tty_driver *driver;
3807
3808         driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3809         if (driver) {
3810                 driver->magic = TTY_DRIVER_MAGIC;
3811                 driver->num = lines;
3812                 /* later we'll move allocation of tables here */
3813         }
3814         return driver;
3815 }
3816
3817 void put_tty_driver(struct tty_driver *driver)
3818 {
3819         kfree(driver);
3820 }
3821
3822 void tty_set_operations(struct tty_driver *driver,
3823                         const struct tty_operations *op)
3824 {
3825         driver->open = op->open;
3826         driver->close = op->close;
3827         driver->write = op->write;
3828         driver->put_char = op->put_char;
3829         driver->flush_chars = op->flush_chars;
3830         driver->write_room = op->write_room;
3831         driver->chars_in_buffer = op->chars_in_buffer;
3832         driver->ioctl = op->ioctl;
3833         driver->compat_ioctl = op->compat_ioctl;
3834         driver->set_termios = op->set_termios;
3835         driver->throttle = op->throttle;
3836         driver->unthrottle = op->unthrottle;
3837         driver->stop = op->stop;
3838         driver->start = op->start;
3839         driver->hangup = op->hangup;
3840         driver->break_ctl = op->break_ctl;
3841         driver->flush_buffer = op->flush_buffer;
3842         driver->set_ldisc = op->set_ldisc;
3843         driver->wait_until_sent = op->wait_until_sent;
3844         driver->send_xchar = op->send_xchar;
3845         driver->read_proc = op->read_proc;
3846         driver->write_proc = op->write_proc;
3847         driver->tiocmget = op->tiocmget;
3848         driver->tiocmset = op->tiocmset;
3849 }
3850
3851
3852 EXPORT_SYMBOL(alloc_tty_driver);
3853 EXPORT_SYMBOL(put_tty_driver);
3854 EXPORT_SYMBOL(tty_set_operations);
3855
3856 /*
3857  * Called by a tty driver to register itself.
3858  */
3859 int tty_register_driver(struct tty_driver *driver)
3860 {
3861         int error;
3862         int i;
3863         dev_t dev;
3864         void **p = NULL;
3865
3866         if (driver->flags & TTY_DRIVER_INSTALLED)
3867                 return 0;
3868
3869         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
3870                 p = kzalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
3871                 if (!p)
3872                         return -ENOMEM;
3873         }
3874
3875         if (!driver->major) {
3876                 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
3877                                                 driver->name);
3878                 if (!error) {
3879                         driver->major = MAJOR(dev);
3880                         driver->minor_start = MINOR(dev);
3881                 }
3882         } else {
3883                 dev = MKDEV(driver->major, driver->minor_start);
3884                 error = register_chrdev_region(dev, driver->num, driver->name);
3885         }
3886         if (error < 0) {
3887                 kfree(p);
3888                 return error;
3889         }
3890
3891         if (p) {
3892                 driver->ttys = (struct tty_struct **)p;
3893                 driver->termios = (struct ktermios **)(p + driver->num);
3894                 driver->termios_locked = (struct ktermios **)(p + driver->num * 2);
3895         } else {
3896                 driver->ttys = NULL;
3897                 driver->termios = NULL;
3898                 driver->termios_locked = NULL;
3899         }
3900
3901         cdev_init(&driver->cdev, &tty_fops);
3902         driver->cdev.owner = driver->owner;
3903         error = cdev_add(&driver->cdev, dev, driver->num);
3904         if (error) {
3905                 unregister_chrdev_region(dev, driver->num);
3906                 driver->ttys = NULL;
3907                 driver->termios = driver->termios_locked = NULL;
3908                 kfree(p);
3909                 return error;
3910         }
3911
3912         if (!driver->put_char)
3913                 driver->put_char = tty_default_put_char;
3914         
3915         mutex_lock(&tty_mutex);
3916         list_add(&driver->tty_drivers, &tty_drivers);
3917         mutex_unlock(&tty_mutex);
3918         
3919         if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
3920                 for(i = 0; i < driver->num; i++)
3921                     tty_register_device(driver, i, NULL);
3922         }
3923         proc_tty_register_driver(driver);
3924         return 0;
3925 }
3926
3927 EXPORT_SYMBOL(tty_register_driver);
3928
3929 /*
3930  * Called by a tty driver to unregister itself.
3931  */
3932 int tty_unregister_driver(struct tty_driver *driver)
3933 {
3934         int i;
3935         struct ktermios *tp;
3936         void *p;
3937
3938         if (driver->refcount)
3939                 return -EBUSY;
3940
3941         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3942                                 driver->num);
3943         mutex_lock(&tty_mutex);
3944         list_del(&driver->tty_drivers);
3945         mutex_unlock(&tty_mutex);
3946
3947         /*
3948          * Free the termios and termios_locked structures because
3949          * we don't want to get memory leaks when modular tty
3950          * drivers are removed from the kernel.
3951          */
3952         for (i = 0; i < driver->num; i++) {
3953                 tp = driver->termios[i];
3954                 if (tp) {
3955                         driver->termios[i] = NULL;
3956                         kfree(tp);
3957                 }
3958                 tp = driver->termios_locked[i];
3959                 if (tp) {
3960                         driver->termios_locked[i] = NULL;
3961                         kfree(tp);
3962                 }
3963                 if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3964                         tty_unregister_device(driver, i);
3965         }
3966         p = driver->ttys;
3967         proc_tty_unregister_driver(driver);
3968         driver->ttys = NULL;
3969         driver->termios = driver->termios_locked = NULL;
3970         kfree(p);
3971         cdev_del(&driver->cdev);
3972         return 0;
3973 }
3974 EXPORT_SYMBOL(tty_unregister_driver);
3975
3976 dev_t tty_devnum(struct tty_struct *tty)
3977 {
3978         return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3979 }
3980 EXPORT_SYMBOL(tty_devnum);
3981
3982 void proc_clear_tty(struct task_struct *p)
3983 {
3984         spin_lock_irq(&p->sighand->siglock);
3985         p->signal->tty = NULL;
3986         spin_unlock_irq(&p->sighand->siglock);
3987 }
3988 EXPORT_SYMBOL(proc_clear_tty);
3989
3990 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3991 {
3992         if (tty) {
3993                 /* We should not have a session or pgrp to here but.... */
3994                 put_pid(tty->session);
3995                 put_pid(tty->pgrp);
3996                 tty->session = get_pid(task_session(tsk));
3997                 tty->pgrp = get_pid(task_pgrp(tsk));
3998         }
3999         put_pid(tsk->signal->tty_old_pgrp);
4000         tsk->signal->tty = tty;
4001         tsk->signal->tty_old_pgrp = NULL;
4002 }
4003
4004 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
4005 {
4006         spin_lock_irq(&tsk->sighand->siglock);
4007         __proc_set_tty(tsk, tty);
4008         spin_unlock_irq(&tsk->sighand->siglock);
4009 }
4010
4011 struct tty_struct *get_current_tty(void)
4012 {
4013         struct tty_struct *tty;
4014         WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
4015         tty = current->signal->tty;
4016         /*
4017          * session->tty can be changed/cleared from under us, make sure we
4018          * issue the load. The obtained pointer, when not NULL, is valid as
4019          * long as we hold tty_mutex.
4020          */
4021         barrier();
4022         return tty;
4023 }
4024 EXPORT_SYMBOL_GPL(get_current_tty);
4025
4026 /*
4027  * Initialize the console device. This is called *early*, so
4028  * we can't necessarily depend on lots of kernel help here.
4029  * Just do some early initializations, and do the complex setup
4030  * later.
4031  */
4032 void __init console_init(void)
4033 {
4034         initcall_t *call;
4035
4036         /* Setup the default TTY line discipline. */
4037         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
4038
4039         /*
4040          * set up the console device so that later boot sequences can 
4041          * inform about problems etc..
4042          */
4043         call = __con_initcall_start;
4044         while (call < __con_initcall_end) {
4045                 (*call)();
4046                 call++;
4047         }
4048 }
4049
4050 #ifdef CONFIG_VT
4051 extern int vty_init(void);
4052 #endif
4053
4054 static int __init tty_class_init(void)
4055 {
4056         tty_class = class_create(THIS_MODULE, "tty");
4057         if (IS_ERR(tty_class))
4058                 return PTR_ERR(tty_class);
4059         return 0;
4060 }
4061
4062 postcore_initcall(tty_class_init);
4063
4064 /* 3/2004 jmc: why do these devices exist? */
4065
4066 static struct cdev tty_cdev, console_cdev;
4067 #ifdef CONFIG_UNIX98_PTYS
4068 static struct cdev ptmx_cdev;
4069 #endif
4070 #ifdef CONFIG_VT
4071 static struct cdev vc0_cdev;
4072 #endif
4073
4074 /*
4075  * Ok, now we can initialize the rest of the tty devices and can count
4076  * on memory allocations, interrupts etc..
4077  */
4078 static int __init tty_init(void)
4079 {
4080         cdev_init(&tty_cdev, &tty_fops);
4081         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
4082             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
4083                 panic("Couldn't register /dev/tty driver\n");
4084         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
4085
4086         cdev_init(&console_cdev, &console_fops);
4087         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
4088             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
4089                 panic("Couldn't register /dev/console driver\n");
4090         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
4091
4092 #ifdef CONFIG_UNIX98_PTYS
4093         cdev_init(&ptmx_cdev, &ptmx_fops);
4094         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
4095             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
4096                 panic("Couldn't register /dev/ptmx driver\n");
4097         device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
4098 #endif
4099
4100 #ifdef CONFIG_VT
4101         cdev_init(&vc0_cdev, &console_fops);
4102         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
4103             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
4104                 panic("Couldn't register /dev/tty0 driver\n");
4105         device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
4106
4107         vty_init();
4108 #endif
4109         return 0;
4110 }
4111 module_init(tty_init);