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