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