xref: /openbmc/linux/drivers/tty/tty_ioctl.c (revision f531d25bda553c71696bb5fc6bf90fb28c6fae36)
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 	return 0;
61 }
62 EXPORT_SYMBOL(tty_chars_in_buffer);
63 
64 /**
65  *	tty_write_room		-	write queue space
66  *	@tty: terminal
67  *
68  *	Return the number of bytes that can be queued to this device
69  *	at the present time. The result should be treated as a guarantee
70  *	and the driver cannot offer a value it later shrinks by more than
71  *	the number of bytes written. If no method is provided 2K is always
72  *	returned and data may be lost as there will be no flow control.
73  */
74 
75 int 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 }
81 EXPORT_SYMBOL(tty_write_room);
82 
83 /**
84  *	tty_driver_flush_buffer	-	discard internal buffer
85  *	@tty: terminal
86  *
87  *	Discard the internal output buffer for this device. If no method
88  *	is provided then either the buffer cannot be hardware flushed or
89  *	there is no buffer driver side.
90  */
91 void tty_driver_flush_buffer(struct tty_struct *tty)
92 {
93 	if (tty->ops->flush_buffer)
94 		tty->ops->flush_buffer(tty);
95 }
96 EXPORT_SYMBOL(tty_driver_flush_buffer);
97 
98 /**
99  *	tty_throttle		-	flow control
100  *	@tty: terminal
101  *
102  *	Indicate that a tty should stop transmitting data down the stack.
103  *	Takes the termios rwsem to protect against parallel throttle/unthrottle
104  *	and also to ensure the driver can consistently reference its own
105  *	termios data at this point when implementing software flow control.
106  */
107 
108 void tty_throttle(struct tty_struct *tty)
109 {
110 	down_write(&tty->termios_rwsem);
111 	/* check TTY_THROTTLED first so it indicates our state */
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 }
118 EXPORT_SYMBOL(tty_throttle);
119 
120 /**
121  *	tty_unthrottle		-	flow control
122  *	@tty: terminal
123  *
124  *	Indicate that a tty may continue transmitting data down the stack.
125  *	Takes the termios rwsem to protect against parallel throttle/unthrottle
126  *	and also to ensure the driver can consistently reference its own
127  *	termios data at this point when implementing software flow control.
128  *
129  *	Drivers should however remember that the stack can issue a throttle,
130  *	then change flow control method, then unthrottle.
131  */
132 
133 void 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 }
142 EXPORT_SYMBOL(tty_unthrottle);
143 
144 /**
145  *	tty_throttle_safe	-	flow control
146  *	@tty: terminal
147  *
148  *	Similar to tty_throttle() but will only attempt throttle
149  *	if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
150  *	throttle due to race conditions when throttling is conditional
151  *	on factors evaluated prior to throttling.
152  *
153  *	Returns 0 if tty is throttled (or was already throttled)
154  */
155 
156 int 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  *	tty_unthrottle_safe	-	flow control
177  *	@tty: terminal
178  *
179  *	Similar to tty_unthrottle() but will only attempt unthrottle
180  *	if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
181  *	unthrottle due to race conditions when unthrottling is conditional
182  *	on factors evaluated prior to unthrottling.
183  *
184  *	Returns 0 if tty is unthrottled (or was already unthrottled)
185  */
186 
187 int 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  *	tty_wait_until_sent	-	wait for I/O to finish
208  *	@tty: tty we are waiting for
209  *	@timeout: how long we will wait
210  *
211  *	Wait for characters pending in a tty driver to hit the wire, or
212  *	for a timeout to occur (eg due to flow control)
213  *
214  *	Locking: none
215  */
216 
217 void 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 }
235 EXPORT_SYMBOL(tty_wait_until_sent);
236 
237 
238 /*
239  *		Termios Helper Methods
240  */
241 
242 static 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 	/* FIXME: What should we do for i/ospeed */
259 }
260 
261 /**
262  *	tty_termios_copy_hw	-	copy hardware settings
263  *	@new: New termios
264  *	@old: Old termios
265  *
266  *	Propagate the hardware specific terminal setting bits from
267  *	the old termios structure to the new one. This is used in cases
268  *	where the hardware does not support reconfiguration or as a helper
269  *	in some cases where only minimal reconfiguration is supported
270  */
271 
272 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
273 {
274 	/* The bits a dumb device handles in software. Smart devices need
275 	   to always provide a set_termios method */
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 }
281 EXPORT_SYMBOL(tty_termios_copy_hw);
282 
283 /**
284  *	tty_termios_hw_change	-	check for setting change
285  *	@a: termios
286  *	@b: termios to compare
287  *
288  *	Check if any of the bits that affect a dumb device have changed
289  *	between the two termios structures, or a speed change is needed.
290  */
291 
292 int tty_termios_hw_change(const struct ktermios *a, const 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 }
300 EXPORT_SYMBOL(tty_termios_hw_change);
301 
302 /**
303  *	tty_set_termios		-	update termios values
304  *	@tty: tty to update
305  *	@new_termios: desired new value
306  *
307  *	Perform updates to the termios values set on this terminal.
308  *	A master pty's termios should never be set.
309  *
310  *	Locking: termios_rwsem
311  */
312 
313 int 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 	 *	Perform the actual termios internal changes under lock.
322 	 */
323 
324 
325 	/* FIXME: we need to decide on some locking/ordering semantics
326 	   for the set_termios notification eventually */
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 }
346 EXPORT_SYMBOL_GPL(tty_set_termios);
347 
348 /**
349  *	set_termios		-	set termios values for a tty
350  *	@tty: terminal device
351  *	@arg: user data
352  *	@opt: option information
353  *
354  *	Helper function to prepare termios data and run necessary other
355  *	functions before using tty_set_termios to do the actual changes.
356  *
357  *	Locking:
358  *		Called functions take ldisc and termios_rwsem locks
359  */
360 
361 static 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 	/* If old style Bfoo values are used then load c_ispeed/c_ospeed
395 	 * with the real speed so its unconditionally usable */
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 	/* FIXME: Arguably if tmp_termios == tty->termios AND the
416 	   actual requested termios was not tmp_termios then we may
417 	   want to return an error as no user requested change has
418 	   succeeded */
419 	return 0;
420 }
421 
422 static 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 
429 static 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 
436 static 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 #ifdef TIOCGETP
446 /*
447  * These are deprecated, but there is limited support..
448  *
449  * The "sg_flags" translation is a joke..
450  */
451 static int get_sgflags(struct tty_struct *tty)
452 {
453 	int flags = 0;
454 
455 	if (!L_ICANON(tty)) {
456 		if (L_ISIG(tty))
457 			flags |= 0x02;		/* cbreak */
458 		else
459 			flags |= 0x20;		/* raw */
460 	}
461 	if (L_ECHO(tty))
462 		flags |= 0x08;			/* echo */
463 	if (O_OPOST(tty))
464 		if (O_ONLCR(tty))
465 			flags |= 0x10;		/* crmod */
466 	return flags;
467 }
468 
469 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
470 {
471 	struct sgttyb tmp;
472 
473 	down_read(&tty->termios_rwsem);
474 	tmp.sg_ispeed = tty->termios.c_ispeed;
475 	tmp.sg_ospeed = tty->termios.c_ospeed;
476 	tmp.sg_erase = tty->termios.c_cc[VERASE];
477 	tmp.sg_kill = tty->termios.c_cc[VKILL];
478 	tmp.sg_flags = get_sgflags(tty);
479 	up_read(&tty->termios_rwsem);
480 
481 	return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
482 }
483 
484 static void set_sgflags(struct ktermios *termios, int flags)
485 {
486 	termios->c_iflag = ICRNL | IXON;
487 	termios->c_oflag = 0;
488 	termios->c_lflag = ISIG | ICANON;
489 	if (flags & 0x02) {	/* cbreak */
490 		termios->c_iflag = 0;
491 		termios->c_lflag &= ~ICANON;
492 	}
493 	if (flags & 0x08) {		/* echo */
494 		termios->c_lflag |= ECHO | ECHOE | ECHOK |
495 				    ECHOCTL | ECHOKE | IEXTEN;
496 	}
497 	if (flags & 0x10) {		/* crmod */
498 		termios->c_oflag |= OPOST | ONLCR;
499 	}
500 	if (flags & 0x20) {	/* raw */
501 		termios->c_iflag = 0;
502 		termios->c_lflag &= ~(ISIG | ICANON);
503 	}
504 	if (!(termios->c_lflag & ICANON)) {
505 		termios->c_cc[VMIN] = 1;
506 		termios->c_cc[VTIME] = 0;
507 	}
508 }
509 
510 /**
511  *	set_sgttyb		-	set legacy terminal values
512  *	@tty: tty structure
513  *	@sgttyb: pointer to old style terminal structure
514  *
515  *	Updates a terminal from the legacy BSD style terminal information
516  *	structure.
517  *
518  *	Locking: termios_rwsem
519  */
520 
521 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
522 {
523 	int retval;
524 	struct sgttyb tmp;
525 	struct ktermios termios;
526 
527 	retval = tty_check_change(tty);
528 	if (retval)
529 		return retval;
530 
531 	if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
532 		return -EFAULT;
533 
534 	down_write(&tty->termios_rwsem);
535 	termios = tty->termios;
536 	termios.c_cc[VERASE] = tmp.sg_erase;
537 	termios.c_cc[VKILL] = tmp.sg_kill;
538 	set_sgflags(&termios, tmp.sg_flags);
539 	/* Try and encode into Bfoo format */
540 #ifdef BOTHER
541 	tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
542 						termios.c_ospeed);
543 #endif
544 	up_write(&tty->termios_rwsem);
545 	tty_set_termios(tty, &termios);
546 	return 0;
547 }
548 #endif
549 
550 #ifdef TIOCGETC
551 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
552 {
553 	struct tchars tmp;
554 
555 	down_read(&tty->termios_rwsem);
556 	tmp.t_intrc = tty->termios.c_cc[VINTR];
557 	tmp.t_quitc = tty->termios.c_cc[VQUIT];
558 	tmp.t_startc = tty->termios.c_cc[VSTART];
559 	tmp.t_stopc = tty->termios.c_cc[VSTOP];
560 	tmp.t_eofc = tty->termios.c_cc[VEOF];
561 	tmp.t_brkc = tty->termios.c_cc[VEOL2];	/* what is brkc anyway? */
562 	up_read(&tty->termios_rwsem);
563 	return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
564 }
565 
566 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
567 {
568 	struct tchars tmp;
569 
570 	if (copy_from_user(&tmp, tchars, sizeof(tmp)))
571 		return -EFAULT;
572 	down_write(&tty->termios_rwsem);
573 	tty->termios.c_cc[VINTR] = tmp.t_intrc;
574 	tty->termios.c_cc[VQUIT] = tmp.t_quitc;
575 	tty->termios.c_cc[VSTART] = tmp.t_startc;
576 	tty->termios.c_cc[VSTOP] = tmp.t_stopc;
577 	tty->termios.c_cc[VEOF] = tmp.t_eofc;
578 	tty->termios.c_cc[VEOL2] = tmp.t_brkc;	/* what is brkc anyway? */
579 	up_write(&tty->termios_rwsem);
580 	return 0;
581 }
582 #endif
583 
584 #ifdef TIOCGLTC
585 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
586 {
587 	struct ltchars tmp;
588 
589 	down_read(&tty->termios_rwsem);
590 	tmp.t_suspc = tty->termios.c_cc[VSUSP];
591 	/* what is dsuspc anyway? */
592 	tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
593 	tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
594 	/* what is flushc anyway? */
595 	tmp.t_flushc = tty->termios.c_cc[VEOL2];
596 	tmp.t_werasc = tty->termios.c_cc[VWERASE];
597 	tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
598 	up_read(&tty->termios_rwsem);
599 	return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
600 }
601 
602 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
603 {
604 	struct ltchars tmp;
605 
606 	if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
607 		return -EFAULT;
608 
609 	down_write(&tty->termios_rwsem);
610 	tty->termios.c_cc[VSUSP] = tmp.t_suspc;
611 	/* what is dsuspc anyway? */
612 	tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
613 	tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
614 	/* what is flushc anyway? */
615 	tty->termios.c_cc[VEOL2] = tmp.t_flushc;
616 	tty->termios.c_cc[VWERASE] = tmp.t_werasc;
617 	tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
618 	up_write(&tty->termios_rwsem);
619 	return 0;
620 }
621 #endif
622 
623 /**
624  *	tty_change_softcar	-	carrier change ioctl helper
625  *	@tty: tty to update
626  *	@arg: enable/disable CLOCAL
627  *
628  *	Perform a change to the CLOCAL state and call into the driver
629  *	layer to make it visible. All done with the termios rwsem
630  */
631 
632 static int tty_change_softcar(struct tty_struct *tty, int arg)
633 {
634 	int ret = 0;
635 	int bit = arg ? CLOCAL : 0;
636 	struct ktermios old;
637 
638 	down_write(&tty->termios_rwsem);
639 	old = tty->termios;
640 	tty->termios.c_cflag &= ~CLOCAL;
641 	tty->termios.c_cflag |= bit;
642 	if (tty->ops->set_termios)
643 		tty->ops->set_termios(tty, &old);
644 	if (C_CLOCAL(tty) != bit)
645 		ret = -EINVAL;
646 	up_write(&tty->termios_rwsem);
647 	return ret;
648 }
649 
650 /**
651  *	tty_mode_ioctl		-	mode related ioctls
652  *	@tty: tty for the ioctl
653  *	@file: file pointer for the tty
654  *	@cmd: command
655  *	@arg: ioctl argument
656  *
657  *	Perform non line discipline specific mode control ioctls. This
658  *	is designed to be called by line disciplines to ensure they provide
659  *	consistent mode setting.
660  */
661 
662 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
663 			unsigned int cmd, unsigned long arg)
664 {
665 	struct tty_struct *real_tty;
666 	void __user *p = (void __user *)arg;
667 	int ret = 0;
668 	struct ktermios kterm;
669 
670 	BUG_ON(file == NULL);
671 
672 	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
673 	    tty->driver->subtype == PTY_TYPE_MASTER)
674 		real_tty = tty->link;
675 	else
676 		real_tty = tty;
677 
678 	switch (cmd) {
679 #ifdef TIOCGETP
680 	case TIOCGETP:
681 		return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
682 	case TIOCSETP:
683 	case TIOCSETN:
684 		return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
685 #endif
686 #ifdef TIOCGETC
687 	case TIOCGETC:
688 		return get_tchars(real_tty, p);
689 	case TIOCSETC:
690 		return set_tchars(real_tty, p);
691 #endif
692 #ifdef TIOCGLTC
693 	case TIOCGLTC:
694 		return get_ltchars(real_tty, p);
695 	case TIOCSLTC:
696 		return set_ltchars(real_tty, p);
697 #endif
698 	case TCSETSF:
699 		return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
700 	case TCSETSW:
701 		return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
702 	case TCSETS:
703 		return set_termios(real_tty, p, TERMIOS_OLD);
704 #ifndef TCGETS2
705 	case TCGETS:
706 		copy_termios(real_tty, &kterm);
707 		if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
708 			ret = -EFAULT;
709 		return ret;
710 #else
711 	case TCGETS:
712 		copy_termios(real_tty, &kterm);
713 		if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
714 			ret = -EFAULT;
715 		return ret;
716 	case TCGETS2:
717 		copy_termios(real_tty, &kterm);
718 		if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
719 			ret = -EFAULT;
720 		return ret;
721 	case TCSETSF2:
722 		return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
723 	case TCSETSW2:
724 		return set_termios(real_tty, p, TERMIOS_WAIT);
725 	case TCSETS2:
726 		return set_termios(real_tty, p, 0);
727 #endif
728 	case TCGETA:
729 		return get_termio(real_tty, p);
730 	case TCSETAF:
731 		return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
732 	case TCSETAW:
733 		return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
734 	case TCSETA:
735 		return set_termios(real_tty, p, TERMIOS_TERMIO);
736 #ifndef TCGETS2
737 	case TIOCGLCKTRMIOS:
738 		copy_termios_locked(real_tty, &kterm);
739 		if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
740 			ret = -EFAULT;
741 		return ret;
742 	case TIOCSLCKTRMIOS:
743 		if (!capable(CAP_SYS_ADMIN))
744 			return -EPERM;
745 		copy_termios_locked(real_tty, &kterm);
746 		if (user_termios_to_kernel_termios(&kterm,
747 					       (struct termios __user *) arg))
748 			return -EFAULT;
749 		down_write(&real_tty->termios_rwsem);
750 		real_tty->termios_locked = kterm;
751 		up_write(&real_tty->termios_rwsem);
752 		return 0;
753 #else
754 	case TIOCGLCKTRMIOS:
755 		copy_termios_locked(real_tty, &kterm);
756 		if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
757 			ret = -EFAULT;
758 		return ret;
759 	case TIOCSLCKTRMIOS:
760 		if (!capable(CAP_SYS_ADMIN))
761 			return -EPERM;
762 		copy_termios_locked(real_tty, &kterm);
763 		if (user_termios_to_kernel_termios_1(&kterm,
764 					       (struct termios __user *) arg))
765 			return -EFAULT;
766 		down_write(&real_tty->termios_rwsem);
767 		real_tty->termios_locked = kterm;
768 		up_write(&real_tty->termios_rwsem);
769 		return ret;
770 #endif
771 #ifdef TCGETX
772 	case TCGETX:
773 	case TCSETX:
774 	case TCSETXW:
775 	case TCSETXF:
776 		return -EINVAL;
777 #endif
778 	case TIOCGSOFTCAR:
779 		copy_termios(real_tty, &kterm);
780 		ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
781 						(int __user *)arg);
782 		return ret;
783 	case TIOCSSOFTCAR:
784 		if (get_user(arg, (unsigned int __user *) arg))
785 			return -EFAULT;
786 		return tty_change_softcar(real_tty, arg);
787 	default:
788 		return -ENOIOCTLCMD;
789 	}
790 }
791 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
792 
793 
794 /* Caller guarantees ldisc reference is held */
795 static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
796 {
797 	struct tty_ldisc *ld = tty->ldisc;
798 
799 	switch (arg) {
800 	case TCIFLUSH:
801 		if (ld && ld->ops->flush_buffer) {
802 			ld->ops->flush_buffer(tty);
803 			tty_unthrottle(tty);
804 		}
805 		break;
806 	case TCIOFLUSH:
807 		if (ld && ld->ops->flush_buffer) {
808 			ld->ops->flush_buffer(tty);
809 			tty_unthrottle(tty);
810 		}
811 		fallthrough;
812 	case TCOFLUSH:
813 		tty_driver_flush_buffer(tty);
814 		break;
815 	default:
816 		return -EINVAL;
817 	}
818 	return 0;
819 }
820 
821 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
822 {
823 	struct tty_ldisc *ld;
824 	int retval = tty_check_change(tty);
825 	if (retval)
826 		return retval;
827 
828 	ld = tty_ldisc_ref_wait(tty);
829 	retval = __tty_perform_flush(tty, arg);
830 	if (ld)
831 		tty_ldisc_deref(ld);
832 	return retval;
833 }
834 EXPORT_SYMBOL_GPL(tty_perform_flush);
835 
836 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
837 		       unsigned int cmd, unsigned long arg)
838 {
839 	int retval;
840 
841 	switch (cmd) {
842 	case TCXONC:
843 		retval = tty_check_change(tty);
844 		if (retval)
845 			return retval;
846 		switch (arg) {
847 		case TCOOFF:
848 			spin_lock_irq(&tty->flow_lock);
849 			if (!tty->flow_stopped) {
850 				tty->flow_stopped = 1;
851 				__stop_tty(tty);
852 			}
853 			spin_unlock_irq(&tty->flow_lock);
854 			break;
855 		case TCOON:
856 			spin_lock_irq(&tty->flow_lock);
857 			if (tty->flow_stopped) {
858 				tty->flow_stopped = 0;
859 				__start_tty(tty);
860 			}
861 			spin_unlock_irq(&tty->flow_lock);
862 			break;
863 		case TCIOFF:
864 			if (STOP_CHAR(tty) != __DISABLED_CHAR)
865 				retval = tty_send_xchar(tty, STOP_CHAR(tty));
866 			break;
867 		case TCION:
868 			if (START_CHAR(tty) != __DISABLED_CHAR)
869 				retval = tty_send_xchar(tty, START_CHAR(tty));
870 			break;
871 		default:
872 			return -EINVAL;
873 		}
874 		return retval;
875 	case TCFLSH:
876 		retval = tty_check_change(tty);
877 		if (retval)
878 			return retval;
879 		return __tty_perform_flush(tty, arg);
880 	default:
881 		/* Try the mode commands */
882 		return tty_mode_ioctl(tty, file, cmd, arg);
883 	}
884 }
885 EXPORT_SYMBOL(n_tty_ioctl_helper);
886