]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/tty/tty_ioctl.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
5 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
6 * which can be dynamically activated and de-activated by the line
7 * discipline handling modules (like SLIP).
10 #include <linux/types.h>
11 #include <linux/termios.h>
12 #include <linux/errno.h>
13 #include <linux/sched/signal.h>
14 #include <linux/kernel.h>
15 #include <linux/major.h>
16 #include <linux/tty.h>
17 #include <linux/fcntl.h>
18 #include <linux/string.h>
20 #include <linux/module.h>
21 #include <linux/bitops.h>
22 #include <linux/mutex.h>
23 #include <linux/compat.h>
27 #include <linux/uaccess.h>
29 #undef TTY_DEBUG_WAIT_UNTIL_SENT
31 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
32 # define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
34 # define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
40 * Internal flag options for termios setting behavior
42 #define TERMIOS_FLUSH 1
43 #define TERMIOS_WAIT 2
44 #define TERMIOS_TERMIO 4
49 * tty_chars_in_buffer - characters pending
52 * Return the number of bytes of data in the device private
53 * output queue. If no private method is supplied there is assumed
54 * to be no queue on the device.
57 int tty_chars_in_buffer(struct tty_struct
*tty
)
59 if (tty
->ops
->chars_in_buffer
)
60 return tty
->ops
->chars_in_buffer(tty
);
63 EXPORT_SYMBOL(tty_chars_in_buffer
);
66 * tty_write_room - write queue space
69 * Return the number of bytes that can be queued to this device
70 * at the present time. The result should be treated as a guarantee
71 * and the driver cannot offer a value it later shrinks by more than
72 * the number of bytes written. If no method is provided 2K is always
73 * returned and data may be lost as there will be no flow control.
76 int tty_write_room(struct tty_struct
*tty
)
78 if (tty
->ops
->write_room
)
79 return tty
->ops
->write_room(tty
);
82 EXPORT_SYMBOL(tty_write_room
);
85 * tty_driver_flush_buffer - discard internal buffer
88 * Discard the internal output buffer for this device. If no method
89 * is provided then either the buffer cannot be hardware flushed or
90 * there is no buffer driver side.
92 void tty_driver_flush_buffer(struct tty_struct
*tty
)
94 if (tty
->ops
->flush_buffer
)
95 tty
->ops
->flush_buffer(tty
);
97 EXPORT_SYMBOL(tty_driver_flush_buffer
);
100 * tty_throttle - flow control
103 * Indicate that a tty should stop transmitting data down the stack.
104 * Takes the termios rwsem to protect against parallel throttle/unthrottle
105 * and also to ensure the driver can consistently reference its own
106 * termios data at this point when implementing software flow control.
109 void tty_throttle(struct tty_struct
*tty
)
111 down_write(&tty
->termios_rwsem
);
112 /* check TTY_THROTTLED first so it indicates our state */
113 if (!test_and_set_bit(TTY_THROTTLED
, &tty
->flags
) &&
115 tty
->ops
->throttle(tty
);
116 tty
->flow_change
= 0;
117 up_write(&tty
->termios_rwsem
);
119 EXPORT_SYMBOL(tty_throttle
);
122 * tty_unthrottle - flow control
125 * Indicate that a tty may continue transmitting data down the stack.
126 * Takes the termios rwsem to protect against parallel throttle/unthrottle
127 * and also to ensure the driver can consistently reference its own
128 * termios data at this point when implementing software flow control.
130 * Drivers should however remember that the stack can issue a throttle,
131 * then change flow control method, then unthrottle.
134 void tty_unthrottle(struct tty_struct
*tty
)
136 down_write(&tty
->termios_rwsem
);
137 if (test_and_clear_bit(TTY_THROTTLED
, &tty
->flags
) &&
138 tty
->ops
->unthrottle
)
139 tty
->ops
->unthrottle(tty
);
140 tty
->flow_change
= 0;
141 up_write(&tty
->termios_rwsem
);
143 EXPORT_SYMBOL(tty_unthrottle
);
146 * tty_throttle_safe - flow control
149 * Similar to tty_throttle() but will only attempt throttle
150 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
151 * throttle due to race conditions when throttling is conditional
152 * on factors evaluated prior to throttling.
154 * Returns 0 if tty is throttled (or was already throttled)
157 int tty_throttle_safe(struct tty_struct
*tty
)
161 mutex_lock(&tty
->throttle_mutex
);
162 if (!tty_throttled(tty
)) {
163 if (tty
->flow_change
!= TTY_THROTTLE_SAFE
)
166 set_bit(TTY_THROTTLED
, &tty
->flags
);
167 if (tty
->ops
->throttle
)
168 tty
->ops
->throttle(tty
);
171 mutex_unlock(&tty
->throttle_mutex
);
177 * tty_unthrottle_safe - flow control
180 * Similar to tty_unthrottle() but will only attempt unthrottle
181 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
182 * unthrottle due to race conditions when unthrottling is conditional
183 * on factors evaluated prior to unthrottling.
185 * Returns 0 if tty is unthrottled (or was already unthrottled)
188 int tty_unthrottle_safe(struct tty_struct
*tty
)
192 mutex_lock(&tty
->throttle_mutex
);
193 if (tty_throttled(tty
)) {
194 if (tty
->flow_change
!= TTY_UNTHROTTLE_SAFE
)
197 clear_bit(TTY_THROTTLED
, &tty
->flags
);
198 if (tty
->ops
->unthrottle
)
199 tty
->ops
->unthrottle(tty
);
202 mutex_unlock(&tty
->throttle_mutex
);
208 * tty_wait_until_sent - wait for I/O to finish
209 * @tty: tty we are waiting for
210 * @timeout: how long we will wait
212 * Wait for characters pending in a tty driver to hit the wire, or
213 * for a timeout to occur (eg due to flow control)
218 void tty_wait_until_sent(struct tty_struct
*tty
, long timeout
)
220 tty_debug_wait_until_sent(tty
, "wait until sent, timeout=%ld\n", timeout
);
223 timeout
= MAX_SCHEDULE_TIMEOUT
;
225 timeout
= wait_event_interruptible_timeout(tty
->write_wait
,
226 !tty_chars_in_buffer(tty
), timeout
);
230 if (timeout
== MAX_SCHEDULE_TIMEOUT
)
233 if (tty
->ops
->wait_until_sent
)
234 tty
->ops
->wait_until_sent(tty
, timeout
);
236 EXPORT_SYMBOL(tty_wait_until_sent
);
240 * Termios Helper Methods
243 static void unset_locked_termios(struct tty_struct
*tty
, struct ktermios
*old
)
245 struct ktermios
*termios
= &tty
->termios
;
246 struct ktermios
*locked
= &tty
->termios_locked
;
249 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
251 NOSET_MASK(termios
->c_iflag
, old
->c_iflag
, locked
->c_iflag
);
252 NOSET_MASK(termios
->c_oflag
, old
->c_oflag
, locked
->c_oflag
);
253 NOSET_MASK(termios
->c_cflag
, old
->c_cflag
, locked
->c_cflag
);
254 NOSET_MASK(termios
->c_lflag
, old
->c_lflag
, locked
->c_lflag
);
255 termios
->c_line
= locked
->c_line
? old
->c_line
: termios
->c_line
;
256 for (i
= 0; i
< NCCS
; i
++)
257 termios
->c_cc
[i
] = locked
->c_cc
[i
] ?
258 old
->c_cc
[i
] : termios
->c_cc
[i
];
259 /* FIXME: What should we do for i/ospeed */
263 * tty_termios_copy_hw - copy hardware settings
267 * Propagate the hardware specific terminal setting bits from
268 * the old termios structure to the new one. This is used in cases
269 * where the hardware does not support reconfiguration or as a helper
270 * in some cases where only minimal reconfiguration is supported
273 void tty_termios_copy_hw(struct ktermios
*new, struct ktermios
*old
)
275 /* The bits a dumb device handles in software. Smart devices need
276 to always provide a set_termios method */
277 new->c_cflag
&= HUPCL
| CREAD
| CLOCAL
;
278 new->c_cflag
|= old
->c_cflag
& ~(HUPCL
| CREAD
| CLOCAL
);
279 new->c_ispeed
= old
->c_ispeed
;
280 new->c_ospeed
= old
->c_ospeed
;
282 EXPORT_SYMBOL(tty_termios_copy_hw
);
285 * tty_termios_hw_change - check for setting change
287 * @b: termios to compare
289 * Check if any of the bits that affect a dumb device have changed
290 * between the two termios structures, or a speed change is needed.
293 int tty_termios_hw_change(const struct ktermios
*a
, const struct ktermios
*b
)
295 if (a
->c_ispeed
!= b
->c_ispeed
|| a
->c_ospeed
!= b
->c_ospeed
)
297 if ((a
->c_cflag
^ b
->c_cflag
) & ~(HUPCL
| CREAD
| CLOCAL
))
301 EXPORT_SYMBOL(tty_termios_hw_change
);
304 * tty_set_termios - update termios values
305 * @tty: tty to update
306 * @new_termios: desired new value
308 * Perform updates to the termios values set on this terminal.
309 * A master pty's termios should never be set.
311 * Locking: termios_rwsem
314 int tty_set_termios(struct tty_struct
*tty
, struct ktermios
*new_termios
)
316 struct ktermios old_termios
;
317 struct tty_ldisc
*ld
;
319 WARN_ON(tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
320 tty
->driver
->subtype
== PTY_TYPE_MASTER
);
322 * Perform the actual termios internal changes under lock.
326 /* FIXME: we need to decide on some locking/ordering semantics
327 for the set_termios notification eventually */
328 down_write(&tty
->termios_rwsem
);
329 old_termios
= tty
->termios
;
330 tty
->termios
= *new_termios
;
331 unset_locked_termios(tty
, &old_termios
);
333 if (tty
->ops
->set_termios
)
334 tty
->ops
->set_termios(tty
, &old_termios
);
336 tty_termios_copy_hw(&tty
->termios
, &old_termios
);
338 ld
= tty_ldisc_ref(tty
);
340 if (ld
->ops
->set_termios
)
341 ld
->ops
->set_termios(tty
, &old_termios
);
344 up_write(&tty
->termios_rwsem
);
347 EXPORT_SYMBOL_GPL(tty_set_termios
);
350 * set_termios - set termios values for a tty
351 * @tty: terminal device
353 * @opt: option information
355 * Helper function to prepare termios data and run necessary other
356 * functions before using tty_set_termios to do the actual changes.
359 * Called functions take ldisc and termios_rwsem locks
362 static int set_termios(struct tty_struct
*tty
, void __user
*arg
, int opt
)
364 struct ktermios tmp_termios
;
365 struct tty_ldisc
*ld
;
366 int retval
= tty_check_change(tty
);
371 down_read(&tty
->termios_rwsem
);
372 tmp_termios
= tty
->termios
;
373 up_read(&tty
->termios_rwsem
);
375 if (opt
& TERMIOS_TERMIO
) {
376 if (user_termio_to_kernel_termios(&tmp_termios
,
377 (struct termio __user
*)arg
))
380 } else if (opt
& TERMIOS_OLD
) {
381 if (user_termios_to_kernel_termios_1(&tmp_termios
,
382 (struct termios __user
*)arg
))
385 if (user_termios_to_kernel_termios(&tmp_termios
,
386 (struct termios2 __user
*)arg
))
390 } else if (user_termios_to_kernel_termios(&tmp_termios
,
391 (struct termios __user
*)arg
))
395 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
396 * with the real speed so its unconditionally usable */
397 tmp_termios
.c_ispeed
= tty_termios_input_baud_rate(&tmp_termios
);
398 tmp_termios
.c_ospeed
= tty_termios_baud_rate(&tmp_termios
);
400 ld
= tty_ldisc_ref(tty
);
403 if ((opt
& TERMIOS_FLUSH
) && ld
->ops
->flush_buffer
)
404 ld
->ops
->flush_buffer(tty
);
408 if (opt
& TERMIOS_WAIT
) {
409 tty_wait_until_sent(tty
, 0);
410 if (signal_pending(current
))
414 tty_set_termios(tty
, &tmp_termios
);
416 /* FIXME: Arguably if tmp_termios == tty->termios AND the
417 actual requested termios was not tmp_termios then we may
418 want to return an error as no user requested change has
423 static void copy_termios(struct tty_struct
*tty
, struct ktermios
*kterm
)
425 down_read(&tty
->termios_rwsem
);
426 *kterm
= tty
->termios
;
427 up_read(&tty
->termios_rwsem
);
430 static void copy_termios_locked(struct tty_struct
*tty
, struct ktermios
*kterm
)
432 down_read(&tty
->termios_rwsem
);
433 *kterm
= tty
->termios_locked
;
434 up_read(&tty
->termios_rwsem
);
437 static int get_termio(struct tty_struct
*tty
, struct termio __user
*termio
)
439 struct ktermios kterm
;
440 copy_termios(tty
, &kterm
);
441 if (kernel_termios_to_user_termio(termio
, &kterm
))
448 * These are deprecated, but there is limited support..
450 * The "sg_flags" translation is a joke..
452 static int get_sgflags(struct tty_struct
*tty
)
456 if (!L_ICANON(tty
)) {
458 flags
|= 0x02; /* cbreak */
460 flags
|= 0x20; /* raw */
463 flags
|= 0x08; /* echo */
466 flags
|= 0x10; /* crmod */
470 static int get_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
474 down_read(&tty
->termios_rwsem
);
475 tmp
.sg_ispeed
= tty
->termios
.c_ispeed
;
476 tmp
.sg_ospeed
= tty
->termios
.c_ospeed
;
477 tmp
.sg_erase
= tty
->termios
.c_cc
[VERASE
];
478 tmp
.sg_kill
= tty
->termios
.c_cc
[VKILL
];
479 tmp
.sg_flags
= get_sgflags(tty
);
480 up_read(&tty
->termios_rwsem
);
482 return copy_to_user(sgttyb
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
485 static void set_sgflags(struct ktermios
*termios
, int flags
)
487 termios
->c_iflag
= ICRNL
| IXON
;
488 termios
->c_oflag
= 0;
489 termios
->c_lflag
= ISIG
| ICANON
;
490 if (flags
& 0x02) { /* cbreak */
491 termios
->c_iflag
= 0;
492 termios
->c_lflag
&= ~ICANON
;
494 if (flags
& 0x08) { /* echo */
495 termios
->c_lflag
|= ECHO
| ECHOE
| ECHOK
|
496 ECHOCTL
| ECHOKE
| IEXTEN
;
498 if (flags
& 0x10) { /* crmod */
499 termios
->c_oflag
|= OPOST
| ONLCR
;
501 if (flags
& 0x20) { /* raw */
502 termios
->c_iflag
= 0;
503 termios
->c_lflag
&= ~(ISIG
| ICANON
);
505 if (!(termios
->c_lflag
& ICANON
)) {
506 termios
->c_cc
[VMIN
] = 1;
507 termios
->c_cc
[VTIME
] = 0;
512 * set_sgttyb - set legacy terminal values
513 * @tty: tty structure
514 * @sgttyb: pointer to old style terminal structure
516 * Updates a terminal from the legacy BSD style terminal information
519 * Locking: termios_rwsem
522 static int set_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
526 struct ktermios termios
;
528 retval
= tty_check_change(tty
);
532 if (copy_from_user(&tmp
, sgttyb
, sizeof(tmp
)))
535 down_write(&tty
->termios_rwsem
);
536 termios
= tty
->termios
;
537 termios
.c_cc
[VERASE
] = tmp
.sg_erase
;
538 termios
.c_cc
[VKILL
] = tmp
.sg_kill
;
539 set_sgflags(&termios
, tmp
.sg_flags
);
540 /* Try and encode into Bfoo format */
542 tty_termios_encode_baud_rate(&termios
, termios
.c_ispeed
,
545 up_write(&tty
->termios_rwsem
);
546 tty_set_termios(tty
, &termios
);
552 static int get_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
556 down_read(&tty
->termios_rwsem
);
557 tmp
.t_intrc
= tty
->termios
.c_cc
[VINTR
];
558 tmp
.t_quitc
= tty
->termios
.c_cc
[VQUIT
];
559 tmp
.t_startc
= tty
->termios
.c_cc
[VSTART
];
560 tmp
.t_stopc
= tty
->termios
.c_cc
[VSTOP
];
561 tmp
.t_eofc
= tty
->termios
.c_cc
[VEOF
];
562 tmp
.t_brkc
= tty
->termios
.c_cc
[VEOL2
]; /* what is brkc anyway? */
563 up_read(&tty
->termios_rwsem
);
564 return copy_to_user(tchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
567 static int set_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
571 if (copy_from_user(&tmp
, tchars
, sizeof(tmp
)))
573 down_write(&tty
->termios_rwsem
);
574 tty
->termios
.c_cc
[VINTR
] = tmp
.t_intrc
;
575 tty
->termios
.c_cc
[VQUIT
] = tmp
.t_quitc
;
576 tty
->termios
.c_cc
[VSTART
] = tmp
.t_startc
;
577 tty
->termios
.c_cc
[VSTOP
] = tmp
.t_stopc
;
578 tty
->termios
.c_cc
[VEOF
] = tmp
.t_eofc
;
579 tty
->termios
.c_cc
[VEOL2
] = tmp
.t_brkc
; /* what is brkc anyway? */
580 up_write(&tty
->termios_rwsem
);
586 static int get_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
590 down_read(&tty
->termios_rwsem
);
591 tmp
.t_suspc
= tty
->termios
.c_cc
[VSUSP
];
592 /* what is dsuspc anyway? */
593 tmp
.t_dsuspc
= tty
->termios
.c_cc
[VSUSP
];
594 tmp
.t_rprntc
= tty
->termios
.c_cc
[VREPRINT
];
595 /* what is flushc anyway? */
596 tmp
.t_flushc
= tty
->termios
.c_cc
[VEOL2
];
597 tmp
.t_werasc
= tty
->termios
.c_cc
[VWERASE
];
598 tmp
.t_lnextc
= tty
->termios
.c_cc
[VLNEXT
];
599 up_read(&tty
->termios_rwsem
);
600 return copy_to_user(ltchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
603 static int set_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
607 if (copy_from_user(&tmp
, ltchars
, sizeof(tmp
)))
610 down_write(&tty
->termios_rwsem
);
611 tty
->termios
.c_cc
[VSUSP
] = tmp
.t_suspc
;
612 /* what is dsuspc anyway? */
613 tty
->termios
.c_cc
[VEOL2
] = tmp
.t_dsuspc
;
614 tty
->termios
.c_cc
[VREPRINT
] = tmp
.t_rprntc
;
615 /* what is flushc anyway? */
616 tty
->termios
.c_cc
[VEOL2
] = tmp
.t_flushc
;
617 tty
->termios
.c_cc
[VWERASE
] = tmp
.t_werasc
;
618 tty
->termios
.c_cc
[VLNEXT
] = tmp
.t_lnextc
;
619 up_write(&tty
->termios_rwsem
);
625 * tty_change_softcar - carrier change ioctl helper
626 * @tty: tty to update
627 * @arg: enable/disable CLOCAL
629 * Perform a change to the CLOCAL state and call into the driver
630 * layer to make it visible. All done with the termios rwsem
633 static int tty_change_softcar(struct tty_struct
*tty
, int arg
)
636 int bit
= arg
? CLOCAL
: 0;
639 down_write(&tty
->termios_rwsem
);
641 tty
->termios
.c_cflag
&= ~CLOCAL
;
642 tty
->termios
.c_cflag
|= bit
;
643 if (tty
->ops
->set_termios
)
644 tty
->ops
->set_termios(tty
, &old
);
645 if (C_CLOCAL(tty
) != bit
)
647 up_write(&tty
->termios_rwsem
);
652 * tty_mode_ioctl - mode related ioctls
653 * @tty: tty for the ioctl
654 * @file: file pointer for the tty
656 * @arg: ioctl argument
658 * Perform non line discipline specific mode control ioctls. This
659 * is designed to be called by line disciplines to ensure they provide
660 * consistent mode setting.
663 int tty_mode_ioctl(struct tty_struct
*tty
, struct file
*file
,
664 unsigned int cmd
, unsigned long arg
)
666 struct tty_struct
*real_tty
;
667 void __user
*p
= (void __user
*)arg
;
669 struct ktermios kterm
;
671 BUG_ON(file
== NULL
);
673 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
674 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
675 real_tty
= tty
->link
;
682 return get_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
685 return set_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
689 return get_tchars(real_tty
, p
);
691 return set_tchars(real_tty
, p
);
695 return get_ltchars(real_tty
, p
);
697 return set_ltchars(real_tty
, p
);
700 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_OLD
);
702 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_OLD
);
704 return set_termios(real_tty
, p
, TERMIOS_OLD
);
707 copy_termios(real_tty
, &kterm
);
708 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, &kterm
))
713 copy_termios(real_tty
, &kterm
);
714 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, &kterm
))
718 copy_termios(real_tty
, &kterm
);
719 if (kernel_termios_to_user_termios((struct termios2 __user
*)arg
, &kterm
))
723 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
);
725 return set_termios(real_tty
, p
, TERMIOS_WAIT
);
727 return set_termios(real_tty
, p
, 0);
730 return get_termio(real_tty
, p
);
732 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_TERMIO
);
734 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_TERMIO
);
736 return set_termios(real_tty
, p
, TERMIOS_TERMIO
);
739 copy_termios_locked(real_tty
, &kterm
);
740 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, &kterm
))
744 if (!capable(CAP_SYS_ADMIN
))
746 copy_termios_locked(real_tty
, &kterm
);
747 if (user_termios_to_kernel_termios(&kterm
,
748 (struct termios __user
*) arg
))
750 down_write(&real_tty
->termios_rwsem
);
751 real_tty
->termios_locked
= kterm
;
752 up_write(&real_tty
->termios_rwsem
);
756 copy_termios_locked(real_tty
, &kterm
);
757 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, &kterm
))
761 if (!capable(CAP_SYS_ADMIN
))
763 copy_termios_locked(real_tty
, &kterm
);
764 if (user_termios_to_kernel_termios_1(&kterm
,
765 (struct termios __user
*) arg
))
767 down_write(&real_tty
->termios_rwsem
);
768 real_tty
->termios_locked
= kterm
;
769 up_write(&real_tty
->termios_rwsem
);
780 copy_termios(real_tty
, &kterm
);
781 ret
= put_user((kterm
.c_cflag
& CLOCAL
) ? 1 : 0,
785 if (get_user(arg
, (unsigned int __user
*) arg
))
787 return tty_change_softcar(real_tty
, arg
);
792 EXPORT_SYMBOL_GPL(tty_mode_ioctl
);
795 /* Caller guarantees ldisc reference is held */
796 static int __tty_perform_flush(struct tty_struct
*tty
, unsigned long arg
)
798 struct tty_ldisc
*ld
= tty
->ldisc
;
802 if (ld
&& ld
->ops
->flush_buffer
) {
803 ld
->ops
->flush_buffer(tty
);
808 if (ld
&& ld
->ops
->flush_buffer
) {
809 ld
->ops
->flush_buffer(tty
);
814 tty_driver_flush_buffer(tty
);
822 int tty_perform_flush(struct tty_struct
*tty
, unsigned long arg
)
824 struct tty_ldisc
*ld
;
825 int retval
= tty_check_change(tty
);
829 ld
= tty_ldisc_ref_wait(tty
);
830 retval
= __tty_perform_flush(tty
, arg
);
835 EXPORT_SYMBOL_GPL(tty_perform_flush
);
837 int n_tty_ioctl_helper(struct tty_struct
*tty
, struct file
*file
,
838 unsigned int cmd
, unsigned long arg
)
844 retval
= tty_check_change(tty
);
849 spin_lock_irq(&tty
->flow_lock
);
850 if (!tty
->flow_stopped
) {
851 tty
->flow_stopped
= 1;
854 spin_unlock_irq(&tty
->flow_lock
);
857 spin_lock_irq(&tty
->flow_lock
);
858 if (tty
->flow_stopped
) {
859 tty
->flow_stopped
= 0;
862 spin_unlock_irq(&tty
->flow_lock
);
865 if (STOP_CHAR(tty
) != __DISABLED_CHAR
)
866 retval
= tty_send_xchar(tty
, STOP_CHAR(tty
));
869 if (START_CHAR(tty
) != __DISABLED_CHAR
)
870 retval
= tty_send_xchar(tty
, START_CHAR(tty
));
877 retval
= tty_check_change(tty
);
880 return __tty_perform_flush(tty
, arg
);
882 /* Try the mode commands */
883 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
886 EXPORT_SYMBOL(n_tty_ioctl_helper
);