Merge branch 'pending' of master.kernel.org:/pub/scm/linux/kernel/git/vxy/lksctp-dev
[linux-2.6] / drivers / char / tty_ioctl.c
1 /*
2  *  linux/drivers/char/tty_ioctl.c
3  *
4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
5  *
6  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
7  * which can be dynamically activated and de-activated by the line
8  * discipline handling modules (like SLIP).
9  */
10
11 #include <linux/types.h>
12 #include <linux/termios.h>
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/major.h>
17 #include <linux/tty.h>
18 #include <linux/fcntl.h>
19 #include <linux/string.h>
20 #include <linux/mm.h>
21 #include <linux/module.h>
22 #include <linux/bitops.h>
23 #include <linux/mutex.h>
24
25 #include <asm/io.h>
26 #include <asm/uaccess.h>
27 #include <asm/system.h>
28
29 #undef TTY_DEBUG_WAIT_UNTIL_SENT
30
31 #undef  DEBUG
32
33 /*
34  * Internal flag options for termios setting behavior
35  */
36 #define TERMIOS_FLUSH   1
37 #define TERMIOS_WAIT    2
38 #define TERMIOS_TERMIO  4
39 #define TERMIOS_OLD     8
40
41
42 /**
43  *      tty_wait_until_sent     -       wait for I/O to finish
44  *      @tty: tty we are waiting for
45  *      @timeout: how long we will wait
46  *
47  *      Wait for characters pending in a tty driver to hit the wire, or
48  *      for a timeout to occur (eg due to flow control)
49  *
50  *      Locking: none
51  */
52
53 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
54 {
55 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
56         char buf[64];
57
58         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
59 #endif
60         if (!tty->driver->chars_in_buffer)
61                 return;
62         if (!timeout)
63                 timeout = MAX_SCHEDULE_TIMEOUT;
64         if (wait_event_interruptible_timeout(tty->write_wait,
65                         !tty->driver->chars_in_buffer(tty), timeout) < 0)
66                 return;
67         if (tty->driver->wait_until_sent)
68                 tty->driver->wait_until_sent(tty, timeout);
69 }
70 EXPORT_SYMBOL(tty_wait_until_sent);
71
72 static void unset_locked_termios(struct ktermios *termios,
73                                  struct ktermios *old,
74                                  struct ktermios *locked)
75 {
76         int     i;
77
78 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
79
80         if (!locked) {
81                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
82                 return;
83         }
84
85         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
86         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
87         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
88         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
89         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
90         for (i = 0; i < NCCS; i++)
91                 termios->c_cc[i] = locked->c_cc[i] ?
92                         old->c_cc[i] : termios->c_cc[i];
93         /* FIXME: What should we do for i/ospeed */
94 }
95
96 /*
97  * Routine which returns the baud rate of the tty
98  *
99  * Note that the baud_table needs to be kept in sync with the
100  * include/asm/termbits.h file.
101  */
102 static const speed_t baud_table[] = {
103         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
104         9600, 19200, 38400, 57600, 115200, 230400, 460800,
105 #ifdef __sparc__
106         76800, 153600, 307200, 614400, 921600
107 #else
108         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
109         2500000, 3000000, 3500000, 4000000
110 #endif
111 };
112
113 #ifndef __sparc__
114 static const tcflag_t baud_bits[] = {
115         B0, B50, B75, B110, B134, B150, B200, B300, B600,
116         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
117         B57600, B115200, B230400, B460800, B500000, B576000,
118         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
119         B3000000, B3500000, B4000000
120 };
121 #else
122 static const tcflag_t baud_bits[] = {
123         B0, B50, B75, B110, B134, B150, B200, B300, B600,
124         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
125         B57600, B115200, B230400, B460800, B76800, B153600,
126         B307200, B614400, B921600
127 };
128 #endif
129
130 static int n_baud_table = ARRAY_SIZE(baud_table);
131
132 /**
133  *      tty_termios_baud_rate
134  *      @termios: termios structure
135  *
136  *      Convert termios baud rate data into a speed. This should be called
137  *      with the termios lock held if this termios is a terminal termios
138  *      structure. May change the termios data. Device drivers can call this
139  *      function but should use ->c_[io]speed directly as they are updated.
140  *
141  *      Locking: none
142  */
143
144 speed_t tty_termios_baud_rate(struct ktermios *termios)
145 {
146         unsigned int cbaud;
147
148         cbaud = termios->c_cflag & CBAUD;
149
150 #ifdef BOTHER
151         /* Magic token for arbitary speed via c_ispeed/c_ospeed */
152         if (cbaud == BOTHER)
153                 return termios->c_ospeed;
154 #endif
155         if (cbaud & CBAUDEX) {
156                 cbaud &= ~CBAUDEX;
157
158                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
159                         termios->c_cflag &= ~CBAUDEX;
160                 else
161                         cbaud += 15;
162         }
163         return baud_table[cbaud];
164 }
165 EXPORT_SYMBOL(tty_termios_baud_rate);
166
167 /**
168  *      tty_termios_input_baud_rate
169  *      @termios: termios structure
170  *
171  *      Convert termios baud rate data into a speed. This should be called
172  *      with the termios lock held if this termios is a terminal termios
173  *      structure. May change the termios data. Device drivers can call this
174  *      function but should use ->c_[io]speed directly as they are updated.
175  *
176  *      Locking: none
177  */
178
179 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
180 {
181 #ifdef IBSHIFT
182         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
183
184         if (cbaud == B0)
185                 return tty_termios_baud_rate(termios);
186
187         /* Magic token for arbitary speed via c_ispeed*/
188         if (cbaud == BOTHER)
189                 return termios->c_ispeed;
190
191         if (cbaud & CBAUDEX) {
192                 cbaud &= ~CBAUDEX;
193
194                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
195                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
196                 else
197                         cbaud += 15;
198         }
199         return baud_table[cbaud];
200 #else
201         return tty_termios_baud_rate(termios);
202 #endif
203 }
204 EXPORT_SYMBOL(tty_termios_input_baud_rate);
205
206 /**
207  *      tty_termios_encode_baud_rate
208  *      @termios: ktermios structure holding user requested state
209  *      @ispeed: input speed
210  *      @ospeed: output speed
211  *
212  *      Encode the speeds set into the passed termios structure. This is
213  *      used as a library helper for drivers os that they can report back
214  *      the actual speed selected when it differs from the speed requested
215  *
216  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
217  *      we need to carefully set the bits when the user does not get the
218  *      desired speed. We allow small margins and preserve as much of possible
219  *      of the input intent to keep compatiblity.
220  *
221  *      Locking: Caller should hold termios lock. This is already held
222  *      when calling this function from the driver termios handler.
223  *
224  *      The ifdefs deal with platforms whose owners have yet to update them
225  *      and will all go away once this is done.
226  */
227
228 void tty_termios_encode_baud_rate(struct ktermios *termios,
229                                   speed_t ibaud, speed_t obaud)
230 {
231         int i = 0;
232         int ifound = -1, ofound = -1;
233         int iclose = ibaud/50, oclose = obaud/50;
234         int ibinput = 0;
235
236         if (obaud == 0)                 /* CD dropped             */
237                 ibaud = 0;              /* Clear ibaud to be sure */
238
239         termios->c_ispeed = ibaud;
240         termios->c_ospeed = obaud;
241
242 #ifdef BOTHER
243         /* If the user asked for a precise weird speed give a precise weird
244            answer. If they asked for a Bfoo speed they many have problems
245            digesting non-exact replies so fuzz a bit */
246
247         if ((termios->c_cflag & CBAUD) == BOTHER)
248                 oclose = 0;
249         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
250                 iclose = 0;
251         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
252                 ibinput = 1;    /* An input speed was specified */
253 #endif
254         termios->c_cflag &= ~CBAUD;
255
256         /*
257          *      Our goal is to find a close match to the standard baud rate
258          *      returned. Walk the baud rate table and if we get a very close
259          *      match then report back the speed as a POSIX Bxxxx value by
260          *      preference
261          */
262
263         do {
264                 if (obaud - oclose <= baud_table[i] &&
265                     obaud + oclose >= baud_table[i]) {
266                         termios->c_cflag |= baud_bits[i];
267                         ofound = i;
268                 }
269                 if (ibaud - iclose <= baud_table[i] &&
270                     ibaud + iclose >= baud_table[i]) {
271                         /* For the case input == output don't set IBAUD bits
272                            if the user didn't do so */
273                         if (ofound == i && !ibinput)
274                                 ifound  = i;
275 #ifdef IBSHIFT
276                         else {
277                                 ifound = i;
278                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
279                         }
280 #endif
281                 }
282         } while (++i < n_baud_table);
283
284         /*
285          *      If we found no match then use BOTHER if provided or warn
286          *      the user their platform maintainer needs to wake up if not.
287          */
288 #ifdef BOTHER
289         if (ofound == -1)
290                 termios->c_cflag |= BOTHER;
291         /* Set exact input bits only if the input and output differ or the
292            user already did */
293         if (ifound == -1 && (ibaud != obaud || ibinput))
294                 termios->c_cflag |= (BOTHER << IBSHIFT);
295 #else
296         if (ifound == -1 || ofound == -1) {
297                 static int warned;
298                 if (!warned++)
299                         printk(KERN_WARNING "tty: Unable to return correct "
300                           "speed data as your architecture needs updating.\n");
301         }
302 #endif
303 }
304 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
305
306 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
307 {
308         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
309 }
310 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
311
312 /**
313  *      tty_get_baud_rate       -       get tty bit rates
314  *      @tty: tty to query
315  *
316  *      Returns the baud rate as an integer for this terminal. The
317  *      termios lock must be held by the caller and the terminal bit
318  *      flags may be updated.
319  *
320  *      Locking: none
321  */
322
323 speed_t tty_get_baud_rate(struct tty_struct *tty)
324 {
325         speed_t baud = tty_termios_baud_rate(tty->termios);
326
327         if (baud == 38400 && tty->alt_speed) {
328                 if (!tty->warned) {
329                         printk(KERN_WARNING "Use of setserial/setrocket to "
330                                             "set SPD_* flags is deprecated\n");
331                         tty->warned = 1;
332                 }
333                 baud = tty->alt_speed;
334         }
335
336         return baud;
337 }
338 EXPORT_SYMBOL(tty_get_baud_rate);
339
340 /**
341  *      tty_termios_copy_hw     -       copy hardware settings
342  *      @new: New termios
343  *      @old: Old termios
344  *
345  *      Propogate the hardware specific terminal setting bits from
346  *      the old termios structure to the new one. This is used in cases
347  *      where the hardware does not support reconfiguration or as a helper
348  *      in some cases where only minimal reconfiguration is supported
349  */
350
351 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
352 {
353         /* The bits a dumb device handles in software. Smart devices need
354            to always provide a set_termios method */
355         new->c_cflag &= HUPCL | CREAD | CLOCAL;
356         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
357         new->c_ispeed = old->c_ispeed;
358         new->c_ospeed = old->c_ospeed;
359 }
360 EXPORT_SYMBOL(tty_termios_copy_hw);
361
362 /**
363  *      tty_termios_hw_change   -       check for setting change
364  *      @a: termios
365  *      @b: termios to compare
366  *
367  *      Check if any of the bits that affect a dumb device have changed
368  *      between the two termios structures, or a speed change is needed.
369  */
370
371 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
372 {
373         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
374                 return 1;
375         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
376                 return 1;
377         return 0;
378 }
379 EXPORT_SYMBOL(tty_termios_hw_change);
380
381 /**
382  *      change_termios          -       update termios values
383  *      @tty: tty to update
384  *      @new_termios: desired new value
385  *
386  *      Perform updates to the termios values set on this terminal. There
387  *      is a bit of layering violation here with n_tty in terms of the
388  *      internal knowledge of this function.
389  *
390  *      Locking: termios_sem
391  */
392
393 static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
394 {
395         int canon_change;
396         struct ktermios old_termios = *tty->termios;
397         struct tty_ldisc *ld;
398
399         /*
400          *      Perform the actual termios internal changes under lock.
401          */
402
403
404         /* FIXME: we need to decide on some locking/ordering semantics
405            for the set_termios notification eventually */
406         mutex_lock(&tty->termios_mutex);
407
408         *tty->termios = *new_termios;
409         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
410         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
411         if (canon_change) {
412                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
413                 tty->canon_head = tty->read_tail;
414                 tty->canon_data = 0;
415                 tty->erasing = 0;
416         }
417
418         /* This bit should be in the ldisc code */
419         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
420                 /* Get characters left over from canonical mode. */
421                 wake_up_interruptible(&tty->read_wait);
422
423         /* See if packet mode change of state. */
424         if (tty->link && tty->link->packet) {
425                 int old_flow = ((old_termios.c_iflag & IXON) &&
426                                 (old_termios.c_cc[VSTOP] == '\023') &&
427                                 (old_termios.c_cc[VSTART] == '\021'));
428                 int new_flow = (I_IXON(tty) &&
429                                 STOP_CHAR(tty) == '\023' &&
430                                 START_CHAR(tty) == '\021');
431                 if (old_flow != new_flow) {
432                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
433                         if (new_flow)
434                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
435                         else
436                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
437                         wake_up_interruptible(&tty->link->read_wait);
438                 }
439         }
440
441         if (tty->driver->set_termios)
442                 (*tty->driver->set_termios)(tty, &old_termios);
443         else
444                 tty_termios_copy_hw(tty->termios, &old_termios);
445
446         ld = tty_ldisc_ref(tty);
447         if (ld != NULL) {
448                 if (ld->set_termios)
449                         (ld->set_termios)(tty, &old_termios);
450                 tty_ldisc_deref(ld);
451         }
452         mutex_unlock(&tty->termios_mutex);
453 }
454
455 /**
456  *      set_termios             -       set termios values for a tty
457  *      @tty: terminal device
458  *      @arg: user data
459  *      @opt: option information
460  *
461  *      Helper function to prepare termios data and run necessary other
462  *      functions before using change_termios to do the actual changes.
463  *
464  *      Locking:
465  *              Called functions take ldisc and termios_sem locks
466  */
467
468 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
469 {
470         struct ktermios tmp_termios;
471         struct tty_ldisc *ld;
472         int retval = tty_check_change(tty);
473
474         if (retval)
475                 return retval;
476
477         memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
478
479         if (opt & TERMIOS_TERMIO) {
480                 if (user_termio_to_kernel_termios(&tmp_termios,
481                                                 (struct termio __user *)arg))
482                         return -EFAULT;
483 #ifdef TCGETS2
484         } else if (opt & TERMIOS_OLD) {
485                 if (user_termios_to_kernel_termios_1(&tmp_termios,
486                                                 (struct termios __user *)arg))
487                         return -EFAULT;
488         } else {
489                 if (user_termios_to_kernel_termios(&tmp_termios,
490                                                 (struct termios2 __user *)arg))
491                         return -EFAULT;
492         }
493 #else
494         } else if (user_termios_to_kernel_termios(&tmp_termios,
495                                         (struct termios __user *)arg))
496                 return -EFAULT;
497 #endif
498
499         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
500          * with the real speed so its unconditionally usable */
501         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
502         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
503
504         ld = tty_ldisc_ref(tty);
505
506         if (ld != NULL) {
507                 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
508                         ld->flush_buffer(tty);
509                 tty_ldisc_deref(ld);
510         }
511
512         if (opt & TERMIOS_WAIT) {
513                 tty_wait_until_sent(tty, 0);
514                 if (signal_pending(current))
515                         return -EINTR;
516         }
517
518         change_termios(tty, &tmp_termios);
519
520         /* FIXME: Arguably if tmp_termios == tty->termios AND the
521            actual requested termios was not tmp_termios then we may
522            want to return an error as no user requested change has
523            succeeded */
524         return 0;
525 }
526
527 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
528 {
529         if (kernel_termios_to_user_termio(termio, tty->termios))
530                 return -EFAULT;
531         return 0;
532 }
533
534 static unsigned long inq_canon(struct tty_struct *tty)
535 {
536         int nr, head, tail;
537
538         if (!tty->canon_data || !tty->read_buf)
539                 return 0;
540         head = tty->canon_head;
541         tail = tty->read_tail;
542         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
543         /* Skip EOF-chars.. */
544         while (head != tail) {
545                 if (test_bit(tail, tty->read_flags) &&
546                     tty->read_buf[tail] == __DISABLED_CHAR)
547                         nr--;
548                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
549         }
550         return nr;
551 }
552
553 #ifdef TIOCGETP
554 /*
555  * These are deprecated, but there is limited support..
556  *
557  * The "sg_flags" translation is a joke..
558  */
559 static int get_sgflags(struct tty_struct *tty)
560 {
561         int flags = 0;
562
563         if (!(tty->termios->c_lflag & ICANON)) {
564                 if (tty->termios->c_lflag & ISIG)
565                         flags |= 0x02;          /* cbreak */
566                 else
567                         flags |= 0x20;          /* raw */
568         }
569         if (tty->termios->c_lflag & ECHO)
570                 flags |= 0x08;                  /* echo */
571         if (tty->termios->c_oflag & OPOST)
572                 if (tty->termios->c_oflag & ONLCR)
573                         flags |= 0x10;          /* crmod */
574         return flags;
575 }
576
577 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
578 {
579         struct sgttyb tmp;
580
581         mutex_lock(&tty->termios_mutex);
582         tmp.sg_ispeed = tty->termios->c_ispeed;
583         tmp.sg_ospeed = tty->termios->c_ospeed;
584         tmp.sg_erase = tty->termios->c_cc[VERASE];
585         tmp.sg_kill = tty->termios->c_cc[VKILL];
586         tmp.sg_flags = get_sgflags(tty);
587         mutex_unlock(&tty->termios_mutex);
588
589         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
590 }
591
592 static void set_sgflags(struct ktermios *termios, int flags)
593 {
594         termios->c_iflag = ICRNL | IXON;
595         termios->c_oflag = 0;
596         termios->c_lflag = ISIG | ICANON;
597         if (flags & 0x02) {     /* cbreak */
598                 termios->c_iflag = 0;
599                 termios->c_lflag &= ~ICANON;
600         }
601         if (flags & 0x08) {             /* echo */
602                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
603                                     ECHOCTL | ECHOKE | IEXTEN;
604         }
605         if (flags & 0x10) {             /* crmod */
606                 termios->c_oflag |= OPOST | ONLCR;
607         }
608         if (flags & 0x20) {     /* raw */
609                 termios->c_iflag = 0;
610                 termios->c_lflag &= ~(ISIG | ICANON);
611         }
612         if (!(termios->c_lflag & ICANON)) {
613                 termios->c_cc[VMIN] = 1;
614                 termios->c_cc[VTIME] = 0;
615         }
616 }
617
618 /**
619  *      set_sgttyb              -       set legacy terminal values
620  *      @tty: tty structure
621  *      @sgttyb: pointer to old style terminal structure
622  *
623  *      Updates a terminal from the legacy BSD style terminal information
624  *      structure.
625  *
626  *      Locking: termios_sem
627  */
628
629 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
630 {
631         int retval;
632         struct sgttyb tmp;
633         struct ktermios termios;
634
635         retval = tty_check_change(tty);
636         if (retval)
637                 return retval;
638
639         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
640                 return -EFAULT;
641
642         mutex_lock(&tty->termios_mutex);
643         termios = *tty->termios;
644         termios.c_cc[VERASE] = tmp.sg_erase;
645         termios.c_cc[VKILL] = tmp.sg_kill;
646         set_sgflags(&termios, tmp.sg_flags);
647         /* Try and encode into Bfoo format */
648 #ifdef BOTHER
649         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
650                                                 termios.c_ospeed);
651 #endif
652         mutex_unlock(&tty->termios_mutex);
653         change_termios(tty, &termios);
654         return 0;
655 }
656 #endif
657
658 #ifdef TIOCGETC
659 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
660 {
661         struct tchars tmp;
662
663         tmp.t_intrc = tty->termios->c_cc[VINTR];
664         tmp.t_quitc = tty->termios->c_cc[VQUIT];
665         tmp.t_startc = tty->termios->c_cc[VSTART];
666         tmp.t_stopc = tty->termios->c_cc[VSTOP];
667         tmp.t_eofc = tty->termios->c_cc[VEOF];
668         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
669         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
670 }
671
672 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
673 {
674         struct tchars tmp;
675
676         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
677                 return -EFAULT;
678         tty->termios->c_cc[VINTR] = tmp.t_intrc;
679         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
680         tty->termios->c_cc[VSTART] = tmp.t_startc;
681         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
682         tty->termios->c_cc[VEOF] = tmp.t_eofc;
683         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
684         return 0;
685 }
686 #endif
687
688 #ifdef TIOCGLTC
689 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
690 {
691         struct ltchars tmp;
692
693         tmp.t_suspc = tty->termios->c_cc[VSUSP];
694         /* what is dsuspc anyway? */
695         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
696         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
697         /* what is flushc anyway? */
698         tmp.t_flushc = tty->termios->c_cc[VEOL2];
699         tmp.t_werasc = tty->termios->c_cc[VWERASE];
700         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
701         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
702 }
703
704 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
705 {
706         struct ltchars tmp;
707
708         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
709                 return -EFAULT;
710
711         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
712         /* what is dsuspc anyway? */
713         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
714         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
715         /* what is flushc anyway? */
716         tty->termios->c_cc[VEOL2] = tmp.t_flushc;
717         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
718         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
719         return 0;
720 }
721 #endif
722
723 /**
724  *      send_prio_char          -       send priority character
725  *
726  *      Send a high priority character to the tty even if stopped
727  *
728  *      Locking: none for xchar method, write ordering for write method.
729  */
730
731 static int send_prio_char(struct tty_struct *tty, char ch)
732 {
733         int     was_stopped = tty->stopped;
734
735         if (tty->driver->send_xchar) {
736                 tty->driver->send_xchar(tty, ch);
737                 return 0;
738         }
739
740         if (tty_write_lock(tty, 0) < 0)
741                 return -ERESTARTSYS;
742
743         if (was_stopped)
744                 start_tty(tty);
745         tty->driver->write(tty, &ch, 1);
746         if (was_stopped)
747                 stop_tty(tty);
748         tty_write_unlock(tty);
749         return 0;
750 }
751
752 /**
753  *      tty_mode_ioctl          -       mode related ioctls
754  *      @tty: tty for the ioctl
755  *      @file: file pointer for the tty
756  *      @cmd: command
757  *      @arg: ioctl argument
758  *
759  *      Perform non line discipline specific mode control ioctls. This
760  *      is designed to be called by line disciplines to ensure they provide
761  *      consistent mode setting.
762  */
763
764 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
765                         unsigned int cmd, unsigned long arg)
766 {
767         struct tty_struct *real_tty;
768         void __user *p = (void __user *)arg;
769
770         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
771             tty->driver->subtype == PTY_TYPE_MASTER)
772                 real_tty = tty->link;
773         else
774                 real_tty = tty;
775
776         switch (cmd) {
777 #ifdef TIOCGETP
778         case TIOCGETP:
779                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
780         case TIOCSETP:
781         case TIOCSETN:
782                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
783 #endif
784 #ifdef TIOCGETC
785         case TIOCGETC:
786                 return get_tchars(real_tty, p);
787         case TIOCSETC:
788                 return set_tchars(real_tty, p);
789 #endif
790 #ifdef TIOCGLTC
791         case TIOCGLTC:
792                 return get_ltchars(real_tty, p);
793         case TIOCSLTC:
794                 return set_ltchars(real_tty, p);
795 #endif
796         case TCSETSF:
797                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
798         case TCSETSW:
799                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
800         case TCSETS:
801                 return set_termios(real_tty, p, TERMIOS_OLD);
802 #ifndef TCGETS2
803         case TCGETS:
804                 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
805                         return -EFAULT;
806                 return 0;
807 #else
808         case TCGETS:
809                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
810                         return -EFAULT;
811                 return 0;
812         case TCGETS2:
813                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
814                         return -EFAULT;
815                 return 0;
816         case TCSETSF2:
817                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
818         case TCSETSW2:
819                 return set_termios(real_tty, p, TERMIOS_WAIT);
820         case TCSETS2:
821                 return set_termios(real_tty, p, 0);
822 #endif
823         case TCGETA:
824                 return get_termio(real_tty, p);
825         case TCSETAF:
826                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
827         case TCSETAW:
828                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
829         case TCSETA:
830                 return set_termios(real_tty, p, TERMIOS_TERMIO);
831 #ifndef TCGETS2
832         case TIOCGLCKTRMIOS:
833                 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
834                         return -EFAULT;
835                 return 0;
836         case TIOCSLCKTRMIOS:
837                 if (!capable(CAP_SYS_ADMIN))
838                         return -EPERM;
839                 if (user_termios_to_kernel_termios(real_tty->termios_locked,
840                                                (struct termios __user *) arg))
841                         return -EFAULT;
842                 return 0;
843 #else
844         case TIOCGLCKTRMIOS:
845                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios_locked))
846                         return -EFAULT;
847                 return 0;
848         case TIOCSLCKTRMIOS:
849                 if (!capable(CAP_SYS_ADMIN))
850                         return -EPERM;
851                 if (user_termios_to_kernel_termios_1(real_tty->termios_locked,
852                                                (struct termios __user *) arg))
853                         return -EFAULT;
854                         return 0;
855 #endif
856         case TIOCGSOFTCAR:
857                 return put_user(C_CLOCAL(tty) ? 1 : 0,
858                                                 (int __user *)arg);
859         case TIOCSSOFTCAR:
860                 if (get_user(arg, (unsigned int __user *) arg))
861                         return -EFAULT;
862                 mutex_lock(&tty->termios_mutex);
863                 tty->termios->c_cflag =
864                         ((tty->termios->c_cflag & ~CLOCAL) |
865                          (arg ? CLOCAL : 0));
866                 mutex_unlock(&tty->termios_mutex);
867                 return 0;
868         default:
869                 return -ENOIOCTLCMD;
870         }
871 }
872 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
873
874 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
875 {
876         struct tty_ldisc *ld;
877         int retval = tty_check_change(tty);
878         if (retval)
879                 return retval;
880
881         ld = tty_ldisc_ref(tty);
882         switch (arg) {
883         case TCIFLUSH:
884                 if (ld && ld->flush_buffer)
885                         ld->flush_buffer(tty);
886                 break;
887         case TCIOFLUSH:
888                 if (ld && ld->flush_buffer)
889                         ld->flush_buffer(tty);
890                 /* fall through */
891         case TCOFLUSH:
892                 if (tty->driver->flush_buffer)
893                         tty->driver->flush_buffer(tty);
894                 break;
895         default:
896                 tty_ldisc_deref(ld);
897                 return -EINVAL;
898         }
899         tty_ldisc_deref(ld);
900         return 0;
901 }
902 EXPORT_SYMBOL_GPL(tty_perform_flush);
903
904 int n_tty_ioctl(struct tty_struct *tty, struct file *file,
905                        unsigned int cmd, unsigned long arg)
906 {
907         struct tty_struct *real_tty;
908         int retval;
909
910         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
911             tty->driver->subtype == PTY_TYPE_MASTER)
912                 real_tty = tty->link;
913         else
914                 real_tty = tty;
915
916         switch (cmd) {
917         case TCXONC:
918                 retval = tty_check_change(tty);
919                 if (retval)
920                         return retval;
921                 switch (arg) {
922                 case TCOOFF:
923                         if (!tty->flow_stopped) {
924                                 tty->flow_stopped = 1;
925                                 stop_tty(tty);
926                         }
927                         break;
928                 case TCOON:
929                         if (tty->flow_stopped) {
930                                 tty->flow_stopped = 0;
931                                 start_tty(tty);
932                         }
933                         break;
934                 case TCIOFF:
935                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
936                                 return send_prio_char(tty, STOP_CHAR(tty));
937                         break;
938                 case TCION:
939                         if (START_CHAR(tty) != __DISABLED_CHAR)
940                                 return send_prio_char(tty, START_CHAR(tty));
941                         break;
942                 default:
943                         return -EINVAL;
944                 }
945                 return 0;
946         case TCFLSH:
947                 return tty_perform_flush(tty, arg);
948         case TIOCOUTQ:
949                 return put_user(tty->driver->chars_in_buffer ?
950                                 tty->driver->chars_in_buffer(tty) : 0,
951                                 (int __user *) arg);
952         case TIOCINQ:
953                 retval = tty->read_cnt;
954                 if (L_ICANON(tty))
955                         retval = inq_canon(tty);
956                 return put_user(retval, (unsigned int __user *) arg);
957         case TIOCPKT:
958         {
959                 int pktmode;
960
961                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
962                     tty->driver->subtype != PTY_TYPE_MASTER)
963                         return -ENOTTY;
964                 if (get_user(pktmode, (int __user *) arg))
965                         return -EFAULT;
966                 if (pktmode) {
967                         if (!tty->packet) {
968                                 tty->packet = 1;
969                                 tty->link->ctrl_status = 0;
970                         }
971                 } else
972                         tty->packet = 0;
973                 return 0;
974         }
975         default:
976                 /* Try the mode commands */
977                 return tty_mode_ioctl(tty, file, cmd, arg);
978         }
979 }
980 EXPORT_SYMBOL(n_tty_ioctl);