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