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
44 * tty_wait_until_sent - wait for I/O to finish
45 * @tty: tty we are waiting for
46 * @timeout: how long we will wait
48 * Wait for characters pending in a tty driver to hit the wire, or
49 * for a timeout to occur (eg due to flow control)
54 void tty_wait_until_sent(struct tty_struct
*tty
, long timeout
)
56 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
59 printk(KERN_DEBUG
"%s wait until sent...\n", tty_name(tty
, buf
));
61 if (!tty
->driver
->chars_in_buffer
)
64 timeout
= MAX_SCHEDULE_TIMEOUT
;
66 if (wait_event_interruptible_timeout(tty
->write_wait
,
67 !tty
->driver
->chars_in_buffer(tty
), timeout
) >= 0) {
68 if (tty
->driver
->wait_until_sent
)
69 tty
->driver
->wait_until_sent(tty
, timeout
);
73 EXPORT_SYMBOL(tty_wait_until_sent
);
75 static void unset_locked_termios(struct ktermios
*termios
,
77 struct ktermios
*locked
)
81 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
84 printk(KERN_WARNING
"Warning?!? termios_locked is NULL.\n");
88 NOSET_MASK(termios
->c_iflag
, old
->c_iflag
, locked
->c_iflag
);
89 NOSET_MASK(termios
->c_oflag
, old
->c_oflag
, locked
->c_oflag
);
90 NOSET_MASK(termios
->c_cflag
, old
->c_cflag
, locked
->c_cflag
);
91 NOSET_MASK(termios
->c_lflag
, old
->c_lflag
, locked
->c_lflag
);
92 termios
->c_line
= locked
->c_line
? old
->c_line
: termios
->c_line
;
93 for (i
= 0; i
< NCCS
; i
++)
94 termios
->c_cc
[i
] = locked
->c_cc
[i
] ?
95 old
->c_cc
[i
] : termios
->c_cc
[i
];
96 /* FIXME: What should we do for i/ospeed */
100 * Routine which returns the baud rate of the tty
102 * Note that the baud_table needs to be kept in sync with the
103 * include/asm/termbits.h file.
105 static const speed_t baud_table
[] = {
106 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
107 9600, 19200, 38400, 57600, 115200, 230400, 460800,
109 76800, 153600, 307200, 614400, 921600
111 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
112 2500000, 3000000, 3500000, 4000000
117 static const tcflag_t baud_bits
[] = {
118 B0
, B50
, B75
, B110
, B134
, B150
, B200
, B300
, B600
,
119 B1200
, B1800
, B2400
, B4800
, B9600
, B19200
, B38400
,
120 B57600
, B115200
, B230400
, B460800
, B500000
, B576000
,
121 B921600
, B1000000
, B1152000
, B1500000
, B2000000
, B2500000
,
122 B3000000
, B3500000
, B4000000
125 static const tcflag_t baud_bits
[] = {
126 B0
, B50
, B75
, B110
, B134
, B150
, B200
, B300
, B600
,
127 B1200
, B1800
, B2400
, B4800
, B9600
, B19200
, B38400
,
128 B57600
, B115200
, B230400
, B460800
, B76800
, B153600
,
129 B307200
, B614400
, B921600
133 static int n_baud_table
= ARRAY_SIZE(baud_table
);
136 * tty_termios_baud_rate
137 * @termios: termios structure
139 * Convert termios baud rate data into a speed. This should be called
140 * with the termios lock held if this termios is a terminal termios
141 * structure. May change the termios data. Device drivers can call this
142 * function but should use ->c_[io]speed directly as they are updated.
147 speed_t
tty_termios_baud_rate(struct ktermios
*termios
)
151 cbaud
= termios
->c_cflag
& CBAUD
;
154 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
156 return termios
->c_ospeed
;
158 if (cbaud
& CBAUDEX
) {
161 if (cbaud
< 1 || cbaud
+ 15 > n_baud_table
)
162 termios
->c_cflag
&= ~CBAUDEX
;
166 return baud_table
[cbaud
];
168 EXPORT_SYMBOL(tty_termios_baud_rate
);
171 * tty_termios_input_baud_rate
172 * @termios: termios structure
174 * Convert termios baud rate data into a speed. This should be called
175 * with the termios lock held if this termios is a terminal termios
176 * structure. May change the termios data. Device drivers can call this
177 * function but should use ->c_[io]speed directly as they are updated.
182 speed_t
tty_termios_input_baud_rate(struct ktermios
*termios
)
185 unsigned int cbaud
= (termios
->c_cflag
>> IBSHIFT
) & CBAUD
;
188 return tty_termios_baud_rate(termios
);
190 /* Magic token for arbitary speed via c_ispeed*/
192 return termios
->c_ispeed
;
194 if (cbaud
& CBAUDEX
) {
197 if (cbaud
< 1 || cbaud
+ 15 > n_baud_table
)
198 termios
->c_cflag
&= ~(CBAUDEX
<< IBSHIFT
);
202 return baud_table
[cbaud
];
204 return tty_termios_baud_rate(termios
);
207 EXPORT_SYMBOL(tty_termios_input_baud_rate
);
210 * tty_termios_encode_baud_rate
211 * @termios: ktermios structure holding user requested state
212 * @ispeed: input speed
213 * @ospeed: output speed
215 * Encode the speeds set into the passed termios structure. This is
216 * used as a library helper for drivers os that they can report back
217 * the actual speed selected when it differs from the speed requested
219 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
220 * we need to carefully set the bits when the user does not get the
221 * desired speed. We allow small margins and preserve as much of possible
222 * of the input intent to keep compatiblity.
224 * Locking: Caller should hold termios lock. This is already held
225 * when calling this function from the driver termios handler.
227 * The ifdefs deal with platforms whose owners have yet to update them
228 * and will all go away once this is done.
231 void tty_termios_encode_baud_rate(struct ktermios
*termios
,
232 speed_t ibaud
, speed_t obaud
)
235 int ifound
= -1, ofound
= -1;
236 int iclose
= ibaud
/50, oclose
= obaud
/50;
239 if (obaud
== 0) /* CD dropped */
240 ibaud
= 0; /* Clear ibaud to be sure */
242 termios
->c_ispeed
= ibaud
;
243 termios
->c_ospeed
= obaud
;
246 /* If the user asked for a precise weird speed give a precise weird
247 answer. If they asked for a Bfoo speed they many have problems
248 digesting non-exact replies so fuzz a bit */
250 if ((termios
->c_cflag
& CBAUD
) == BOTHER
)
252 if (((termios
->c_cflag
>> IBSHIFT
) & CBAUD
) == BOTHER
)
254 if ((termios
->c_cflag
>> IBSHIFT
) & CBAUD
)
255 ibinput
= 1; /* An input speed was specified */
257 termios
->c_cflag
&= ~CBAUD
;
260 * Our goal is to find a close match to the standard baud rate
261 * returned. Walk the baud rate table and if we get a very close
262 * match then report back the speed as a POSIX Bxxxx value by
267 if (obaud
- oclose
<= baud_table
[i
] &&
268 obaud
+ oclose
>= baud_table
[i
]) {
269 termios
->c_cflag
|= baud_bits
[i
];
272 if (ibaud
- iclose
<= baud_table
[i
] &&
273 ibaud
+ iclose
>= baud_table
[i
]) {
274 /* For the case input == output don't set IBAUD bits
275 if the user didn't do so */
276 if (ofound
== i
&& !ibinput
)
281 termios
->c_cflag
|= (baud_bits
[i
] << IBSHIFT
);
285 } while (++i
< n_baud_table
);
288 * If we found no match then use BOTHER if provided or warn
289 * the user their platform maintainer needs to wake up if not.
293 termios
->c_cflag
|= BOTHER
;
294 /* Set exact input bits only if the input and output differ or the
296 if (ifound
== -1 && (ibaud
!= obaud
|| ibinput
))
297 termios
->c_cflag
|= (BOTHER
<< IBSHIFT
);
299 if (ifound
== -1 || ofound
== -1) {
302 printk(KERN_WARNING
"tty: Unable to return correct "
303 "speed data as your architecture needs updating.\n");
307 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate
);
309 void tty_encode_baud_rate(struct tty_struct
*tty
, speed_t ibaud
, speed_t obaud
)
311 tty_termios_encode_baud_rate(tty
->termios
, ibaud
, obaud
);
313 EXPORT_SYMBOL_GPL(tty_encode_baud_rate
);
316 * tty_get_baud_rate - get tty bit rates
319 * Returns the baud rate as an integer for this terminal. The
320 * termios lock must be held by the caller and the terminal bit
321 * flags may be updated.
326 speed_t
tty_get_baud_rate(struct tty_struct
*tty
)
328 speed_t baud
= tty_termios_baud_rate(tty
->termios
);
330 if (baud
== 38400 && tty
->alt_speed
) {
332 printk(KERN_WARNING
"Use of setserial/setrocket to "
333 "set SPD_* flags is deprecated\n");
336 baud
= tty
->alt_speed
;
341 EXPORT_SYMBOL(tty_get_baud_rate
);
344 * tty_termios_copy_hw - copy hardware settings
348 * Propogate the hardware specific terminal setting bits from
349 * the old termios structure to the new one. This is used in cases
350 * where the hardware does not support reconfiguration or as a helper
351 * in some cases where only minimal reconfiguration is supported
354 void tty_termios_copy_hw(struct ktermios
*new, struct ktermios
*old
)
356 /* The bits a dumb device handles in software. Smart devices need
357 to always provide a set_termios method */
358 new->c_cflag
&= HUPCL
| CREAD
| CLOCAL
;
359 new->c_cflag
|= old
->c_cflag
& ~(HUPCL
| CREAD
| CLOCAL
);
360 new->c_ispeed
= old
->c_ispeed
;
361 new->c_ospeed
= old
->c_ospeed
;
363 EXPORT_SYMBOL(tty_termios_copy_hw
);
366 * tty_termios_hw_change - check for setting change
368 * @b: termios to compare
370 * Check if any of the bits that affect a dumb device have changed
371 * between the two termios structures, or a speed change is needed.
374 int tty_termios_hw_change(struct ktermios
*a
, struct ktermios
*b
)
376 if (a
->c_ispeed
!= b
->c_ispeed
|| a
->c_ospeed
!= b
->c_ospeed
)
378 if ((a
->c_cflag
^ b
->c_cflag
) & ~(HUPCL
| CREAD
| CLOCAL
))
382 EXPORT_SYMBOL(tty_termios_hw_change
);
385 * change_termios - update termios values
386 * @tty: tty to update
387 * @new_termios: desired new value
389 * Perform updates to the termios values set on this terminal. There
390 * is a bit of layering violation here with n_tty in terms of the
391 * internal knowledge of this function.
393 * Locking: termios_sem
396 static void change_termios(struct tty_struct
*tty
, struct ktermios
*new_termios
)
399 struct ktermios old_termios
= *tty
->termios
;
400 struct tty_ldisc
*ld
;
404 * Perform the actual termios internal changes under lock.
408 /* FIXME: we need to decide on some locking/ordering semantics
409 for the set_termios notification eventually */
410 mutex_lock(&tty
->termios_mutex
);
412 *tty
->termios
= *new_termios
;
413 unset_locked_termios(tty
->termios
, &old_termios
, tty
->termios_locked
);
414 canon_change
= (old_termios
.c_lflag
^ tty
->termios
->c_lflag
) & ICANON
;
416 memset(&tty
->read_flags
, 0, sizeof tty
->read_flags
);
417 tty
->canon_head
= tty
->read_tail
;
422 /* This bit should be in the ldisc code */
423 if (canon_change
&& !L_ICANON(tty
) && tty
->read_cnt
)
424 /* Get characters left over from canonical mode. */
425 wake_up_interruptible(&tty
->read_wait
);
427 /* See if packet mode change of state. */
428 if (tty
->link
&& tty
->link
->packet
) {
429 int old_flow
= ((old_termios
.c_iflag
& IXON
) &&
430 (old_termios
.c_cc
[VSTOP
] == '\023') &&
431 (old_termios
.c_cc
[VSTART
] == '\021'));
432 int new_flow
= (I_IXON(tty
) &&
433 STOP_CHAR(tty
) == '\023' &&
434 START_CHAR(tty
) == '\021');
435 if (old_flow
!= new_flow
) {
436 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
437 tty
->ctrl_status
&= ~(TIOCPKT_DOSTOP
| TIOCPKT_NOSTOP
);
439 tty
->ctrl_status
|= TIOCPKT_DOSTOP
;
441 tty
->ctrl_status
|= TIOCPKT_NOSTOP
;
442 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
443 wake_up_interruptible(&tty
->link
->read_wait
);
447 if (tty
->driver
->set_termios
)
448 (*tty
->driver
->set_termios
)(tty
, &old_termios
);
450 tty_termios_copy_hw(tty
->termios
, &old_termios
);
452 ld
= tty_ldisc_ref(tty
);
455 (ld
->set_termios
)(tty
, &old_termios
);
458 mutex_unlock(&tty
->termios_mutex
);
462 * set_termios - set termios values for a tty
463 * @tty: terminal device
465 * @opt: option information
467 * Helper function to prepare termios data and run necessary other
468 * functions before using change_termios to do the actual changes.
471 * Called functions take ldisc and termios_sem locks
474 static int set_termios(struct tty_struct
*tty
, void __user
*arg
, int opt
)
476 struct ktermios tmp_termios
;
477 struct tty_ldisc
*ld
;
478 int retval
= tty_check_change(tty
);
483 memcpy(&tmp_termios
, tty
->termios
, sizeof(struct ktermios
));
485 if (opt
& TERMIOS_TERMIO
) {
486 if (user_termio_to_kernel_termios(&tmp_termios
,
487 (struct termio __user
*)arg
))
490 } else if (opt
& TERMIOS_OLD
) {
491 if (user_termios_to_kernel_termios_1(&tmp_termios
,
492 (struct termios __user
*)arg
))
495 if (user_termios_to_kernel_termios(&tmp_termios
,
496 (struct termios2 __user
*)arg
))
500 } else if (user_termios_to_kernel_termios(&tmp_termios
,
501 (struct termios __user
*)arg
))
505 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
506 * with the real speed so its unconditionally usable */
507 tmp_termios
.c_ispeed
= tty_termios_input_baud_rate(&tmp_termios
);
508 tmp_termios
.c_ospeed
= tty_termios_baud_rate(&tmp_termios
);
510 ld
= tty_ldisc_ref(tty
);
513 if ((opt
& TERMIOS_FLUSH
) && ld
->flush_buffer
)
514 ld
->flush_buffer(tty
);
518 if (opt
& TERMIOS_WAIT
) {
519 tty_wait_until_sent(tty
, 0);
520 if (signal_pending(current
))
524 change_termios(tty
, &tmp_termios
);
526 /* FIXME: Arguably if tmp_termios == tty->termios AND the
527 actual requested termios was not tmp_termios then we may
528 want to return an error as no user requested change has
533 static int get_termio(struct tty_struct
*tty
, struct termio __user
*termio
)
535 if (kernel_termios_to_user_termio(termio
, tty
->termios
))
540 static unsigned long inq_canon(struct tty_struct
*tty
)
544 if (!tty
->canon_data
|| !tty
->read_buf
)
546 head
= tty
->canon_head
;
547 tail
= tty
->read_tail
;
548 nr
= (head
- tail
) & (N_TTY_BUF_SIZE
-1);
549 /* Skip EOF-chars.. */
550 while (head
!= tail
) {
551 if (test_bit(tail
, tty
->read_flags
) &&
552 tty
->read_buf
[tail
] == __DISABLED_CHAR
)
554 tail
= (tail
+1) & (N_TTY_BUF_SIZE
-1);
561 * These are deprecated, but there is limited support..
563 * The "sg_flags" translation is a joke..
565 static int get_sgflags(struct tty_struct
*tty
)
569 if (!(tty
->termios
->c_lflag
& ICANON
)) {
570 if (tty
->termios
->c_lflag
& ISIG
)
571 flags
|= 0x02; /* cbreak */
573 flags
|= 0x20; /* raw */
575 if (tty
->termios
->c_lflag
& ECHO
)
576 flags
|= 0x08; /* echo */
577 if (tty
->termios
->c_oflag
& OPOST
)
578 if (tty
->termios
->c_oflag
& ONLCR
)
579 flags
|= 0x10; /* crmod */
583 static int get_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
587 mutex_lock(&tty
->termios_mutex
);
588 tmp
.sg_ispeed
= tty
->termios
->c_ispeed
;
589 tmp
.sg_ospeed
= tty
->termios
->c_ospeed
;
590 tmp
.sg_erase
= tty
->termios
->c_cc
[VERASE
];
591 tmp
.sg_kill
= tty
->termios
->c_cc
[VKILL
];
592 tmp
.sg_flags
= get_sgflags(tty
);
593 mutex_unlock(&tty
->termios_mutex
);
595 return copy_to_user(sgttyb
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
598 static void set_sgflags(struct ktermios
*termios
, int flags
)
600 termios
->c_iflag
= ICRNL
| IXON
;
601 termios
->c_oflag
= 0;
602 termios
->c_lflag
= ISIG
| ICANON
;
603 if (flags
& 0x02) { /* cbreak */
604 termios
->c_iflag
= 0;
605 termios
->c_lflag
&= ~ICANON
;
607 if (flags
& 0x08) { /* echo */
608 termios
->c_lflag
|= ECHO
| ECHOE
| ECHOK
|
609 ECHOCTL
| ECHOKE
| IEXTEN
;
611 if (flags
& 0x10) { /* crmod */
612 termios
->c_oflag
|= OPOST
| ONLCR
;
614 if (flags
& 0x20) { /* raw */
615 termios
->c_iflag
= 0;
616 termios
->c_lflag
&= ~(ISIG
| ICANON
);
618 if (!(termios
->c_lflag
& ICANON
)) {
619 termios
->c_cc
[VMIN
] = 1;
620 termios
->c_cc
[VTIME
] = 0;
625 * set_sgttyb - set legacy terminal values
626 * @tty: tty structure
627 * @sgttyb: pointer to old style terminal structure
629 * Updates a terminal from the legacy BSD style terminal information
632 * Locking: termios_sem
635 static int set_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
639 struct ktermios termios
;
641 retval
= tty_check_change(tty
);
645 if (copy_from_user(&tmp
, sgttyb
, sizeof(tmp
)))
648 mutex_lock(&tty
->termios_mutex
);
649 termios
= *tty
->termios
;
650 termios
.c_cc
[VERASE
] = tmp
.sg_erase
;
651 termios
.c_cc
[VKILL
] = tmp
.sg_kill
;
652 set_sgflags(&termios
, tmp
.sg_flags
);
653 /* Try and encode into Bfoo format */
655 tty_termios_encode_baud_rate(&termios
, termios
.c_ispeed
,
658 mutex_unlock(&tty
->termios_mutex
);
659 change_termios(tty
, &termios
);
665 static int get_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
669 tmp
.t_intrc
= tty
->termios
->c_cc
[VINTR
];
670 tmp
.t_quitc
= tty
->termios
->c_cc
[VQUIT
];
671 tmp
.t_startc
= tty
->termios
->c_cc
[VSTART
];
672 tmp
.t_stopc
= tty
->termios
->c_cc
[VSTOP
];
673 tmp
.t_eofc
= tty
->termios
->c_cc
[VEOF
];
674 tmp
.t_brkc
= tty
->termios
->c_cc
[VEOL2
]; /* what is brkc anyway? */
675 return copy_to_user(tchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
678 static int set_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
682 if (copy_from_user(&tmp
, tchars
, sizeof(tmp
)))
684 tty
->termios
->c_cc
[VINTR
] = tmp
.t_intrc
;
685 tty
->termios
->c_cc
[VQUIT
] = tmp
.t_quitc
;
686 tty
->termios
->c_cc
[VSTART
] = tmp
.t_startc
;
687 tty
->termios
->c_cc
[VSTOP
] = tmp
.t_stopc
;
688 tty
->termios
->c_cc
[VEOF
] = tmp
.t_eofc
;
689 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_brkc
; /* what is brkc anyway? */
695 static int get_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
699 tmp
.t_suspc
= tty
->termios
->c_cc
[VSUSP
];
700 /* what is dsuspc anyway? */
701 tmp
.t_dsuspc
= tty
->termios
->c_cc
[VSUSP
];
702 tmp
.t_rprntc
= tty
->termios
->c_cc
[VREPRINT
];
703 /* what is flushc anyway? */
704 tmp
.t_flushc
= tty
->termios
->c_cc
[VEOL2
];
705 tmp
.t_werasc
= tty
->termios
->c_cc
[VWERASE
];
706 tmp
.t_lnextc
= tty
->termios
->c_cc
[VLNEXT
];
707 return copy_to_user(ltchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
710 static int set_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
714 if (copy_from_user(&tmp
, ltchars
, sizeof(tmp
)))
717 tty
->termios
->c_cc
[VSUSP
] = tmp
.t_suspc
;
718 /* what is dsuspc anyway? */
719 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_dsuspc
;
720 tty
->termios
->c_cc
[VREPRINT
] = tmp
.t_rprntc
;
721 /* what is flushc anyway? */
722 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_flushc
;
723 tty
->termios
->c_cc
[VWERASE
] = tmp
.t_werasc
;
724 tty
->termios
->c_cc
[VLNEXT
] = tmp
.t_lnextc
;
730 * send_prio_char - send priority character
732 * Send a high priority character to the tty even if stopped
734 * Locking: none for xchar method, write ordering for write method.
737 static int send_prio_char(struct tty_struct
*tty
, char ch
)
739 int was_stopped
= tty
->stopped
;
741 if (tty
->driver
->send_xchar
) {
742 tty
->driver
->send_xchar(tty
, ch
);
746 if (tty_write_lock(tty
, 0) < 0)
751 tty
->driver
->write(tty
, &ch
, 1);
754 tty_write_unlock(tty
);
759 * tty_change_softcar - carrier change ioctl helper
760 * @tty: tty to update
761 * @arg: enable/disable CLOCAL
763 * Perform a change to the CLOCAL state and call into the driver
764 * layer to make it visible. All done with the termios mutex
767 static int tty_change_softcar(struct tty_struct
*tty
, int arg
)
770 int bit
= arg
? CLOCAL
: 0;
771 struct ktermios old
= *tty
->termios
;
773 mutex_lock(&tty
->termios_mutex
);
774 tty
->termios
->c_cflag
&= ~CLOCAL
;
775 tty
->termios
->c_cflag
|= bit
;
776 if (tty
->driver
->set_termios
)
777 tty
->driver
->set_termios(tty
, &old
);
778 if ((tty
->termios
->c_cflag
& CLOCAL
) != bit
)
780 mutex_unlock(&tty
->termios_mutex
);
785 * tty_mode_ioctl - mode related ioctls
786 * @tty: tty for the ioctl
787 * @file: file pointer for the tty
789 * @arg: ioctl argument
791 * Perform non line discipline specific mode control ioctls. This
792 * is designed to be called by line disciplines to ensure they provide
793 * consistent mode setting.
796 int tty_mode_ioctl(struct tty_struct
*tty
, struct file
*file
,
797 unsigned int cmd
, unsigned long arg
)
799 struct tty_struct
*real_tty
;
800 void __user
*p
= (void __user
*)arg
;
802 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
803 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
804 real_tty
= tty
->link
;
811 return get_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
814 return set_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
818 return get_tchars(real_tty
, p
);
820 return set_tchars(real_tty
, p
);
824 return get_ltchars(real_tty
, p
);
826 return set_ltchars(real_tty
, p
);
829 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_OLD
);
831 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_OLD
);
833 return set_termios(real_tty
, p
, TERMIOS_OLD
);
836 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, real_tty
->termios
))
841 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, real_tty
->termios
))
845 if (kernel_termios_to_user_termios((struct termios2 __user
*)arg
, real_tty
->termios
))
849 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
);
851 return set_termios(real_tty
, p
, TERMIOS_WAIT
);
853 return set_termios(real_tty
, p
, 0);
856 return get_termio(real_tty
, p
);
858 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_TERMIO
);
860 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_TERMIO
);
862 return set_termios(real_tty
, p
, TERMIOS_TERMIO
);
865 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, real_tty
->termios_locked
))
869 if (!capable(CAP_SYS_ADMIN
))
871 if (user_termios_to_kernel_termios(real_tty
->termios_locked
,
872 (struct termios __user
*) arg
))
877 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, real_tty
->termios_locked
))
881 if (!capable(CAP_SYS_ADMIN
))
883 if (user_termios_to_kernel_termios_1(real_tty
->termios_locked
,
884 (struct termios __user
*) arg
))
889 return put_user(C_CLOCAL(tty
) ? 1 : 0,
892 if (get_user(arg
, (unsigned int __user
*) arg
))
894 return tty_change_softcar(tty
, arg
);
899 EXPORT_SYMBOL_GPL(tty_mode_ioctl
);
901 int tty_perform_flush(struct tty_struct
*tty
, unsigned long arg
)
903 struct tty_ldisc
*ld
;
904 int retval
= tty_check_change(tty
);
908 ld
= tty_ldisc_ref(tty
);
911 if (ld
&& ld
->flush_buffer
)
912 ld
->flush_buffer(tty
);
915 if (ld
&& ld
->flush_buffer
)
916 ld
->flush_buffer(tty
);
919 if (tty
->driver
->flush_buffer
)
920 tty
->driver
->flush_buffer(tty
);
929 EXPORT_SYMBOL_GPL(tty_perform_flush
);
931 int n_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
932 unsigned int cmd
, unsigned long arg
)
934 struct tty_struct
*real_tty
;
938 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
939 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
940 real_tty
= tty
->link
;
946 retval
= tty_check_change(tty
);
951 if (!tty
->flow_stopped
) {
952 tty
->flow_stopped
= 1;
957 if (tty
->flow_stopped
) {
958 tty
->flow_stopped
= 0;
963 if (STOP_CHAR(tty
) != __DISABLED_CHAR
)
964 return send_prio_char(tty
, STOP_CHAR(tty
));
967 if (START_CHAR(tty
) != __DISABLED_CHAR
)
968 return send_prio_char(tty
, START_CHAR(tty
));
975 return tty_perform_flush(tty
, arg
);
977 return put_user(tty
->driver
->chars_in_buffer
?
978 tty
->driver
->chars_in_buffer(tty
) : 0,
981 retval
= tty
->read_cnt
;
983 retval
= inq_canon(tty
);
984 return put_user(retval
, (unsigned int __user
*) arg
);
989 if (tty
->driver
->type
!= TTY_DRIVER_TYPE_PTY
||
990 tty
->driver
->subtype
!= PTY_TYPE_MASTER
)
992 if (get_user(pktmode
, (int __user
*) arg
))
994 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
998 tty
->link
->ctrl_status
= 0;
1002 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
1006 /* Try the mode commands */
1007 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1010 EXPORT_SYMBOL(n_tty_ioctl
);