Loading...
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/bits.h>
11#include <linux/types.h>
12#include <linux/termios.h>
13#include <linux/errno.h>
14#include <linux/sched/signal.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>
20#include <linux/mm.h>
21#include <linux/module.h>
22#include <linux/bitops.h>
23#include <linux/mutex.h>
24#include <linux/compat.h>
25#include <linux/termios_internal.h>
26#include "tty.h"
27
28#include <asm/io.h>
29#include <linux/uaccess.h>
30
31#undef DEBUG
32
33/*
34 * Internal flag options for termios setting behavior
35 */
36#define TERMIOS_FLUSH BIT(0)
37#define TERMIOS_WAIT BIT(1)
38#define TERMIOS_TERMIO BIT(2)
39#define TERMIOS_OLD BIT(3)
40
41/**
42 * tty_chars_in_buffer - characters pending
43 * @tty: terminal
44 *
45 * Returns: the number of bytes of data in the device private output queue. If
46 * no private method is supplied there is assumed to be no queue on the device.
47 */
48unsigned int tty_chars_in_buffer(struct tty_struct *tty)
49{
50 if (tty->ops->chars_in_buffer)
51 return tty->ops->chars_in_buffer(tty);
52 return 0;
53}
54EXPORT_SYMBOL(tty_chars_in_buffer);
55
56/**
57 * tty_write_room - write queue space
58 * @tty: terminal
59 *
60 * Returns: the number of bytes that can be queued to this device at the present
61 * time. The result should be treated as a guarantee and the driver cannot
62 * offer a value it later shrinks by more than the number of bytes written. If
63 * no method is provided, 2K is always returned and data may be lost as there
64 * will be no flow control.
65 */
66unsigned int tty_write_room(struct tty_struct *tty)
67{
68 if (tty->ops->write_room)
69 return tty->ops->write_room(tty);
70 return 2048;
71}
72EXPORT_SYMBOL(tty_write_room);
73
74/**
75 * tty_driver_flush_buffer - discard internal buffer
76 * @tty: terminal
77 *
78 * Discard the internal output buffer for this device. If no method is provided,
79 * then either the buffer cannot be hardware flushed or there is no buffer
80 * driver side.
81 */
82void tty_driver_flush_buffer(struct tty_struct *tty)
83{
84 if (tty->ops->flush_buffer)
85 tty->ops->flush_buffer(tty);
86}
87EXPORT_SYMBOL(tty_driver_flush_buffer);
88
89/**
90 * tty_unthrottle - flow control
91 * @tty: terminal
92 *
93 * Indicate that a @tty may continue transmitting data down the stack. Takes
94 * the &tty_struct->termios_rwsem to protect against parallel
95 * throttle/unthrottle and also to ensure the driver can consistently reference
96 * its own termios data at this point when implementing software flow control.
97 *
98 * Drivers should however remember that the stack can issue a throttle, then
99 * change flow control method, then unthrottle.
100 */
101void tty_unthrottle(struct tty_struct *tty)
102{
103 down_write(&tty->termios_rwsem);
104 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
105 tty->ops->unthrottle)
106 tty->ops->unthrottle(tty);
107 tty->flow_change = TTY_FLOW_NO_CHANGE;
108 up_write(&tty->termios_rwsem);
109}
110EXPORT_SYMBOL(tty_unthrottle);
111
112/**
113 * tty_throttle_safe - flow control
114 * @tty: terminal
115 *
116 * Indicate that a @tty should stop transmitting data down the stack.
117 * tty_throttle_safe() will only attempt throttle if @tty->flow_change is
118 * %TTY_THROTTLE_SAFE. Prevents an accidental throttle due to race conditions
119 * when throttling is conditional on factors evaluated prior to throttling.
120 *
121 * Returns: %true if @tty is throttled (or was already throttled)
122 */
123bool tty_throttle_safe(struct tty_struct *tty)
124{
125 bool ret = true;
126
127 mutex_lock(&tty->throttle_mutex);
128 if (!tty_throttled(tty)) {
129 if (tty->flow_change != TTY_THROTTLE_SAFE)
130 ret = false;
131 else {
132 set_bit(TTY_THROTTLED, &tty->flags);
133 if (tty->ops->throttle)
134 tty->ops->throttle(tty);
135 }
136 }
137 mutex_unlock(&tty->throttle_mutex);
138
139 return ret;
140}
141
142/**
143 * tty_unthrottle_safe - flow control
144 * @tty: terminal
145 *
146 * Similar to tty_unthrottle() but will only attempt unthrottle if
147 * @tty->flow_change is %TTY_UNTHROTTLE_SAFE. Prevents an accidental unthrottle
148 * due to race conditions when unthrottling is conditional on factors evaluated
149 * prior to unthrottling.
150 *
151 * Returns: %true if @tty is unthrottled (or was already unthrottled)
152 */
153bool tty_unthrottle_safe(struct tty_struct *tty)
154{
155 bool ret = true;
156
157 mutex_lock(&tty->throttle_mutex);
158 if (tty_throttled(tty)) {
159 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
160 ret = false;
161 else {
162 clear_bit(TTY_THROTTLED, &tty->flags);
163 if (tty->ops->unthrottle)
164 tty->ops->unthrottle(tty);
165 }
166 }
167 mutex_unlock(&tty->throttle_mutex);
168
169 return ret;
170}
171
172/**
173 * tty_wait_until_sent - wait for I/O to finish
174 * @tty: tty we are waiting for
175 * @timeout: how long we will wait
176 *
177 * Wait for characters pending in a tty driver to hit the wire, or for a
178 * timeout to occur (eg due to flow control).
179 *
180 * Locking: none
181 */
182
183void tty_wait_until_sent(struct tty_struct *tty, long timeout)
184{
185 if (!timeout)
186 timeout = MAX_SCHEDULE_TIMEOUT;
187
188 timeout = wait_event_interruptible_timeout(tty->write_wait,
189 !tty_chars_in_buffer(tty), timeout);
190 if (timeout <= 0)
191 return;
192
193 if (timeout == MAX_SCHEDULE_TIMEOUT)
194 timeout = 0;
195
196 if (tty->ops->wait_until_sent)
197 tty->ops->wait_until_sent(tty, timeout);
198}
199EXPORT_SYMBOL(tty_wait_until_sent);
200
201
202/*
203 * Termios Helper Methods
204 */
205
206static void unset_locked_termios(struct tty_struct *tty, const struct ktermios *old)
207{
208 struct ktermios *termios = &tty->termios;
209 struct ktermios *locked = &tty->termios_locked;
210 int i;
211
212#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
213
214 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
215 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
216 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
217 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
218 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
219 for (i = 0; i < NCCS; i++)
220 termios->c_cc[i] = locked->c_cc[i] ?
221 old->c_cc[i] : termios->c_cc[i];
222 /* FIXME: What should we do for i/ospeed */
223}
224
225/**
226 * tty_termios_copy_hw - copy hardware settings
227 * @new: new termios
228 * @old: old termios
229 *
230 * Propagate the hardware specific terminal setting bits from the @old termios
231 * structure to the @new one. This is used in cases where the hardware does not
232 * support reconfiguration or as a helper in some cases where only minimal
233 * reconfiguration is supported.
234 */
235void tty_termios_copy_hw(struct ktermios *new, const struct ktermios *old)
236{
237 /* The bits a dumb device handles in software. Smart devices need
238 to always provide a set_termios method */
239 new->c_cflag &= HUPCL | CREAD | CLOCAL;
240 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
241 new->c_ispeed = old->c_ispeed;
242 new->c_ospeed = old->c_ospeed;
243}
244EXPORT_SYMBOL(tty_termios_copy_hw);
245
246/**
247 * tty_termios_hw_change - check for setting change
248 * @a: termios
249 * @b: termios to compare
250 *
251 * Check if any of the bits that affect a dumb device have changed between the
252 * two termios structures, or a speed change is needed.
253 *
254 * Returns: %true if change is needed
255 */
256bool tty_termios_hw_change(const struct ktermios *a, const struct ktermios *b)
257{
258 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
259 return true;
260 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
261 return true;
262 return false;
263}
264EXPORT_SYMBOL(tty_termios_hw_change);
265
266/**
267 * tty_get_char_size - get size of a character
268 * @cflag: termios cflag value
269 *
270 * Returns: size (in bits) of a character depending on @cflag's %CSIZE setting
271 */
272unsigned char tty_get_char_size(unsigned int cflag)
273{
274 switch (cflag & CSIZE) {
275 case CS5:
276 return 5;
277 case CS6:
278 return 6;
279 case CS7:
280 return 7;
281 case CS8:
282 default:
283 return 8;
284 }
285}
286EXPORT_SYMBOL_GPL(tty_get_char_size);
287
288/**
289 * tty_get_frame_size - get size of a frame
290 * @cflag: termios cflag value
291 *
292 * Get the size (in bits) of a frame depending on @cflag's %CSIZE, %CSTOPB, and
293 * %PARENB setting. The result is a sum of character size, start and stop bits
294 * -- one bit each -- second stop bit (if set), and parity bit (if set).
295 *
296 * Returns: size (in bits) of a frame depending on @cflag's setting.
297 */
298unsigned char tty_get_frame_size(unsigned int cflag)
299{
300 unsigned char bits = 2 + tty_get_char_size(cflag);
301
302 if (cflag & CSTOPB)
303 bits++;
304 if (cflag & PARENB)
305 bits++;
306 if (cflag & ADDRB)
307 bits++;
308
309 return bits;
310}
311EXPORT_SYMBOL_GPL(tty_get_frame_size);
312
313/**
314 * tty_set_termios - update termios values
315 * @tty: tty to update
316 * @new_termios: desired new value
317 *
318 * Perform updates to the termios values set on this @tty. A master pty's
319 * termios should never be set.
320 *
321 * Locking: &tty_struct->termios_rwsem
322 */
323int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
324{
325 struct ktermios old_termios;
326 struct tty_ldisc *ld;
327
328 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
329 tty->driver->subtype == PTY_TYPE_MASTER);
330 /*
331 * Perform the actual termios internal changes under lock.
332 */
333
334
335 /* FIXME: we need to decide on some locking/ordering semantics
336 for the set_termios notification eventually */
337 down_write(&tty->termios_rwsem);
338 old_termios = tty->termios;
339 tty->termios = *new_termios;
340 unset_locked_termios(tty, &old_termios);
341 /* Reset any ADDRB changes, ADDRB is changed through ->rs485_config() */
342 tty->termios.c_cflag ^= (tty->termios.c_cflag ^ old_termios.c_cflag) & ADDRB;
343
344 if (tty->ops->set_termios)
345 tty->ops->set_termios(tty, &old_termios);
346 else
347 tty_termios_copy_hw(&tty->termios, &old_termios);
348
349 ld = tty_ldisc_ref(tty);
350 if (ld != NULL) {
351 if (ld->ops->set_termios)
352 ld->ops->set_termios(tty, &old_termios);
353 tty_ldisc_deref(ld);
354 }
355 up_write(&tty->termios_rwsem);
356 return 0;
357}
358EXPORT_SYMBOL_GPL(tty_set_termios);
359
360
361/*
362 * Translate a "termio" structure into a "termios". Ugh.
363 */
364__weak int user_termio_to_kernel_termios(struct ktermios *termios,
365 struct termio __user *termio)
366{
367 struct termio v;
368
369 if (copy_from_user(&v, termio, sizeof(struct termio)))
370 return -EFAULT;
371
372 termios->c_iflag = (0xffff0000 & termios->c_iflag) | v.c_iflag;
373 termios->c_oflag = (0xffff0000 & termios->c_oflag) | v.c_oflag;
374 termios->c_cflag = (0xffff0000 & termios->c_cflag) | v.c_cflag;
375 termios->c_lflag = (0xffff0000 & termios->c_lflag) | v.c_lflag;
376 termios->c_line = (0xffff0000 & termios->c_lflag) | v.c_line;
377 memcpy(termios->c_cc, v.c_cc, NCC);
378 return 0;
379}
380
381/*
382 * Translate a "termios" structure into a "termio". Ugh.
383 */
384__weak int kernel_termios_to_user_termio(struct termio __user *termio,
385 struct ktermios *termios)
386{
387 struct termio v;
388 memset(&v, 0, sizeof(struct termio));
389 v.c_iflag = termios->c_iflag;
390 v.c_oflag = termios->c_oflag;
391 v.c_cflag = termios->c_cflag;
392 v.c_lflag = termios->c_lflag;
393 v.c_line = termios->c_line;
394 memcpy(v.c_cc, termios->c_cc, NCC);
395 return copy_to_user(termio, &v, sizeof(struct termio));
396}
397
398#ifdef TCGETS2
399__weak int user_termios_to_kernel_termios(struct ktermios *k,
400 struct termios2 __user *u)
401{
402 return copy_from_user(k, u, sizeof(struct termios2));
403}
404__weak int kernel_termios_to_user_termios(struct termios2 __user *u,
405 struct ktermios *k)
406{
407 return copy_to_user(u, k, sizeof(struct termios2));
408}
409__weak int user_termios_to_kernel_termios_1(struct ktermios *k,
410 struct termios __user *u)
411{
412 return copy_from_user(k, u, sizeof(struct termios));
413}
414__weak int kernel_termios_to_user_termios_1(struct termios __user *u,
415 struct ktermios *k)
416{
417 return copy_to_user(u, k, sizeof(struct termios));
418}
419
420#else
421
422__weak int user_termios_to_kernel_termios(struct ktermios *k,
423 struct termios __user *u)
424{
425 return copy_from_user(k, u, sizeof(struct termios));
426}
427__weak int kernel_termios_to_user_termios(struct termios __user *u,
428 struct ktermios *k)
429{
430 return copy_to_user(u, k, sizeof(struct termios));
431}
432#endif /* TCGETS2 */
433
434/**
435 * set_termios - set termios values for a tty
436 * @tty: terminal device
437 * @arg: user data
438 * @opt: option information
439 *
440 * Helper function to prepare termios data and run necessary other functions
441 * before using tty_set_termios() to do the actual changes.
442 *
443 * Locking: called functions take &tty_struct->ldisc_sem and
444 * &tty_struct->termios_rwsem locks
445 *
446 * Returns: 0 on success, an error otherwise
447 */
448static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
449{
450 struct ktermios tmp_termios;
451 struct tty_ldisc *ld;
452 int retval = tty_check_change(tty);
453
454 if (retval)
455 return retval;
456
457 down_read(&tty->termios_rwsem);
458 tmp_termios = tty->termios;
459 up_read(&tty->termios_rwsem);
460
461 if (opt & TERMIOS_TERMIO) {
462 if (user_termio_to_kernel_termios(&tmp_termios,
463 (struct termio __user *)arg))
464 return -EFAULT;
465#ifdef TCGETS2
466 } else if (opt & TERMIOS_OLD) {
467 if (user_termios_to_kernel_termios_1(&tmp_termios,
468 (struct termios __user *)arg))
469 return -EFAULT;
470 } else {
471 if (user_termios_to_kernel_termios(&tmp_termios,
472 (struct termios2 __user *)arg))
473 return -EFAULT;
474 }
475#else
476 } else if (user_termios_to_kernel_termios(&tmp_termios,
477 (struct termios __user *)arg))
478 return -EFAULT;
479#endif
480
481 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
482 * with the real speed so its unconditionally usable */
483 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
484 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
485
486 if (opt & (TERMIOS_FLUSH|TERMIOS_WAIT)) {
487retry_write_wait:
488 retval = wait_event_interruptible(tty->write_wait, !tty_chars_in_buffer(tty));
489 if (retval < 0)
490 return retval;
491
492 if (tty_write_lock(tty, false) < 0)
493 goto retry_write_wait;
494
495 /* Racing writer? */
496 if (tty_chars_in_buffer(tty)) {
497 tty_write_unlock(tty);
498 goto retry_write_wait;
499 }
500
501 ld = tty_ldisc_ref(tty);
502 if (ld != NULL) {
503 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
504 ld->ops->flush_buffer(tty);
505 tty_ldisc_deref(ld);
506 }
507
508 if ((opt & TERMIOS_WAIT) && tty->ops->wait_until_sent) {
509 tty->ops->wait_until_sent(tty, 0);
510 if (signal_pending(current)) {
511 tty_write_unlock(tty);
512 return -ERESTARTSYS;
513 }
514 }
515
516 tty_set_termios(tty, &tmp_termios);
517
518 tty_write_unlock(tty);
519 } else {
520 tty_set_termios(tty, &tmp_termios);
521 }
522
523 /* FIXME: Arguably if tmp_termios == tty->termios AND the
524 actual requested termios was not tmp_termios then we may
525 want to return an error as no user requested change has
526 succeeded */
527 return 0;
528}
529
530static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
531{
532 down_read(&tty->termios_rwsem);
533 *kterm = tty->termios;
534 up_read(&tty->termios_rwsem);
535}
536
537static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
538{
539 down_read(&tty->termios_rwsem);
540 *kterm = tty->termios_locked;
541 up_read(&tty->termios_rwsem);
542}
543
544static int get_termio(struct tty_struct *tty, struct termio __user *termio)
545{
546 struct ktermios kterm;
547 copy_termios(tty, &kterm);
548 if (kernel_termios_to_user_termio(termio, &kterm))
549 return -EFAULT;
550 return 0;
551}
552
553#ifdef TIOCGETP
554/*
555 * These are deprecated, but there is limited support..
556 *
557 * The "sg_flags" translation is a joke..
558 */
559static int get_sgflags(struct tty_struct *tty)
560{
561 int flags = 0;
562
563 if (!L_ICANON(tty)) {
564 if (L_ISIG(tty))
565 flags |= 0x02; /* cbreak */
566 else
567 flags |= 0x20; /* raw */
568 }
569 if (L_ECHO(tty))
570 flags |= 0x08; /* echo */
571 if (O_OPOST(tty))
572 if (O_ONLCR(tty))
573 flags |= 0x10; /* crmod */
574 return flags;
575}
576
577static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
578{
579 struct sgttyb tmp;
580
581 down_read(&tty->termios_rwsem);
582 tmp.sg_ispeed = tty->termios.c_ispeed;
583 tmp.sg_ospeed = tty->termios.c_ospeed;
584 tmp.sg_erase = tty->termios.c_cc[VERASE];
585 tmp.sg_kill = tty->termios.c_cc[VKILL];
586 tmp.sg_flags = get_sgflags(tty);
587 up_read(&tty->termios_rwsem);
588
589 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
590}
591
592static void set_sgflags(struct ktermios *termios, int flags)
593{
594 termios->c_iflag = ICRNL | IXON;
595 termios->c_oflag = 0;
596 termios->c_lflag = ISIG | ICANON;
597 if (flags & 0x02) { /* cbreak */
598 termios->c_iflag = 0;
599 termios->c_lflag &= ~ICANON;
600 }
601 if (flags & 0x08) { /* echo */
602 termios->c_lflag |= ECHO | ECHOE | ECHOK |
603 ECHOCTL | ECHOKE | IEXTEN;
604 }
605 if (flags & 0x10) { /* crmod */
606 termios->c_oflag |= OPOST | ONLCR;
607 }
608 if (flags & 0x20) { /* raw */
609 termios->c_iflag = 0;
610 termios->c_lflag &= ~(ISIG | ICANON);
611 }
612 if (!(termios->c_lflag & ICANON)) {
613 termios->c_cc[VMIN] = 1;
614 termios->c_cc[VTIME] = 0;
615 }
616}
617
618/**
619 * set_sgttyb - set legacy terminal values
620 * @tty: tty structure
621 * @sgttyb: pointer to old style terminal structure
622 *
623 * Updates a terminal from the legacy BSD style terminal information structure.
624 *
625 * Locking: &tty_struct->termios_rwsem
626 *
627 * Returns: 0 on success, an error otherwise
628 */
629static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
630{
631 int retval;
632 struct sgttyb tmp;
633 struct ktermios termios;
634
635 retval = tty_check_change(tty);
636 if (retval)
637 return retval;
638
639 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
640 return -EFAULT;
641
642 down_write(&tty->termios_rwsem);
643 termios = tty->termios;
644 termios.c_cc[VERASE] = tmp.sg_erase;
645 termios.c_cc[VKILL] = tmp.sg_kill;
646 set_sgflags(&termios, tmp.sg_flags);
647 /* Try and encode into Bfoo format */
648 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
649 termios.c_ospeed);
650 up_write(&tty->termios_rwsem);
651 tty_set_termios(tty, &termios);
652 return 0;
653}
654#endif
655
656#ifdef TIOCGETC
657static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
658{
659 struct tchars tmp;
660
661 down_read(&tty->termios_rwsem);
662 tmp.t_intrc = tty->termios.c_cc[VINTR];
663 tmp.t_quitc = tty->termios.c_cc[VQUIT];
664 tmp.t_startc = tty->termios.c_cc[VSTART];
665 tmp.t_stopc = tty->termios.c_cc[VSTOP];
666 tmp.t_eofc = tty->termios.c_cc[VEOF];
667 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
668 up_read(&tty->termios_rwsem);
669 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
670}
671
672static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
673{
674 struct tchars tmp;
675
676 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
677 return -EFAULT;
678 down_write(&tty->termios_rwsem);
679 tty->termios.c_cc[VINTR] = tmp.t_intrc;
680 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
681 tty->termios.c_cc[VSTART] = tmp.t_startc;
682 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
683 tty->termios.c_cc[VEOF] = tmp.t_eofc;
684 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
685 up_write(&tty->termios_rwsem);
686 return 0;
687}
688#endif
689
690#ifdef TIOCGLTC
691static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
692{
693 struct ltchars tmp;
694
695 down_read(&tty->termios_rwsem);
696 tmp.t_suspc = tty->termios.c_cc[VSUSP];
697 /* what is dsuspc anyway? */
698 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
699 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
700 /* what is flushc anyway? */
701 tmp.t_flushc = tty->termios.c_cc[VEOL2];
702 tmp.t_werasc = tty->termios.c_cc[VWERASE];
703 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
704 up_read(&tty->termios_rwsem);
705 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
706}
707
708static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
709{
710 struct ltchars tmp;
711
712 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
713 return -EFAULT;
714
715 down_write(&tty->termios_rwsem);
716 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
717 /* what is dsuspc anyway? */
718 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
719 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
720 /* what is flushc anyway? */
721 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
722 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
723 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
724 up_write(&tty->termios_rwsem);
725 return 0;
726}
727#endif
728
729/**
730 * tty_change_softcar - carrier change ioctl helper
731 * @tty: tty to update
732 * @enable: enable/disable %CLOCAL
733 *
734 * Perform a change to the %CLOCAL state and call into the driver layer to make
735 * it visible.
736 *
737 * Locking: &tty_struct->termios_rwsem.
738 *
739 * Returns: 0 on success, an error otherwise
740 */
741static int tty_change_softcar(struct tty_struct *tty, bool enable)
742{
743 int ret = 0;
744 struct ktermios old;
745 tcflag_t bit = enable ? CLOCAL : 0;
746
747 down_write(&tty->termios_rwsem);
748 old = tty->termios;
749 tty->termios.c_cflag &= ~CLOCAL;
750 tty->termios.c_cflag |= bit;
751 if (tty->ops->set_termios)
752 tty->ops->set_termios(tty, &old);
753 if (C_CLOCAL(tty) != bit)
754 ret = -EINVAL;
755 up_write(&tty->termios_rwsem);
756 return ret;
757}
758
759/**
760 * tty_mode_ioctl - mode related ioctls
761 * @tty: tty for the ioctl
762 * @cmd: command
763 * @arg: ioctl argument
764 *
765 * Perform non-line discipline specific mode control ioctls. This is designed
766 * to be called by line disciplines to ensure they provide consistent mode
767 * setting.
768 */
769int tty_mode_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
770{
771 struct tty_struct *real_tty;
772 void __user *p = (void __user *)arg;
773 int ret = 0;
774 struct ktermios kterm;
775
776 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
777 tty->driver->subtype == PTY_TYPE_MASTER)
778 real_tty = tty->link;
779 else
780 real_tty = tty;
781
782 switch (cmd) {
783#ifdef TIOCGETP
784 case TIOCGETP:
785 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
786 case TIOCSETP:
787 case TIOCSETN:
788 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
789#endif
790#ifdef TIOCGETC
791 case TIOCGETC:
792 return get_tchars(real_tty, p);
793 case TIOCSETC:
794 return set_tchars(real_tty, p);
795#endif
796#ifdef TIOCGLTC
797 case TIOCGLTC:
798 return get_ltchars(real_tty, p);
799 case TIOCSLTC:
800 return set_ltchars(real_tty, p);
801#endif
802 case TCSETSF:
803 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
804 case TCSETSW:
805 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
806 case TCSETS:
807 return set_termios(real_tty, p, TERMIOS_OLD);
808#ifndef TCGETS2
809 case TCGETS:
810 copy_termios(real_tty, &kterm);
811 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
812 ret = -EFAULT;
813 return ret;
814#else
815 case TCGETS:
816 copy_termios(real_tty, &kterm);
817 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
818 ret = -EFAULT;
819 return ret;
820 case TCGETS2:
821 copy_termios(real_tty, &kterm);
822 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
823 ret = -EFAULT;
824 return ret;
825 case TCSETSF2:
826 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
827 case TCSETSW2:
828 return set_termios(real_tty, p, TERMIOS_WAIT);
829 case TCSETS2:
830 return set_termios(real_tty, p, 0);
831#endif
832 case TCGETA:
833 return get_termio(real_tty, p);
834 case TCSETAF:
835 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
836 case TCSETAW:
837 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
838 case TCSETA:
839 return set_termios(real_tty, p, TERMIOS_TERMIO);
840#ifndef TCGETS2
841 case TIOCGLCKTRMIOS:
842 copy_termios_locked(real_tty, &kterm);
843 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
844 ret = -EFAULT;
845 return ret;
846 case TIOCSLCKTRMIOS:
847 if (!checkpoint_restore_ns_capable(&init_user_ns))
848 return -EPERM;
849 copy_termios_locked(real_tty, &kterm);
850 if (user_termios_to_kernel_termios(&kterm,
851 (struct termios __user *) arg))
852 return -EFAULT;
853 down_write(&real_tty->termios_rwsem);
854 real_tty->termios_locked = kterm;
855 up_write(&real_tty->termios_rwsem);
856 return 0;
857#else
858 case TIOCGLCKTRMIOS:
859 copy_termios_locked(real_tty, &kterm);
860 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
861 ret = -EFAULT;
862 return ret;
863 case TIOCSLCKTRMIOS:
864 if (!checkpoint_restore_ns_capable(&init_user_ns))
865 return -EPERM;
866 copy_termios_locked(real_tty, &kterm);
867 if (user_termios_to_kernel_termios_1(&kterm,
868 (struct termios __user *) arg))
869 return -EFAULT;
870 down_write(&real_tty->termios_rwsem);
871 real_tty->termios_locked = kterm;
872 up_write(&real_tty->termios_rwsem);
873 return ret;
874#endif
875#ifdef TCGETX
876 case TCGETX:
877 case TCSETX:
878 case TCSETXW:
879 case TCSETXF:
880 return -ENOTTY;
881#endif
882 case TIOCGSOFTCAR:
883 copy_termios(real_tty, &kterm);
884 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
885 (int __user *)arg);
886 return ret;
887 case TIOCSSOFTCAR:
888 if (get_user(arg, (unsigned int __user *) arg))
889 return -EFAULT;
890 return tty_change_softcar(real_tty, arg);
891 default:
892 return -ENOIOCTLCMD;
893 }
894}
895EXPORT_SYMBOL_GPL(tty_mode_ioctl);
896
897
898/* Caller guarantees ldisc reference is held */
899static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
900{
901 struct tty_ldisc *ld = tty->ldisc;
902
903 switch (arg) {
904 case TCIFLUSH:
905 if (ld && ld->ops->flush_buffer) {
906 ld->ops->flush_buffer(tty);
907 tty_unthrottle(tty);
908 }
909 break;
910 case TCIOFLUSH:
911 if (ld && ld->ops->flush_buffer) {
912 ld->ops->flush_buffer(tty);
913 tty_unthrottle(tty);
914 }
915 fallthrough;
916 case TCOFLUSH:
917 tty_driver_flush_buffer(tty);
918 break;
919 default:
920 return -EINVAL;
921 }
922 return 0;
923}
924
925int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
926{
927 struct tty_ldisc *ld;
928 int retval = tty_check_change(tty);
929 if (retval)
930 return retval;
931
932 ld = tty_ldisc_ref_wait(tty);
933 retval = __tty_perform_flush(tty, arg);
934 if (ld)
935 tty_ldisc_deref(ld);
936 return retval;
937}
938EXPORT_SYMBOL_GPL(tty_perform_flush);
939
940int n_tty_ioctl_helper(struct tty_struct *tty, unsigned int cmd,
941 unsigned long arg)
942{
943 int retval;
944
945 switch (cmd) {
946 case TCXONC:
947 retval = tty_check_change(tty);
948 if (retval)
949 return retval;
950 switch (arg) {
951 case TCOOFF:
952 spin_lock_irq(&tty->flow.lock);
953 if (!tty->flow.tco_stopped) {
954 tty->flow.tco_stopped = true;
955 __stop_tty(tty);
956 }
957 spin_unlock_irq(&tty->flow.lock);
958 break;
959 case TCOON:
960 spin_lock_irq(&tty->flow.lock);
961 if (tty->flow.tco_stopped) {
962 tty->flow.tco_stopped = false;
963 __start_tty(tty);
964 }
965 spin_unlock_irq(&tty->flow.lock);
966 break;
967 case TCIOFF:
968 if (STOP_CHAR(tty) != __DISABLED_CHAR)
969 retval = tty_send_xchar(tty, STOP_CHAR(tty));
970 break;
971 case TCION:
972 if (START_CHAR(tty) != __DISABLED_CHAR)
973 retval = tty_send_xchar(tty, START_CHAR(tty));
974 break;
975 default:
976 return -EINVAL;
977 }
978 return retval;
979 case TCFLSH:
980 retval = tty_check_change(tty);
981 if (retval)
982 return retval;
983 return __tty_perform_flush(tty, arg);
984 default:
985 /* Try the mode commands */
986 return tty_mode_ioctl(tty, cmd, arg);
987 }
988}
989EXPORT_SYMBOL(n_tty_ioctl_helper);
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 <linux/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 (!tty_throttled(tty)) {
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 (tty_throttled(tty)) {
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