projects/linux·blob master · refs

985 lines · 25.5 KiB

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 guard(mutex)(&tty->throttle_mutex);
126
127 if (tty_throttled(tty))
128 return true;
129
130 if (tty->flow_change != TTY_THROTTLE_SAFE)
131 return false;
132
133 set_bit(TTY_THROTTLED, &tty->flags);
134 if (tty->ops->throttle)
135 tty->ops->throttle(tty);
136
137 return true;
138}
139
140/**
141 * tty_unthrottle_safe - flow control
142 * @tty: terminal
143 *
144 * Similar to tty_unthrottle() but will only attempt unthrottle if
145 * @tty->flow_change is %TTY_UNTHROTTLE_SAFE. Prevents an accidental unthrottle
146 * due to race conditions when unthrottling is conditional on factors evaluated
147 * prior to unthrottling.
148 *
149 * Returns: %true if @tty is unthrottled (or was already unthrottled)
150 */
151bool tty_unthrottle_safe(struct tty_struct *tty)
152{
153 guard(mutex)(&tty->throttle_mutex);
154
155 if (!tty_throttled(tty))
156 return true;
157
158 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
159 return false;
160
161 clear_bit(TTY_THROTTLED, &tty->flags);
162 if (tty->ops->unthrottle)
163 tty->ops->unthrottle(tty);
164
165 return true;
166}
167
168/**
169 * tty_wait_until_sent - wait for I/O to finish
170 * @tty: tty we are waiting for
171 * @timeout: how long we will wait
172 *
173 * Wait for characters pending in a tty driver to hit the wire, or for a
174 * timeout to occur (eg due to flow control).
175 *
176 * Locking: none
177 */
178
179void tty_wait_until_sent(struct tty_struct *tty, long timeout)
180{
181 if (!timeout)
182 timeout = MAX_SCHEDULE_TIMEOUT;
183
184 timeout = wait_event_interruptible_timeout(tty->write_wait,
185 !tty_chars_in_buffer(tty), timeout);
186 if (timeout <= 0)
187 return;
188
189 if (timeout == MAX_SCHEDULE_TIMEOUT)
190 timeout = 0;
191
192 if (tty->ops->wait_until_sent)
193 tty->ops->wait_until_sent(tty, timeout);
194}
195EXPORT_SYMBOL(tty_wait_until_sent);
196
197
198/*
199 * Termios Helper Methods
200 */
201
202static void unset_locked_termios(struct tty_struct *tty, const struct ktermios *old)
203{
204 struct ktermios *termios = &tty->termios;
205 struct ktermios *locked = &tty->termios_locked;
206 int i;
207
208#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
209
210 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
211 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
212 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
213 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
214 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
215 for (i = 0; i < NCCS; i++)
216 termios->c_cc[i] = locked->c_cc[i] ?
217 old->c_cc[i] : termios->c_cc[i];
218 /* FIXME: What should we do for i/ospeed */
219}
220
221/**
222 * tty_termios_copy_hw - copy hardware settings
223 * @new: new termios
224 * @old: old termios
225 *
226 * Propagate the hardware specific terminal setting bits from the @old termios
227 * structure to the @new one. This is used in cases where the hardware does not
228 * support reconfiguration or as a helper in some cases where only minimal
229 * reconfiguration is supported.
230 */
231void tty_termios_copy_hw(struct ktermios *new, const struct ktermios *old)
232{
233 /* The bits a dumb device handles in software. Smart devices need
234 to always provide a set_termios method */
235 new->c_cflag &= HUPCL | CREAD | CLOCAL;
236 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
237 new->c_ispeed = old->c_ispeed;
238 new->c_ospeed = old->c_ospeed;
239}
240EXPORT_SYMBOL(tty_termios_copy_hw);
241
242/**
243 * tty_termios_hw_change - check for setting change
244 * @a: termios
245 * @b: termios to compare
246 *
247 * Check if any of the bits that affect a dumb device have changed between the
248 * two termios structures, or a speed change is needed.
249 *
250 * Returns: %true if change is needed
251 */
252bool tty_termios_hw_change(const struct ktermios *a, const struct ktermios *b)
253{
254 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
255 return true;
256 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
257 return true;
258 return false;
259}
260EXPORT_SYMBOL(tty_termios_hw_change);
261
262/**
263 * tty_get_char_size - get size of a character
264 * @cflag: termios cflag value
265 *
266 * Returns: size (in bits) of a character depending on @cflag's %CSIZE setting
267 */
268unsigned char tty_get_char_size(unsigned int cflag)
269{
270 switch (cflag & CSIZE) {
271 case CS5:
272 return 5;
273 case CS6:
274 return 6;
275 case CS7:
276 return 7;
277 case CS8:
278 default:
279 return 8;
280 }
281}
282EXPORT_SYMBOL_GPL(tty_get_char_size);
283
284/**
285 * tty_get_frame_size - get size of a frame
286 * @cflag: termios cflag value
287 *
288 * Get the size (in bits) of a frame depending on @cflag's %CSIZE, %CSTOPB, and
289 * %PARENB setting. The result is a sum of character size, start and stop bits
290 * -- one bit each -- second stop bit (if set), and parity bit (if set).
291 *
292 * Returns: size (in bits) of a frame depending on @cflag's setting.
293 */
294unsigned char tty_get_frame_size(unsigned int cflag)
295{
296 unsigned char bits = 2 + tty_get_char_size(cflag);
297
298 if (cflag & CSTOPB)
299 bits++;
300 if (cflag & PARENB)
301 bits++;
302 if (cflag & ADDRB)
303 bits++;
304
305 return bits;
306}
307EXPORT_SYMBOL_GPL(tty_get_frame_size);
308
309/**
310 * tty_set_termios - update termios values
311 * @tty: tty to update
312 * @new_termios: desired new value
313 *
314 * Perform updates to the termios values set on this @tty. A master pty's
315 * termios should never be set.
316 *
317 * Locking: &tty_struct->termios_rwsem
318 */
319int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
320{
321 struct ktermios old_termios;
322 struct tty_ldisc *ld;
323
324 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
325 tty->driver->subtype == PTY_TYPE_MASTER);
326 /*
327 * Perform the actual termios internal changes under lock.
328 */
329
330
331 /* FIXME: we need to decide on some locking/ordering semantics
332 for the set_termios notification eventually */
333 down_write(&tty->termios_rwsem);
334 old_termios = tty->termios;
335 tty->termios = *new_termios;
336 unset_locked_termios(tty, &old_termios);
337 /* Reset any ADDRB changes, ADDRB is changed through ->rs485_config() */
338 tty->termios.c_cflag ^= (tty->termios.c_cflag ^ old_termios.c_cflag) & ADDRB;
339
340 if (tty->ops->set_termios)
341 tty->ops->set_termios(tty, &old_termios);
342 else
343 tty_termios_copy_hw(&tty->termios, &old_termios);
344
345 ld = tty_ldisc_ref(tty);
346 if (ld != NULL) {
347 if (ld->ops->set_termios)
348 ld->ops->set_termios(tty, &old_termios);
349 tty_ldisc_deref(ld);
350 }
351 up_write(&tty->termios_rwsem);
352 return 0;
353}
354EXPORT_SYMBOL_GPL(tty_set_termios);
355
356
357/*
358 * Translate a "termio" structure into a "termios". Ugh.
359 */
360__weak int user_termio_to_kernel_termios(struct ktermios *termios,
361 struct termio __user *termio)
362{
363 struct termio v;
364
365 if (copy_from_user(&v, termio, sizeof(struct termio)))
366 return -EFAULT;
367
368 termios->c_iflag = (0xffff0000 & termios->c_iflag) | v.c_iflag;
369 termios->c_oflag = (0xffff0000 & termios->c_oflag) | v.c_oflag;
370 termios->c_cflag = (0xffff0000 & termios->c_cflag) | v.c_cflag;
371 termios->c_lflag = (0xffff0000 & termios->c_lflag) | v.c_lflag;
372 termios->c_line = (0xffff0000 & termios->c_lflag) | v.c_line;
373 memcpy(termios->c_cc, v.c_cc, NCC);
374 return 0;
375}
376
377/*
378 * Translate a "termios" structure into a "termio". Ugh.
379 */
380__weak int kernel_termios_to_user_termio(struct termio __user *termio,
381 struct ktermios *termios)
382{
383 struct termio v;
384 memset(&v, 0, sizeof(struct termio));
385 v.c_iflag = termios->c_iflag;
386 v.c_oflag = termios->c_oflag;
387 v.c_cflag = termios->c_cflag;
388 v.c_lflag = termios->c_lflag;
389 v.c_line = termios->c_line;
390 memcpy(v.c_cc, termios->c_cc, NCC);
391 return copy_to_user(termio, &v, sizeof(struct termio));
392}
393
394#ifdef TCGETS2
395__weak int user_termios_to_kernel_termios(struct ktermios *k,
396 struct termios2 __user *u)
397{
398 return copy_from_user(k, u, sizeof(struct termios2));
399}
400__weak int kernel_termios_to_user_termios(struct termios2 __user *u,
401 struct ktermios *k)
402{
403 return copy_to_user(u, k, sizeof(struct termios2));
404}
405__weak int user_termios_to_kernel_termios_1(struct ktermios *k,
406 struct termios __user *u)
407{
408 return copy_from_user(k, u, sizeof(struct termios));
409}
410__weak int kernel_termios_to_user_termios_1(struct termios __user *u,
411 struct ktermios *k)
412{
413 return copy_to_user(u, k, sizeof(struct termios));
414}
415
416#else
417
418__weak int user_termios_to_kernel_termios(struct ktermios *k,
419 struct termios __user *u)
420{
421 return copy_from_user(k, u, sizeof(struct termios));
422}
423__weak int kernel_termios_to_user_termios(struct termios __user *u,
424 struct ktermios *k)
425{
426 return copy_to_user(u, k, sizeof(struct termios));
427}
428#endif /* TCGETS2 */
429
430/**
431 * set_termios - set termios values for a tty
432 * @tty: terminal device
433 * @arg: user data
434 * @opt: option information
435 *
436 * Helper function to prepare termios data and run necessary other functions
437 * before using tty_set_termios() to do the actual changes.
438 *
439 * Locking: called functions take &tty_struct->ldisc_sem and
440 * &tty_struct->termios_rwsem locks
441 *
442 * Returns: 0 on success, an error otherwise
443 */
444static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
445{
446 struct ktermios tmp_termios;
447 struct tty_ldisc *ld;
448 int retval = tty_check_change(tty);
449
450 if (retval)
451 return retval;
452
453 down_read(&tty->termios_rwsem);
454 tmp_termios = tty->termios;
455 up_read(&tty->termios_rwsem);
456
457 if (opt & TERMIOS_TERMIO) {
458 if (user_termio_to_kernel_termios(&tmp_termios,
459 (struct termio __user *)arg))
460 return -EFAULT;
461#ifdef TCGETS2
462 } else if (opt & TERMIOS_OLD) {
463 if (user_termios_to_kernel_termios_1(&tmp_termios,
464 (struct termios __user *)arg))
465 return -EFAULT;
466 } else {
467 if (user_termios_to_kernel_termios(&tmp_termios,
468 (struct termios2 __user *)arg))
469 return -EFAULT;
470 }
471#else
472 } else if (user_termios_to_kernel_termios(&tmp_termios,
473 (struct termios __user *)arg))
474 return -EFAULT;
475#endif
476
477 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
478 * with the real speed so its unconditionally usable */
479 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
480 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
481
482 if (opt & (TERMIOS_FLUSH|TERMIOS_WAIT)) {
483retry_write_wait:
484 retval = wait_event_interruptible(tty->write_wait, !tty_chars_in_buffer(tty));
485 if (retval < 0)
486 return retval;
487
488 if (tty_write_lock(tty, false) < 0)
489 goto retry_write_wait;
490
491 /* Racing writer? */
492 if (tty_chars_in_buffer(tty)) {
493 tty_write_unlock(tty);
494 goto retry_write_wait;
495 }
496
497 ld = tty_ldisc_ref(tty);
498 if (ld != NULL) {
499 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
500 ld->ops->flush_buffer(tty);
501 tty_ldisc_deref(ld);
502 }
503
504 if ((opt & TERMIOS_WAIT) && tty->ops->wait_until_sent) {
505 tty->ops->wait_until_sent(tty, 0);
506 if (signal_pending(current)) {
507 tty_write_unlock(tty);
508 return -ERESTARTSYS;
509 }
510 }
511
512 tty_set_termios(tty, &tmp_termios);
513
514 tty_write_unlock(tty);
515 } else {
516 tty_set_termios(tty, &tmp_termios);
517 }
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 structure.
620 *
621 * Locking: &tty_struct->termios_rwsem
622 *
623 * Returns: 0 on success, an error otherwise
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 * @enable: enable/disable %CLOCAL
729 *
730 * Perform a change to the %CLOCAL state and call into the driver layer to make
731 * it visible.
732 *
733 * Locking: &tty_struct->termios_rwsem.
734 *
735 * Returns: 0 on success, an error otherwise
736 */
737static int tty_change_softcar(struct tty_struct *tty, bool enable)
738{
739 int ret = 0;
740 struct ktermios old;
741 tcflag_t bit = enable ? CLOCAL : 0;
742
743 down_write(&tty->termios_rwsem);
744 old = tty->termios;
745 tty->termios.c_cflag &= ~CLOCAL;
746 tty->termios.c_cflag |= bit;
747 if (tty->ops->set_termios)
748 tty->ops->set_termios(tty, &old);
749 if (C_CLOCAL(tty) != bit)
750 ret = -EINVAL;
751 up_write(&tty->termios_rwsem);
752 return ret;
753}
754
755/**
756 * tty_mode_ioctl - mode related ioctls
757 * @tty: tty for the ioctl
758 * @cmd: command
759 * @arg: ioctl argument
760 *
761 * Perform non-line discipline specific mode control ioctls. This is designed
762 * to be called by line disciplines to ensure they provide consistent mode
763 * setting.
764 */
765int tty_mode_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
766{
767 struct tty_struct *real_tty;
768 void __user *p = (void __user *)arg;
769 int ret = 0;
770 struct ktermios kterm;
771
772 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
773 tty->driver->subtype == PTY_TYPE_MASTER)
774 real_tty = tty->link;
775 else
776 real_tty = tty;
777
778 switch (cmd) {
779#ifdef TIOCGETP
780 case TIOCGETP:
781 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
782 case TIOCSETP:
783 case TIOCSETN:
784 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
785#endif
786#ifdef TIOCGETC
787 case TIOCGETC:
788 return get_tchars(real_tty, p);
789 case TIOCSETC:
790 return set_tchars(real_tty, p);
791#endif
792#ifdef TIOCGLTC
793 case TIOCGLTC:
794 return get_ltchars(real_tty, p);
795 case TIOCSLTC:
796 return set_ltchars(real_tty, p);
797#endif
798 case TCSETSF:
799 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
800 case TCSETSW:
801 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
802 case TCSETS:
803 return set_termios(real_tty, p, TERMIOS_OLD);
804#ifndef TCGETS2
805 case TCGETS:
806 copy_termios(real_tty, &kterm);
807 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
808 ret = -EFAULT;
809 return ret;
810#else
811 case TCGETS:
812 copy_termios(real_tty, &kterm);
813 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
814 ret = -EFAULT;
815 return ret;
816 case TCGETS2:
817 copy_termios(real_tty, &kterm);
818 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
819 ret = -EFAULT;
820 return ret;
821 case TCSETSF2:
822 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
823 case TCSETSW2:
824 return set_termios(real_tty, p, TERMIOS_WAIT);
825 case TCSETS2:
826 return set_termios(real_tty, p, 0);
827#endif
828 case TCGETA:
829 return get_termio(real_tty, p);
830 case TCSETAF:
831 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
832 case TCSETAW:
833 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
834 case TCSETA:
835 return set_termios(real_tty, p, TERMIOS_TERMIO);
836#ifndef TCGETS2
837 case TIOCGLCKTRMIOS:
838 copy_termios_locked(real_tty, &kterm);
839 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
840 ret = -EFAULT;
841 return ret;
842 case TIOCSLCKTRMIOS:
843 if (!checkpoint_restore_ns_capable(&init_user_ns))
844 return -EPERM;
845 copy_termios_locked(real_tty, &kterm);
846 if (user_termios_to_kernel_termios(&kterm,
847 (struct termios __user *) arg))
848 return -EFAULT;
849 down_write(&real_tty->termios_rwsem);
850 real_tty->termios_locked = kterm;
851 up_write(&real_tty->termios_rwsem);
852 return 0;
853#else
854 case TIOCGLCKTRMIOS:
855 copy_termios_locked(real_tty, &kterm);
856 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
857 ret = -EFAULT;
858 return ret;
859 case TIOCSLCKTRMIOS:
860 if (!checkpoint_restore_ns_capable(&init_user_ns))
861 return -EPERM;
862 copy_termios_locked(real_tty, &kterm);
863 if (user_termios_to_kernel_termios_1(&kterm,
864 (struct termios __user *) arg))
865 return -EFAULT;
866 down_write(&real_tty->termios_rwsem);
867 real_tty->termios_locked = kterm;
868 up_write(&real_tty->termios_rwsem);
869 return ret;
870#endif
871#ifdef TCGETX
872 case TCGETX:
873 case TCSETX:
874 case TCSETXW:
875 case TCSETXF:
876 return -ENOTTY;
877#endif
878 case TIOCGSOFTCAR:
879 copy_termios(real_tty, &kterm);
880 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
881 (int __user *)arg);
882 return ret;
883 case TIOCSSOFTCAR:
884 if (get_user(arg, (unsigned int __user *) arg))
885 return -EFAULT;
886 return tty_change_softcar(real_tty, arg);
887 default:
888 return -ENOIOCTLCMD;
889 }
890}
891EXPORT_SYMBOL_GPL(tty_mode_ioctl);
892
893
894/* Caller guarantees ldisc reference is held */
895static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
896{
897 struct tty_ldisc *ld = tty->ldisc;
898
899 switch (arg) {
900 case TCIFLUSH:
901 if (ld && ld->ops->flush_buffer) {
902 ld->ops->flush_buffer(tty);
903 tty_unthrottle(tty);
904 }
905 break;
906 case TCIOFLUSH:
907 if (ld && ld->ops->flush_buffer) {
908 ld->ops->flush_buffer(tty);
909 tty_unthrottle(tty);
910 }
911 fallthrough;
912 case TCOFLUSH:
913 tty_driver_flush_buffer(tty);
914 break;
915 default:
916 return -EINVAL;
917 }
918 return 0;
919}
920
921int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
922{
923 struct tty_ldisc *ld;
924 int retval = tty_check_change(tty);
925 if (retval)
926 return retval;
927
928 ld = tty_ldisc_ref_wait(tty);
929 retval = __tty_perform_flush(tty, arg);
930 if (ld)
931 tty_ldisc_deref(ld);
932 return retval;
933}
934EXPORT_SYMBOL_GPL(tty_perform_flush);
935
936int n_tty_ioctl_helper(struct tty_struct *tty, unsigned int cmd,
937 unsigned long arg)
938{
939 int retval;
940
941 switch (cmd) {
942 case TCXONC:
943 retval = tty_check_change(tty);
944 if (retval)
945 return retval;
946 switch (arg) {
947 case TCOOFF:
948 spin_lock_irq(&tty->flow.lock);
949 if (!tty->flow.tco_stopped) {
950 tty->flow.tco_stopped = true;
951 __stop_tty(tty);
952 }
953 spin_unlock_irq(&tty->flow.lock);
954 break;
955 case TCOON:
956 spin_lock_irq(&tty->flow.lock);
957 if (tty->flow.tco_stopped) {
958 tty->flow.tco_stopped = false;
959 __start_tty(tty);
960 }
961 spin_unlock_irq(&tty->flow.lock);
962 break;
963 case TCIOFF:
964 if (STOP_CHAR(tty) != __DISABLED_CHAR)
965 retval = tty_send_xchar(tty, STOP_CHAR(tty));
966 break;
967 case TCION:
968 if (START_CHAR(tty) != __DISABLED_CHAR)
969 retval = tty_send_xchar(tty, START_CHAR(tty));
970 break;
971 default:
972 return -EINVAL;
973 }
974 return retval;
975 case TCFLSH:
976 retval = tty_check_change(tty);
977 if (retval)
978 return retval;
979 return __tty_perform_flush(tty, arg);
980 default:
981 /* Try the mode commands */
982 return tty_mode_ioctl(tty, cmd, arg);
983 }
984}
985EXPORT_SYMBOL(n_tty_ioctl_helper);