xref: /openbmc/linux/drivers/tty/tty_ioctl.c (revision b830f94f)
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 
56 int 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 }
63 EXPORT_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 
76 int 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 }
82 EXPORT_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  */
92 void tty_driver_flush_buffer(struct tty_struct *tty)
93 {
94 	if (tty->ops->flush_buffer)
95 		tty->ops->flush_buffer(tty);
96 }
97 EXPORT_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 
109 void 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 }
119 EXPORT_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 
134 void 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 }
143 EXPORT_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 
157 int 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 
188 int 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 
218 void 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 }
236 EXPORT_SYMBOL(tty_wait_until_sent);
237 
238 
239 /*
240  *		Termios Helper Methods
241  */
242 
243 static 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 
273 void 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 }
282 EXPORT_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 
293 int 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 }
301 EXPORT_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 
314 int 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 }
347 EXPORT_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 
362 static 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 
423 static 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 
430 static 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 
437 static 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 
459 static 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  */
497 static 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 
515 static 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 
530 static 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 
567 static 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
597 static 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 
612 static 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
631 static 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 
648 static 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 
678 static 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 
708 int 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 }
849 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
850 
851 
852 /* Caller guarantees ldisc reference is held */
853 static 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 		/* fall through */
870 	case TCOFLUSH:
871 		tty_driver_flush_buffer(tty);
872 		break;
873 	default:
874 		return -EINVAL;
875 	}
876 	return 0;
877 }
878 
879 int 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 }
892 EXPORT_SYMBOL_GPL(tty_perform_flush);
893 
894 int 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 }
943 EXPORT_SYMBOL(n_tty_ioctl_helper);
944