Loading...
1/*
2 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
3 *
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).
7 */
8
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>
18#include <linux/mm.h>
19#include <linux/module.h>
20#include <linux/bitops.h>
21#include <linux/mutex.h>
22#include <linux/compat.h>
23
24#include <asm/io.h>
25#include <asm/uaccess.h>
26
27#undef TTY_DEBUG_WAIT_UNTIL_SENT
28
29#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
30# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
31#else
32# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
33#endif
34
35#undef DEBUG
36
37/*
38 * Internal flag options for termios setting behavior
39 */
40#define TERMIOS_FLUSH 1
41#define TERMIOS_WAIT 2
42#define TERMIOS_TERMIO 4
43#define TERMIOS_OLD 8
44
45
46/**
47 * tty_chars_in_buffer - characters pending
48 * @tty: terminal
49 *
50 * Return the number of bytes of data in the device private
51 * output queue. If no private method is supplied there is assumed
52 * to be no queue on the device.
53 */
54
55int tty_chars_in_buffer(struct tty_struct *tty)
56{
57 if (tty->ops->chars_in_buffer)
58 return tty->ops->chars_in_buffer(tty);
59 else
60 return 0;
61}
62EXPORT_SYMBOL(tty_chars_in_buffer);
63
64/**
65 * tty_write_room - write queue space
66 * @tty: terminal
67 *
68 * Return the number of bytes that can be queued to this device
69 * at the present time. The result should be treated as a guarantee
70 * and the driver cannot offer a value it later shrinks by more than
71 * the number of bytes written. If no method is provided 2K is always
72 * returned and data may be lost as there will be no flow control.
73 */
74
75int tty_write_room(struct tty_struct *tty)
76{
77 if (tty->ops->write_room)
78 return tty->ops->write_room(tty);
79 return 2048;
80}
81EXPORT_SYMBOL(tty_write_room);
82
83/**
84 * tty_driver_flush_buffer - discard internal buffer
85 * @tty: terminal
86 *
87 * Discard the internal output buffer for this device. If no method
88 * is provided then either the buffer cannot be hardware flushed or
89 * there is no buffer driver side.
90 */
91void tty_driver_flush_buffer(struct tty_struct *tty)
92{
93 if (tty->ops->flush_buffer)
94 tty->ops->flush_buffer(tty);
95}
96EXPORT_SYMBOL(tty_driver_flush_buffer);
97
98/**
99 * tty_throttle - flow control
100 * @tty: terminal
101 *
102 * Indicate that a tty should stop transmitting data down the stack.
103 * Takes the termios rwsem to protect against parallel throttle/unthrottle
104 * and also to ensure the driver can consistently reference its own
105 * termios data at this point when implementing software flow control.
106 */
107
108void tty_throttle(struct tty_struct *tty)
109{
110 down_write(&tty->termios_rwsem);
111 /* check TTY_THROTTLED first so it indicates our state */
112 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
113 tty->ops->throttle)
114 tty->ops->throttle(tty);
115 tty->flow_change = 0;
116 up_write(&tty->termios_rwsem);
117}
118EXPORT_SYMBOL(tty_throttle);
119
120/**
121 * tty_unthrottle - flow control
122 * @tty: terminal
123 *
124 * Indicate that a tty may continue transmitting data down the stack.
125 * Takes the termios rwsem to protect against parallel throttle/unthrottle
126 * and also to ensure the driver can consistently reference its own
127 * termios data at this point when implementing software flow control.
128 *
129 * Drivers should however remember that the stack can issue a throttle,
130 * then change flow control method, then unthrottle.
131 */
132
133void tty_unthrottle(struct tty_struct *tty)
134{
135 down_write(&tty->termios_rwsem);
136 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
137 tty->ops->unthrottle)
138 tty->ops->unthrottle(tty);
139 tty->flow_change = 0;
140 up_write(&tty->termios_rwsem);
141}
142EXPORT_SYMBOL(tty_unthrottle);
143
144/**
145 * tty_throttle_safe - flow control
146 * @tty: terminal
147 *
148 * Similar to tty_throttle() but will only attempt throttle
149 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
150 * throttle due to race conditions when throttling is conditional
151 * on factors evaluated prior to throttling.
152 *
153 * Returns 0 if tty is throttled (or was already throttled)
154 */
155
156int tty_throttle_safe(struct tty_struct *tty)
157{
158 int ret = 0;
159
160 mutex_lock(&tty->throttle_mutex);
161 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
162 if (tty->flow_change != TTY_THROTTLE_SAFE)
163 ret = 1;
164 else {
165 set_bit(TTY_THROTTLED, &tty->flags);
166 if (tty->ops->throttle)
167 tty->ops->throttle(tty);
168 }
169 }
170 mutex_unlock(&tty->throttle_mutex);
171
172 return ret;
173}
174
175/**
176 * tty_unthrottle_safe - flow control
177 * @tty: terminal
178 *
179 * Similar to tty_unthrottle() but will only attempt unthrottle
180 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
181 * unthrottle due to race conditions when unthrottling is conditional
182 * on factors evaluated prior to unthrottling.
183 *
184 * Returns 0 if tty is unthrottled (or was already unthrottled)
185 */
186
187int tty_unthrottle_safe(struct tty_struct *tty)
188{
189 int ret = 0;
190
191 mutex_lock(&tty->throttle_mutex);
192 if (test_bit(TTY_THROTTLED, &tty->flags)) {
193 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
194 ret = 1;
195 else {
196 clear_bit(TTY_THROTTLED, &tty->flags);
197 if (tty->ops->unthrottle)
198 tty->ops->unthrottle(tty);
199 }
200 }
201 mutex_unlock(&tty->throttle_mutex);
202
203 return ret;
204}
205
206/**
207 * tty_wait_until_sent - wait for I/O to finish
208 * @tty: tty we are waiting for
209 * @timeout: how long we will wait
210 *
211 * Wait for characters pending in a tty driver to hit the wire, or
212 * for a timeout to occur (eg due to flow control)
213 *
214 * Locking: none
215 */
216
217void tty_wait_until_sent(struct tty_struct *tty, long timeout)
218{
219 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
220
221 if (!timeout)
222 timeout = MAX_SCHEDULE_TIMEOUT;
223
224 timeout = wait_event_interruptible_timeout(tty->write_wait,
225 !tty_chars_in_buffer(tty), timeout);
226 if (timeout <= 0)
227 return;
228
229 if (timeout == MAX_SCHEDULE_TIMEOUT)
230 timeout = 0;
231
232 if (tty->ops->wait_until_sent)
233 tty->ops->wait_until_sent(tty, timeout);
234}
235EXPORT_SYMBOL(tty_wait_until_sent);
236
237
238/*
239 * Termios Helper Methods
240 */
241
242static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
243{
244 struct ktermios *termios = &tty->termios;
245 struct ktermios *locked = &tty->termios_locked;
246 int i;
247
248#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
249
250 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
251 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
252 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
253 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
254 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
255 for (i = 0; i < NCCS; i++)
256 termios->c_cc[i] = locked->c_cc[i] ?
257 old->c_cc[i] : termios->c_cc[i];
258 /* FIXME: What should we do for i/ospeed */
259}
260
261/*
262 * Routine which returns the baud rate of the tty
263 *
264 * Note that the baud_table needs to be kept in sync with the
265 * include/asm/termbits.h file.
266 */
267static const speed_t baud_table[] = {
268 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
269 9600, 19200, 38400, 57600, 115200, 230400, 460800,
270#ifdef __sparc__
271 76800, 153600, 307200, 614400, 921600
272#else
273 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
274 2500000, 3000000, 3500000, 4000000
275#endif
276};
277
278#ifndef __sparc__
279static const tcflag_t baud_bits[] = {
280 B0, B50, B75, B110, B134, B150, B200, B300, B600,
281 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
282 B57600, B115200, B230400, B460800, B500000, B576000,
283 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
284 B3000000, B3500000, B4000000
285};
286#else
287static const tcflag_t baud_bits[] = {
288 B0, B50, B75, B110, B134, B150, B200, B300, B600,
289 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
290 B57600, B115200, B230400, B460800, B76800, B153600,
291 B307200, B614400, B921600
292};
293#endif
294
295static int n_baud_table = ARRAY_SIZE(baud_table);
296
297/**
298 * tty_termios_baud_rate
299 * @termios: termios structure
300 *
301 * Convert termios baud rate data into a speed. This should be called
302 * with the termios lock held if this termios is a terminal termios
303 * structure. May change the termios data. Device drivers can call this
304 * function but should use ->c_[io]speed directly as they are updated.
305 *
306 * Locking: none
307 */
308
309speed_t tty_termios_baud_rate(struct ktermios *termios)
310{
311 unsigned int cbaud;
312
313 cbaud = termios->c_cflag & CBAUD;
314
315#ifdef BOTHER
316 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
317 if (cbaud == BOTHER)
318 return termios->c_ospeed;
319#endif
320 if (cbaud & CBAUDEX) {
321 cbaud &= ~CBAUDEX;
322
323 if (cbaud < 1 || cbaud + 15 > n_baud_table)
324 termios->c_cflag &= ~CBAUDEX;
325 else
326 cbaud += 15;
327 }
328 return baud_table[cbaud];
329}
330EXPORT_SYMBOL(tty_termios_baud_rate);
331
332/**
333 * tty_termios_input_baud_rate
334 * @termios: termios structure
335 *
336 * Convert termios baud rate data into a speed. This should be called
337 * with the termios lock held if this termios is a terminal termios
338 * structure. May change the termios data. Device drivers can call this
339 * function but should use ->c_[io]speed directly as they are updated.
340 *
341 * Locking: none
342 */
343
344speed_t tty_termios_input_baud_rate(struct ktermios *termios)
345{
346#ifdef IBSHIFT
347 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
348
349 if (cbaud == B0)
350 return tty_termios_baud_rate(termios);
351
352 /* Magic token for arbitrary speed via c_ispeed*/
353 if (cbaud == BOTHER)
354 return termios->c_ispeed;
355
356 if (cbaud & CBAUDEX) {
357 cbaud &= ~CBAUDEX;
358
359 if (cbaud < 1 || cbaud + 15 > n_baud_table)
360 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
361 else
362 cbaud += 15;
363 }
364 return baud_table[cbaud];
365#else
366 return tty_termios_baud_rate(termios);
367#endif
368}
369EXPORT_SYMBOL(tty_termios_input_baud_rate);
370
371/**
372 * tty_termios_encode_baud_rate
373 * @termios: ktermios structure holding user requested state
374 * @ispeed: input speed
375 * @ospeed: output speed
376 *
377 * Encode the speeds set into the passed termios structure. This is
378 * used as a library helper for drivers so that they can report back
379 * the actual speed selected when it differs from the speed requested
380 *
381 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
382 * we need to carefully set the bits when the user does not get the
383 * desired speed. We allow small margins and preserve as much of possible
384 * of the input intent to keep compatibility.
385 *
386 * Locking: Caller should hold termios lock. This is already held
387 * when calling this function from the driver termios handler.
388 *
389 * The ifdefs deal with platforms whose owners have yet to update them
390 * and will all go away once this is done.
391 */
392
393void tty_termios_encode_baud_rate(struct ktermios *termios,
394 speed_t ibaud, speed_t obaud)
395{
396 int i = 0;
397 int ifound = -1, ofound = -1;
398 int iclose = ibaud/50, oclose = obaud/50;
399 int ibinput = 0;
400
401 if (obaud == 0) /* CD dropped */
402 ibaud = 0; /* Clear ibaud to be sure */
403
404 termios->c_ispeed = ibaud;
405 termios->c_ospeed = obaud;
406
407#ifdef BOTHER
408 /* If the user asked for a precise weird speed give a precise weird
409 answer. If they asked for a Bfoo speed they may have problems
410 digesting non-exact replies so fuzz a bit */
411
412 if ((termios->c_cflag & CBAUD) == BOTHER)
413 oclose = 0;
414 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
415 iclose = 0;
416 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
417 ibinput = 1; /* An input speed was specified */
418#endif
419 termios->c_cflag &= ~CBAUD;
420
421 /*
422 * Our goal is to find a close match to the standard baud rate
423 * returned. Walk the baud rate table and if we get a very close
424 * match then report back the speed as a POSIX Bxxxx value by
425 * preference
426 */
427
428 do {
429 if (obaud - oclose <= baud_table[i] &&
430 obaud + oclose >= baud_table[i]) {
431 termios->c_cflag |= baud_bits[i];
432 ofound = i;
433 }
434 if (ibaud - iclose <= baud_table[i] &&
435 ibaud + iclose >= baud_table[i]) {
436 /* For the case input == output don't set IBAUD bits
437 if the user didn't do so */
438 if (ofound == i && !ibinput)
439 ifound = i;
440#ifdef IBSHIFT
441 else {
442 ifound = i;
443 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
444 }
445#endif
446 }
447 } while (++i < n_baud_table);
448
449 /*
450 * If we found no match then use BOTHER if provided or warn
451 * the user their platform maintainer needs to wake up if not.
452 */
453#ifdef BOTHER
454 if (ofound == -1)
455 termios->c_cflag |= BOTHER;
456 /* Set exact input bits only if the input and output differ or the
457 user already did */
458 if (ifound == -1 && (ibaud != obaud || ibinput))
459 termios->c_cflag |= (BOTHER << IBSHIFT);
460#else
461 if (ifound == -1 || ofound == -1)
462 pr_warn_once("tty: Unable to return correct speed data as your architecture needs updating.\n");
463#endif
464}
465EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
466
467/**
468 * tty_encode_baud_rate - set baud rate of the tty
469 * @ibaud: input baud rate
470 * @obad: output baud rate
471 *
472 * Update the current termios data for the tty with the new speed
473 * settings. The caller must hold the termios_rwsem for the tty in
474 * question.
475 */
476
477void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
478{
479 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
480}
481EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
482
483/**
484 * tty_termios_copy_hw - copy hardware settings
485 * @new: New termios
486 * @old: Old termios
487 *
488 * Propagate the hardware specific terminal setting bits from
489 * the old termios structure to the new one. This is used in cases
490 * where the hardware does not support reconfiguration or as a helper
491 * in some cases where only minimal reconfiguration is supported
492 */
493
494void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
495{
496 /* The bits a dumb device handles in software. Smart devices need
497 to always provide a set_termios method */
498 new->c_cflag &= HUPCL | CREAD | CLOCAL;
499 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
500 new->c_ispeed = old->c_ispeed;
501 new->c_ospeed = old->c_ospeed;
502}
503EXPORT_SYMBOL(tty_termios_copy_hw);
504
505/**
506 * tty_termios_hw_change - check for setting change
507 * @a: termios
508 * @b: termios to compare
509 *
510 * Check if any of the bits that affect a dumb device have changed
511 * between the two termios structures, or a speed change is needed.
512 */
513
514int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
515{
516 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
517 return 1;
518 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
519 return 1;
520 return 0;
521}
522EXPORT_SYMBOL(tty_termios_hw_change);
523
524/**
525 * tty_set_termios - update termios values
526 * @tty: tty to update
527 * @new_termios: desired new value
528 *
529 * Perform updates to the termios values set on this terminal.
530 * A master pty's termios should never be set.
531 *
532 * Locking: termios_rwsem
533 */
534
535int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
536{
537 struct ktermios old_termios;
538 struct tty_ldisc *ld;
539
540 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
541 tty->driver->subtype == PTY_TYPE_MASTER);
542 /*
543 * Perform the actual termios internal changes under lock.
544 */
545
546
547 /* FIXME: we need to decide on some locking/ordering semantics
548 for the set_termios notification eventually */
549 down_write(&tty->termios_rwsem);
550 old_termios = tty->termios;
551 tty->termios = *new_termios;
552 unset_locked_termios(tty, &old_termios);
553
554 if (tty->ops->set_termios)
555 tty->ops->set_termios(tty, &old_termios);
556 else
557 tty_termios_copy_hw(&tty->termios, &old_termios);
558
559 ld = tty_ldisc_ref(tty);
560 if (ld != NULL) {
561 if (ld->ops->set_termios)
562 ld->ops->set_termios(tty, &old_termios);
563 tty_ldisc_deref(ld);
564 }
565 up_write(&tty->termios_rwsem);
566 return 0;
567}
568EXPORT_SYMBOL_GPL(tty_set_termios);
569
570/**
571 * set_termios - set termios values for a tty
572 * @tty: terminal device
573 * @arg: user data
574 * @opt: option information
575 *
576 * Helper function to prepare termios data and run necessary other
577 * functions before using tty_set_termios to do the actual changes.
578 *
579 * Locking:
580 * Called functions take ldisc and termios_rwsem locks
581 */
582
583static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
584{
585 struct ktermios tmp_termios;
586 struct tty_ldisc *ld;
587 int retval = tty_check_change(tty);
588
589 if (retval)
590 return retval;
591
592 down_read(&tty->termios_rwsem);
593 tmp_termios = tty->termios;
594 up_read(&tty->termios_rwsem);
595
596 if (opt & TERMIOS_TERMIO) {
597 if (user_termio_to_kernel_termios(&tmp_termios,
598 (struct termio __user *)arg))
599 return -EFAULT;
600#ifdef TCGETS2
601 } else if (opt & TERMIOS_OLD) {
602 if (user_termios_to_kernel_termios_1(&tmp_termios,
603 (struct termios __user *)arg))
604 return -EFAULT;
605 } else {
606 if (user_termios_to_kernel_termios(&tmp_termios,
607 (struct termios2 __user *)arg))
608 return -EFAULT;
609 }
610#else
611 } else if (user_termios_to_kernel_termios(&tmp_termios,
612 (struct termios __user *)arg))
613 return -EFAULT;
614#endif
615
616 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
617 * with the real speed so its unconditionally usable */
618 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
619 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
620
621 ld = tty_ldisc_ref(tty);
622
623 if (ld != NULL) {
624 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
625 ld->ops->flush_buffer(tty);
626 tty_ldisc_deref(ld);
627 }
628
629 if (opt & TERMIOS_WAIT) {
630 tty_wait_until_sent(tty, 0);
631 if (signal_pending(current))
632 return -ERESTARTSYS;
633 }
634
635 tty_set_termios(tty, &tmp_termios);
636
637 /* FIXME: Arguably if tmp_termios == tty->termios AND the
638 actual requested termios was not tmp_termios then we may
639 want to return an error as no user requested change has
640 succeeded */
641 return 0;
642}
643
644static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
645{
646 down_read(&tty->termios_rwsem);
647 *kterm = tty->termios;
648 up_read(&tty->termios_rwsem);
649}
650
651static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
652{
653 down_read(&tty->termios_rwsem);
654 *kterm = tty->termios_locked;
655 up_read(&tty->termios_rwsem);
656}
657
658static int get_termio(struct tty_struct *tty, struct termio __user *termio)
659{
660 struct ktermios kterm;
661 copy_termios(tty, &kterm);
662 if (kernel_termios_to_user_termio(termio, &kterm))
663 return -EFAULT;
664 return 0;
665}
666
667
668#ifdef TCGETX
669
670/**
671 * set_termiox - set termiox fields if possible
672 * @tty: terminal
673 * @arg: termiox structure from user
674 * @opt: option flags for ioctl type
675 *
676 * Implement the device calling points for the SYS5 termiox ioctl
677 * interface in Linux
678 */
679
680static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
681{
682 struct termiox tnew;
683 struct tty_ldisc *ld;
684
685 if (tty->termiox == NULL)
686 return -EINVAL;
687 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
688 return -EFAULT;
689
690 ld = tty_ldisc_ref(tty);
691 if (ld != NULL) {
692 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
693 ld->ops->flush_buffer(tty);
694 tty_ldisc_deref(ld);
695 }
696 if (opt & TERMIOS_WAIT) {
697 tty_wait_until_sent(tty, 0);
698 if (signal_pending(current))
699 return -ERESTARTSYS;
700 }
701
702 down_write(&tty->termios_rwsem);
703 if (tty->ops->set_termiox)
704 tty->ops->set_termiox(tty, &tnew);
705 up_write(&tty->termios_rwsem);
706 return 0;
707}
708
709#endif
710
711
712#ifdef TIOCGETP
713/*
714 * These are deprecated, but there is limited support..
715 *
716 * The "sg_flags" translation is a joke..
717 */
718static int get_sgflags(struct tty_struct *tty)
719{
720 int flags = 0;
721
722 if (!L_ICANON(tty)) {
723 if (L_ISIG(tty))
724 flags |= 0x02; /* cbreak */
725 else
726 flags |= 0x20; /* raw */
727 }
728 if (L_ECHO(tty))
729 flags |= 0x08; /* echo */
730 if (O_OPOST(tty))
731 if (O_ONLCR(tty))
732 flags |= 0x10; /* crmod */
733 return flags;
734}
735
736static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
737{
738 struct sgttyb tmp;
739
740 down_read(&tty->termios_rwsem);
741 tmp.sg_ispeed = tty->termios.c_ispeed;
742 tmp.sg_ospeed = tty->termios.c_ospeed;
743 tmp.sg_erase = tty->termios.c_cc[VERASE];
744 tmp.sg_kill = tty->termios.c_cc[VKILL];
745 tmp.sg_flags = get_sgflags(tty);
746 up_read(&tty->termios_rwsem);
747
748 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
749}
750
751static void set_sgflags(struct ktermios *termios, int flags)
752{
753 termios->c_iflag = ICRNL | IXON;
754 termios->c_oflag = 0;
755 termios->c_lflag = ISIG | ICANON;
756 if (flags & 0x02) { /* cbreak */
757 termios->c_iflag = 0;
758 termios->c_lflag &= ~ICANON;
759 }
760 if (flags & 0x08) { /* echo */
761 termios->c_lflag |= ECHO | ECHOE | ECHOK |
762 ECHOCTL | ECHOKE | IEXTEN;
763 }
764 if (flags & 0x10) { /* crmod */
765 termios->c_oflag |= OPOST | ONLCR;
766 }
767 if (flags & 0x20) { /* raw */
768 termios->c_iflag = 0;
769 termios->c_lflag &= ~(ISIG | ICANON);
770 }
771 if (!(termios->c_lflag & ICANON)) {
772 termios->c_cc[VMIN] = 1;
773 termios->c_cc[VTIME] = 0;
774 }
775}
776
777/**
778 * set_sgttyb - set legacy terminal values
779 * @tty: tty structure
780 * @sgttyb: pointer to old style terminal structure
781 *
782 * Updates a terminal from the legacy BSD style terminal information
783 * structure.
784 *
785 * Locking: termios_rwsem
786 */
787
788static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
789{
790 int retval;
791 struct sgttyb tmp;
792 struct ktermios termios;
793
794 retval = tty_check_change(tty);
795 if (retval)
796 return retval;
797
798 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
799 return -EFAULT;
800
801 down_write(&tty->termios_rwsem);
802 termios = tty->termios;
803 termios.c_cc[VERASE] = tmp.sg_erase;
804 termios.c_cc[VKILL] = tmp.sg_kill;
805 set_sgflags(&termios, tmp.sg_flags);
806 /* Try and encode into Bfoo format */
807#ifdef BOTHER
808 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
809 termios.c_ospeed);
810#endif
811 up_write(&tty->termios_rwsem);
812 tty_set_termios(tty, &termios);
813 return 0;
814}
815#endif
816
817#ifdef TIOCGETC
818static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
819{
820 struct tchars tmp;
821
822 down_read(&tty->termios_rwsem);
823 tmp.t_intrc = tty->termios.c_cc[VINTR];
824 tmp.t_quitc = tty->termios.c_cc[VQUIT];
825 tmp.t_startc = tty->termios.c_cc[VSTART];
826 tmp.t_stopc = tty->termios.c_cc[VSTOP];
827 tmp.t_eofc = tty->termios.c_cc[VEOF];
828 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
829 up_read(&tty->termios_rwsem);
830 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
831}
832
833static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
834{
835 struct tchars tmp;
836
837 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
838 return -EFAULT;
839 down_write(&tty->termios_rwsem);
840 tty->termios.c_cc[VINTR] = tmp.t_intrc;
841 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
842 tty->termios.c_cc[VSTART] = tmp.t_startc;
843 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
844 tty->termios.c_cc[VEOF] = tmp.t_eofc;
845 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
846 up_write(&tty->termios_rwsem);
847 return 0;
848}
849#endif
850
851#ifdef TIOCGLTC
852static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
853{
854 struct ltchars tmp;
855
856 down_read(&tty->termios_rwsem);
857 tmp.t_suspc = tty->termios.c_cc[VSUSP];
858 /* what is dsuspc anyway? */
859 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
860 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
861 /* what is flushc anyway? */
862 tmp.t_flushc = tty->termios.c_cc[VEOL2];
863 tmp.t_werasc = tty->termios.c_cc[VWERASE];
864 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
865 up_read(&tty->termios_rwsem);
866 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
867}
868
869static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
870{
871 struct ltchars tmp;
872
873 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
874 return -EFAULT;
875
876 down_write(&tty->termios_rwsem);
877 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
878 /* what is dsuspc anyway? */
879 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
880 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
881 /* what is flushc anyway? */
882 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
883 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
884 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
885 up_write(&tty->termios_rwsem);
886 return 0;
887}
888#endif
889
890/**
891 * tty_change_softcar - carrier change ioctl helper
892 * @tty: tty to update
893 * @arg: enable/disable CLOCAL
894 *
895 * Perform a change to the CLOCAL state and call into the driver
896 * layer to make it visible. All done with the termios rwsem
897 */
898
899static int tty_change_softcar(struct tty_struct *tty, int arg)
900{
901 int ret = 0;
902 int bit = arg ? CLOCAL : 0;
903 struct ktermios old;
904
905 down_write(&tty->termios_rwsem);
906 old = tty->termios;
907 tty->termios.c_cflag &= ~CLOCAL;
908 tty->termios.c_cflag |= bit;
909 if (tty->ops->set_termios)
910 tty->ops->set_termios(tty, &old);
911 if (C_CLOCAL(tty) != bit)
912 ret = -EINVAL;
913 up_write(&tty->termios_rwsem);
914 return ret;
915}
916
917/**
918 * tty_mode_ioctl - mode related ioctls
919 * @tty: tty for the ioctl
920 * @file: file pointer for the tty
921 * @cmd: command
922 * @arg: ioctl argument
923 *
924 * Perform non line discipline specific mode control ioctls. This
925 * is designed to be called by line disciplines to ensure they provide
926 * consistent mode setting.
927 */
928
929int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
930 unsigned int cmd, unsigned long arg)
931{
932 struct tty_struct *real_tty;
933 void __user *p = (void __user *)arg;
934 int ret = 0;
935 struct ktermios kterm;
936
937 BUG_ON(file == NULL);
938
939 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
940 tty->driver->subtype == PTY_TYPE_MASTER)
941 real_tty = tty->link;
942 else
943 real_tty = tty;
944
945 switch (cmd) {
946#ifdef TIOCGETP
947 case TIOCGETP:
948 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
949 case TIOCSETP:
950 case TIOCSETN:
951 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
952#endif
953#ifdef TIOCGETC
954 case TIOCGETC:
955 return get_tchars(real_tty, p);
956 case TIOCSETC:
957 return set_tchars(real_tty, p);
958#endif
959#ifdef TIOCGLTC
960 case TIOCGLTC:
961 return get_ltchars(real_tty, p);
962 case TIOCSLTC:
963 return set_ltchars(real_tty, p);
964#endif
965 case TCSETSF:
966 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
967 case TCSETSW:
968 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
969 case TCSETS:
970 return set_termios(real_tty, p, TERMIOS_OLD);
971#ifndef TCGETS2
972 case TCGETS:
973 copy_termios(real_tty, &kterm);
974 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
975 ret = -EFAULT;
976 return ret;
977#else
978 case TCGETS:
979 copy_termios(real_tty, &kterm);
980 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
981 ret = -EFAULT;
982 return ret;
983 case TCGETS2:
984 copy_termios(real_tty, &kterm);
985 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
986 ret = -EFAULT;
987 return ret;
988 case TCSETSF2:
989 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
990 case TCSETSW2:
991 return set_termios(real_tty, p, TERMIOS_WAIT);
992 case TCSETS2:
993 return set_termios(real_tty, p, 0);
994#endif
995 case TCGETA:
996 return get_termio(real_tty, p);
997 case TCSETAF:
998 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
999 case TCSETAW:
1000 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1001 case TCSETA:
1002 return set_termios(real_tty, p, TERMIOS_TERMIO);
1003#ifndef TCGETS2
1004 case TIOCGLCKTRMIOS:
1005 copy_termios_locked(real_tty, &kterm);
1006 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1007 ret = -EFAULT;
1008 return ret;
1009 case TIOCSLCKTRMIOS:
1010 if (!capable(CAP_SYS_ADMIN))
1011 return -EPERM;
1012 copy_termios_locked(real_tty, &kterm);
1013 if (user_termios_to_kernel_termios(&kterm,
1014 (struct termios __user *) arg))
1015 return -EFAULT;
1016 down_write(&real_tty->termios_rwsem);
1017 real_tty->termios_locked = kterm;
1018 up_write(&real_tty->termios_rwsem);
1019 return 0;
1020#else
1021 case TIOCGLCKTRMIOS:
1022 copy_termios_locked(real_tty, &kterm);
1023 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1024 ret = -EFAULT;
1025 return ret;
1026 case TIOCSLCKTRMIOS:
1027 if (!capable(CAP_SYS_ADMIN))
1028 return -EPERM;
1029 copy_termios_locked(real_tty, &kterm);
1030 if (user_termios_to_kernel_termios_1(&kterm,
1031 (struct termios __user *) arg))
1032 return -EFAULT;
1033 down_write(&real_tty->termios_rwsem);
1034 real_tty->termios_locked = kterm;
1035 up_write(&real_tty->termios_rwsem);
1036 return ret;
1037#endif
1038#ifdef TCGETX
1039 case TCGETX: {
1040 struct termiox ktermx;
1041 if (real_tty->termiox == NULL)
1042 return -EINVAL;
1043 down_read(&real_tty->termios_rwsem);
1044 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1045 up_read(&real_tty->termios_rwsem);
1046 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1047 ret = -EFAULT;
1048 return ret;
1049 }
1050 case TCSETX:
1051 return set_termiox(real_tty, p, 0);
1052 case TCSETXW:
1053 return set_termiox(real_tty, p, TERMIOS_WAIT);
1054 case TCSETXF:
1055 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1056#endif
1057 case TIOCGSOFTCAR:
1058 copy_termios(real_tty, &kterm);
1059 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1060 (int __user *)arg);
1061 return ret;
1062 case TIOCSSOFTCAR:
1063 if (get_user(arg, (unsigned int __user *) arg))
1064 return -EFAULT;
1065 return tty_change_softcar(real_tty, arg);
1066 default:
1067 return -ENOIOCTLCMD;
1068 }
1069}
1070EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1071
1072
1073/* Caller guarantees ldisc reference is held */
1074static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1075{
1076 struct tty_ldisc *ld = tty->ldisc;
1077
1078 switch (arg) {
1079 case TCIFLUSH:
1080 if (ld && ld->ops->flush_buffer) {
1081 ld->ops->flush_buffer(tty);
1082 tty_unthrottle(tty);
1083 }
1084 break;
1085 case TCIOFLUSH:
1086 if (ld && ld->ops->flush_buffer) {
1087 ld->ops->flush_buffer(tty);
1088 tty_unthrottle(tty);
1089 }
1090 /* fall through */
1091 case TCOFLUSH:
1092 tty_driver_flush_buffer(tty);
1093 break;
1094 default:
1095 return -EINVAL;
1096 }
1097 return 0;
1098}
1099
1100int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1101{
1102 struct tty_ldisc *ld;
1103 int retval = tty_check_change(tty);
1104 if (retval)
1105 return retval;
1106
1107 ld = tty_ldisc_ref_wait(tty);
1108 retval = __tty_perform_flush(tty, arg);
1109 if (ld)
1110 tty_ldisc_deref(ld);
1111 return retval;
1112}
1113EXPORT_SYMBOL_GPL(tty_perform_flush);
1114
1115int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1116 unsigned int cmd, unsigned long arg)
1117{
1118 int retval;
1119
1120 switch (cmd) {
1121 case TCXONC:
1122 retval = tty_check_change(tty);
1123 if (retval)
1124 return retval;
1125 switch (arg) {
1126 case TCOOFF:
1127 spin_lock_irq(&tty->flow_lock);
1128 if (!tty->flow_stopped) {
1129 tty->flow_stopped = 1;
1130 __stop_tty(tty);
1131 }
1132 spin_unlock_irq(&tty->flow_lock);
1133 break;
1134 case TCOON:
1135 spin_lock_irq(&tty->flow_lock);
1136 if (tty->flow_stopped) {
1137 tty->flow_stopped = 0;
1138 __start_tty(tty);
1139 }
1140 spin_unlock_irq(&tty->flow_lock);
1141 break;
1142 case TCIOFF:
1143 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1144 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1145 break;
1146 case TCION:
1147 if (START_CHAR(tty) != __DISABLED_CHAR)
1148 retval = tty_send_xchar(tty, START_CHAR(tty));
1149 break;
1150 default:
1151 return -EINVAL;
1152 }
1153 return retval;
1154 case TCFLSH:
1155 retval = tty_check_change(tty);
1156 if (retval)
1157 return retval;
1158 return __tty_perform_flush(tty, arg);
1159 default:
1160 /* Try the mode commands */
1161 return tty_mode_ioctl(tty, file, cmd, arg);
1162 }
1163}
1164EXPORT_SYMBOL(n_tty_ioctl_helper);
1165
1166#ifdef CONFIG_COMPAT
1167long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1168 unsigned int cmd, unsigned long arg)
1169{
1170 switch (cmd) {
1171 case TIOCGLCKTRMIOS:
1172 case TIOCSLCKTRMIOS:
1173 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1174 default:
1175 return -ENOIOCTLCMD;
1176 }
1177}
1178EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1179#endif
1180
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
4 *
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).
8 */
9
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>
19#include <linux/mm.h>
20#include <linux/module.h>
21#include <linux/bitops.h>
22#include <linux/mutex.h>
23#include <linux/compat.h>
24#include <linux/termios_internal.h>
25#include "tty.h"
26
27#include <asm/io.h>
28#include <linux/uaccess.h>
29
30#undef TTY_DEBUG_WAIT_UNTIL_SENT
31
32#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
33# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
34#else
35# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
36#endif
37
38#undef DEBUG
39
40/*
41 * Internal flag options for termios setting behavior
42 */
43#define TERMIOS_FLUSH 1
44#define TERMIOS_WAIT 2
45#define TERMIOS_TERMIO 4
46#define TERMIOS_OLD 8
47
48
49/**
50 * tty_chars_in_buffer - characters pending
51 * @tty: terminal
52 *
53 * Return the number of bytes of data in the device private
54 * output queue. If no private method is supplied there is assumed
55 * to be no queue on the device.
56 */
57
58unsigned int tty_chars_in_buffer(struct tty_struct *tty)
59{
60 if (tty->ops->chars_in_buffer)
61 return tty->ops->chars_in_buffer(tty);
62 return 0;
63}
64EXPORT_SYMBOL(tty_chars_in_buffer);
65
66/**
67 * tty_write_room - write queue space
68 * @tty: terminal
69 *
70 * Return the number of bytes that can be queued to this device
71 * at the present time. The result should be treated as a guarantee
72 * and the driver cannot offer a value it later shrinks by more than
73 * the number of bytes written. If no method is provided 2K is always
74 * returned and data may be lost as there will be no flow control.
75 */
76
77unsigned int tty_write_room(struct tty_struct *tty)
78{
79 if (tty->ops->write_room)
80 return tty->ops->write_room(tty);
81 return 2048;
82}
83EXPORT_SYMBOL(tty_write_room);
84
85/**
86 * tty_driver_flush_buffer - discard internal buffer
87 * @tty: terminal
88 *
89 * Discard the internal output buffer for this device. If no method
90 * is provided then either the buffer cannot be hardware flushed or
91 * there is no buffer driver side.
92 */
93void tty_driver_flush_buffer(struct tty_struct *tty)
94{
95 if (tty->ops->flush_buffer)
96 tty->ops->flush_buffer(tty);
97}
98EXPORT_SYMBOL(tty_driver_flush_buffer);
99
100/**
101 * tty_unthrottle - flow control
102 * @tty: terminal
103 *
104 * Indicate that a tty may continue transmitting data down the stack.
105 * Takes the termios rwsem to protect against parallel throttle/unthrottle
106 * and also to ensure the driver can consistently reference its own
107 * termios data at this point when implementing software flow control.
108 *
109 * Drivers should however remember that the stack can issue a throttle,
110 * then change flow control method, then unthrottle.
111 */
112
113void tty_unthrottle(struct tty_struct *tty)
114{
115 down_write(&tty->termios_rwsem);
116 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
117 tty->ops->unthrottle)
118 tty->ops->unthrottle(tty);
119 tty->flow_change = 0;
120 up_write(&tty->termios_rwsem);
121}
122EXPORT_SYMBOL(tty_unthrottle);
123
124/**
125 * tty_throttle_safe - flow control
126 * @tty: terminal
127 *
128 * Indicate that a tty should stop transmitting data down the stack.
129 * tty_throttle_safe will only attempt throttle if tty->flow_change is
130 * TTY_THROTTLE_SAFE. Prevents an accidental throttle due to race
131 * conditions when throttling is conditional on factors evaluated prior to
132 * throttling.
133 *
134 * Returns 0 if tty is throttled (or was already throttled)
135 */
136
137int tty_throttle_safe(struct tty_struct *tty)
138{
139 int ret = 0;
140
141 mutex_lock(&tty->throttle_mutex);
142 if (!tty_throttled(tty)) {
143 if (tty->flow_change != TTY_THROTTLE_SAFE)
144 ret = 1;
145 else {
146 set_bit(TTY_THROTTLED, &tty->flags);
147 if (tty->ops->throttle)
148 tty->ops->throttle(tty);
149 }
150 }
151 mutex_unlock(&tty->throttle_mutex);
152
153 return ret;
154}
155
156/**
157 * tty_unthrottle_safe - flow control
158 * @tty: terminal
159 *
160 * Similar to tty_unthrottle() but will only attempt unthrottle
161 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
162 * unthrottle due to race conditions when unthrottling is conditional
163 * on factors evaluated prior to unthrottling.
164 *
165 * Returns 0 if tty is unthrottled (or was already unthrottled)
166 */
167
168int tty_unthrottle_safe(struct tty_struct *tty)
169{
170 int ret = 0;
171
172 mutex_lock(&tty->throttle_mutex);
173 if (tty_throttled(tty)) {
174 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
175 ret = 1;
176 else {
177 clear_bit(TTY_THROTTLED, &tty->flags);
178 if (tty->ops->unthrottle)
179 tty->ops->unthrottle(tty);
180 }
181 }
182 mutex_unlock(&tty->throttle_mutex);
183
184 return ret;
185}
186
187/**
188 * tty_wait_until_sent - wait for I/O to finish
189 * @tty: tty we are waiting for
190 * @timeout: how long we will wait
191 *
192 * Wait for characters pending in a tty driver to hit the wire, or
193 * for a timeout to occur (eg due to flow control)
194 *
195 * Locking: none
196 */
197
198void tty_wait_until_sent(struct tty_struct *tty, long timeout)
199{
200 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
201
202 if (!timeout)
203 timeout = MAX_SCHEDULE_TIMEOUT;
204
205 timeout = wait_event_interruptible_timeout(tty->write_wait,
206 !tty_chars_in_buffer(tty), timeout);
207 if (timeout <= 0)
208 return;
209
210 if (timeout == MAX_SCHEDULE_TIMEOUT)
211 timeout = 0;
212
213 if (tty->ops->wait_until_sent)
214 tty->ops->wait_until_sent(tty, timeout);
215}
216EXPORT_SYMBOL(tty_wait_until_sent);
217
218
219/*
220 * Termios Helper Methods
221 */
222
223static void unset_locked_termios(struct tty_struct *tty, const struct ktermios *old)
224{
225 struct ktermios *termios = &tty->termios;
226 struct ktermios *locked = &tty->termios_locked;
227 int i;
228
229#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
230
231 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
232 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
233 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
234 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
235 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
236 for (i = 0; i < NCCS; i++)
237 termios->c_cc[i] = locked->c_cc[i] ?
238 old->c_cc[i] : termios->c_cc[i];
239 /* FIXME: What should we do for i/ospeed */
240}
241
242/**
243 * tty_termios_copy_hw - copy hardware settings
244 * @new: New termios
245 * @old: Old termios
246 *
247 * Propagate the hardware specific terminal setting bits from
248 * the old termios structure to the new one. This is used in cases
249 * where the hardware does not support reconfiguration or as a helper
250 * in some cases where only minimal reconfiguration is supported
251 */
252
253void tty_termios_copy_hw(struct ktermios *new, const struct ktermios *old)
254{
255 /* The bits a dumb device handles in software. Smart devices need
256 to always provide a set_termios method */
257 new->c_cflag &= HUPCL | CREAD | CLOCAL;
258 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
259 new->c_ispeed = old->c_ispeed;
260 new->c_ospeed = old->c_ospeed;
261}
262EXPORT_SYMBOL(tty_termios_copy_hw);
263
264/**
265 * tty_termios_hw_change - check for setting change
266 * @a: termios
267 * @b: termios to compare
268 *
269 * Check if any of the bits that affect a dumb device have changed
270 * between the two termios structures, or a speed change is needed.
271 */
272
273int tty_termios_hw_change(const struct ktermios *a, const struct ktermios *b)
274{
275 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
276 return 1;
277 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
278 return 1;
279 return 0;
280}
281EXPORT_SYMBOL(tty_termios_hw_change);
282
283/**
284 * tty_get_char_size - get size of a character
285 * @cflag: termios cflag value
286 *
287 * Get the size (in bits) of a character depending on @cflag's %CSIZE
288 * setting.
289 */
290unsigned char tty_get_char_size(unsigned int cflag)
291{
292 switch (cflag & CSIZE) {
293 case CS5:
294 return 5;
295 case CS6:
296 return 6;
297 case CS7:
298 return 7;
299 case CS8:
300 default:
301 return 8;
302 }
303}
304EXPORT_SYMBOL_GPL(tty_get_char_size);
305
306/**
307 * tty_get_frame_size - get size of a frame
308 * @cflag: termios cflag value
309 *
310 * Get the size (in bits) of a frame depending on @cflag's %CSIZE, %CSTOPB,
311 * and %PARENB setting. The result is a sum of character size, start and
312 * stop bits -- one bit each -- second stop bit (if set), and parity bit
313 * (if set).
314 */
315unsigned char tty_get_frame_size(unsigned int cflag)
316{
317 unsigned char bits = 2 + tty_get_char_size(cflag);
318
319 if (cflag & CSTOPB)
320 bits++;
321 if (cflag & PARENB)
322 bits++;
323 if (cflag & ADDRB)
324 bits++;
325
326 return bits;
327}
328EXPORT_SYMBOL_GPL(tty_get_frame_size);
329
330/**
331 * tty_set_termios - update termios values
332 * @tty: tty to update
333 * @new_termios: desired new value
334 *
335 * Perform updates to the termios values set on this terminal.
336 * A master pty's termios should never be set.
337 *
338 * Locking: termios_rwsem
339 */
340
341int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
342{
343 struct ktermios old_termios;
344 struct tty_ldisc *ld;
345
346 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
347 tty->driver->subtype == PTY_TYPE_MASTER);
348 /*
349 * Perform the actual termios internal changes under lock.
350 */
351
352
353 /* FIXME: we need to decide on some locking/ordering semantics
354 for the set_termios notification eventually */
355 down_write(&tty->termios_rwsem);
356 old_termios = tty->termios;
357 tty->termios = *new_termios;
358 unset_locked_termios(tty, &old_termios);
359 /* Reset any ADDRB changes, ADDRB is changed through ->rs485_config() */
360 tty->termios.c_cflag ^= (tty->termios.c_cflag ^ old_termios.c_cflag) & ADDRB;
361
362 if (tty->ops->set_termios)
363 tty->ops->set_termios(tty, &old_termios);
364 else
365 tty_termios_copy_hw(&tty->termios, &old_termios);
366
367 ld = tty_ldisc_ref(tty);
368 if (ld != NULL) {
369 if (ld->ops->set_termios)
370 ld->ops->set_termios(tty, &old_termios);
371 tty_ldisc_deref(ld);
372 }
373 up_write(&tty->termios_rwsem);
374 return 0;
375}
376EXPORT_SYMBOL_GPL(tty_set_termios);
377
378
379/*
380 * Translate a "termio" structure into a "termios". Ugh.
381 */
382__weak int user_termio_to_kernel_termios(struct ktermios *termios,
383 struct termio __user *termio)
384{
385 struct termio v;
386
387 if (copy_from_user(&v, termio, sizeof(struct termio)))
388 return -EFAULT;
389
390 termios->c_iflag = (0xffff0000 & termios->c_iflag) | v.c_iflag;
391 termios->c_oflag = (0xffff0000 & termios->c_oflag) | v.c_oflag;
392 termios->c_cflag = (0xffff0000 & termios->c_cflag) | v.c_cflag;
393 termios->c_lflag = (0xffff0000 & termios->c_lflag) | v.c_lflag;
394 termios->c_line = (0xffff0000 & termios->c_lflag) | v.c_line;
395 memcpy(termios->c_cc, v.c_cc, NCC);
396 return 0;
397}
398
399/*
400 * Translate a "termios" structure into a "termio". Ugh.
401 */
402__weak int kernel_termios_to_user_termio(struct termio __user *termio,
403 struct ktermios *termios)
404{
405 struct termio v;
406 memset(&v, 0, sizeof(struct termio));
407 v.c_iflag = termios->c_iflag;
408 v.c_oflag = termios->c_oflag;
409 v.c_cflag = termios->c_cflag;
410 v.c_lflag = termios->c_lflag;
411 v.c_line = termios->c_line;
412 memcpy(v.c_cc, termios->c_cc, NCC);
413 return copy_to_user(termio, &v, sizeof(struct termio));
414}
415
416#ifdef TCGETS2
417__weak int user_termios_to_kernel_termios(struct ktermios *k,
418 struct termios2 __user *u)
419{
420 return copy_from_user(k, u, sizeof(struct termios2));
421}
422__weak int kernel_termios_to_user_termios(struct termios2 __user *u,
423 struct ktermios *k)
424{
425 return copy_to_user(u, k, sizeof(struct termios2));
426}
427__weak int user_termios_to_kernel_termios_1(struct ktermios *k,
428 struct termios __user *u)
429{
430 return copy_from_user(k, u, sizeof(struct termios));
431}
432__weak int kernel_termios_to_user_termios_1(struct termios __user *u,
433 struct ktermios *k)
434{
435 return copy_to_user(u, k, sizeof(struct termios));
436}
437
438#else
439
440__weak int user_termios_to_kernel_termios(struct ktermios *k,
441 struct termios __user *u)
442{
443 return copy_from_user(k, u, sizeof(struct termios));
444}
445__weak int kernel_termios_to_user_termios(struct termios __user *u,
446 struct ktermios *k)
447{
448 return copy_to_user(u, k, sizeof(struct termios));
449}
450#endif /* TCGETS2 */
451
452/**
453 * set_termios - set termios values for a tty
454 * @tty: terminal device
455 * @arg: user data
456 * @opt: option information
457 *
458 * Helper function to prepare termios data and run necessary other
459 * functions before using tty_set_termios to do the actual changes.
460 *
461 * Locking:
462 * Called functions take ldisc and termios_rwsem locks
463 */
464
465static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
466{
467 struct ktermios tmp_termios;
468 struct tty_ldisc *ld;
469 int retval = tty_check_change(tty);
470
471 if (retval)
472 return retval;
473
474 down_read(&tty->termios_rwsem);
475 tmp_termios = tty->termios;
476 up_read(&tty->termios_rwsem);
477
478 if (opt & TERMIOS_TERMIO) {
479 if (user_termio_to_kernel_termios(&tmp_termios,
480 (struct termio __user *)arg))
481 return -EFAULT;
482#ifdef TCGETS2
483 } else if (opt & TERMIOS_OLD) {
484 if (user_termios_to_kernel_termios_1(&tmp_termios,
485 (struct termios __user *)arg))
486 return -EFAULT;
487 } else {
488 if (user_termios_to_kernel_termios(&tmp_termios,
489 (struct termios2 __user *)arg))
490 return -EFAULT;
491 }
492#else
493 } else if (user_termios_to_kernel_termios(&tmp_termios,
494 (struct termios __user *)arg))
495 return -EFAULT;
496#endif
497
498 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
499 * with the real speed so its unconditionally usable */
500 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
501 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
502
503 ld = tty_ldisc_ref(tty);
504
505 if (ld != NULL) {
506 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
507 ld->ops->flush_buffer(tty);
508 tty_ldisc_deref(ld);
509 }
510
511 if (opt & TERMIOS_WAIT) {
512 tty_wait_until_sent(tty, 0);
513 if (signal_pending(current))
514 return -ERESTARTSYS;
515 }
516
517 tty_set_termios(tty, &tmp_termios);
518
519 /* FIXME: Arguably if tmp_termios == tty->termios AND the
520 actual requested termios was not tmp_termios then we may
521 want to return an error as no user requested change has
522 succeeded */
523 return 0;
524}
525
526static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
527{
528 down_read(&tty->termios_rwsem);
529 *kterm = tty->termios;
530 up_read(&tty->termios_rwsem);
531}
532
533static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
534{
535 down_read(&tty->termios_rwsem);
536 *kterm = tty->termios_locked;
537 up_read(&tty->termios_rwsem);
538}
539
540static int get_termio(struct tty_struct *tty, struct termio __user *termio)
541{
542 struct ktermios kterm;
543 copy_termios(tty, &kterm);
544 if (kernel_termios_to_user_termio(termio, &kterm))
545 return -EFAULT;
546 return 0;
547}
548
549#ifdef TIOCGETP
550/*
551 * These are deprecated, but there is limited support..
552 *
553 * The "sg_flags" translation is a joke..
554 */
555static int get_sgflags(struct tty_struct *tty)
556{
557 int flags = 0;
558
559 if (!L_ICANON(tty)) {
560 if (L_ISIG(tty))
561 flags |= 0x02; /* cbreak */
562 else
563 flags |= 0x20; /* raw */
564 }
565 if (L_ECHO(tty))
566 flags |= 0x08; /* echo */
567 if (O_OPOST(tty))
568 if (O_ONLCR(tty))
569 flags |= 0x10; /* crmod */
570 return flags;
571}
572
573static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
574{
575 struct sgttyb tmp;
576
577 down_read(&tty->termios_rwsem);
578 tmp.sg_ispeed = tty->termios.c_ispeed;
579 tmp.sg_ospeed = tty->termios.c_ospeed;
580 tmp.sg_erase = tty->termios.c_cc[VERASE];
581 tmp.sg_kill = tty->termios.c_cc[VKILL];
582 tmp.sg_flags = get_sgflags(tty);
583 up_read(&tty->termios_rwsem);
584
585 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
586}
587
588static void set_sgflags(struct ktermios *termios, int flags)
589{
590 termios->c_iflag = ICRNL | IXON;
591 termios->c_oflag = 0;
592 termios->c_lflag = ISIG | ICANON;
593 if (flags & 0x02) { /* cbreak */
594 termios->c_iflag = 0;
595 termios->c_lflag &= ~ICANON;
596 }
597 if (flags & 0x08) { /* echo */
598 termios->c_lflag |= ECHO | ECHOE | ECHOK |
599 ECHOCTL | ECHOKE | IEXTEN;
600 }
601 if (flags & 0x10) { /* crmod */
602 termios->c_oflag |= OPOST | ONLCR;
603 }
604 if (flags & 0x20) { /* raw */
605 termios->c_iflag = 0;
606 termios->c_lflag &= ~(ISIG | ICANON);
607 }
608 if (!(termios->c_lflag & ICANON)) {
609 termios->c_cc[VMIN] = 1;
610 termios->c_cc[VTIME] = 0;
611 }
612}
613
614/**
615 * set_sgttyb - set legacy terminal values
616 * @tty: tty structure
617 * @sgttyb: pointer to old style terminal structure
618 *
619 * Updates a terminal from the legacy BSD style terminal information
620 * structure.
621 *
622 * Locking: termios_rwsem
623 */
624
625static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
626{
627 int retval;
628 struct sgttyb tmp;
629 struct ktermios termios;
630
631 retval = tty_check_change(tty);
632 if (retval)
633 return retval;
634
635 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
636 return -EFAULT;
637
638 down_write(&tty->termios_rwsem);
639 termios = tty->termios;
640 termios.c_cc[VERASE] = tmp.sg_erase;
641 termios.c_cc[VKILL] = tmp.sg_kill;
642 set_sgflags(&termios, tmp.sg_flags);
643 /* Try and encode into Bfoo format */
644 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
645 termios.c_ospeed);
646 up_write(&tty->termios_rwsem);
647 tty_set_termios(tty, &termios);
648 return 0;
649}
650#endif
651
652#ifdef TIOCGETC
653static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
654{
655 struct tchars tmp;
656
657 down_read(&tty->termios_rwsem);
658 tmp.t_intrc = tty->termios.c_cc[VINTR];
659 tmp.t_quitc = tty->termios.c_cc[VQUIT];
660 tmp.t_startc = tty->termios.c_cc[VSTART];
661 tmp.t_stopc = tty->termios.c_cc[VSTOP];
662 tmp.t_eofc = tty->termios.c_cc[VEOF];
663 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
664 up_read(&tty->termios_rwsem);
665 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
666}
667
668static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
669{
670 struct tchars tmp;
671
672 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
673 return -EFAULT;
674 down_write(&tty->termios_rwsem);
675 tty->termios.c_cc[VINTR] = tmp.t_intrc;
676 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
677 tty->termios.c_cc[VSTART] = tmp.t_startc;
678 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
679 tty->termios.c_cc[VEOF] = tmp.t_eofc;
680 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
681 up_write(&tty->termios_rwsem);
682 return 0;
683}
684#endif
685
686#ifdef TIOCGLTC
687static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
688{
689 struct ltchars tmp;
690
691 down_read(&tty->termios_rwsem);
692 tmp.t_suspc = tty->termios.c_cc[VSUSP];
693 /* what is dsuspc anyway? */
694 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
695 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
696 /* what is flushc anyway? */
697 tmp.t_flushc = tty->termios.c_cc[VEOL2];
698 tmp.t_werasc = tty->termios.c_cc[VWERASE];
699 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
700 up_read(&tty->termios_rwsem);
701 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
702}
703
704static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
705{
706 struct ltchars tmp;
707
708 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
709 return -EFAULT;
710
711 down_write(&tty->termios_rwsem);
712 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
713 /* what is dsuspc anyway? */
714 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
715 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
716 /* what is flushc anyway? */
717 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
718 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
719 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
720 up_write(&tty->termios_rwsem);
721 return 0;
722}
723#endif
724
725/**
726 * tty_change_softcar - carrier change ioctl helper
727 * @tty: tty to update
728 * @arg: enable/disable CLOCAL
729 *
730 * Perform a change to the CLOCAL state and call into the driver
731 * layer to make it visible. All done with the termios rwsem
732 */
733
734static int tty_change_softcar(struct tty_struct *tty, int arg)
735{
736 int ret = 0;
737 int bit = arg ? CLOCAL : 0;
738 struct ktermios old;
739
740 down_write(&tty->termios_rwsem);
741 old = tty->termios;
742 tty->termios.c_cflag &= ~CLOCAL;
743 tty->termios.c_cflag |= bit;
744 if (tty->ops->set_termios)
745 tty->ops->set_termios(tty, &old);
746 if (C_CLOCAL(tty) != bit)
747 ret = -EINVAL;
748 up_write(&tty->termios_rwsem);
749 return ret;
750}
751
752/**
753 * tty_mode_ioctl - mode related ioctls
754 * @tty: tty for the ioctl
755 * @cmd: command
756 * @arg: ioctl argument
757 *
758 * Perform non line discipline specific mode control ioctls. This
759 * is designed to be called by line disciplines to ensure they provide
760 * consistent mode setting.
761 */
762
763int tty_mode_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
764{
765 struct tty_struct *real_tty;
766 void __user *p = (void __user *)arg;
767 int ret = 0;
768 struct ktermios kterm;
769
770 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
771 tty->driver->subtype == PTY_TYPE_MASTER)
772 real_tty = tty->link;
773 else
774 real_tty = tty;
775
776 switch (cmd) {
777#ifdef TIOCGETP
778 case TIOCGETP:
779 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
780 case TIOCSETP:
781 case TIOCSETN:
782 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
783#endif
784#ifdef TIOCGETC
785 case TIOCGETC:
786 return get_tchars(real_tty, p);
787 case TIOCSETC:
788 return set_tchars(real_tty, p);
789#endif
790#ifdef TIOCGLTC
791 case TIOCGLTC:
792 return get_ltchars(real_tty, p);
793 case TIOCSLTC:
794 return set_ltchars(real_tty, p);
795#endif
796 case TCSETSF:
797 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
798 case TCSETSW:
799 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
800 case TCSETS:
801 return set_termios(real_tty, p, TERMIOS_OLD);
802#ifndef TCGETS2
803 case TCGETS:
804 copy_termios(real_tty, &kterm);
805 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
806 ret = -EFAULT;
807 return ret;
808#else
809 case TCGETS:
810 copy_termios(real_tty, &kterm);
811 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
812 ret = -EFAULT;
813 return ret;
814 case TCGETS2:
815 copy_termios(real_tty, &kterm);
816 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
817 ret = -EFAULT;
818 return ret;
819 case TCSETSF2:
820 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
821 case TCSETSW2:
822 return set_termios(real_tty, p, TERMIOS_WAIT);
823 case TCSETS2:
824 return set_termios(real_tty, p, 0);
825#endif
826 case TCGETA:
827 return get_termio(real_tty, p);
828 case TCSETAF:
829 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
830 case TCSETAW:
831 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
832 case TCSETA:
833 return set_termios(real_tty, p, TERMIOS_TERMIO);
834#ifndef TCGETS2
835 case TIOCGLCKTRMIOS:
836 copy_termios_locked(real_tty, &kterm);
837 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
838 ret = -EFAULT;
839 return ret;
840 case TIOCSLCKTRMIOS:
841 if (!capable(CAP_SYS_ADMIN))
842 return -EPERM;
843 copy_termios_locked(real_tty, &kterm);
844 if (user_termios_to_kernel_termios(&kterm,
845 (struct termios __user *) arg))
846 return -EFAULT;
847 down_write(&real_tty->termios_rwsem);
848 real_tty->termios_locked = kterm;
849 up_write(&real_tty->termios_rwsem);
850 return 0;
851#else
852 case TIOCGLCKTRMIOS:
853 copy_termios_locked(real_tty, &kterm);
854 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
855 ret = -EFAULT;
856 return ret;
857 case TIOCSLCKTRMIOS:
858 if (!capable(CAP_SYS_ADMIN))
859 return -EPERM;
860 copy_termios_locked(real_tty, &kterm);
861 if (user_termios_to_kernel_termios_1(&kterm,
862 (struct termios __user *) arg))
863 return -EFAULT;
864 down_write(&real_tty->termios_rwsem);
865 real_tty->termios_locked = kterm;
866 up_write(&real_tty->termios_rwsem);
867 return ret;
868#endif
869#ifdef TCGETX
870 case TCGETX:
871 case TCSETX:
872 case TCSETXW:
873 case TCSETXF:
874 return -ENOTTY;
875#endif
876 case TIOCGSOFTCAR:
877 copy_termios(real_tty, &kterm);
878 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
879 (int __user *)arg);
880 return ret;
881 case TIOCSSOFTCAR:
882 if (get_user(arg, (unsigned int __user *) arg))
883 return -EFAULT;
884 return tty_change_softcar(real_tty, arg);
885 default:
886 return -ENOIOCTLCMD;
887 }
888}
889EXPORT_SYMBOL_GPL(tty_mode_ioctl);
890
891
892/* Caller guarantees ldisc reference is held */
893static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
894{
895 struct tty_ldisc *ld = tty->ldisc;
896
897 switch (arg) {
898 case TCIFLUSH:
899 if (ld && ld->ops->flush_buffer) {
900 ld->ops->flush_buffer(tty);
901 tty_unthrottle(tty);
902 }
903 break;
904 case TCIOFLUSH:
905 if (ld && ld->ops->flush_buffer) {
906 ld->ops->flush_buffer(tty);
907 tty_unthrottle(tty);
908 }
909 fallthrough;
910 case TCOFLUSH:
911 tty_driver_flush_buffer(tty);
912 break;
913 default:
914 return -EINVAL;
915 }
916 return 0;
917}
918
919int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
920{
921 struct tty_ldisc *ld;
922 int retval = tty_check_change(tty);
923 if (retval)
924 return retval;
925
926 ld = tty_ldisc_ref_wait(tty);
927 retval = __tty_perform_flush(tty, arg);
928 if (ld)
929 tty_ldisc_deref(ld);
930 return retval;
931}
932EXPORT_SYMBOL_GPL(tty_perform_flush);
933
934int n_tty_ioctl_helper(struct tty_struct *tty, unsigned int cmd,
935 unsigned long arg)
936{
937 int retval;
938
939 switch (cmd) {
940 case TCXONC:
941 retval = tty_check_change(tty);
942 if (retval)
943 return retval;
944 switch (arg) {
945 case TCOOFF:
946 spin_lock_irq(&tty->flow.lock);
947 if (!tty->flow.tco_stopped) {
948 tty->flow.tco_stopped = true;
949 __stop_tty(tty);
950 }
951 spin_unlock_irq(&tty->flow.lock);
952 break;
953 case TCOON:
954 spin_lock_irq(&tty->flow.lock);
955 if (tty->flow.tco_stopped) {
956 tty->flow.tco_stopped = false;
957 __start_tty(tty);
958 }
959 spin_unlock_irq(&tty->flow.lock);
960 break;
961 case TCIOFF:
962 if (STOP_CHAR(tty) != __DISABLED_CHAR)
963 retval = tty_send_xchar(tty, STOP_CHAR(tty));
964 break;
965 case TCION:
966 if (START_CHAR(tty) != __DISABLED_CHAR)
967 retval = tty_send_xchar(tty, START_CHAR(tty));
968 break;
969 default:
970 return -EINVAL;
971 }
972 return retval;
973 case TCFLSH:
974 retval = tty_check_change(tty);
975 if (retval)
976 return retval;
977 return __tty_perform_flush(tty, arg);
978 default:
979 /* Try the mode commands */
980 return tty_mode_ioctl(tty, cmd, arg);
981 }
982}
983EXPORT_SYMBOL(n_tty_ioctl_helper);