2 * linux/drivers/char/tty_ioctl.c
4 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
6 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
7 * which can be dynamically activated and de-activated by the line
8 * discipline handling modules (like SLIP).
11 #include <linux/types.h>
12 #include <linux/termios.h>
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/major.h>
17 #include <linux/tty.h>
18 #include <linux/fcntl.h>
19 #include <linux/string.h>
21 #include <linux/module.h>
22 #include <linux/bitops.h>
23 #include <linux/mutex.h>
24 #include <linux/smp_lock.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
30 #undef TTY_DEBUG_WAIT_UNTIL_SENT
35 * Internal flag options for termios setting behavior
37 #define TERMIOS_FLUSH 1
38 #define TERMIOS_WAIT 2
39 #define TERMIOS_TERMIO 4
43 int tty_chars_in_buffer(struct tty_struct *tty)
45 if (tty->ops->chars_in_buffer)
46 return tty->ops->chars_in_buffer(tty);
51 EXPORT_SYMBOL(tty_chars_in_buffer);
53 int tty_write_room(struct tty_struct *tty)
55 if (tty->ops->write_room)
56 return tty->ops->write_room(tty);
60 EXPORT_SYMBOL(tty_write_room);
62 void tty_driver_flush_buffer(struct tty_struct *tty)
64 if (tty->ops->flush_buffer)
65 tty->ops->flush_buffer(tty);
68 EXPORT_SYMBOL(tty_driver_flush_buffer);
70 void tty_throttle(struct tty_struct *tty)
72 /* check TTY_THROTTLED first so it indicates our state */
73 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
75 tty->ops->throttle(tty);
77 EXPORT_SYMBOL(tty_throttle);
79 void tty_unthrottle(struct tty_struct *tty)
81 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
83 tty->ops->unthrottle(tty);
85 EXPORT_SYMBOL(tty_unthrottle);
88 * tty_wait_until_sent - wait for I/O to finish
89 * @tty: tty we are waiting for
90 * @timeout: how long we will wait
92 * Wait for characters pending in a tty driver to hit the wire, or
93 * for a timeout to occur (eg due to flow control)
98 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
100 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
103 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
106 timeout = MAX_SCHEDULE_TIMEOUT;
107 if (wait_event_interruptible_timeout(tty->write_wait,
108 !tty_chars_in_buffer(tty), timeout) >= 0) {
109 if (tty->ops->wait_until_sent)
110 tty->ops->wait_until_sent(tty, timeout);
113 EXPORT_SYMBOL(tty_wait_until_sent);
115 static void unset_locked_termios(struct ktermios *termios,
116 struct ktermios *old,
117 struct ktermios *locked)
121 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
124 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
128 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
129 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
130 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
131 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
132 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
133 for (i = 0; i < NCCS; i++)
134 termios->c_cc[i] = locked->c_cc[i] ?
135 old->c_cc[i] : termios->c_cc[i];
136 /* FIXME: What should we do for i/ospeed */
140 * Routine which returns the baud rate of the tty
142 * Note that the baud_table needs to be kept in sync with the
143 * include/asm/termbits.h file.
145 static const speed_t baud_table[] = {
146 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
147 9600, 19200, 38400, 57600, 115200, 230400, 460800,
149 76800, 153600, 307200, 614400, 921600
151 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
152 2500000, 3000000, 3500000, 4000000
157 static const tcflag_t baud_bits[] = {
158 B0, B50, B75, B110, B134, B150, B200, B300, B600,
159 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
160 B57600, B115200, B230400, B460800, B500000, B576000,
161 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
162 B3000000, B3500000, B4000000
165 static const tcflag_t baud_bits[] = {
166 B0, B50, B75, B110, B134, B150, B200, B300, B600,
167 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
168 B57600, B115200, B230400, B460800, B76800, B153600,
169 B307200, B614400, B921600
173 static int n_baud_table = ARRAY_SIZE(baud_table);
176 * tty_termios_baud_rate
177 * @termios: termios structure
179 * Convert termios baud rate data into a speed. This should be called
180 * with the termios lock held if this termios is a terminal termios
181 * structure. May change the termios data. Device drivers can call this
182 * function but should use ->c_[io]speed directly as they are updated.
187 speed_t tty_termios_baud_rate(struct ktermios *termios)
191 cbaud = termios->c_cflag & CBAUD;
194 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
196 return termios->c_ospeed;
198 if (cbaud & CBAUDEX) {
201 if (cbaud < 1 || cbaud + 15 > n_baud_table)
202 termios->c_cflag &= ~CBAUDEX;
206 return baud_table[cbaud];
208 EXPORT_SYMBOL(tty_termios_baud_rate);
211 * tty_termios_input_baud_rate
212 * @termios: termios structure
214 * Convert termios baud rate data into a speed. This should be called
215 * with the termios lock held if this termios is a terminal termios
216 * structure. May change the termios data. Device drivers can call this
217 * function but should use ->c_[io]speed directly as they are updated.
222 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
225 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
228 return tty_termios_baud_rate(termios);
230 /* Magic token for arbitary speed via c_ispeed*/
232 return termios->c_ispeed;
234 if (cbaud & CBAUDEX) {
237 if (cbaud < 1 || cbaud + 15 > n_baud_table)
238 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
242 return baud_table[cbaud];
244 return tty_termios_baud_rate(termios);
247 EXPORT_SYMBOL(tty_termios_input_baud_rate);
250 * tty_termios_encode_baud_rate
251 * @termios: ktermios structure holding user requested state
252 * @ispeed: input speed
253 * @ospeed: output speed
255 * Encode the speeds set into the passed termios structure. This is
256 * used as a library helper for drivers os that they can report back
257 * the actual speed selected when it differs from the speed requested
259 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
260 * we need to carefully set the bits when the user does not get the
261 * desired speed. We allow small margins and preserve as much of possible
262 * of the input intent to keep compatiblity.
264 * Locking: Caller should hold termios lock. This is already held
265 * when calling this function from the driver termios handler.
267 * The ifdefs deal with platforms whose owners have yet to update them
268 * and will all go away once this is done.
271 void tty_termios_encode_baud_rate(struct ktermios *termios,
272 speed_t ibaud, speed_t obaud)
275 int ifound = -1, ofound = -1;
276 int iclose = ibaud/50, oclose = obaud/50;
279 if (obaud == 0) /* CD dropped */
280 ibaud = 0; /* Clear ibaud to be sure */
282 termios->c_ispeed = ibaud;
283 termios->c_ospeed = obaud;
286 /* If the user asked for a precise weird speed give a precise weird
287 answer. If they asked for a Bfoo speed they many have problems
288 digesting non-exact replies so fuzz a bit */
290 if ((termios->c_cflag & CBAUD) == BOTHER)
292 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
294 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
295 ibinput = 1; /* An input speed was specified */
297 termios->c_cflag &= ~CBAUD;
300 * Our goal is to find a close match to the standard baud rate
301 * returned. Walk the baud rate table and if we get a very close
302 * match then report back the speed as a POSIX Bxxxx value by
307 if (obaud - oclose <= baud_table[i] &&
308 obaud + oclose >= baud_table[i]) {
309 termios->c_cflag |= baud_bits[i];
312 if (ibaud - iclose <= baud_table[i] &&
313 ibaud + iclose >= baud_table[i]) {
314 /* For the case input == output don't set IBAUD bits
315 if the user didn't do so */
316 if (ofound == i && !ibinput)
321 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
325 } while (++i < n_baud_table);
328 * If we found no match then use BOTHER if provided or warn
329 * the user their platform maintainer needs to wake up if not.
333 termios->c_cflag |= BOTHER;
334 /* Set exact input bits only if the input and output differ or the
336 if (ifound == -1 && (ibaud != obaud || ibinput))
337 termios->c_cflag |= (BOTHER << IBSHIFT);
339 if (ifound == -1 || ofound == -1) {
342 printk(KERN_WARNING "tty: Unable to return correct "
343 "speed data as your architecture needs updating.\n");
347 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
349 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
351 tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
353 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
356 * tty_get_baud_rate - get tty bit rates
359 * Returns the baud rate as an integer for this terminal. The
360 * termios lock must be held by the caller and the terminal bit
361 * flags may be updated.
366 speed_t tty_get_baud_rate(struct tty_struct *tty)
368 speed_t baud = tty_termios_baud_rate(tty->termios);
370 if (baud == 38400 && tty->alt_speed) {
372 printk(KERN_WARNING "Use of setserial/setrocket to "
373 "set SPD_* flags is deprecated\n");
376 baud = tty->alt_speed;
381 EXPORT_SYMBOL(tty_get_baud_rate);
384 * tty_termios_copy_hw - copy hardware settings
388 * Propogate the hardware specific terminal setting bits from
389 * the old termios structure to the new one. This is used in cases
390 * where the hardware does not support reconfiguration or as a helper
391 * in some cases where only minimal reconfiguration is supported
394 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
396 /* The bits a dumb device handles in software. Smart devices need
397 to always provide a set_termios method */
398 new->c_cflag &= HUPCL | CREAD | CLOCAL;
399 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
400 new->c_ispeed = old->c_ispeed;
401 new->c_ospeed = old->c_ospeed;
403 EXPORT_SYMBOL(tty_termios_copy_hw);
406 * tty_termios_hw_change - check for setting change
408 * @b: termios to compare
410 * Check if any of the bits that affect a dumb device have changed
411 * between the two termios structures, or a speed change is needed.
414 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
416 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
418 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
422 EXPORT_SYMBOL(tty_termios_hw_change);
425 * change_termios - update termios values
426 * @tty: tty to update
427 * @new_termios: desired new value
429 * Perform updates to the termios values set on this terminal. There
430 * is a bit of layering violation here with n_tty in terms of the
431 * internal knowledge of this function.
433 * Locking: termios_sem
436 static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
439 struct ktermios old_termios;
440 struct tty_ldisc *ld;
444 * Perform the actual termios internal changes under lock.
448 /* FIXME: we need to decide on some locking/ordering semantics
449 for the set_termios notification eventually */
450 mutex_lock(&tty->termios_mutex);
451 old_termios = *tty->termios;
452 *tty->termios = *new_termios;
453 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
454 canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
456 memset(&tty->read_flags, 0, sizeof tty->read_flags);
457 tty->canon_head = tty->read_tail;
462 /* This bit should be in the ldisc code */
463 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
464 /* Get characters left over from canonical mode. */
465 wake_up_interruptible(&tty->read_wait);
467 /* See if packet mode change of state. */
468 if (tty->link && tty->link->packet) {
469 int old_flow = ((old_termios.c_iflag & IXON) &&
470 (old_termios.c_cc[VSTOP] == '\023') &&
471 (old_termios.c_cc[VSTART] == '\021'));
472 int new_flow = (I_IXON(tty) &&
473 STOP_CHAR(tty) == '\023' &&
474 START_CHAR(tty) == '\021');
475 if (old_flow != new_flow) {
476 spin_lock_irqsave(&tty->ctrl_lock, flags);
477 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
479 tty->ctrl_status |= TIOCPKT_DOSTOP;
481 tty->ctrl_status |= TIOCPKT_NOSTOP;
482 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
483 wake_up_interruptible(&tty->link->read_wait);
487 if (tty->ops->set_termios)
488 (*tty->ops->set_termios)(tty, &old_termios);
490 tty_termios_copy_hw(tty->termios, &old_termios);
492 ld = tty_ldisc_ref(tty);
494 if (ld->ops->set_termios)
495 (ld->ops->set_termios)(tty, &old_termios);
498 mutex_unlock(&tty->termios_mutex);
502 * set_termios - set termios values for a tty
503 * @tty: terminal device
505 * @opt: option information
507 * Helper function to prepare termios data and run necessary other
508 * functions before using change_termios to do the actual changes.
511 * Called functions take ldisc and termios_sem locks
514 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
516 struct ktermios tmp_termios;
517 struct tty_ldisc *ld;
518 int retval = tty_check_change(tty);
523 mutex_lock(&tty->termios_mutex);
524 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
525 mutex_unlock(&tty->termios_mutex);
527 if (opt & TERMIOS_TERMIO) {
528 if (user_termio_to_kernel_termios(&tmp_termios,
529 (struct termio __user *)arg))
532 } else if (opt & TERMIOS_OLD) {
533 if (user_termios_to_kernel_termios_1(&tmp_termios,
534 (struct termios __user *)arg))
537 if (user_termios_to_kernel_termios(&tmp_termios,
538 (struct termios2 __user *)arg))
542 } else if (user_termios_to_kernel_termios(&tmp_termios,
543 (struct termios __user *)arg))
547 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
548 * with the real speed so its unconditionally usable */
549 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
550 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
552 ld = tty_ldisc_ref(tty);
555 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
556 ld->ops->flush_buffer(tty);
560 if (opt & TERMIOS_WAIT) {
561 tty_wait_until_sent(tty, 0);
562 if (signal_pending(current))
566 change_termios(tty, &tmp_termios);
568 /* FIXME: Arguably if tmp_termios == tty->termios AND the
569 actual requested termios was not tmp_termios then we may
570 want to return an error as no user requested change has
575 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
577 if (kernel_termios_to_user_termio(termio, tty->termios))
586 * set_termiox - set termiox fields if possible
588 * @arg: termiox structure from user
589 * @opt: option flags for ioctl type
591 * Implement the device calling points for the SYS5 termiox ioctl
595 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
598 struct tty_ldisc *ld;
600 if (tty->termiox == NULL)
602 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
605 ld = tty_ldisc_ref(tty);
607 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
608 ld->ops->flush_buffer(tty);
611 if (opt & TERMIOS_WAIT) {
612 tty_wait_until_sent(tty, 0);
613 if (signal_pending(current))
617 mutex_lock(&tty->termios_mutex);
618 if (tty->ops->set_termiox)
619 tty->ops->set_termiox(tty, &tnew);
620 mutex_unlock(&tty->termios_mutex);
626 static unsigned long inq_canon(struct tty_struct *tty)
630 if (!tty->canon_data || !tty->read_buf)
632 head = tty->canon_head;
633 tail = tty->read_tail;
634 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
635 /* Skip EOF-chars.. */
636 while (head != tail) {
637 if (test_bit(tail, tty->read_flags) &&
638 tty->read_buf[tail] == __DISABLED_CHAR)
640 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
647 * These are deprecated, but there is limited support..
649 * The "sg_flags" translation is a joke..
651 static int get_sgflags(struct tty_struct *tty)
655 if (!(tty->termios->c_lflag & ICANON)) {
656 if (tty->termios->c_lflag & ISIG)
657 flags |= 0x02; /* cbreak */
659 flags |= 0x20; /* raw */
661 if (tty->termios->c_lflag & ECHO)
662 flags |= 0x08; /* echo */
663 if (tty->termios->c_oflag & OPOST)
664 if (tty->termios->c_oflag & ONLCR)
665 flags |= 0x10; /* crmod */
669 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
673 mutex_lock(&tty->termios_mutex);
674 tmp.sg_ispeed = tty->termios->c_ispeed;
675 tmp.sg_ospeed = tty->termios->c_ospeed;
676 tmp.sg_erase = tty->termios->c_cc[VERASE];
677 tmp.sg_kill = tty->termios->c_cc[VKILL];
678 tmp.sg_flags = get_sgflags(tty);
679 mutex_unlock(&tty->termios_mutex);
681 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
684 static void set_sgflags(struct ktermios *termios, int flags)
686 termios->c_iflag = ICRNL | IXON;
687 termios->c_oflag = 0;
688 termios->c_lflag = ISIG | ICANON;
689 if (flags & 0x02) { /* cbreak */
690 termios->c_iflag = 0;
691 termios->c_lflag &= ~ICANON;
693 if (flags & 0x08) { /* echo */
694 termios->c_lflag |= ECHO | ECHOE | ECHOK |
695 ECHOCTL | ECHOKE | IEXTEN;
697 if (flags & 0x10) { /* crmod */
698 termios->c_oflag |= OPOST | ONLCR;
700 if (flags & 0x20) { /* raw */
701 termios->c_iflag = 0;
702 termios->c_lflag &= ~(ISIG | ICANON);
704 if (!(termios->c_lflag & ICANON)) {
705 termios->c_cc[VMIN] = 1;
706 termios->c_cc[VTIME] = 0;
711 * set_sgttyb - set legacy terminal values
712 * @tty: tty structure
713 * @sgttyb: pointer to old style terminal structure
715 * Updates a terminal from the legacy BSD style terminal information
718 * Locking: termios_sem
721 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
725 struct ktermios termios;
727 retval = tty_check_change(tty);
731 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
734 mutex_lock(&tty->termios_mutex);
735 termios = *tty->termios;
736 termios.c_cc[VERASE] = tmp.sg_erase;
737 termios.c_cc[VKILL] = tmp.sg_kill;
738 set_sgflags(&termios, tmp.sg_flags);
739 /* Try and encode into Bfoo format */
741 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
744 mutex_unlock(&tty->termios_mutex);
745 change_termios(tty, &termios);
751 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
755 mutex_lock(&tty->termios_mutex);
756 tmp.t_intrc = tty->termios->c_cc[VINTR];
757 tmp.t_quitc = tty->termios->c_cc[VQUIT];
758 tmp.t_startc = tty->termios->c_cc[VSTART];
759 tmp.t_stopc = tty->termios->c_cc[VSTOP];
760 tmp.t_eofc = tty->termios->c_cc[VEOF];
761 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
762 mutex_unlock(&tty->termios_mutex);
763 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
766 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
770 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
772 mutex_lock(&tty->termios_mutex);
773 tty->termios->c_cc[VINTR] = tmp.t_intrc;
774 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
775 tty->termios->c_cc[VSTART] = tmp.t_startc;
776 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
777 tty->termios->c_cc[VEOF] = tmp.t_eofc;
778 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
779 mutex_unlock(&tty->termios_mutex);
785 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
789 mutex_lock(&tty->termios_mutex);
790 tmp.t_suspc = tty->termios->c_cc[VSUSP];
791 /* what is dsuspc anyway? */
792 tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
793 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
794 /* what is flushc anyway? */
795 tmp.t_flushc = tty->termios->c_cc[VEOL2];
796 tmp.t_werasc = tty->termios->c_cc[VWERASE];
797 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
798 mutex_unlock(&tty->termios_mutex);
799 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
802 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
806 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
809 mutex_lock(&tty->termios_mutex);
810 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
811 /* what is dsuspc anyway? */
812 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
813 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
814 /* what is flushc anyway? */
815 tty->termios->c_cc[VEOL2] = tmp.t_flushc;
816 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
817 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
818 mutex_unlock(&tty->termios_mutex);
824 * send_prio_char - send priority character
826 * Send a high priority character to the tty even if stopped
828 * Locking: none for xchar method, write ordering for write method.
831 static int send_prio_char(struct tty_struct *tty, char ch)
833 int was_stopped = tty->stopped;
835 if (tty->ops->send_xchar) {
836 tty->ops->send_xchar(tty, ch);
840 if (tty_write_lock(tty, 0) < 0)
845 tty->ops->write(tty, &ch, 1);
848 tty_write_unlock(tty);
853 * tty_change_softcar - carrier change ioctl helper
854 * @tty: tty to update
855 * @arg: enable/disable CLOCAL
857 * Perform a change to the CLOCAL state and call into the driver
858 * layer to make it visible. All done with the termios mutex
861 static int tty_change_softcar(struct tty_struct *tty, int arg)
864 int bit = arg ? CLOCAL : 0;
867 mutex_lock(&tty->termios_mutex);
869 tty->termios->c_cflag &= ~CLOCAL;
870 tty->termios->c_cflag |= bit;
871 if (tty->ops->set_termios)
872 tty->ops->set_termios(tty, &old);
873 if ((tty->termios->c_cflag & CLOCAL) != bit)
875 mutex_unlock(&tty->termios_mutex);
880 * tty_mode_ioctl - mode related ioctls
881 * @tty: tty for the ioctl
882 * @file: file pointer for the tty
884 * @arg: ioctl argument
886 * Perform non line discipline specific mode control ioctls. This
887 * is designed to be called by line disciplines to ensure they provide
888 * consistent mode setting.
891 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
892 unsigned int cmd, unsigned long arg)
894 struct tty_struct *real_tty;
895 void __user *p = (void __user *)arg;
898 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
899 tty->driver->subtype == PTY_TYPE_MASTER)
900 real_tty = tty->link;
907 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
910 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
914 return get_tchars(real_tty, p);
916 return set_tchars(real_tty, p);
920 return get_ltchars(real_tty, p);
922 return set_ltchars(real_tty, p);
925 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
927 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
929 return set_termios(real_tty, p, TERMIOS_OLD);
932 mutex_lock(&real_tty->termios_mutex);
933 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
935 mutex_unlock(&real_tty->termios_mutex);
939 mutex_lock(&real_tty->termios_mutex);
940 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
942 mutex_unlock(&real_tty->termios_mutex);
945 mutex_lock(&real_tty->termios_mutex);
946 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
948 mutex_unlock(&real_tty->termios_mutex);
951 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
953 return set_termios(real_tty, p, TERMIOS_WAIT);
955 return set_termios(real_tty, p, 0);
958 return get_termio(real_tty, p);
960 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
962 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
964 return set_termios(real_tty, p, TERMIOS_TERMIO);
967 mutex_lock(&real_tty->termios_mutex);
968 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
970 mutex_unlock(&real_tty->termios_mutex);
973 if (!capable(CAP_SYS_ADMIN))
975 mutex_lock(&real_tty->termios_mutex);
976 if (user_termios_to_kernel_termios(real_tty->termios_locked,
977 (struct termios __user *) arg))
979 mutex_unlock(&real_tty->termios_mutex);
983 mutex_lock(&real_tty->termios_mutex);
984 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios_locked))
986 mutex_unlock(&real_tty->termios_mutex);
989 if (!capable(CAP_SYS_ADMIN))
991 mutex_lock(&real_tty->termios_mutex);
992 if (user_termios_to_kernel_termios_1(real_tty->termios_locked,
993 (struct termios __user *) arg))
995 mutex_unlock(&real_tty->termios_mutex);
1000 if (real_tty->termiox == NULL)
1002 mutex_lock(&real_tty->termios_mutex);
1003 if (copy_to_user(p, real_tty->termiox, sizeof(struct termiox)))
1005 mutex_unlock(&real_tty->termios_mutex);
1008 return set_termiox(real_tty, p, 0);
1010 return set_termiox(real_tty, p, TERMIOS_WAIT);
1012 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1015 mutex_lock(&real_tty->termios_mutex);
1016 ret = put_user(C_CLOCAL(real_tty) ? 1 : 0,
1018 mutex_unlock(&real_tty->termios_mutex);
1021 if (get_user(arg, (unsigned int __user *) arg))
1023 return tty_change_softcar(real_tty, arg);
1025 return -ENOIOCTLCMD;
1028 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1030 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1032 struct tty_ldisc *ld;
1033 int retval = tty_check_change(tty);
1037 ld = tty_ldisc_ref(tty);
1040 if (ld && ld->ops->flush_buffer)
1041 ld->ops->flush_buffer(tty);
1044 if (ld && ld->ops->flush_buffer)
1045 ld->ops->flush_buffer(tty);
1048 tty_driver_flush_buffer(tty);
1051 tty_ldisc_deref(ld);
1054 tty_ldisc_deref(ld);
1057 EXPORT_SYMBOL_GPL(tty_perform_flush);
1059 int n_tty_ioctl(struct tty_struct *tty, struct file *file,
1060 unsigned int cmd, unsigned long arg)
1062 unsigned long flags;
1067 retval = tty_check_change(tty);
1072 if (!tty->flow_stopped) {
1073 tty->flow_stopped = 1;
1078 if (tty->flow_stopped) {
1079 tty->flow_stopped = 0;
1084 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1085 return send_prio_char(tty, STOP_CHAR(tty));
1088 if (START_CHAR(tty) != __DISABLED_CHAR)
1089 return send_prio_char(tty, START_CHAR(tty));
1096 return tty_perform_flush(tty, arg);
1098 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
1100 retval = tty->read_cnt;
1102 retval = inq_canon(tty);
1103 return put_user(retval, (unsigned int __user *) arg);
1108 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1109 tty->driver->subtype != PTY_TYPE_MASTER)
1111 if (get_user(pktmode, (int __user *) arg))
1113 spin_lock_irqsave(&tty->ctrl_lock, flags);
1117 tty->link->ctrl_status = 0;
1121 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1125 /* Try the mode commands */
1126 return tty_mode_ioctl(tty, file, cmd, arg);
1129 EXPORT_SYMBOL(n_tty_ioctl);