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
216 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
219 timeout = MAX_SCHEDULE_TIMEOUT;
221 timeout = wait_event_interruptible_timeout(tty->write_wait,
222 !tty_chars_in_buffer(tty), timeout);
226 if (timeout == MAX_SCHEDULE_TIMEOUT)
229 if (tty->ops->wait_until_sent)
230 tty->ops->wait_until_sent(tty, timeout);
232 EXPORT_SYMBOL(tty_wait_until_sent);
236 * Termios Helper Methods
239 static void unset_locked_termios(struct ktermios *termios,
240 struct ktermios *old,
241 struct ktermios *locked)
245 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
248 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
252 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
253 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
254 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
255 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
256 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
257 for (i = 0; i < NCCS; i++)
258 termios->c_cc[i] = locked->c_cc[i] ?
259 old->c_cc[i] : termios->c_cc[i];
260 /* FIXME: What should we do for i/ospeed */
264 * Routine which returns the baud rate of the tty
266 * Note that the baud_table needs to be kept in sync with the
267 * include/asm/termbits.h file.
269 static const speed_t baud_table[] = {
270 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
271 9600, 19200, 38400, 57600, 115200, 230400, 460800,
273 76800, 153600, 307200, 614400, 921600
275 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
276 2500000, 3000000, 3500000, 4000000
281 static const tcflag_t baud_bits[] = {
282 B0, B50, B75, B110, B134, B150, B200, B300, B600,
283 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
284 B57600, B115200, B230400, B460800, B500000, B576000,
285 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
286 B3000000, B3500000, B4000000
289 static const tcflag_t baud_bits[] = {
290 B0, B50, B75, B110, B134, B150, B200, B300, B600,
291 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
292 B57600, B115200, B230400, B460800, B76800, B153600,
293 B307200, B614400, B921600
297 static int n_baud_table = ARRAY_SIZE(baud_table);
300 * tty_termios_baud_rate
301 * @termios: termios structure
303 * Convert termios baud rate data into a speed. This should be called
304 * with the termios lock held if this termios is a terminal termios
305 * structure. May change the termios data. Device drivers can call this
306 * function but should use ->c_[io]speed directly as they are updated.
311 speed_t tty_termios_baud_rate(struct ktermios *termios)
315 cbaud = termios->c_cflag & CBAUD;
318 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
320 return termios->c_ospeed;
322 if (cbaud & CBAUDEX) {
325 if (cbaud < 1 || cbaud + 15 > n_baud_table)
326 termios->c_cflag &= ~CBAUDEX;
330 return baud_table[cbaud];
332 EXPORT_SYMBOL(tty_termios_baud_rate);
335 * tty_termios_input_baud_rate
336 * @termios: termios structure
338 * Convert termios baud rate data into a speed. This should be called
339 * with the termios lock held if this termios is a terminal termios
340 * structure. May change the termios data. Device drivers can call this
341 * function but should use ->c_[io]speed directly as they are updated.
346 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
349 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
352 return tty_termios_baud_rate(termios);
354 /* Magic token for arbitrary speed via c_ispeed*/
356 return termios->c_ispeed;
358 if (cbaud & CBAUDEX) {
361 if (cbaud < 1 || cbaud + 15 > n_baud_table)
362 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
366 return baud_table[cbaud];
368 return tty_termios_baud_rate(termios);
371 EXPORT_SYMBOL(tty_termios_input_baud_rate);
374 * tty_termios_encode_baud_rate
375 * @termios: ktermios structure holding user requested state
376 * @ispeed: input speed
377 * @ospeed: output speed
379 * Encode the speeds set into the passed termios structure. This is
380 * used as a library helper for drivers so that they can report back
381 * the actual speed selected when it differs from the speed requested
383 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
384 * we need to carefully set the bits when the user does not get the
385 * desired speed. We allow small margins and preserve as much of possible
386 * of the input intent to keep compatibility.
388 * Locking: Caller should hold termios lock. This is already held
389 * when calling this function from the driver termios handler.
391 * The ifdefs deal with platforms whose owners have yet to update them
392 * and will all go away once this is done.
395 void tty_termios_encode_baud_rate(struct ktermios *termios,
396 speed_t ibaud, speed_t obaud)
399 int ifound = -1, ofound = -1;
400 int iclose = ibaud/50, oclose = obaud/50;
403 if (obaud == 0) /* CD dropped */
404 ibaud = 0; /* Clear ibaud to be sure */
406 termios->c_ispeed = ibaud;
407 termios->c_ospeed = obaud;
410 /* If the user asked for a precise weird speed give a precise weird
411 answer. If they asked for a Bfoo speed they may have problems
412 digesting non-exact replies so fuzz a bit */
414 if ((termios->c_cflag & CBAUD) == BOTHER)
416 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
418 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
419 ibinput = 1; /* An input speed was specified */
421 termios->c_cflag &= ~CBAUD;
424 * Our goal is to find a close match to the standard baud rate
425 * returned. Walk the baud rate table and if we get a very close
426 * match then report back the speed as a POSIX Bxxxx value by
431 if (obaud - oclose <= baud_table[i] &&
432 obaud + oclose >= baud_table[i]) {
433 termios->c_cflag |= baud_bits[i];
436 if (ibaud - iclose <= baud_table[i] &&
437 ibaud + iclose >= baud_table[i]) {
438 /* For the case input == output don't set IBAUD bits
439 if the user didn't do so */
440 if (ofound == i && !ibinput)
445 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
449 } while (++i < n_baud_table);
452 * If we found no match then use BOTHER if provided or warn
453 * the user their platform maintainer needs to wake up if not.
457 termios->c_cflag |= BOTHER;
458 /* Set exact input bits only if the input and output differ or the
460 if (ifound == -1 && (ibaud != obaud || ibinput))
461 termios->c_cflag |= (BOTHER << IBSHIFT);
463 if (ifound == -1 || ofound == -1) {
464 printk_once(KERN_WARNING "tty: Unable to return correct "
465 "speed data as your architecture needs updating.\n");
469 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
472 * tty_encode_baud_rate - set baud rate of the tty
473 * @ibaud: input baud rate
474 * @obad: output baud rate
476 * Update the current termios data for the tty with the new speed
477 * settings. The caller must hold the termios_rwsem for the tty in
481 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
483 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
485 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
488 * tty_termios_copy_hw - copy hardware settings
492 * Propagate the hardware specific terminal setting bits from
493 * the old termios structure to the new one. This is used in cases
494 * where the hardware does not support reconfiguration or as a helper
495 * in some cases where only minimal reconfiguration is supported
498 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
500 /* The bits a dumb device handles in software. Smart devices need
501 to always provide a set_termios method */
502 new->c_cflag &= HUPCL | CREAD | CLOCAL;
503 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
504 new->c_ispeed = old->c_ispeed;
505 new->c_ospeed = old->c_ospeed;
507 EXPORT_SYMBOL(tty_termios_copy_hw);
510 * tty_termios_hw_change - check for setting change
512 * @b: termios to compare
514 * Check if any of the bits that affect a dumb device have changed
515 * between the two termios structures, or a speed change is needed.
518 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
520 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
522 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
526 EXPORT_SYMBOL(tty_termios_hw_change);
529 * tty_set_termios - update termios values
530 * @tty: tty to update
531 * @new_termios: desired new value
533 * Perform updates to the termios values set on this terminal.
534 * A master pty's termios should never be set.
536 * Locking: termios_rwsem
539 static int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
541 struct ktermios old_termios;
542 struct tty_ldisc *ld;
544 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
545 tty->driver->subtype == PTY_TYPE_MASTER);
547 * Perform the actual termios internal changes under lock.
551 /* FIXME: we need to decide on some locking/ordering semantics
552 for the set_termios notification eventually */
553 down_write(&tty->termios_rwsem);
554 old_termios = tty->termios;
555 tty->termios = *new_termios;
556 unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
558 if (tty->ops->set_termios)
559 tty->ops->set_termios(tty, &old_termios);
561 tty_termios_copy_hw(&tty->termios, &old_termios);
563 ld = tty_ldisc_ref(tty);
565 if (ld->ops->set_termios)
566 ld->ops->set_termios(tty, &old_termios);
569 up_write(&tty->termios_rwsem);
574 * set_termios - set termios values for a tty
575 * @tty: terminal device
577 * @opt: option information
579 * Helper function to prepare termios data and run necessary other
580 * functions before using tty_set_termios to do the actual changes.
583 * Called functions take ldisc and termios_rwsem locks
586 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
588 struct ktermios tmp_termios;
589 struct tty_ldisc *ld;
590 int retval = tty_check_change(tty);
595 down_read(&tty->termios_rwsem);
596 tmp_termios = tty->termios;
597 up_read(&tty->termios_rwsem);
599 if (opt & TERMIOS_TERMIO) {
600 if (user_termio_to_kernel_termios(&tmp_termios,
601 (struct termio __user *)arg))
604 } else if (opt & TERMIOS_OLD) {
605 if (user_termios_to_kernel_termios_1(&tmp_termios,
606 (struct termios __user *)arg))
609 if (user_termios_to_kernel_termios(&tmp_termios,
610 (struct termios2 __user *)arg))
614 } else if (user_termios_to_kernel_termios(&tmp_termios,
615 (struct termios __user *)arg))
619 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
620 * with the real speed so its unconditionally usable */
621 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
622 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
624 ld = tty_ldisc_ref(tty);
627 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
628 ld->ops->flush_buffer(tty);
632 if (opt & TERMIOS_WAIT) {
633 tty_wait_until_sent(tty, 0);
634 if (signal_pending(current))
638 tty_set_termios(tty, &tmp_termios);
640 /* FIXME: Arguably if tmp_termios == tty->termios AND the
641 actual requested termios was not tmp_termios then we may
642 want to return an error as no user requested change has
647 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
649 down_read(&tty->termios_rwsem);
650 *kterm = tty->termios;
651 up_read(&tty->termios_rwsem);
654 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
656 down_read(&tty->termios_rwsem);
657 *kterm = tty->termios_locked;
658 up_read(&tty->termios_rwsem);
661 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
663 struct ktermios kterm;
664 copy_termios(tty, &kterm);
665 if (kernel_termios_to_user_termio(termio, &kterm))
674 * set_termiox - set termiox fields if possible
676 * @arg: termiox structure from user
677 * @opt: option flags for ioctl type
679 * Implement the device calling points for the SYS5 termiox ioctl
683 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
686 struct tty_ldisc *ld;
688 if (tty->termiox == NULL)
690 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
693 ld = tty_ldisc_ref(tty);
695 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
696 ld->ops->flush_buffer(tty);
699 if (opt & TERMIOS_WAIT) {
700 tty_wait_until_sent(tty, 0);
701 if (signal_pending(current))
705 down_write(&tty->termios_rwsem);
706 if (tty->ops->set_termiox)
707 tty->ops->set_termiox(tty, &tnew);
708 up_write(&tty->termios_rwsem);
717 * These are deprecated, but there is limited support..
719 * The "sg_flags" translation is a joke..
721 static int get_sgflags(struct tty_struct *tty)
725 if (!(tty->termios.c_lflag & ICANON)) {
726 if (tty->termios.c_lflag & ISIG)
727 flags |= 0x02; /* cbreak */
729 flags |= 0x20; /* raw */
731 if (tty->termios.c_lflag & ECHO)
732 flags |= 0x08; /* echo */
733 if (tty->termios.c_oflag & OPOST)
734 if (tty->termios.c_oflag & ONLCR)
735 flags |= 0x10; /* crmod */
739 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
743 down_read(&tty->termios_rwsem);
744 tmp.sg_ispeed = tty->termios.c_ispeed;
745 tmp.sg_ospeed = tty->termios.c_ospeed;
746 tmp.sg_erase = tty->termios.c_cc[VERASE];
747 tmp.sg_kill = tty->termios.c_cc[VKILL];
748 tmp.sg_flags = get_sgflags(tty);
749 up_read(&tty->termios_rwsem);
751 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
754 static void set_sgflags(struct ktermios *termios, int flags)
756 termios->c_iflag = ICRNL | IXON;
757 termios->c_oflag = 0;
758 termios->c_lflag = ISIG | ICANON;
759 if (flags & 0x02) { /* cbreak */
760 termios->c_iflag = 0;
761 termios->c_lflag &= ~ICANON;
763 if (flags & 0x08) { /* echo */
764 termios->c_lflag |= ECHO | ECHOE | ECHOK |
765 ECHOCTL | ECHOKE | IEXTEN;
767 if (flags & 0x10) { /* crmod */
768 termios->c_oflag |= OPOST | ONLCR;
770 if (flags & 0x20) { /* raw */
771 termios->c_iflag = 0;
772 termios->c_lflag &= ~(ISIG | ICANON);
774 if (!(termios->c_lflag & ICANON)) {
775 termios->c_cc[VMIN] = 1;
776 termios->c_cc[VTIME] = 0;
781 * set_sgttyb - set legacy terminal values
782 * @tty: tty structure
783 * @sgttyb: pointer to old style terminal structure
785 * Updates a terminal from the legacy BSD style terminal information
788 * Locking: termios_rwsem
791 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
795 struct ktermios termios;
797 retval = tty_check_change(tty);
801 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
804 down_write(&tty->termios_rwsem);
805 termios = tty->termios;
806 termios.c_cc[VERASE] = tmp.sg_erase;
807 termios.c_cc[VKILL] = tmp.sg_kill;
808 set_sgflags(&termios, tmp.sg_flags);
809 /* Try and encode into Bfoo format */
811 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
814 up_write(&tty->termios_rwsem);
815 tty_set_termios(tty, &termios);
821 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
825 down_read(&tty->termios_rwsem);
826 tmp.t_intrc = tty->termios.c_cc[VINTR];
827 tmp.t_quitc = tty->termios.c_cc[VQUIT];
828 tmp.t_startc = tty->termios.c_cc[VSTART];
829 tmp.t_stopc = tty->termios.c_cc[VSTOP];
830 tmp.t_eofc = tty->termios.c_cc[VEOF];
831 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
832 up_read(&tty->termios_rwsem);
833 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
836 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
840 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
842 down_write(&tty->termios_rwsem);
843 tty->termios.c_cc[VINTR] = tmp.t_intrc;
844 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
845 tty->termios.c_cc[VSTART] = tmp.t_startc;
846 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
847 tty->termios.c_cc[VEOF] = tmp.t_eofc;
848 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
849 up_write(&tty->termios_rwsem);
855 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
859 down_read(&tty->termios_rwsem);
860 tmp.t_suspc = tty->termios.c_cc[VSUSP];
861 /* what is dsuspc anyway? */
862 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
863 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
864 /* what is flushc anyway? */
865 tmp.t_flushc = tty->termios.c_cc[VEOL2];
866 tmp.t_werasc = tty->termios.c_cc[VWERASE];
867 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
868 up_read(&tty->termios_rwsem);
869 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
872 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
876 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
879 down_write(&tty->termios_rwsem);
880 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
881 /* what is dsuspc anyway? */
882 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
883 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
884 /* what is flushc anyway? */
885 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
886 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
887 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
888 up_write(&tty->termios_rwsem);
894 * tty_change_softcar - carrier change ioctl helper
895 * @tty: tty to update
896 * @arg: enable/disable CLOCAL
898 * Perform a change to the CLOCAL state and call into the driver
899 * layer to make it visible. All done with the termios rwsem
902 static int tty_change_softcar(struct tty_struct *tty, int arg)
905 int bit = arg ? CLOCAL : 0;
908 down_write(&tty->termios_rwsem);
910 tty->termios.c_cflag &= ~CLOCAL;
911 tty->termios.c_cflag |= bit;
912 if (tty->ops->set_termios)
913 tty->ops->set_termios(tty, &old);
914 if ((tty->termios.c_cflag & CLOCAL) != bit)
916 up_write(&tty->termios_rwsem);
921 * tty_mode_ioctl - mode related ioctls
922 * @tty: tty for the ioctl
923 * @file: file pointer for the tty
925 * @arg: ioctl argument
927 * Perform non line discipline specific mode control ioctls. This
928 * is designed to be called by line disciplines to ensure they provide
929 * consistent mode setting.
932 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
933 unsigned int cmd, unsigned long arg)
935 struct tty_struct *real_tty;
936 void __user *p = (void __user *)arg;
938 struct ktermios kterm;
940 BUG_ON(file == NULL);
942 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
943 tty->driver->subtype == PTY_TYPE_MASTER)
944 real_tty = tty->link;
951 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
954 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
958 return get_tchars(real_tty, p);
960 return set_tchars(real_tty, p);
964 return get_ltchars(real_tty, p);
966 return set_ltchars(real_tty, p);
969 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
971 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
973 return set_termios(real_tty, p, TERMIOS_OLD);
976 copy_termios(real_tty, &kterm);
977 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
982 copy_termios(real_tty, &kterm);
983 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
987 copy_termios(real_tty, &kterm);
988 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
992 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
994 return set_termios(real_tty, p, TERMIOS_WAIT);
996 return set_termios(real_tty, p, 0);
999 return get_termio(real_tty, p);
1001 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1003 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1005 return set_termios(real_tty, p, TERMIOS_TERMIO);
1007 case TIOCGLCKTRMIOS:
1008 copy_termios_locked(real_tty, &kterm);
1009 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1012 case TIOCSLCKTRMIOS:
1013 if (!capable(CAP_SYS_ADMIN))
1015 copy_termios_locked(real_tty, &kterm);
1016 if (user_termios_to_kernel_termios(&kterm,
1017 (struct termios __user *) arg))
1019 down_write(&real_tty->termios_rwsem);
1020 real_tty->termios_locked = kterm;
1021 up_write(&real_tty->termios_rwsem);
1024 case TIOCGLCKTRMIOS:
1025 copy_termios_locked(real_tty, &kterm);
1026 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1029 case TIOCSLCKTRMIOS:
1030 if (!capable(CAP_SYS_ADMIN))
1032 copy_termios_locked(real_tty, &kterm);
1033 if (user_termios_to_kernel_termios_1(&kterm,
1034 (struct termios __user *) arg))
1036 down_write(&real_tty->termios_rwsem);
1037 real_tty->termios_locked = kterm;
1038 up_write(&real_tty->termios_rwsem);
1043 struct termiox ktermx;
1044 if (real_tty->termiox == NULL)
1046 down_read(&real_tty->termios_rwsem);
1047 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1048 up_read(&real_tty->termios_rwsem);
1049 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1054 return set_termiox(real_tty, p, 0);
1056 return set_termiox(real_tty, p, TERMIOS_WAIT);
1058 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1061 copy_termios(real_tty, &kterm);
1062 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1066 if (get_user(arg, (unsigned int __user *) arg))
1068 return tty_change_softcar(real_tty, arg);
1070 return -ENOIOCTLCMD;
1073 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1076 /* Caller guarantees ldisc reference is held */
1077 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1079 struct tty_ldisc *ld = tty->ldisc;
1083 if (ld && ld->ops->flush_buffer) {
1084 ld->ops->flush_buffer(tty);
1085 tty_unthrottle(tty);
1089 if (ld && ld->ops->flush_buffer) {
1090 ld->ops->flush_buffer(tty);
1091 tty_unthrottle(tty);
1095 tty_driver_flush_buffer(tty);
1103 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1105 struct tty_ldisc *ld;
1106 int retval = tty_check_change(tty);
1110 ld = tty_ldisc_ref_wait(tty);
1111 retval = __tty_perform_flush(tty, arg);
1113 tty_ldisc_deref(ld);
1116 EXPORT_SYMBOL_GPL(tty_perform_flush);
1118 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1119 unsigned int cmd, unsigned long arg)
1125 retval = tty_check_change(tty);
1130 spin_lock_irq(&tty->flow_lock);
1131 if (!tty->flow_stopped) {
1132 tty->flow_stopped = 1;
1135 spin_unlock_irq(&tty->flow_lock);
1138 spin_lock_irq(&tty->flow_lock);
1139 if (tty->flow_stopped) {
1140 tty->flow_stopped = 0;
1143 spin_unlock_irq(&tty->flow_lock);
1146 down_read(&tty->termios_rwsem);
1147 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1148 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1149 up_read(&tty->termios_rwsem);
1152 down_read(&tty->termios_rwsem);
1153 if (START_CHAR(tty) != __DISABLED_CHAR)
1154 retval = tty_send_xchar(tty, START_CHAR(tty));
1155 up_read(&tty->termios_rwsem);
1162 retval = tty_check_change(tty);
1165 return __tty_perform_flush(tty, arg);
1167 /* Try the mode commands */
1168 return tty_mode_ioctl(tty, file, cmd, arg);
1171 EXPORT_SYMBOL(n_tty_ioctl_helper);
1173 #ifdef CONFIG_COMPAT
1174 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1175 unsigned int cmd, unsigned long arg)
1178 case TIOCGLCKTRMIOS:
1179 case TIOCSLCKTRMIOS:
1180 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1182 return -ENOIOCTLCMD;
1185 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);