2 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
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).
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>
19 #include <linux/module.h>
20 #include <linux/bitops.h>
21 #include <linux/mutex.h>
22 #include <linux/compat.h>
25 #include <asm/uaccess.h>
27 #undef TTY_DEBUG_WAIT_UNTIL_SENT
32 * Internal flag options for termios setting behavior
34 #define TERMIOS_FLUSH 1
35 #define TERMIOS_WAIT 2
36 #define TERMIOS_TERMIO 4
41 * tty_chars_in_buffer - characters pending
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.
49 int tty_chars_in_buffer(struct tty_struct *tty)
51 if (tty->ops->chars_in_buffer)
52 return tty->ops->chars_in_buffer(tty);
56 EXPORT_SYMBOL(tty_chars_in_buffer);
59 * tty_write_room - write queue space
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.
69 int tty_write_room(struct tty_struct *tty)
71 if (tty->ops->write_room)
72 return tty->ops->write_room(tty);
75 EXPORT_SYMBOL(tty_write_room);
78 * tty_driver_flush_buffer - discard internal buffer
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.
85 void tty_driver_flush_buffer(struct tty_struct *tty)
87 if (tty->ops->flush_buffer)
88 tty->ops->flush_buffer(tty);
90 EXPORT_SYMBOL(tty_driver_flush_buffer);
93 * tty_throttle - flow control
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.
102 void tty_throttle(struct tty_struct *tty)
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) &&
108 tty->ops->throttle(tty);
109 tty->flow_change = 0;
110 up_write(&tty->termios_rwsem);
112 EXPORT_SYMBOL(tty_throttle);
115 * tty_unthrottle - flow control
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.
123 * Drivers should however remember that the stack can issue a throttle,
124 * then change flow control method, then unthrottle.
127 void tty_unthrottle(struct tty_struct *tty)
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);
136 EXPORT_SYMBOL(tty_unthrottle);
139 * tty_throttle_safe - flow control
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.
147 * Returns 0 if tty is throttled (or was already throttled)
150 int tty_throttle_safe(struct tty_struct *tty)
154 mutex_lock(&tty->throttle_mutex);
155 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
156 if (tty->flow_change != TTY_THROTTLE_SAFE)
159 set_bit(TTY_THROTTLED, &tty->flags);
160 if (tty->ops->throttle)
161 tty->ops->throttle(tty);
164 mutex_unlock(&tty->throttle_mutex);
170 * tty_unthrottle_safe - flow control
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.
178 * Returns 0 if tty is unthrottled (or was already unthrottled)
181 int tty_unthrottle_safe(struct tty_struct *tty)
185 mutex_lock(&tty->throttle_mutex);
186 if (test_bit(TTY_THROTTLED, &tty->flags)) {
187 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
190 clear_bit(TTY_THROTTLED, &tty->flags);
191 if (tty->ops->unthrottle)
192 tty->ops->unthrottle(tty);
195 mutex_unlock(&tty->throttle_mutex);
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
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)
211 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
213 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
214 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty));
217 timeout = MAX_SCHEDULE_TIMEOUT;
219 timeout = wait_event_interruptible_timeout(tty->write_wait,
220 !tty_chars_in_buffer(tty), timeout);
224 if (timeout == MAX_SCHEDULE_TIMEOUT)
227 if (tty->ops->wait_until_sent)
228 tty->ops->wait_until_sent(tty, timeout);
230 EXPORT_SYMBOL(tty_wait_until_sent);
234 * Termios Helper Methods
237 static void unset_locked_termios(struct ktermios *termios,
238 struct ktermios *old,
239 struct ktermios *locked)
243 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
246 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
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 */
262 * Routine which returns the baud rate of the tty
264 * Note that the baud_table needs to be kept in sync with the
265 * include/asm/termbits.h file.
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,
271 76800, 153600, 307200, 614400, 921600
273 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
274 2500000, 3000000, 3500000, 4000000
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
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
295 static int n_baud_table = ARRAY_SIZE(baud_table);
298 * tty_termios_baud_rate
299 * @termios: termios structure
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.
309 speed_t tty_termios_baud_rate(struct ktermios *termios)
313 cbaud = termios->c_cflag & CBAUD;
316 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
318 return termios->c_ospeed;
320 if (cbaud & CBAUDEX) {
323 if (cbaud < 1 || cbaud + 15 > n_baud_table)
324 termios->c_cflag &= ~CBAUDEX;
328 return baud_table[cbaud];
330 EXPORT_SYMBOL(tty_termios_baud_rate);
333 * tty_termios_input_baud_rate
334 * @termios: termios structure
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.
344 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
347 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
350 return tty_termios_baud_rate(termios);
352 /* Magic token for arbitrary speed via c_ispeed*/
354 return termios->c_ispeed;
356 if (cbaud & CBAUDEX) {
359 if (cbaud < 1 || cbaud + 15 > n_baud_table)
360 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
364 return baud_table[cbaud];
366 return tty_termios_baud_rate(termios);
369 EXPORT_SYMBOL(tty_termios_input_baud_rate);
372 * tty_termios_encode_baud_rate
373 * @termios: ktermios structure holding user requested state
374 * @ispeed: input speed
375 * @ospeed: output speed
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
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.
386 * Locking: Caller should hold termios lock. This is already held
387 * when calling this function from the driver termios handler.
389 * The ifdefs deal with platforms whose owners have yet to update them
390 * and will all go away once this is done.
393 void tty_termios_encode_baud_rate(struct ktermios *termios,
394 speed_t ibaud, speed_t obaud)
397 int ifound = -1, ofound = -1;
398 int iclose = ibaud/50, oclose = obaud/50;
401 if (obaud == 0) /* CD dropped */
402 ibaud = 0; /* Clear ibaud to be sure */
404 termios->c_ispeed = ibaud;
405 termios->c_ospeed = obaud;
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 */
412 if ((termios->c_cflag & CBAUD) == BOTHER)
414 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
416 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
417 ibinput = 1; /* An input speed was specified */
419 termios->c_cflag &= ~CBAUD;
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
429 if (obaud - oclose <= baud_table[i] &&
430 obaud + oclose >= baud_table[i]) {
431 termios->c_cflag |= baud_bits[i];
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)
443 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
447 } while (++i < n_baud_table);
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.
455 termios->c_cflag |= BOTHER;
456 /* Set exact input bits only if the input and output differ or the
458 if (ifound == -1 && (ibaud != obaud || ibinput))
459 termios->c_cflag |= (BOTHER << IBSHIFT);
461 if (ifound == -1 || ofound == -1) {
462 printk_once(KERN_WARNING "tty: Unable to return correct "
463 "speed data as your architecture needs updating.\n");
467 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
470 * tty_encode_baud_rate - set baud rate of the tty
471 * @ibaud: input baud rate
472 * @obad: output baud rate
474 * Update the current termios data for the tty with the new speed
475 * settings. The caller must hold the termios_rwsem for the tty in
479 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
481 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
483 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
486 * tty_termios_copy_hw - copy hardware settings
490 * Propagate the hardware specific terminal setting bits from
491 * the old termios structure to the new one. This is used in cases
492 * where the hardware does not support reconfiguration or as a helper
493 * in some cases where only minimal reconfiguration is supported
496 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
498 /* The bits a dumb device handles in software. Smart devices need
499 to always provide a set_termios method */
500 new->c_cflag &= HUPCL | CREAD | CLOCAL;
501 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
502 new->c_ispeed = old->c_ispeed;
503 new->c_ospeed = old->c_ospeed;
505 EXPORT_SYMBOL(tty_termios_copy_hw);
508 * tty_termios_hw_change - check for setting change
510 * @b: termios to compare
512 * Check if any of the bits that affect a dumb device have changed
513 * between the two termios structures, or a speed change is needed.
516 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
518 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
520 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
524 EXPORT_SYMBOL(tty_termios_hw_change);
527 * tty_set_termios - update termios values
528 * @tty: tty to update
529 * @new_termios: desired new value
531 * Perform updates to the termios values set on this terminal.
532 * A master pty's termios should never be set.
534 * Locking: termios_rwsem
537 int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
539 struct ktermios old_termios;
540 struct tty_ldisc *ld;
542 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
543 tty->driver->subtype == PTY_TYPE_MASTER);
545 * Perform the actual termios internal changes under lock.
549 /* FIXME: we need to decide on some locking/ordering semantics
550 for the set_termios notification eventually */
551 down_write(&tty->termios_rwsem);
552 old_termios = tty->termios;
553 tty->termios = *new_termios;
554 unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
556 if (tty->ops->set_termios)
557 tty->ops->set_termios(tty, &old_termios);
559 tty_termios_copy_hw(&tty->termios, &old_termios);
561 ld = tty_ldisc_ref(tty);
563 if (ld->ops->set_termios)
564 ld->ops->set_termios(tty, &old_termios);
567 up_write(&tty->termios_rwsem);
570 EXPORT_SYMBOL_GPL(tty_set_termios);
573 * set_termios - set termios values for a tty
574 * @tty: terminal device
576 * @opt: option information
578 * Helper function to prepare termios data and run necessary other
579 * functions before using tty_set_termios to do the actual changes.
582 * Called functions take ldisc and termios_rwsem locks
585 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
587 struct ktermios tmp_termios;
588 struct tty_ldisc *ld;
589 int retval = tty_check_change(tty);
594 down_read(&tty->termios_rwsem);
595 tmp_termios = tty->termios;
596 up_read(&tty->termios_rwsem);
598 if (opt & TERMIOS_TERMIO) {
599 if (user_termio_to_kernel_termios(&tmp_termios,
600 (struct termio __user *)arg))
603 } else if (opt & TERMIOS_OLD) {
604 if (user_termios_to_kernel_termios_1(&tmp_termios,
605 (struct termios __user *)arg))
608 if (user_termios_to_kernel_termios(&tmp_termios,
609 (struct termios2 __user *)arg))
613 } else if (user_termios_to_kernel_termios(&tmp_termios,
614 (struct termios __user *)arg))
618 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
619 * with the real speed so its unconditionally usable */
620 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
621 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
623 ld = tty_ldisc_ref(tty);
626 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
627 ld->ops->flush_buffer(tty);
631 if (opt & TERMIOS_WAIT) {
632 tty_wait_until_sent(tty, 0);
633 if (signal_pending(current))
637 tty_set_termios(tty, &tmp_termios);
639 /* FIXME: Arguably if tmp_termios == tty->termios AND the
640 actual requested termios was not tmp_termios then we may
641 want to return an error as no user requested change has
646 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
648 down_read(&tty->termios_rwsem);
649 *kterm = tty->termios;
650 up_read(&tty->termios_rwsem);
653 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
655 down_read(&tty->termios_rwsem);
656 *kterm = tty->termios_locked;
657 up_read(&tty->termios_rwsem);
660 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
662 struct ktermios kterm;
663 copy_termios(tty, &kterm);
664 if (kernel_termios_to_user_termio(termio, &kterm))
673 * set_termiox - set termiox fields if possible
675 * @arg: termiox structure from user
676 * @opt: option flags for ioctl type
678 * Implement the device calling points for the SYS5 termiox ioctl
682 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
685 struct tty_ldisc *ld;
687 if (tty->termiox == NULL)
689 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
692 ld = tty_ldisc_ref(tty);
694 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
695 ld->ops->flush_buffer(tty);
698 if (opt & TERMIOS_WAIT) {
699 tty_wait_until_sent(tty, 0);
700 if (signal_pending(current))
704 down_write(&tty->termios_rwsem);
705 if (tty->ops->set_termiox)
706 tty->ops->set_termiox(tty, &tnew);
707 up_write(&tty->termios_rwsem);
716 * These are deprecated, but there is limited support..
718 * The "sg_flags" translation is a joke..
720 static int get_sgflags(struct tty_struct *tty)
724 if (!(tty->termios.c_lflag & ICANON)) {
725 if (tty->termios.c_lflag & ISIG)
726 flags |= 0x02; /* cbreak */
728 flags |= 0x20; /* raw */
730 if (tty->termios.c_lflag & ECHO)
731 flags |= 0x08; /* echo */
732 if (tty->termios.c_oflag & OPOST)
733 if (tty->termios.c_oflag & ONLCR)
734 flags |= 0x10; /* crmod */
738 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
742 down_read(&tty->termios_rwsem);
743 tmp.sg_ispeed = tty->termios.c_ispeed;
744 tmp.sg_ospeed = tty->termios.c_ospeed;
745 tmp.sg_erase = tty->termios.c_cc[VERASE];
746 tmp.sg_kill = tty->termios.c_cc[VKILL];
747 tmp.sg_flags = get_sgflags(tty);
748 up_read(&tty->termios_rwsem);
750 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
753 static void set_sgflags(struct ktermios *termios, int flags)
755 termios->c_iflag = ICRNL | IXON;
756 termios->c_oflag = 0;
757 termios->c_lflag = ISIG | ICANON;
758 if (flags & 0x02) { /* cbreak */
759 termios->c_iflag = 0;
760 termios->c_lflag &= ~ICANON;
762 if (flags & 0x08) { /* echo */
763 termios->c_lflag |= ECHO | ECHOE | ECHOK |
764 ECHOCTL | ECHOKE | IEXTEN;
766 if (flags & 0x10) { /* crmod */
767 termios->c_oflag |= OPOST | ONLCR;
769 if (flags & 0x20) { /* raw */
770 termios->c_iflag = 0;
771 termios->c_lflag &= ~(ISIG | ICANON);
773 if (!(termios->c_lflag & ICANON)) {
774 termios->c_cc[VMIN] = 1;
775 termios->c_cc[VTIME] = 0;
780 * set_sgttyb - set legacy terminal values
781 * @tty: tty structure
782 * @sgttyb: pointer to old style terminal structure
784 * Updates a terminal from the legacy BSD style terminal information
787 * Locking: termios_rwsem
790 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
794 struct ktermios termios;
796 retval = tty_check_change(tty);
800 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
803 down_write(&tty->termios_rwsem);
804 termios = tty->termios;
805 termios.c_cc[VERASE] = tmp.sg_erase;
806 termios.c_cc[VKILL] = tmp.sg_kill;
807 set_sgflags(&termios, tmp.sg_flags);
808 /* Try and encode into Bfoo format */
810 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
813 up_write(&tty->termios_rwsem);
814 tty_set_termios(tty, &termios);
820 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
824 down_read(&tty->termios_rwsem);
825 tmp.t_intrc = tty->termios.c_cc[VINTR];
826 tmp.t_quitc = tty->termios.c_cc[VQUIT];
827 tmp.t_startc = tty->termios.c_cc[VSTART];
828 tmp.t_stopc = tty->termios.c_cc[VSTOP];
829 tmp.t_eofc = tty->termios.c_cc[VEOF];
830 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
831 up_read(&tty->termios_rwsem);
832 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
835 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
839 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
841 down_write(&tty->termios_rwsem);
842 tty->termios.c_cc[VINTR] = tmp.t_intrc;
843 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
844 tty->termios.c_cc[VSTART] = tmp.t_startc;
845 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
846 tty->termios.c_cc[VEOF] = tmp.t_eofc;
847 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
848 up_write(&tty->termios_rwsem);
854 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
858 down_read(&tty->termios_rwsem);
859 tmp.t_suspc = tty->termios.c_cc[VSUSP];
860 /* what is dsuspc anyway? */
861 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
862 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
863 /* what is flushc anyway? */
864 tmp.t_flushc = tty->termios.c_cc[VEOL2];
865 tmp.t_werasc = tty->termios.c_cc[VWERASE];
866 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
867 up_read(&tty->termios_rwsem);
868 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
871 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
875 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
878 down_write(&tty->termios_rwsem);
879 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
880 /* what is dsuspc anyway? */
881 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
882 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
883 /* what is flushc anyway? */
884 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
885 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
886 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
887 up_write(&tty->termios_rwsem);
893 * tty_change_softcar - carrier change ioctl helper
894 * @tty: tty to update
895 * @arg: enable/disable CLOCAL
897 * Perform a change to the CLOCAL state and call into the driver
898 * layer to make it visible. All done with the termios rwsem
901 static int tty_change_softcar(struct tty_struct *tty, int arg)
904 int bit = arg ? CLOCAL : 0;
907 down_write(&tty->termios_rwsem);
909 tty->termios.c_cflag &= ~CLOCAL;
910 tty->termios.c_cflag |= bit;
911 if (tty->ops->set_termios)
912 tty->ops->set_termios(tty, &old);
913 if ((tty->termios.c_cflag & CLOCAL) != bit)
915 up_write(&tty->termios_rwsem);
920 * tty_mode_ioctl - mode related ioctls
921 * @tty: tty for the ioctl
922 * @file: file pointer for the tty
924 * @arg: ioctl argument
926 * Perform non line discipline specific mode control ioctls. This
927 * is designed to be called by line disciplines to ensure they provide
928 * consistent mode setting.
931 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
932 unsigned int cmd, unsigned long arg)
934 struct tty_struct *real_tty;
935 void __user *p = (void __user *)arg;
937 struct ktermios kterm;
939 BUG_ON(file == NULL);
941 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
942 tty->driver->subtype == PTY_TYPE_MASTER)
943 real_tty = tty->link;
950 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
953 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
957 return get_tchars(real_tty, p);
959 return set_tchars(real_tty, p);
963 return get_ltchars(real_tty, p);
965 return set_ltchars(real_tty, p);
968 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
970 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
972 return set_termios(real_tty, p, TERMIOS_OLD);
975 copy_termios(real_tty, &kterm);
976 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
981 copy_termios(real_tty, &kterm);
982 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
986 copy_termios(real_tty, &kterm);
987 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
991 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
993 return set_termios(real_tty, p, TERMIOS_WAIT);
995 return set_termios(real_tty, p, 0);
998 return get_termio(real_tty, p);
1000 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1002 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1004 return set_termios(real_tty, p, TERMIOS_TERMIO);
1006 case TIOCGLCKTRMIOS:
1007 copy_termios_locked(real_tty, &kterm);
1008 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1011 case TIOCSLCKTRMIOS:
1012 if (!capable(CAP_SYS_ADMIN))
1014 copy_termios_locked(real_tty, &kterm);
1015 if (user_termios_to_kernel_termios(&kterm,
1016 (struct termios __user *) arg))
1018 down_write(&real_tty->termios_rwsem);
1019 real_tty->termios_locked = kterm;
1020 up_write(&real_tty->termios_rwsem);
1023 case TIOCGLCKTRMIOS:
1024 copy_termios_locked(real_tty, &kterm);
1025 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1028 case TIOCSLCKTRMIOS:
1029 if (!capable(CAP_SYS_ADMIN))
1031 copy_termios_locked(real_tty, &kterm);
1032 if (user_termios_to_kernel_termios_1(&kterm,
1033 (struct termios __user *) arg))
1035 down_write(&real_tty->termios_rwsem);
1036 real_tty->termios_locked = kterm;
1037 up_write(&real_tty->termios_rwsem);
1042 struct termiox ktermx;
1043 if (real_tty->termiox == NULL)
1045 down_read(&real_tty->termios_rwsem);
1046 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1047 up_read(&real_tty->termios_rwsem);
1048 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1053 return set_termiox(real_tty, p, 0);
1055 return set_termiox(real_tty, p, TERMIOS_WAIT);
1057 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1060 copy_termios(real_tty, &kterm);
1061 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1065 if (get_user(arg, (unsigned int __user *) arg))
1067 return tty_change_softcar(real_tty, arg);
1069 return -ENOIOCTLCMD;
1072 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1075 /* Caller guarantees ldisc reference is held */
1076 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1078 struct tty_ldisc *ld = tty->ldisc;
1082 if (ld && ld->ops->flush_buffer) {
1083 ld->ops->flush_buffer(tty);
1084 tty_unthrottle(tty);
1088 if (ld && ld->ops->flush_buffer) {
1089 ld->ops->flush_buffer(tty);
1090 tty_unthrottle(tty);
1094 tty_driver_flush_buffer(tty);
1102 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1104 struct tty_ldisc *ld;
1105 int retval = tty_check_change(tty);
1109 ld = tty_ldisc_ref_wait(tty);
1110 retval = __tty_perform_flush(tty, arg);
1112 tty_ldisc_deref(ld);
1115 EXPORT_SYMBOL_GPL(tty_perform_flush);
1117 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1118 unsigned int cmd, unsigned long arg)
1124 retval = tty_check_change(tty);
1129 spin_lock_irq(&tty->flow_lock);
1130 if (!tty->flow_stopped) {
1131 tty->flow_stopped = 1;
1134 spin_unlock_irq(&tty->flow_lock);
1137 spin_lock_irq(&tty->flow_lock);
1138 if (tty->flow_stopped) {
1139 tty->flow_stopped = 0;
1142 spin_unlock_irq(&tty->flow_lock);
1145 down_read(&tty->termios_rwsem);
1146 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1147 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1148 up_read(&tty->termios_rwsem);
1151 down_read(&tty->termios_rwsem);
1152 if (START_CHAR(tty) != __DISABLED_CHAR)
1153 retval = tty_send_xchar(tty, START_CHAR(tty));
1154 up_read(&tty->termios_rwsem);
1161 retval = tty_check_change(tty);
1164 return __tty_perform_flush(tty, arg);
1166 /* Try the mode commands */
1167 return tty_mode_ioctl(tty, file, cmd, arg);
1170 EXPORT_SYMBOL(n_tty_ioctl_helper);
1172 #ifdef CONFIG_COMPAT
1173 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1174 unsigned int cmd, unsigned long arg)
1177 case TIOCGLCKTRMIOS:
1178 case TIOCSLCKTRMIOS:
1179 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1181 return -ENOIOCTLCMD;
1184 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);