Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tty_ioctl.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
3  *
4  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
5  * which can be dynamically activated and de-activated by the line
6  * discipline handling modules (like SLIP).
7  */
8 
9 #include <linux/types.h>
10 #include <linux/termios.h>
11 #include <linux/errno.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/major.h>
15 #include <linux/tty.h>
16 #include <linux/fcntl.h>
17 #include <linux/string.h>
18 #include <linux/mm.h>
19 #include <linux/module.h>
20 #include <linux/bitops.h>
21 #include <linux/mutex.h>
22 #include <linux/compat.h>
23 
24 #include <asm/io.h>
25 #include <asm/uaccess.h>
26 
27 #undef TTY_DEBUG_WAIT_UNTIL_SENT
28 
29 #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 
50 {
51  if (tty->ops->chars_in_buffer)
52  return tty->ops->chars_in_buffer(tty);
53  else
54  return 0;
55 }
57 
69 int 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 }
76 
86 {
87  if (tty->ops->flush_buffer)
88  tty->ops->flush_buffer(tty);
89 }
91 
102 void 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);
110 }
112 
126 void 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);
133 }
135 
147 void 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;
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 }
163 
164 
165 /*
166  * Termios Helper Methods
167  */
168 
169 static 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  */
199 static 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__
211 static const tcflag_t baud_bits[] = {
212  B0, B50, B75, B110, B134, B150, B200, B300, B600,
217 };
218 #else
219 static const tcflag_t baud_bits[] = {
220  B0, B50, B75, B110, B134, B150, B200, B300, B600,
224 };
225 #endif
226 
227 static int n_baud_table = ARRAY_SIZE(baud_table);
228 
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 }
263 
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 }
302 
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 }
400 
411 void 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 }
416 
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 }
444 
456 void 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 }
466 
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 }
485 
498 int 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) {
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  }
554  return 0;
555 }
557 
571 static 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  tmp_termios = tty->termios;
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 
632 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
633 {
634  mutex_lock(&tty->termios_mutex);
635  *kterm = tty->termios;
637 }
638 
639 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
640 {
641  mutex_lock(&tty->termios_mutex);
642  *kterm = tty->termios_locked;
644 }
645 
646 static 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 
668 static 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);
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  */
706 static 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 
724 static 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);
735 
736  return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
737 }
738 
739 static 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 
776 static 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
800  tty_set_termios(tty, &termios);
801  return 0;
802 }
803 #endif
804 
805 #ifdef TIOCGETC
806 static 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? */
818  return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
819 }
820 
821 static 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? */
835  return 0;
836 }
837 #endif
838 
839 #ifdef TIOCGLTC
840 static 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];
854  return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
855 }
856 
857 static 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;
874  return 0;
875 }
876 #endif
877 
886 static 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 
916 static 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;
931  return ret;
932 }
933 
946 int 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  real_tty->termios_locked = kterm;
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);
1048  (struct termios __user *) arg))
1049  return -EFAULT;
1050  mutex_lock(&real_tty->termios_mutex);
1051  real_tty->termios_locked = kterm;
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 }
1088 
1089 int 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:
1108  break;
1109  default:
1110  tty_ldisc_deref(ld);
1111  return -EINVAL;
1112  }
1113  tty_ldisc_deref(ld);
1114  return 0;
1115 }
1117 
1118 int 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 }
1182 
1183 #ifdef CONFIG_COMPAT
1184 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1185  unsigned int cmd, unsigned long arg)
1186 {
1187  switch (cmd) {
1188  case TIOCGLCKTRMIOS:
1189  case TIOCSLCKTRMIOS:
1190  return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1191  default:
1192  return -ENOIOCTLCMD;
1193  }
1194 }
1196 #endif
1197