1
2
3
4
5
6
7
8
9#include <linux/types.h>
10#include <linux/termios.h>
11#include <linux/errno.h>
12#include <linux/sched/signal.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
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
48
49
50
51
52
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
66
67
68
69
70
71
72
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
85
86
87
88
89
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
100
101
102
103
104
105
106
107
108void tty_throttle(struct tty_struct *tty)
109{
110 down_write(&tty->termios_rwsem);
111
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
122
123
124
125
126
127
128
129
130
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
146
147
148
149
150
151
152
153
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
177
178
179
180
181
182
183
184
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
208
209
210
211
212
213
214
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
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
259}
260
261
262
263
264
265
266
267
268
269
270
271
272void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
273{
274
275
276 new->c_cflag &= HUPCL | CREAD | CLOCAL;
277 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
278 new->c_ispeed = old->c_ispeed;
279 new->c_ospeed = old->c_ospeed;
280}
281EXPORT_SYMBOL(tty_termios_copy_hw);
282
283
284
285
286
287
288
289
290
291
292int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
293{
294 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
295 return 1;
296 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
297 return 1;
298 return 0;
299}
300EXPORT_SYMBOL(tty_termios_hw_change);
301
302
303
304
305
306
307
308
309
310
311
312
313int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
314{
315 struct ktermios old_termios;
316 struct tty_ldisc *ld;
317
318 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
319 tty->driver->subtype == PTY_TYPE_MASTER);
320
321
322
323
324
325
326
327 down_write(&tty->termios_rwsem);
328 old_termios = tty->termios;
329 tty->termios = *new_termios;
330 unset_locked_termios(tty, &old_termios);
331
332 if (tty->ops->set_termios)
333 tty->ops->set_termios(tty, &old_termios);
334 else
335 tty_termios_copy_hw(&tty->termios, &old_termios);
336
337 ld = tty_ldisc_ref(tty);
338 if (ld != NULL) {
339 if (ld->ops->set_termios)
340 ld->ops->set_termios(tty, &old_termios);
341 tty_ldisc_deref(ld);
342 }
343 up_write(&tty->termios_rwsem);
344 return 0;
345}
346EXPORT_SYMBOL_GPL(tty_set_termios);
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
362{
363 struct ktermios tmp_termios;
364 struct tty_ldisc *ld;
365 int retval = tty_check_change(tty);
366
367 if (retval)
368 return retval;
369
370 down_read(&tty->termios_rwsem);
371 tmp_termios = tty->termios;
372 up_read(&tty->termios_rwsem);
373
374 if (opt & TERMIOS_TERMIO) {
375 if (user_termio_to_kernel_termios(&tmp_termios,
376 (struct termio __user *)arg))
377 return -EFAULT;
378#ifdef TCGETS2
379 } else if (opt & TERMIOS_OLD) {
380 if (user_termios_to_kernel_termios_1(&tmp_termios,
381 (struct termios __user *)arg))
382 return -EFAULT;
383 } else {
384 if (user_termios_to_kernel_termios(&tmp_termios,
385 (struct termios2 __user *)arg))
386 return -EFAULT;
387 }
388#else
389 } else if (user_termios_to_kernel_termios(&tmp_termios,
390 (struct termios __user *)arg))
391 return -EFAULT;
392#endif
393
394
395
396 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
397 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
398
399 ld = tty_ldisc_ref(tty);
400
401 if (ld != NULL) {
402 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
403 ld->ops->flush_buffer(tty);
404 tty_ldisc_deref(ld);
405 }
406
407 if (opt & TERMIOS_WAIT) {
408 tty_wait_until_sent(tty, 0);
409 if (signal_pending(current))
410 return -ERESTARTSYS;
411 }
412
413 tty_set_termios(tty, &tmp_termios);
414
415
416
417
418
419 return 0;
420}
421
422static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
423{
424 down_read(&tty->termios_rwsem);
425 *kterm = tty->termios;
426 up_read(&tty->termios_rwsem);
427}
428
429static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
430{
431 down_read(&tty->termios_rwsem);
432 *kterm = tty->termios_locked;
433 up_read(&tty->termios_rwsem);
434}
435
436static int get_termio(struct tty_struct *tty, struct termio __user *termio)
437{
438 struct ktermios kterm;
439 copy_termios(tty, &kterm);
440 if (kernel_termios_to_user_termio(termio, &kterm))
441 return -EFAULT;
442 return 0;
443}
444
445
446#ifdef TCGETX
447
448
449
450
451
452
453
454
455
456
457
458static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
459{
460 struct termiox tnew;
461 struct tty_ldisc *ld;
462
463 if (tty->termiox == NULL)
464 return -EINVAL;
465 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
466 return -EFAULT;
467
468 ld = tty_ldisc_ref(tty);
469 if (ld != NULL) {
470 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
471 ld->ops->flush_buffer(tty);
472 tty_ldisc_deref(ld);
473 }
474 if (opt & TERMIOS_WAIT) {
475 tty_wait_until_sent(tty, 0);
476 if (signal_pending(current))
477 return -ERESTARTSYS;
478 }
479
480 down_write(&tty->termios_rwsem);
481 if (tty->ops->set_termiox)
482 tty->ops->set_termiox(tty, &tnew);
483 up_write(&tty->termios_rwsem);
484 return 0;
485}
486
487#endif
488
489
490#ifdef TIOCGETP
491
492
493
494
495
496static int get_sgflags(struct tty_struct *tty)
497{
498 int flags = 0;
499
500 if (!L_ICANON(tty)) {
501 if (L_ISIG(tty))
502 flags |= 0x02;
503 else
504 flags |= 0x20;
505 }
506 if (L_ECHO(tty))
507 flags |= 0x08;
508 if (O_OPOST(tty))
509 if (O_ONLCR(tty))
510 flags |= 0x10;
511 return flags;
512}
513
514static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
515{
516 struct sgttyb tmp;
517
518 down_read(&tty->termios_rwsem);
519 tmp.sg_ispeed = tty->termios.c_ispeed;
520 tmp.sg_ospeed = tty->termios.c_ospeed;
521 tmp.sg_erase = tty->termios.c_cc[VERASE];
522 tmp.sg_kill = tty->termios.c_cc[VKILL];
523 tmp.sg_flags = get_sgflags(tty);
524 up_read(&tty->termios_rwsem);
525
526 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
527}
528
529static void set_sgflags(struct ktermios *termios, int flags)
530{
531 termios->c_iflag = ICRNL | IXON;
532 termios->c_oflag = 0;
533 termios->c_lflag = ISIG | ICANON;
534 if (flags & 0x02) {
535 termios->c_iflag = 0;
536 termios->c_lflag &= ~ICANON;
537 }
538 if (flags & 0x08) {
539 termios->c_lflag |= ECHO | ECHOE | ECHOK |
540 ECHOCTL | ECHOKE | IEXTEN;
541 }
542 if (flags & 0x10) {
543 termios->c_oflag |= OPOST | ONLCR;
544 }
545 if (flags & 0x20) {
546 termios->c_iflag = 0;
547 termios->c_lflag &= ~(ISIG | ICANON);
548 }
549 if (!(termios->c_lflag & ICANON)) {
550 termios->c_cc[VMIN] = 1;
551 termios->c_cc[VTIME] = 0;
552 }
553}
554
555
556
557
558
559
560
561
562
563
564
565
566static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
567{
568 int retval;
569 struct sgttyb tmp;
570 struct ktermios termios;
571
572 retval = tty_check_change(tty);
573 if (retval)
574 return retval;
575
576 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
577 return -EFAULT;
578
579 down_write(&tty->termios_rwsem);
580 termios = tty->termios;
581 termios.c_cc[VERASE] = tmp.sg_erase;
582 termios.c_cc[VKILL] = tmp.sg_kill;
583 set_sgflags(&termios, tmp.sg_flags);
584
585#ifdef BOTHER
586 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
587 termios.c_ospeed);
588#endif
589 up_write(&tty->termios_rwsem);
590 tty_set_termios(tty, &termios);
591 return 0;
592}
593#endif
594
595#ifdef TIOCGETC
596static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
597{
598 struct tchars tmp;
599
600 down_read(&tty->termios_rwsem);
601 tmp.t_intrc = tty->termios.c_cc[VINTR];
602 tmp.t_quitc = tty->termios.c_cc[VQUIT];
603 tmp.t_startc = tty->termios.c_cc[VSTART];
604 tmp.t_stopc = tty->termios.c_cc[VSTOP];
605 tmp.t_eofc = tty->termios.c_cc[VEOF];
606 tmp.t_brkc = tty->termios.c_cc[VEOL2];
607 up_read(&tty->termios_rwsem);
608 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
609}
610
611static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
612{
613 struct tchars tmp;
614
615 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
616 return -EFAULT;
617 down_write(&tty->termios_rwsem);
618 tty->termios.c_cc[VINTR] = tmp.t_intrc;
619 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
620 tty->termios.c_cc[VSTART] = tmp.t_startc;
621 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
622 tty->termios.c_cc[VEOF] = tmp.t_eofc;
623 tty->termios.c_cc[VEOL2] = tmp.t_brkc;
624 up_write(&tty->termios_rwsem);
625 return 0;
626}
627#endif
628
629#ifdef TIOCGLTC
630static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
631{
632 struct ltchars tmp;
633
634 down_read(&tty->termios_rwsem);
635 tmp.t_suspc = tty->termios.c_cc[VSUSP];
636
637 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
638 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
639
640 tmp.t_flushc = tty->termios.c_cc[VEOL2];
641 tmp.t_werasc = tty->termios.c_cc[VWERASE];
642 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
643 up_read(&tty->termios_rwsem);
644 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
645}
646
647static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
648{
649 struct ltchars tmp;
650
651 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
652 return -EFAULT;
653
654 down_write(&tty->termios_rwsem);
655 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
656
657 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
658 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
659
660 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
661 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
662 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
663 up_write(&tty->termios_rwsem);
664 return 0;
665}
666#endif
667
668
669
670
671
672
673
674
675
676
677static int tty_change_softcar(struct tty_struct *tty, int arg)
678{
679 int ret = 0;
680 int bit = arg ? CLOCAL : 0;
681 struct ktermios old;
682
683 down_write(&tty->termios_rwsem);
684 old = tty->termios;
685 tty->termios.c_cflag &= ~CLOCAL;
686 tty->termios.c_cflag |= bit;
687 if (tty->ops->set_termios)
688 tty->ops->set_termios(tty, &old);
689 if (C_CLOCAL(tty) != bit)
690 ret = -EINVAL;
691 up_write(&tty->termios_rwsem);
692 return ret;
693}
694
695
696
697
698
699
700
701
702
703
704
705
706
707int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
708 unsigned int cmd, unsigned long arg)
709{
710 struct tty_struct *real_tty;
711 void __user *p = (void __user *)arg;
712 int ret = 0;
713 struct ktermios kterm;
714
715 BUG_ON(file == NULL);
716
717 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
718 tty->driver->subtype == PTY_TYPE_MASTER)
719 real_tty = tty->link;
720 else
721 real_tty = tty;
722
723 switch (cmd) {
724#ifdef TIOCGETP
725 case TIOCGETP:
726 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
727 case TIOCSETP:
728 case TIOCSETN:
729 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
730#endif
731#ifdef TIOCGETC
732 case TIOCGETC:
733 return get_tchars(real_tty, p);
734 case TIOCSETC:
735 return set_tchars(real_tty, p);
736#endif
737#ifdef TIOCGLTC
738 case TIOCGLTC:
739 return get_ltchars(real_tty, p);
740 case TIOCSLTC:
741 return set_ltchars(real_tty, p);
742#endif
743 case TCSETSF:
744 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
745 case TCSETSW:
746 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
747 case TCSETS:
748 return set_termios(real_tty, p, TERMIOS_OLD);
749#ifndef TCGETS2
750 case TCGETS:
751 copy_termios(real_tty, &kterm);
752 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
753 ret = -EFAULT;
754 return ret;
755#else
756 case TCGETS:
757 copy_termios(real_tty, &kterm);
758 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
759 ret = -EFAULT;
760 return ret;
761 case TCGETS2:
762 copy_termios(real_tty, &kterm);
763 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
764 ret = -EFAULT;
765 return ret;
766 case TCSETSF2:
767 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
768 case TCSETSW2:
769 return set_termios(real_tty, p, TERMIOS_WAIT);
770 case TCSETS2:
771 return set_termios(real_tty, p, 0);
772#endif
773 case TCGETA:
774 return get_termio(real_tty, p);
775 case TCSETAF:
776 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
777 case TCSETAW:
778 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
779 case TCSETA:
780 return set_termios(real_tty, p, TERMIOS_TERMIO);
781#ifndef TCGETS2
782 case TIOCGLCKTRMIOS:
783 copy_termios_locked(real_tty, &kterm);
784 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
785 ret = -EFAULT;
786 return ret;
787 case TIOCSLCKTRMIOS:
788 if (!capable(CAP_SYS_ADMIN))
789 return -EPERM;
790 copy_termios_locked(real_tty, &kterm);
791 if (user_termios_to_kernel_termios(&kterm,
792 (struct termios __user *) arg))
793 return -EFAULT;
794 down_write(&real_tty->termios_rwsem);
795 real_tty->termios_locked = kterm;
796 up_write(&real_tty->termios_rwsem);
797 return 0;
798#else
799 case TIOCGLCKTRMIOS:
800 copy_termios_locked(real_tty, &kterm);
801 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
802 ret = -EFAULT;
803 return ret;
804 case TIOCSLCKTRMIOS:
805 if (!capable(CAP_SYS_ADMIN))
806 return -EPERM;
807 copy_termios_locked(real_tty, &kterm);
808 if (user_termios_to_kernel_termios_1(&kterm,
809 (struct termios __user *) arg))
810 return -EFAULT;
811 down_write(&real_tty->termios_rwsem);
812 real_tty->termios_locked = kterm;
813 up_write(&real_tty->termios_rwsem);
814 return ret;
815#endif
816#ifdef TCGETX
817 case TCGETX: {
818 struct termiox ktermx;
819 if (real_tty->termiox == NULL)
820 return -EINVAL;
821 down_read(&real_tty->termios_rwsem);
822 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
823 up_read(&real_tty->termios_rwsem);
824 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
825 ret = -EFAULT;
826 return ret;
827 }
828 case TCSETX:
829 return set_termiox(real_tty, p, 0);
830 case TCSETXW:
831 return set_termiox(real_tty, p, TERMIOS_WAIT);
832 case TCSETXF:
833 return set_termiox(real_tty, p, TERMIOS_FLUSH);
834#endif
835 case TIOCGSOFTCAR:
836 copy_termios(real_tty, &kterm);
837 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
838 (int __user *)arg);
839 return ret;
840 case TIOCSSOFTCAR:
841 if (get_user(arg, (unsigned int __user *) arg))
842 return -EFAULT;
843 return tty_change_softcar(real_tty, arg);
844 default:
845 return -ENOIOCTLCMD;
846 }
847}
848EXPORT_SYMBOL_GPL(tty_mode_ioctl);
849
850
851
852static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
853{
854 struct tty_ldisc *ld = tty->ldisc;
855
856 switch (arg) {
857 case TCIFLUSH:
858 if (ld && ld->ops->flush_buffer) {
859 ld->ops->flush_buffer(tty);
860 tty_unthrottle(tty);
861 }
862 break;
863 case TCIOFLUSH:
864 if (ld && ld->ops->flush_buffer) {
865 ld->ops->flush_buffer(tty);
866 tty_unthrottle(tty);
867 }
868
869 case TCOFLUSH:
870 tty_driver_flush_buffer(tty);
871 break;
872 default:
873 return -EINVAL;
874 }
875 return 0;
876}
877
878int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
879{
880 struct tty_ldisc *ld;
881 int retval = tty_check_change(tty);
882 if (retval)
883 return retval;
884
885 ld = tty_ldisc_ref_wait(tty);
886 retval = __tty_perform_flush(tty, arg);
887 if (ld)
888 tty_ldisc_deref(ld);
889 return retval;
890}
891EXPORT_SYMBOL_GPL(tty_perform_flush);
892
893int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
894 unsigned int cmd, unsigned long arg)
895{
896 int retval;
897
898 switch (cmd) {
899 case TCXONC:
900 retval = tty_check_change(tty);
901 if (retval)
902 return retval;
903 switch (arg) {
904 case TCOOFF:
905 spin_lock_irq(&tty->flow_lock);
906 if (!tty->flow_stopped) {
907 tty->flow_stopped = 1;
908 __stop_tty(tty);
909 }
910 spin_unlock_irq(&tty->flow_lock);
911 break;
912 case TCOON:
913 spin_lock_irq(&tty->flow_lock);
914 if (tty->flow_stopped) {
915 tty->flow_stopped = 0;
916 __start_tty(tty);
917 }
918 spin_unlock_irq(&tty->flow_lock);
919 break;
920 case TCIOFF:
921 if (STOP_CHAR(tty) != __DISABLED_CHAR)
922 retval = tty_send_xchar(tty, STOP_CHAR(tty));
923 break;
924 case TCION:
925 if (START_CHAR(tty) != __DISABLED_CHAR)
926 retval = tty_send_xchar(tty, START_CHAR(tty));
927 break;
928 default:
929 return -EINVAL;
930 }
931 return retval;
932 case TCFLSH:
933 retval = tty_check_change(tty);
934 if (retval)
935 return retval;
936 return __tty_perform_flush(tty, arg);
937 default:
938
939 return tty_mode_ioctl(tty, file, cmd, arg);
940 }
941}
942EXPORT_SYMBOL(n_tty_ioctl_helper);
943
944#ifdef CONFIG_COMPAT
945long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
946 unsigned int cmd, unsigned long arg)
947{
948 switch (cmd) {
949 case TIOCGLCKTRMIOS:
950 case TIOCSLCKTRMIOS:
951 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
952 default:
953 return -ENOIOCTLCMD;
954 }
955}
956EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
957#endif
958
959