GNU Linux-libre 4.9.309-gnu1
[releases.git] / drivers / tty / tty_ioctl.c
1 /*
2  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
3  *
4  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
5  * which can be dynamically activated and de-activated by the line
6  * discipline handling modules (like SLIP).
7  */
8
9 #include <linux/types.h>
10 #include <linux/termios.h>
11 #include <linux/errno.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/major.h>
15 #include <linux/tty.h>
16 #include <linux/fcntl.h>
17 #include <linux/string.h>
18 #include <linux/mm.h>
19 #include <linux/module.h>
20 #include <linux/bitops.h>
21 #include <linux/mutex.h>
22 #include <linux/compat.h>
23
24 #include <asm/io.h>
25 #include <asm/uaccess.h>
26
27 #undef TTY_DEBUG_WAIT_UNTIL_SENT
28
29 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
30 # define tty_debug_wait_until_sent(tty, f, args...)    tty_debug(tty, f, ##args)
31 #else
32 # define tty_debug_wait_until_sent(tty, f, args...)    do {} while (0)
33 #endif
34
35 #undef  DEBUG
36
37 /*
38  * Internal flag options for termios setting behavior
39  */
40 #define TERMIOS_FLUSH   1
41 #define TERMIOS_WAIT    2
42 #define TERMIOS_TERMIO  4
43 #define TERMIOS_OLD     8
44
45
46 /**
47  *      tty_chars_in_buffer     -       characters pending
48  *      @tty: terminal
49  *
50  *      Return the number of bytes of data in the device private
51  *      output queue. If no private method is supplied there is assumed
52  *      to be no queue on the device.
53  */
54
55 int tty_chars_in_buffer(struct tty_struct *tty)
56 {
57         if (tty->ops->chars_in_buffer)
58                 return tty->ops->chars_in_buffer(tty);
59         else
60                 return 0;
61 }
62 EXPORT_SYMBOL(tty_chars_in_buffer);
63
64 /**
65  *      tty_write_room          -       write queue space
66  *      @tty: terminal
67  *
68  *      Return the number of bytes that can be queued to this device
69  *      at the present time. The result should be treated as a guarantee
70  *      and the driver cannot offer a value it later shrinks by more than
71  *      the number of bytes written. If no method is provided 2K is always
72  *      returned and data may be lost as there will be no flow control.
73  */
74  
75 int tty_write_room(struct tty_struct *tty)
76 {
77         if (tty->ops->write_room)
78                 return tty->ops->write_room(tty);
79         return 2048;
80 }
81 EXPORT_SYMBOL(tty_write_room);
82
83 /**
84  *      tty_driver_flush_buffer -       discard internal buffer
85  *      @tty: terminal
86  *
87  *      Discard the internal output buffer for this device. If no method
88  *      is provided then either the buffer cannot be hardware flushed or
89  *      there is no buffer driver side.
90  */
91 void tty_driver_flush_buffer(struct tty_struct *tty)
92 {
93         if (tty->ops->flush_buffer)
94                 tty->ops->flush_buffer(tty);
95 }
96 EXPORT_SYMBOL(tty_driver_flush_buffer);
97
98 /**
99  *      tty_throttle            -       flow control
100  *      @tty: terminal
101  *
102  *      Indicate that a tty should stop transmitting data down the stack.
103  *      Takes the termios rwsem to protect against parallel throttle/unthrottle
104  *      and also to ensure the driver can consistently reference its own
105  *      termios data at this point when implementing software flow control.
106  */
107
108 void tty_throttle(struct tty_struct *tty)
109 {
110         down_write(&tty->termios_rwsem);
111         /* check TTY_THROTTLED first so it indicates our state */
112         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
113             tty->ops->throttle)
114                 tty->ops->throttle(tty);
115         tty->flow_change = 0;
116         up_write(&tty->termios_rwsem);
117 }
118 EXPORT_SYMBOL(tty_throttle);
119
120 /**
121  *      tty_unthrottle          -       flow control
122  *      @tty: terminal
123  *
124  *      Indicate that a tty may continue transmitting data down the stack.
125  *      Takes the termios rwsem to protect against parallel throttle/unthrottle
126  *      and also to ensure the driver can consistently reference its own
127  *      termios data at this point when implementing software flow control.
128  *
129  *      Drivers should however remember that the stack can issue a throttle,
130  *      then change flow control method, then unthrottle.
131  */
132
133 void tty_unthrottle(struct tty_struct *tty)
134 {
135         down_write(&tty->termios_rwsem);
136         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
137             tty->ops->unthrottle)
138                 tty->ops->unthrottle(tty);
139         tty->flow_change = 0;
140         up_write(&tty->termios_rwsem);
141 }
142 EXPORT_SYMBOL(tty_unthrottle);
143
144 /**
145  *      tty_throttle_safe       -       flow control
146  *      @tty: terminal
147  *
148  *      Similar to tty_throttle() but will only attempt throttle
149  *      if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
150  *      throttle due to race conditions when throttling is conditional
151  *      on factors evaluated prior to throttling.
152  *
153  *      Returns 0 if tty is throttled (or was already throttled)
154  */
155
156 int tty_throttle_safe(struct tty_struct *tty)
157 {
158         int ret = 0;
159
160         mutex_lock(&tty->throttle_mutex);
161         if (!tty_throttled(tty)) {
162                 if (tty->flow_change != TTY_THROTTLE_SAFE)
163                         ret = 1;
164                 else {
165                         set_bit(TTY_THROTTLED, &tty->flags);
166                         if (tty->ops->throttle)
167                                 tty->ops->throttle(tty);
168                 }
169         }
170         mutex_unlock(&tty->throttle_mutex);
171
172         return ret;
173 }
174
175 /**
176  *      tty_unthrottle_safe     -       flow control
177  *      @tty: terminal
178  *
179  *      Similar to tty_unthrottle() but will only attempt unthrottle
180  *      if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
181  *      unthrottle due to race conditions when unthrottling is conditional
182  *      on factors evaluated prior to unthrottling.
183  *
184  *      Returns 0 if tty is unthrottled (or was already unthrottled)
185  */
186
187 int tty_unthrottle_safe(struct tty_struct *tty)
188 {
189         int ret = 0;
190
191         mutex_lock(&tty->throttle_mutex);
192         if (tty_throttled(tty)) {
193                 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
194                         ret = 1;
195                 else {
196                         clear_bit(TTY_THROTTLED, &tty->flags);
197                         if (tty->ops->unthrottle)
198                                 tty->ops->unthrottle(tty);
199                 }
200         }
201         mutex_unlock(&tty->throttle_mutex);
202
203         return ret;
204 }
205
206 /**
207  *      tty_wait_until_sent     -       wait for I/O to finish
208  *      @tty: tty we are waiting for
209  *      @timeout: how long we will wait
210  *
211  *      Wait for characters pending in a tty driver to hit the wire, or
212  *      for a timeout to occur (eg due to flow control)
213  *
214  *      Locking: none
215  */
216
217 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
218 {
219         tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
220
221         if (!timeout)
222                 timeout = MAX_SCHEDULE_TIMEOUT;
223
224         timeout = wait_event_interruptible_timeout(tty->write_wait,
225                         !tty_chars_in_buffer(tty), timeout);
226         if (timeout <= 0)
227                 return;
228
229         if (timeout == MAX_SCHEDULE_TIMEOUT)
230                 timeout = 0;
231
232         if (tty->ops->wait_until_sent)
233                 tty->ops->wait_until_sent(tty, timeout);
234 }
235 EXPORT_SYMBOL(tty_wait_until_sent);
236
237
238 /*
239  *              Termios Helper Methods
240  */
241
242 static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
243 {
244         struct ktermios *termios = &tty->termios;
245         struct ktermios *locked  = &tty->termios_locked;
246         int     i;
247
248 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
249
250         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
251         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
252         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
253         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
254         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
255         for (i = 0; i < NCCS; i++)
256                 termios->c_cc[i] = locked->c_cc[i] ?
257                         old->c_cc[i] : termios->c_cc[i];
258         /* FIXME: What should we do for i/ospeed */
259 }
260
261 /*
262  * Routine which returns the baud rate of the tty
263  *
264  * Note that the baud_table needs to be kept in sync with the
265  * include/asm/termbits.h file.
266  */
267 static const speed_t baud_table[] = {
268         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
269         9600, 19200, 38400, 57600, 115200, 230400, 460800,
270 #ifdef __sparc__
271         76800, 153600, 307200, 614400, 921600
272 #else
273         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
274         2500000, 3000000, 3500000, 4000000
275 #endif
276 };
277
278 #ifndef __sparc__
279 static const tcflag_t baud_bits[] = {
280         B0, B50, B75, B110, B134, B150, B200, B300, B600,
281         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
282         B57600, B115200, B230400, B460800, B500000, B576000,
283         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
284         B3000000, B3500000, B4000000
285 };
286 #else
287 static const tcflag_t baud_bits[] = {
288         B0, B50, B75, B110, B134, B150, B200, B300, B600,
289         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
290         B57600, B115200, B230400, B460800, B76800, B153600,
291         B307200, B614400, B921600
292 };
293 #endif
294
295 static int n_baud_table = ARRAY_SIZE(baud_table);
296
297 /**
298  *      tty_termios_baud_rate
299  *      @termios: termios structure
300  *
301  *      Convert termios baud rate data into a speed. This should be called
302  *      with the termios lock held if this termios is a terminal termios
303  *      structure. May change the termios data. Device drivers can call this
304  *      function but should use ->c_[io]speed directly as they are updated.
305  *
306  *      Locking: none
307  */
308
309 speed_t tty_termios_baud_rate(struct ktermios *termios)
310 {
311         unsigned int cbaud;
312
313         cbaud = termios->c_cflag & CBAUD;
314
315 #ifdef BOTHER
316         /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
317         if (cbaud == BOTHER)
318                 return termios->c_ospeed;
319 #endif
320         if (cbaud & CBAUDEX) {
321                 cbaud &= ~CBAUDEX;
322
323                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
324                         termios->c_cflag &= ~CBAUDEX;
325                 else
326                         cbaud += 15;
327         }
328         return cbaud >= n_baud_table ? 0 : baud_table[cbaud];
329 }
330 EXPORT_SYMBOL(tty_termios_baud_rate);
331
332 /**
333  *      tty_termios_input_baud_rate
334  *      @termios: termios structure
335  *
336  *      Convert termios baud rate data into a speed. This should be called
337  *      with the termios lock held if this termios is a terminal termios
338  *      structure. May change the termios data. Device drivers can call this
339  *      function but should use ->c_[io]speed directly as they are updated.
340  *
341  *      Locking: none
342  */
343
344 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
345 {
346 #ifdef IBSHIFT
347         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
348
349         if (cbaud == B0)
350                 return tty_termios_baud_rate(termios);
351
352         /* Magic token for arbitrary speed via c_ispeed*/
353         if (cbaud == BOTHER)
354                 return termios->c_ispeed;
355
356         if (cbaud & CBAUDEX) {
357                 cbaud &= ~CBAUDEX;
358
359                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
360                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
361                 else
362                         cbaud += 15;
363         }
364         return cbaud >= n_baud_table ? 0 : baud_table[cbaud];
365 #else
366         return tty_termios_baud_rate(termios);
367 #endif
368 }
369 EXPORT_SYMBOL(tty_termios_input_baud_rate);
370
371 /**
372  *      tty_termios_encode_baud_rate
373  *      @termios: ktermios structure holding user requested state
374  *      @ispeed: input speed
375  *      @ospeed: output speed
376  *
377  *      Encode the speeds set into the passed termios structure. This is
378  *      used as a library helper for drivers so that they can report back
379  *      the actual speed selected when it differs from the speed requested
380  *
381  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
382  *      we need to carefully set the bits when the user does not get the
383  *      desired speed. We allow small margins and preserve as much of possible
384  *      of the input intent to keep compatibility.
385  *
386  *      Locking: Caller should hold termios lock. This is already held
387  *      when calling this function from the driver termios handler.
388  *
389  *      The ifdefs deal with platforms whose owners have yet to update them
390  *      and will all go away once this is done.
391  */
392
393 void tty_termios_encode_baud_rate(struct ktermios *termios,
394                                   speed_t ibaud, speed_t obaud)
395 {
396         int i = 0;
397         int ifound = -1, ofound = -1;
398         int iclose = ibaud/50, oclose = obaud/50;
399         int ibinput = 0;
400
401         if (obaud == 0)                 /* CD dropped             */
402                 ibaud = 0;              /* Clear ibaud to be sure */
403
404         termios->c_ispeed = ibaud;
405         termios->c_ospeed = obaud;
406
407 #ifdef BOTHER
408         /* If the user asked for a precise weird speed give a precise weird
409            answer. If they asked for a Bfoo speed they may have problems
410            digesting non-exact replies so fuzz a bit */
411
412         if ((termios->c_cflag & CBAUD) == BOTHER)
413                 oclose = 0;
414         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
415                 iclose = 0;
416         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
417                 ibinput = 1;    /* An input speed was specified */
418 #endif
419         termios->c_cflag &= ~CBAUD;
420
421         /*
422          *      Our goal is to find a close match to the standard baud rate
423          *      returned. Walk the baud rate table and if we get a very close
424          *      match then report back the speed as a POSIX Bxxxx value by
425          *      preference
426          */
427
428         do {
429                 if (obaud - oclose <= baud_table[i] &&
430                     obaud + oclose >= baud_table[i]) {
431                         termios->c_cflag |= baud_bits[i];
432                         ofound = i;
433                 }
434                 if (ibaud - iclose <= baud_table[i] &&
435                     ibaud + iclose >= baud_table[i]) {
436                         /* For the case input == output don't set IBAUD bits
437                            if the user didn't do so */
438                         if (ofound == i && !ibinput)
439                                 ifound  = i;
440 #ifdef IBSHIFT
441                         else {
442                                 ifound = i;
443                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
444                         }
445 #endif
446                 }
447         } while (++i < n_baud_table);
448
449         /*
450          *      If we found no match then use BOTHER if provided or warn
451          *      the user their platform maintainer needs to wake up if not.
452          */
453 #ifdef BOTHER
454         if (ofound == -1)
455                 termios->c_cflag |= BOTHER;
456         /* Set exact input bits only if the input and output differ or the
457            user already did */
458         if (ifound == -1 && (ibaud != obaud || ibinput))
459                 termios->c_cflag |= (BOTHER << IBSHIFT);
460 #else
461         if (ifound == -1 || ofound == -1)
462                 pr_warn_once("tty: Unable to return correct speed data as your architecture needs updating.\n");
463 #endif
464 }
465 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
466
467 /**
468  *      tty_encode_baud_rate            -       set baud rate of the tty
469  *      @ibaud: input baud rate
470  *      @obad: output baud rate
471  *
472  *      Update the current termios data for the tty with the new speed
473  *      settings. The caller must hold the termios_rwsem for the tty in
474  *      question.
475  */
476
477 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
478 {
479         tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
480 }
481 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
482
483 /**
484  *      tty_termios_copy_hw     -       copy hardware settings
485  *      @new: New termios
486  *      @old: Old termios
487  *
488  *      Propagate the hardware specific terminal setting bits from
489  *      the old termios structure to the new one. This is used in cases
490  *      where the hardware does not support reconfiguration or as a helper
491  *      in some cases where only minimal reconfiguration is supported
492  */
493
494 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
495 {
496         /* The bits a dumb device handles in software. Smart devices need
497            to always provide a set_termios method */
498         new->c_cflag &= HUPCL | CREAD | CLOCAL;
499         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
500         new->c_ispeed = old->c_ispeed;
501         new->c_ospeed = old->c_ospeed;
502 }
503 EXPORT_SYMBOL(tty_termios_copy_hw);
504
505 /**
506  *      tty_termios_hw_change   -       check for setting change
507  *      @a: termios
508  *      @b: termios to compare
509  *
510  *      Check if any of the bits that affect a dumb device have changed
511  *      between the two termios structures, or a speed change is needed.
512  */
513
514 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
515 {
516         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
517                 return 1;
518         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
519                 return 1;
520         return 0;
521 }
522 EXPORT_SYMBOL(tty_termios_hw_change);
523
524 /**
525  *      tty_set_termios         -       update termios values
526  *      @tty: tty to update
527  *      @new_termios: desired new value
528  *
529  *      Perform updates to the termios values set on this terminal.
530  *      A master pty's termios should never be set.
531  *
532  *      Locking: termios_rwsem
533  */
534
535 int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
536 {
537         struct ktermios old_termios;
538         struct tty_ldisc *ld;
539
540         WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
541                 tty->driver->subtype == PTY_TYPE_MASTER);
542         /*
543          *      Perform the actual termios internal changes under lock.
544          */
545
546
547         /* FIXME: we need to decide on some locking/ordering semantics
548            for the set_termios notification eventually */
549         down_write(&tty->termios_rwsem);
550         old_termios = tty->termios;
551         tty->termios = *new_termios;
552         unset_locked_termios(tty, &old_termios);
553
554         if (tty->ops->set_termios)
555                 tty->ops->set_termios(tty, &old_termios);
556         else
557                 tty_termios_copy_hw(&tty->termios, &old_termios);
558
559         ld = tty_ldisc_ref(tty);
560         if (ld != NULL) {
561                 if (ld->ops->set_termios)
562                         ld->ops->set_termios(tty, &old_termios);
563                 tty_ldisc_deref(ld);
564         }
565         up_write(&tty->termios_rwsem);
566         return 0;
567 }
568 EXPORT_SYMBOL_GPL(tty_set_termios);
569
570 /**
571  *      set_termios             -       set termios values for a tty
572  *      @tty: terminal device
573  *      @arg: user data
574  *      @opt: option information
575  *
576  *      Helper function to prepare termios data and run necessary other
577  *      functions before using tty_set_termios to do the actual changes.
578  *
579  *      Locking:
580  *              Called functions take ldisc and termios_rwsem locks
581  */
582
583 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
584 {
585         struct ktermios tmp_termios;
586         struct tty_ldisc *ld;
587         int retval = tty_check_change(tty);
588
589         if (retval)
590                 return retval;
591
592         down_read(&tty->termios_rwsem);
593         tmp_termios = tty->termios;
594         up_read(&tty->termios_rwsem);
595
596         if (opt & TERMIOS_TERMIO) {
597                 if (user_termio_to_kernel_termios(&tmp_termios,
598                                                 (struct termio __user *)arg))
599                         return -EFAULT;
600 #ifdef TCGETS2
601         } else if (opt & TERMIOS_OLD) {
602                 if (user_termios_to_kernel_termios_1(&tmp_termios,
603                                                 (struct termios __user *)arg))
604                         return -EFAULT;
605         } else {
606                 if (user_termios_to_kernel_termios(&tmp_termios,
607                                                 (struct termios2 __user *)arg))
608                         return -EFAULT;
609         }
610 #else
611         } else if (user_termios_to_kernel_termios(&tmp_termios,
612                                         (struct termios __user *)arg))
613                 return -EFAULT;
614 #endif
615
616         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
617          * with the real speed so its unconditionally usable */
618         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
619         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
620
621         ld = tty_ldisc_ref(tty);
622
623         if (ld != NULL) {
624                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
625                         ld->ops->flush_buffer(tty);
626                 tty_ldisc_deref(ld);
627         }
628
629         if (opt & TERMIOS_WAIT) {
630                 tty_wait_until_sent(tty, 0);
631                 if (signal_pending(current))
632                         return -ERESTARTSYS;
633         }
634
635         tty_set_termios(tty, &tmp_termios);
636
637         /* FIXME: Arguably if tmp_termios == tty->termios AND the
638            actual requested termios was not tmp_termios then we may
639            want to return an error as no user requested change has
640            succeeded */
641         return 0;
642 }
643
644 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
645 {
646         down_read(&tty->termios_rwsem);
647         *kterm = tty->termios;
648         up_read(&tty->termios_rwsem);
649 }
650
651 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
652 {
653         down_read(&tty->termios_rwsem);
654         *kterm = tty->termios_locked;
655         up_read(&tty->termios_rwsem);
656 }
657
658 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
659 {
660         struct ktermios kterm;
661         copy_termios(tty, &kterm);
662         if (kernel_termios_to_user_termio(termio, &kterm))
663                 return -EFAULT;
664         return 0;
665 }
666
667
668 #ifdef TCGETX
669
670 /**
671  *      set_termiox     -       set termiox fields if possible
672  *      @tty: terminal
673  *      @arg: termiox structure from user
674  *      @opt: option flags for ioctl type
675  *
676  *      Implement the device calling points for the SYS5 termiox ioctl
677  *      interface in Linux
678  */
679
680 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
681 {
682         struct termiox tnew;
683         struct tty_ldisc *ld;
684
685         if (tty->termiox == NULL)
686                 return -EINVAL;
687         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
688                 return -EFAULT;
689
690         ld = tty_ldisc_ref(tty);
691         if (ld != NULL) {
692                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
693                         ld->ops->flush_buffer(tty);
694                 tty_ldisc_deref(ld);
695         }
696         if (opt & TERMIOS_WAIT) {
697                 tty_wait_until_sent(tty, 0);
698                 if (signal_pending(current))
699                         return -ERESTARTSYS;
700         }
701
702         down_write(&tty->termios_rwsem);
703         if (tty->ops->set_termiox)
704                 tty->ops->set_termiox(tty, &tnew);
705         up_write(&tty->termios_rwsem);
706         return 0;
707 }
708
709 #endif
710
711
712 #ifdef TIOCGETP
713 /*
714  * These are deprecated, but there is limited support..
715  *
716  * The "sg_flags" translation is a joke..
717  */
718 static int get_sgflags(struct tty_struct *tty)
719 {
720         int flags = 0;
721
722         if (!L_ICANON(tty)) {
723                 if (L_ISIG(tty))
724                         flags |= 0x02;          /* cbreak */
725                 else
726                         flags |= 0x20;          /* raw */
727         }
728         if (L_ECHO(tty))
729                 flags |= 0x08;                  /* echo */
730         if (O_OPOST(tty))
731                 if (O_ONLCR(tty))
732                         flags |= 0x10;          /* crmod */
733         return flags;
734 }
735
736 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
737 {
738         struct sgttyb tmp;
739
740         down_read(&tty->termios_rwsem);
741         tmp.sg_ispeed = tty->termios.c_ispeed;
742         tmp.sg_ospeed = tty->termios.c_ospeed;
743         tmp.sg_erase = tty->termios.c_cc[VERASE];
744         tmp.sg_kill = tty->termios.c_cc[VKILL];
745         tmp.sg_flags = get_sgflags(tty);
746         up_read(&tty->termios_rwsem);
747
748         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
749 }
750
751 static void set_sgflags(struct ktermios *termios, int flags)
752 {
753         termios->c_iflag = ICRNL | IXON;
754         termios->c_oflag = 0;
755         termios->c_lflag = ISIG | ICANON;
756         if (flags & 0x02) {     /* cbreak */
757                 termios->c_iflag = 0;
758                 termios->c_lflag &= ~ICANON;
759         }
760         if (flags & 0x08) {             /* echo */
761                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
762                                     ECHOCTL | ECHOKE | IEXTEN;
763         }
764         if (flags & 0x10) {             /* crmod */
765                 termios->c_oflag |= OPOST | ONLCR;
766         }
767         if (flags & 0x20) {     /* raw */
768                 termios->c_iflag = 0;
769                 termios->c_lflag &= ~(ISIG | ICANON);
770         }
771         if (!(termios->c_lflag & ICANON)) {
772                 termios->c_cc[VMIN] = 1;
773                 termios->c_cc[VTIME] = 0;
774         }
775 }
776
777 /**
778  *      set_sgttyb              -       set legacy terminal values
779  *      @tty: tty structure
780  *      @sgttyb: pointer to old style terminal structure
781  *
782  *      Updates a terminal from the legacy BSD style terminal information
783  *      structure.
784  *
785  *      Locking: termios_rwsem
786  */
787
788 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
789 {
790         int retval;
791         struct sgttyb tmp;
792         struct ktermios termios;
793
794         retval = tty_check_change(tty);
795         if (retval)
796                 return retval;
797
798         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
799                 return -EFAULT;
800
801         down_write(&tty->termios_rwsem);
802         termios = tty->termios;
803         termios.c_cc[VERASE] = tmp.sg_erase;
804         termios.c_cc[VKILL] = tmp.sg_kill;
805         set_sgflags(&termios, tmp.sg_flags);
806         /* Try and encode into Bfoo format */
807 #ifdef BOTHER
808         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
809                                                 termios.c_ospeed);
810 #endif
811         up_write(&tty->termios_rwsem);
812         tty_set_termios(tty, &termios);
813         return 0;
814 }
815 #endif
816
817 #ifdef TIOCGETC
818 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
819 {
820         struct tchars tmp;
821
822         down_read(&tty->termios_rwsem);
823         tmp.t_intrc = tty->termios.c_cc[VINTR];
824         tmp.t_quitc = tty->termios.c_cc[VQUIT];
825         tmp.t_startc = tty->termios.c_cc[VSTART];
826         tmp.t_stopc = tty->termios.c_cc[VSTOP];
827         tmp.t_eofc = tty->termios.c_cc[VEOF];
828         tmp.t_brkc = tty->termios.c_cc[VEOL2];  /* what is brkc anyway? */
829         up_read(&tty->termios_rwsem);
830         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
831 }
832
833 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
834 {
835         struct tchars tmp;
836
837         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
838                 return -EFAULT;
839         down_write(&tty->termios_rwsem);
840         tty->termios.c_cc[VINTR] = tmp.t_intrc;
841         tty->termios.c_cc[VQUIT] = tmp.t_quitc;
842         tty->termios.c_cc[VSTART] = tmp.t_startc;
843         tty->termios.c_cc[VSTOP] = tmp.t_stopc;
844         tty->termios.c_cc[VEOF] = tmp.t_eofc;
845         tty->termios.c_cc[VEOL2] = tmp.t_brkc;  /* what is brkc anyway? */
846         up_write(&tty->termios_rwsem);
847         return 0;
848 }
849 #endif
850
851 #ifdef TIOCGLTC
852 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
853 {
854         struct ltchars tmp;
855
856         down_read(&tty->termios_rwsem);
857         tmp.t_suspc = tty->termios.c_cc[VSUSP];
858         /* what is dsuspc anyway? */
859         tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
860         tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
861         /* what is flushc anyway? */
862         tmp.t_flushc = tty->termios.c_cc[VEOL2];
863         tmp.t_werasc = tty->termios.c_cc[VWERASE];
864         tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
865         up_read(&tty->termios_rwsem);
866         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
867 }
868
869 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
870 {
871         struct ltchars tmp;
872
873         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
874                 return -EFAULT;
875
876         down_write(&tty->termios_rwsem);
877         tty->termios.c_cc[VSUSP] = tmp.t_suspc;
878         /* what is dsuspc anyway? */
879         tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
880         tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
881         /* what is flushc anyway? */
882         tty->termios.c_cc[VEOL2] = tmp.t_flushc;
883         tty->termios.c_cc[VWERASE] = tmp.t_werasc;
884         tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
885         up_write(&tty->termios_rwsem);
886         return 0;
887 }
888 #endif
889
890 /**
891  *      tty_change_softcar      -       carrier change ioctl helper
892  *      @tty: tty to update
893  *      @arg: enable/disable CLOCAL
894  *
895  *      Perform a change to the CLOCAL state and call into the driver
896  *      layer to make it visible. All done with the termios rwsem
897  */
898
899 static int tty_change_softcar(struct tty_struct *tty, int arg)
900 {
901         int ret = 0;
902         int bit = arg ? CLOCAL : 0;
903         struct ktermios old;
904
905         down_write(&tty->termios_rwsem);
906         old = tty->termios;
907         tty->termios.c_cflag &= ~CLOCAL;
908         tty->termios.c_cflag |= bit;
909         if (tty->ops->set_termios)
910                 tty->ops->set_termios(tty, &old);
911         if (C_CLOCAL(tty) != bit)
912                 ret = -EINVAL;
913         up_write(&tty->termios_rwsem);
914         return ret;
915 }
916
917 /**
918  *      tty_mode_ioctl          -       mode related ioctls
919  *      @tty: tty for the ioctl
920  *      @file: file pointer for the tty
921  *      @cmd: command
922  *      @arg: ioctl argument
923  *
924  *      Perform non line discipline specific mode control ioctls. This
925  *      is designed to be called by line disciplines to ensure they provide
926  *      consistent mode setting.
927  */
928
929 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
930                         unsigned int cmd, unsigned long arg)
931 {
932         struct tty_struct *real_tty;
933         void __user *p = (void __user *)arg;
934         int ret = 0;
935         struct ktermios kterm;
936
937         BUG_ON(file == NULL);
938
939         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
940             tty->driver->subtype == PTY_TYPE_MASTER)
941                 real_tty = tty->link;
942         else
943                 real_tty = tty;
944
945         switch (cmd) {
946 #ifdef TIOCGETP
947         case TIOCGETP:
948                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
949         case TIOCSETP:
950         case TIOCSETN:
951                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
952 #endif
953 #ifdef TIOCGETC
954         case TIOCGETC:
955                 return get_tchars(real_tty, p);
956         case TIOCSETC:
957                 return set_tchars(real_tty, p);
958 #endif
959 #ifdef TIOCGLTC
960         case TIOCGLTC:
961                 return get_ltchars(real_tty, p);
962         case TIOCSLTC:
963                 return set_ltchars(real_tty, p);
964 #endif
965         case TCSETSF:
966                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
967         case TCSETSW:
968                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
969         case TCSETS:
970                 return set_termios(real_tty, p, TERMIOS_OLD);
971 #ifndef TCGETS2
972         case TCGETS:
973                 copy_termios(real_tty, &kterm);
974                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
975                         ret = -EFAULT;
976                 return ret;
977 #else
978         case TCGETS:
979                 copy_termios(real_tty, &kterm);
980                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
981                         ret = -EFAULT;
982                 return ret;
983         case TCGETS2:
984                 copy_termios(real_tty, &kterm);
985                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
986                         ret = -EFAULT;
987                 return ret;
988         case TCSETSF2:
989                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
990         case TCSETSW2:
991                 return set_termios(real_tty, p, TERMIOS_WAIT);
992         case TCSETS2:
993                 return set_termios(real_tty, p, 0);
994 #endif
995         case TCGETA:
996                 return get_termio(real_tty, p);
997         case TCSETAF:
998                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
999         case TCSETAW:
1000                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1001         case TCSETA:
1002                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1003 #ifndef TCGETS2
1004         case TIOCGLCKTRMIOS:
1005                 copy_termios_locked(real_tty, &kterm);
1006                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1007                         ret = -EFAULT;
1008                 return ret;
1009         case TIOCSLCKTRMIOS:
1010                 if (!capable(CAP_SYS_ADMIN))
1011                         return -EPERM;
1012                 copy_termios_locked(real_tty, &kterm);
1013                 if (user_termios_to_kernel_termios(&kterm,
1014                                                (struct termios __user *) arg))
1015                         return -EFAULT;
1016                 down_write(&real_tty->termios_rwsem);
1017                 real_tty->termios_locked = kterm;
1018                 up_write(&real_tty->termios_rwsem);
1019                 return 0;
1020 #else
1021         case TIOCGLCKTRMIOS:
1022                 copy_termios_locked(real_tty, &kterm);
1023                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1024                         ret = -EFAULT;
1025                 return ret;
1026         case TIOCSLCKTRMIOS:
1027                 if (!capable(CAP_SYS_ADMIN))
1028                         return -EPERM;
1029                 copy_termios_locked(real_tty, &kterm);
1030                 if (user_termios_to_kernel_termios_1(&kterm,
1031                                                (struct termios __user *) arg))
1032                         return -EFAULT;
1033                 down_write(&real_tty->termios_rwsem);
1034                 real_tty->termios_locked = kterm;
1035                 up_write(&real_tty->termios_rwsem);
1036                 return ret;
1037 #endif
1038 #ifdef TCGETX
1039         case TCGETX: {
1040                 struct termiox ktermx;
1041                 if (real_tty->termiox == NULL)
1042                         return -EINVAL;
1043                 down_read(&real_tty->termios_rwsem);
1044                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1045                 up_read(&real_tty->termios_rwsem);
1046                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1047                         ret = -EFAULT;
1048                 return ret;
1049         }
1050         case TCSETX:
1051                 return set_termiox(real_tty, p, 0);
1052         case TCSETXW:
1053                 return set_termiox(real_tty, p, TERMIOS_WAIT);
1054         case TCSETXF:
1055                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1056 #endif          
1057         case TIOCGSOFTCAR:
1058                 copy_termios(real_tty, &kterm);
1059                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1060                                                 (int __user *)arg);
1061                 return ret;
1062         case TIOCSSOFTCAR:
1063                 if (get_user(arg, (unsigned int __user *) arg))
1064                         return -EFAULT;
1065                 return tty_change_softcar(real_tty, arg);
1066         default:
1067                 return -ENOIOCTLCMD;
1068         }
1069 }
1070 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1071
1072
1073 /* Caller guarantees ldisc reference is held */
1074 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1075 {
1076         struct tty_ldisc *ld = tty->ldisc;
1077
1078         switch (arg) {
1079         case TCIFLUSH:
1080                 if (ld && ld->ops->flush_buffer) {
1081                         ld->ops->flush_buffer(tty);
1082                         tty_unthrottle(tty);
1083                 }
1084                 break;
1085         case TCIOFLUSH:
1086                 if (ld && ld->ops->flush_buffer) {
1087                         ld->ops->flush_buffer(tty);
1088                         tty_unthrottle(tty);
1089                 }
1090                 /* fall through */
1091         case TCOFLUSH:
1092                 tty_driver_flush_buffer(tty);
1093                 break;
1094         default:
1095                 return -EINVAL;
1096         }
1097         return 0;
1098 }
1099
1100 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1101 {
1102         struct tty_ldisc *ld;
1103         int retval = tty_check_change(tty);
1104         if (retval)
1105                 return retval;
1106
1107         ld = tty_ldisc_ref_wait(tty);
1108         retval = __tty_perform_flush(tty, arg);
1109         if (ld)
1110                 tty_ldisc_deref(ld);
1111         return retval;
1112 }
1113 EXPORT_SYMBOL_GPL(tty_perform_flush);
1114
1115 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1116                        unsigned int cmd, unsigned long arg)
1117 {
1118         int retval;
1119
1120         switch (cmd) {
1121         case TCXONC:
1122                 retval = tty_check_change(tty);
1123                 if (retval)
1124                         return retval;
1125                 switch (arg) {
1126                 case TCOOFF:
1127                         spin_lock_irq(&tty->flow_lock);
1128                         if (!tty->flow_stopped) {
1129                                 tty->flow_stopped = 1;
1130                                 __stop_tty(tty);
1131                         }
1132                         spin_unlock_irq(&tty->flow_lock);
1133                         break;
1134                 case TCOON:
1135                         spin_lock_irq(&tty->flow_lock);
1136                         if (tty->flow_stopped) {
1137                                 tty->flow_stopped = 0;
1138                                 __start_tty(tty);
1139                         }
1140                         spin_unlock_irq(&tty->flow_lock);
1141                         break;
1142                 case TCIOFF:
1143                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1144                                 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1145                         break;
1146                 case TCION:
1147                         if (START_CHAR(tty) != __DISABLED_CHAR)
1148                                 retval = tty_send_xchar(tty, START_CHAR(tty));
1149                         break;
1150                 default:
1151                         return -EINVAL;
1152                 }
1153                 return retval;
1154         case TCFLSH:
1155                 retval = tty_check_change(tty);
1156                 if (retval)
1157                         return retval;
1158                 return __tty_perform_flush(tty, arg);
1159         default:
1160                 /* Try the mode commands */
1161                 return tty_mode_ioctl(tty, file, cmd, arg);
1162         }
1163 }
1164 EXPORT_SYMBOL(n_tty_ioctl_helper);
1165
1166 #ifdef CONFIG_COMPAT
1167 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1168                                         unsigned int cmd, unsigned long arg)
1169 {
1170         switch (cmd) {
1171         case TIOCGLCKTRMIOS:
1172         case TIOCSLCKTRMIOS:
1173                 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1174         default:
1175                 return -ENOIOCTLCMD;
1176         }
1177 }
1178 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1179 #endif
1180