2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
|
|
|
|
* which can be dynamically activated and de-activated by the line
|
|
|
|
* discipline handling modules (like SLIP).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/termios.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-09-29 03:00:43 -06:00
|
|
|
#include <linux/mutex.h>
|
2011-10-05 15:13:13 -06:00
|
|
|
#include <linux/compat.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#undef TTY_DEBUG_WAIT_UNTIL_SENT
|
|
|
|
|
2015-07-12 20:49:11 -06:00
|
|
|
#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
|
|
|
|
# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
|
|
|
|
#else
|
|
|
|
# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#undef DEBUG
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal flag options for termios setting behavior
|
|
|
|
*/
|
|
|
|
#define TERMIOS_FLUSH 1
|
|
|
|
#define TERMIOS_WAIT 2
|
|
|
|
#define TERMIOS_TERMIO 4
|
2006-12-08 03:38:44 -07:00
|
|
|
#define TERMIOS_OLD 8
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-27 02:24:01 -06:00
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_chars_in_buffer - characters pending
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Return the number of bytes of data in the device private
|
|
|
|
* output queue. If no private method is supplied there is assumed
|
|
|
|
* to be no queue on the device.
|
|
|
|
*/
|
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
int tty_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (tty->ops->chars_in_buffer)
|
|
|
|
return tty->ops->chars_in_buffer(tty);
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_chars_in_buffer);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_write_room - write queue space
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Return the number of bytes that can be queued to this device
|
|
|
|
* at the present time. The result should be treated as a guarantee
|
|
|
|
* and the driver cannot offer a value it later shrinks by more than
|
|
|
|
* the number of bytes written. If no method is provided 2K is always
|
|
|
|
* returned and data may be lost as there will be no flow control.
|
|
|
|
*/
|
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
int tty_write_room(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (tty->ops->write_room)
|
|
|
|
return tty->ops->write_room(tty);
|
|
|
|
return 2048;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_write_room);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_driver_flush_buffer - discard internal buffer
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Discard the internal output buffer for this device. If no method
|
|
|
|
* is provided then either the buffer cannot be hardware flushed or
|
|
|
|
* there is no buffer driver side.
|
|
|
|
*/
|
2008-04-30 01:54:13 -06:00
|
|
|
void tty_driver_flush_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (tty->ops->flush_buffer)
|
|
|
|
tty->ops->flush_buffer(tty);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_driver_flush_buffer);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_throttle - flow control
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Indicate that a tty should stop transmitting data down the stack.
|
2013-06-15 07:14:23 -06:00
|
|
|
* Takes the termios rwsem to protect against parallel throttle/unthrottle
|
2009-06-11 05:44:17 -06:00
|
|
|
* and also to ensure the driver can consistently reference its own
|
|
|
|
* termios data at this point when implementing software flow control.
|
2008-10-13 03:41:42 -06:00
|
|
|
*/
|
|
|
|
|
2008-04-30 01:54:18 -06:00
|
|
|
void tty_throttle(struct tty_struct *tty)
|
|
|
|
{
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2008-04-30 01:54:18 -06:00
|
|
|
/* check TTY_THROTTLED first so it indicates our state */
|
|
|
|
if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
|
|
|
|
tty->ops->throttle)
|
|
|
|
tty->ops->throttle(tty);
|
2013-03-06 06:20:52 -07:00
|
|
|
tty->flow_change = 0;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2008-04-30 01:54:18 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_throttle);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_unthrottle - flow control
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Indicate that a tty may continue transmitting data down the stack.
|
2013-06-15 07:14:23 -06:00
|
|
|
* Takes the termios rwsem to protect against parallel throttle/unthrottle
|
2009-06-11 05:44:17 -06:00
|
|
|
* and also to ensure the driver can consistently reference its own
|
|
|
|
* termios data at this point when implementing software flow control.
|
|
|
|
*
|
|
|
|
* Drivers should however remember that the stack can issue a throttle,
|
|
|
|
* then change flow control method, then unthrottle.
|
2008-10-13 03:41:42 -06:00
|
|
|
*/
|
|
|
|
|
2008-04-30 01:54:18 -06:00
|
|
|
void tty_unthrottle(struct tty_struct *tty)
|
|
|
|
{
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2008-04-30 01:54:18 -06:00
|
|
|
if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
|
|
|
|
tty->ops->unthrottle)
|
|
|
|
tty->ops->unthrottle(tty);
|
2013-03-06 06:20:52 -07:00
|
|
|
tty->flow_change = 0;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2008-04-30 01:54:18 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_unthrottle);
|
2008-04-30 01:54:13 -06:00
|
|
|
|
2013-03-06 06:20:52 -07:00
|
|
|
/**
|
|
|
|
* tty_throttle_safe - flow control
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Similar to tty_throttle() but will only attempt throttle
|
|
|
|
* if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
|
|
|
|
* throttle due to race conditions when throttling is conditional
|
|
|
|
* on factors evaluated prior to throttling.
|
|
|
|
*
|
|
|
|
* Returns 0 if tty is throttled (or was already throttled)
|
|
|
|
*/
|
|
|
|
|
|
|
|
int tty_throttle_safe(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2013-06-15 07:14:31 -06:00
|
|
|
mutex_lock(&tty->throttle_mutex);
|
2016-04-09 18:11:36 -06:00
|
|
|
if (!tty_throttled(tty)) {
|
2013-03-06 06:20:52 -07:00
|
|
|
if (tty->flow_change != TTY_THROTTLE_SAFE)
|
|
|
|
ret = 1;
|
|
|
|
else {
|
2013-04-15 09:06:06 -06:00
|
|
|
set_bit(TTY_THROTTLED, &tty->flags);
|
2013-03-06 06:20:52 -07:00
|
|
|
if (tty->ops->throttle)
|
|
|
|
tty->ops->throttle(tty);
|
|
|
|
}
|
|
|
|
}
|
2013-06-15 07:14:31 -06:00
|
|
|
mutex_unlock(&tty->throttle_mutex);
|
2013-03-06 06:20:52 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_unthrottle_safe - flow control
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Similar to tty_unthrottle() but will only attempt unthrottle
|
|
|
|
* if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
|
|
|
|
* unthrottle due to race conditions when unthrottling is conditional
|
|
|
|
* on factors evaluated prior to unthrottling.
|
|
|
|
*
|
|
|
|
* Returns 0 if tty is unthrottled (or was already unthrottled)
|
|
|
|
*/
|
|
|
|
|
|
|
|
int tty_unthrottle_safe(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2013-06-15 07:14:31 -06:00
|
|
|
mutex_lock(&tty->throttle_mutex);
|
2016-04-09 18:11:36 -06:00
|
|
|
if (tty_throttled(tty)) {
|
2013-03-06 06:20:52 -07:00
|
|
|
if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
|
|
|
|
ret = 1;
|
|
|
|
else {
|
2013-04-15 09:06:06 -06:00
|
|
|
clear_bit(TTY_THROTTLED, &tty->flags);
|
2013-03-06 06:20:52 -07:00
|
|
|
if (tty->ops->unthrottle)
|
|
|
|
tty->ops->unthrottle(tty);
|
|
|
|
}
|
|
|
|
}
|
2013-06-15 07:14:31 -06:00
|
|
|
mutex_unlock(&tty->throttle_mutex);
|
2013-03-06 06:20:52 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-08-27 02:24:01 -06:00
|
|
|
/**
|
|
|
|
* tty_wait_until_sent - wait for I/O to finish
|
|
|
|
* @tty: tty we are waiting for
|
|
|
|
* @timeout: how long we will wait
|
|
|
|
*
|
|
|
|
* Wait for characters pending in a tty driver to hit the wire, or
|
|
|
|
* for a timeout to occur (eg due to flow control)
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
void tty_wait_until_sent(struct tty_struct *tty, long timeout)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-11-08 11:01:19 -07:00
|
|
|
tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
|
2015-07-12 20:49:11 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!timeout)
|
|
|
|
timeout = MAX_SCHEDULE_TIMEOUT;
|
2015-03-04 02:39:06 -07:00
|
|
|
|
2015-03-04 02:39:07 -07:00
|
|
|
timeout = wait_event_interruptible_timeout(tty->write_wait,
|
|
|
|
!tty_chars_in_buffer(tty), timeout);
|
|
|
|
if (timeout <= 0)
|
2015-03-04 02:39:06 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (timeout == MAX_SCHEDULE_TIMEOUT)
|
|
|
|
timeout = 0;
|
|
|
|
|
|
|
|
if (tty->ops->wait_until_sent)
|
|
|
|
tty->ops->wait_until_sent(tty, timeout);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_wait_until_sent);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Termios Helper Methods
|
|
|
|
*/
|
|
|
|
|
2015-11-08 11:01:16 -07:00
|
|
|
static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-11-08 11:01:16 -07:00
|
|
|
struct ktermios *termios = &tty->termios;
|
|
|
|
struct ktermios *locked = &tty->termios_locked;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
2008-02-08 05:18:48 -07:00
|
|
|
|
|
|
|
#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
|
|
|
|
NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
|
|
|
|
NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
|
|
|
|
NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
|
|
|
|
termios->c_line = locked->c_line ? old->c_line : termios->c_line;
|
2008-02-08 05:18:48 -07:00
|
|
|
for (i = 0; i < NCCS; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
termios->c_cc[i] = locked->c_cc[i] ?
|
|
|
|
old->c_cc[i] : termios->c_cc[i];
|
2006-12-08 03:38:44 -07:00
|
|
|
/* FIXME: What should we do for i/ospeed */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-12-08 03:38:44 -07:00
|
|
|
/*
|
|
|
|
* Routine which returns the baud rate of the tty
|
|
|
|
*
|
|
|
|
* Note that the baud_table needs to be kept in sync with the
|
|
|
|
* include/asm/termbits.h file.
|
|
|
|
*/
|
|
|
|
static const speed_t baud_table[] = {
|
|
|
|
0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
|
|
|
|
9600, 19200, 38400, 57600, 115200, 230400, 460800,
|
|
|
|
#ifdef __sparc__
|
|
|
|
76800, 153600, 307200, 614400, 921600
|
|
|
|
#else
|
|
|
|
500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
|
|
|
|
2500000, 3000000, 3500000, 4000000
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifndef __sparc__
|
|
|
|
static const tcflag_t baud_bits[] = {
|
|
|
|
B0, B50, B75, B110, B134, B150, B200, B300, B600,
|
|
|
|
B1200, B1800, B2400, B4800, B9600, B19200, B38400,
|
|
|
|
B57600, B115200, B230400, B460800, B500000, B576000,
|
|
|
|
B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
|
|
|
|
B3000000, B3500000, B4000000
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
static const tcflag_t baud_bits[] = {
|
|
|
|
B0, B50, B75, B110, B134, B150, B200, B300, B600,
|
|
|
|
B1200, B1800, B2400, B4800, B9600, B19200, B38400,
|
|
|
|
B57600, B115200, B230400, B460800, B76800, B153600,
|
|
|
|
B307200, B614400, B921600
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int n_baud_table = ARRAY_SIZE(baud_table);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_termios_baud_rate
|
|
|
|
* @termios: termios structure
|
|
|
|
*
|
|
|
|
* Convert termios baud rate data into a speed. This should be called
|
|
|
|
* with the termios lock held if this termios is a terminal termios
|
|
|
|
* structure. May change the termios data. Device drivers can call this
|
|
|
|
* function but should use ->c_[io]speed directly as they are updated.
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
|
|
|
speed_t tty_termios_baud_rate(struct ktermios *termios)
|
|
|
|
{
|
|
|
|
unsigned int cbaud;
|
|
|
|
|
|
|
|
cbaud = termios->c_cflag & CBAUD;
|
|
|
|
|
|
|
|
#ifdef BOTHER
|
2011-03-30 19:57:33 -06:00
|
|
|
/* Magic token for arbitrary speed via c_ispeed/c_ospeed */
|
2006-12-08 03:38:44 -07:00
|
|
|
if (cbaud == BOTHER)
|
|
|
|
return termios->c_ospeed;
|
|
|
|
#endif
|
|
|
|
if (cbaud & CBAUDEX) {
|
|
|
|
cbaud &= ~CBAUDEX;
|
|
|
|
|
|
|
|
if (cbaud < 1 || cbaud + 15 > n_baud_table)
|
|
|
|
termios->c_cflag &= ~CBAUDEX;
|
|
|
|
else
|
|
|
|
cbaud += 15;
|
|
|
|
}
|
|
|
|
return baud_table[cbaud];
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_termios_baud_rate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_termios_input_baud_rate
|
|
|
|
* @termios: termios structure
|
|
|
|
*
|
|
|
|
* Convert termios baud rate data into a speed. This should be called
|
|
|
|
* with the termios lock held if this termios is a terminal termios
|
|
|
|
* structure. May change the termios data. Device drivers can call this
|
|
|
|
* function but should use ->c_[io]speed directly as they are updated.
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
|
|
|
speed_t tty_termios_input_baud_rate(struct ktermios *termios)
|
|
|
|
{
|
|
|
|
#ifdef IBSHIFT
|
|
|
|
unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
|
|
|
|
|
|
|
|
if (cbaud == B0)
|
|
|
|
return tty_termios_baud_rate(termios);
|
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* Magic token for arbitrary speed via c_ispeed*/
|
2006-12-08 03:38:44 -07:00
|
|
|
if (cbaud == BOTHER)
|
|
|
|
return termios->c_ispeed;
|
|
|
|
|
|
|
|
if (cbaud & CBAUDEX) {
|
|
|
|
cbaud &= ~CBAUDEX;
|
|
|
|
|
|
|
|
if (cbaud < 1 || cbaud + 15 > n_baud_table)
|
|
|
|
termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
|
|
|
|
else
|
|
|
|
cbaud += 15;
|
|
|
|
}
|
|
|
|
return baud_table[cbaud];
|
|
|
|
#else
|
|
|
|
return tty_termios_baud_rate(termios);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_termios_input_baud_rate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_termios_encode_baud_rate
|
2007-02-10 02:45:57 -07:00
|
|
|
* @termios: ktermios structure holding user requested state
|
2006-12-08 03:38:44 -07:00
|
|
|
* @ispeed: input speed
|
|
|
|
* @ospeed: output speed
|
|
|
|
*
|
|
|
|
* Encode the speeds set into the passed termios structure. This is
|
2011-04-12 01:59:29 -06:00
|
|
|
* used as a library helper for drivers so that they can report back
|
2006-12-08 03:38:44 -07:00
|
|
|
* the actual speed selected when it differs from the speed requested
|
|
|
|
*
|
2007-02-10 02:45:57 -07:00
|
|
|
* For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
|
|
|
|
* we need to carefully set the bits when the user does not get the
|
|
|
|
* desired speed. We allow small margins and preserve as much of possible
|
2009-09-28 19:43:57 -06:00
|
|
|
* of the input intent to keep compatibility.
|
2006-12-08 03:38:44 -07:00
|
|
|
*
|
|
|
|
* Locking: Caller should hold termios lock. This is already held
|
|
|
|
* when calling this function from the driver termios handler.
|
2007-10-17 00:30:07 -06:00
|
|
|
*
|
|
|
|
* The ifdefs deal with platforms whose owners have yet to update them
|
|
|
|
* and will all go away once this is done.
|
2006-12-08 03:38:44 -07:00
|
|
|
*/
|
|
|
|
|
2007-10-18 04:04:35 -06:00
|
|
|
void tty_termios_encode_baud_rate(struct ktermios *termios,
|
|
|
|
speed_t ibaud, speed_t obaud)
|
2006-12-08 03:38:44 -07:00
|
|
|
{
|
|
|
|
int i = 0;
|
2007-02-10 02:45:57 -07:00
|
|
|
int ifound = -1, ofound = -1;
|
|
|
|
int iclose = ibaud/50, oclose = obaud/50;
|
|
|
|
int ibinput = 0;
|
2006-12-08 03:38:44 -07:00
|
|
|
|
2007-10-17 00:30:07 -06:00
|
|
|
if (obaud == 0) /* CD dropped */
|
|
|
|
ibaud = 0; /* Clear ibaud to be sure */
|
|
|
|
|
2006-12-08 03:38:44 -07:00
|
|
|
termios->c_ispeed = ibaud;
|
|
|
|
termios->c_ospeed = obaud;
|
|
|
|
|
2007-10-17 00:30:07 -06:00
|
|
|
#ifdef BOTHER
|
2007-02-10 02:45:57 -07:00
|
|
|
/* If the user asked for a precise weird speed give a precise weird
|
2014-08-08 05:01:21 -06:00
|
|
|
answer. If they asked for a Bfoo speed they may have problems
|
2007-02-10 02:45:57 -07:00
|
|
|
digesting non-exact replies so fuzz a bit */
|
|
|
|
|
|
|
|
if ((termios->c_cflag & CBAUD) == BOTHER)
|
|
|
|
oclose = 0;
|
|
|
|
if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
|
|
|
|
iclose = 0;
|
|
|
|
if ((termios->c_cflag >> IBSHIFT) & CBAUD)
|
|
|
|
ibinput = 1; /* An input speed was specified */
|
2007-10-17 00:30:07 -06:00
|
|
|
#endif
|
2006-12-08 03:38:44 -07:00
|
|
|
termios->c_cflag &= ~CBAUD;
|
|
|
|
|
2007-10-17 00:30:07 -06:00
|
|
|
/*
|
|
|
|
* Our goal is to find a close match to the standard baud rate
|
|
|
|
* returned. Walk the baud rate table and if we get a very close
|
|
|
|
* match then report back the speed as a POSIX Bxxxx value by
|
|
|
|
* preference
|
|
|
|
*/
|
|
|
|
|
2006-12-08 03:38:44 -07:00
|
|
|
do {
|
2007-10-18 04:04:35 -06:00
|
|
|
if (obaud - oclose <= baud_table[i] &&
|
|
|
|
obaud + oclose >= baud_table[i]) {
|
2006-12-08 03:38:44 -07:00
|
|
|
termios->c_cflag |= baud_bits[i];
|
2007-02-10 02:45:57 -07:00
|
|
|
ofound = i;
|
2006-12-08 03:38:44 -07:00
|
|
|
}
|
2007-10-18 04:04:35 -06:00
|
|
|
if (ibaud - iclose <= baud_table[i] &&
|
|
|
|
ibaud + iclose >= baud_table[i]) {
|
|
|
|
/* For the case input == output don't set IBAUD bits
|
|
|
|
if the user didn't do so */
|
2007-10-17 00:30:07 -06:00
|
|
|
if (ofound == i && !ibinput)
|
|
|
|
ifound = i;
|
|
|
|
#ifdef IBSHIFT
|
|
|
|
else {
|
|
|
|
ifound = i;
|
2007-02-10 02:45:57 -07:00
|
|
|
termios->c_cflag |= (baud_bits[i] << IBSHIFT);
|
2007-10-17 00:30:07 -06:00
|
|
|
}
|
|
|
|
#endif
|
2006-12-08 03:38:44 -07:00
|
|
|
}
|
2007-07-16 00:40:18 -06:00
|
|
|
} while (++i < n_baud_table);
|
2007-10-17 00:30:07 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we found no match then use BOTHER if provided or warn
|
|
|
|
* the user their platform maintainer needs to wake up if not.
|
|
|
|
*/
|
|
|
|
#ifdef BOTHER
|
2007-02-10 02:45:57 -07:00
|
|
|
if (ofound == -1)
|
2006-12-08 03:38:44 -07:00
|
|
|
termios->c_cflag |= BOTHER;
|
2007-02-10 02:45:57 -07:00
|
|
|
/* Set exact input bits only if the input and output differ or the
|
|
|
|
user already did */
|
2007-07-16 00:40:18 -06:00
|
|
|
if (ifound == -1 && (ibaud != obaud || ibinput))
|
2006-12-08 03:38:44 -07:00
|
|
|
termios->c_cflag |= (BOTHER << IBSHIFT);
|
2007-10-17 00:30:07 -06:00
|
|
|
#else
|
2015-11-08 11:01:18 -07:00
|
|
|
if (ifound == -1 || ofound == -1)
|
|
|
|
pr_warn_once("tty: Unable to return correct speed data as your architecture needs updating.\n");
|
2007-10-17 00:30:07 -06:00
|
|
|
#endif
|
2006-12-08 03:38:44 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
|
|
|
|
|
2008-10-13 03:41:42 -06:00
|
|
|
/**
|
|
|
|
* tty_encode_baud_rate - set baud rate of the tty
|
|
|
|
* @ibaud: input baud rate
|
|
|
|
* @obad: output baud rate
|
|
|
|
*
|
|
|
|
* Update the current termios data for the tty with the new speed
|
2013-06-15 07:14:23 -06:00
|
|
|
* settings. The caller must hold the termios_rwsem for the tty in
|
2008-10-13 03:41:42 -06:00
|
|
|
* question.
|
|
|
|
*/
|
|
|
|
|
2007-10-17 00:30:07 -06:00
|
|
|
void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
|
|
|
|
{
|
2012-07-14 08:31:47 -06:00
|
|
|
tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
|
2007-10-17 00:30:07 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
|
2006-12-08 03:38:44 -07:00
|
|
|
|
2007-10-17 00:30:07 -06:00
|
|
|
/**
|
|
|
|
* tty_termios_copy_hw - copy hardware settings
|
|
|
|
* @new: New termios
|
|
|
|
* @old: Old termios
|
|
|
|
*
|
2011-03-30 19:57:33 -06:00
|
|
|
* Propagate the hardware specific terminal setting bits from
|
2007-10-17 00:30:07 -06:00
|
|
|
* the old termios structure to the new one. This is used in cases
|
|
|
|
* where the hardware does not support reconfiguration or as a helper
|
|
|
|
* in some cases where only minimal reconfiguration is supported
|
|
|
|
*/
|
|
|
|
|
|
|
|
void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
|
|
|
|
{
|
|
|
|
/* The bits a dumb device handles in software. Smart devices need
|
|
|
|
to always provide a set_termios method */
|
|
|
|
new->c_cflag &= HUPCL | CREAD | CLOCAL;
|
|
|
|
new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
|
|
|
|
new->c_ispeed = old->c_ispeed;
|
|
|
|
new->c_ospeed = old->c_ospeed;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_termios_copy_hw);
|
|
|
|
|
2008-01-08 07:55:51 -07:00
|
|
|
/**
|
|
|
|
* tty_termios_hw_change - check for setting change
|
|
|
|
* @a: termios
|
|
|
|
* @b: termios to compare
|
|
|
|
*
|
|
|
|
* Check if any of the bits that affect a dumb device have changed
|
|
|
|
* between the two termios structures, or a speed change is needed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
|
|
|
|
{
|
|
|
|
if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
|
|
|
|
return 1;
|
|
|
|
if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_termios_hw_change);
|
|
|
|
|
2006-08-27 02:24:01 -06:00
|
|
|
/**
|
2011-02-14 09:27:53 -07:00
|
|
|
* tty_set_termios - update termios values
|
2006-08-27 02:24:01 -06:00
|
|
|
* @tty: tty to update
|
|
|
|
* @new_termios: desired new value
|
|
|
|
*
|
2014-10-16 13:33:23 -06:00
|
|
|
* Perform updates to the termios values set on this terminal.
|
2014-10-16 13:33:22 -06:00
|
|
|
* A master pty's termios should never be set.
|
|
|
|
*
|
2013-06-15 07:14:23 -06:00
|
|
|
* Locking: termios_rwsem
|
2006-08-27 02:24:01 -06:00
|
|
|
*/
|
|
|
|
|
2015-04-10 07:13:05 -06:00
|
|
|
int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-30 01:53:59 -06:00
|
|
|
struct ktermios old_termios;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct tty_ldisc *ld;
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2014-10-16 13:33:22 -06:00
|
|
|
WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_MASTER);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Perform the actual termios internal changes under lock.
|
|
|
|
*/
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* FIXME: we need to decide on some locking/ordering semantics
|
|
|
|
for the set_termios notification eventually */
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
old_termios = tty->termios;
|
|
|
|
tty->termios = *new_termios;
|
2015-11-08 11:01:16 -07:00
|
|
|
unset_locked_termios(tty, &old_termios);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->set_termios)
|
2014-11-05 10:26:25 -07:00
|
|
|
tty->ops->set_termios(tty, &old_termios);
|
2007-10-17 00:30:07 -06:00
|
|
|
else
|
2012-07-14 08:31:47 -06:00
|
|
|
tty_termios_copy_hw(&tty->termios, &old_termios);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ld = tty_ldisc_ref(tty);
|
|
|
|
if (ld != NULL) {
|
2008-07-16 14:53:12 -06:00
|
|
|
if (ld->ops->set_termios)
|
2014-11-05 10:26:25 -07:00
|
|
|
ld->ops->set_termios(tty, &old_termios);
|
2005-04-16 16:20:36 -06:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2011-02-14 09:27:53 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-04-10 07:13:05 -06:00
|
|
|
EXPORT_SYMBOL_GPL(tty_set_termios);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-27 02:24:01 -06:00
|
|
|
/**
|
|
|
|
* set_termios - set termios values for a tty
|
|
|
|
* @tty: terminal device
|
|
|
|
* @arg: user data
|
|
|
|
* @opt: option information
|
|
|
|
*
|
2007-10-19 15:10:43 -06:00
|
|
|
* Helper function to prepare termios data and run necessary other
|
2011-02-14 09:27:53 -07:00
|
|
|
* functions before using tty_set_termios to do the actual changes.
|
2006-08-27 02:24:01 -06:00
|
|
|
*
|
|
|
|
* Locking:
|
2013-06-15 07:14:23 -06:00
|
|
|
* Called functions take ldisc and termios_rwsem locks
|
2006-08-27 02:24:01 -06:00
|
|
|
*/
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-12-08 03:38:44 -07:00
|
|
|
struct ktermios tmp_termios;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct tty_ldisc *ld;
|
|
|
|
int retval = tty_check_change(tty);
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp_termios = tty->termios;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2006-12-08 03:38:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (opt & TERMIOS_TERMIO) {
|
|
|
|
if (user_termio_to_kernel_termios(&tmp_termios,
|
|
|
|
(struct termio __user *)arg))
|
|
|
|
return -EFAULT;
|
2006-12-08 03:38:44 -07:00
|
|
|
#ifdef TCGETS2
|
|
|
|
} else if (opt & TERMIOS_OLD) {
|
|
|
|
if (user_termios_to_kernel_termios_1(&tmp_termios,
|
2006-12-08 03:38:47 -07:00
|
|
|
(struct termios __user *)arg))
|
2006-12-08 03:38:44 -07:00
|
|
|
return -EFAULT;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
if (user_termios_to_kernel_termios(&tmp_termios,
|
2006-12-08 03:38:47 -07:00
|
|
|
(struct termios2 __user *)arg))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
2006-12-08 03:38:47 -07:00
|
|
|
#else
|
|
|
|
} else if (user_termios_to_kernel_termios(&tmp_termios,
|
|
|
|
(struct termios __user *)arg))
|
|
|
|
return -EFAULT;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
/* If old style Bfoo values are used then load c_ispeed/c_ospeed
|
|
|
|
* with the real speed so its unconditionally usable */
|
2006-12-08 03:38:44 -07:00
|
|
|
tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
|
|
|
|
tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ld = tty_ldisc_ref(tty);
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ld != NULL) {
|
2008-07-16 14:53:12 -06:00
|
|
|
if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
|
|
|
|
ld->ops->flush_buffer(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (opt & TERMIOS_WAIT) {
|
|
|
|
tty_wait_until_sent(tty, 0);
|
|
|
|
if (signal_pending(current))
|
2013-01-29 12:07:41 -07:00
|
|
|
return -ERESTARTSYS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-02-14 09:27:53 -07:00
|
|
|
tty_set_termios(tty, &tmp_termios);
|
2007-10-17 00:30:07 -06:00
|
|
|
|
|
|
|
/* FIXME: Arguably if tmp_termios == tty->termios AND the
|
|
|
|
actual requested termios was not tmp_termios then we may
|
|
|
|
want to return an error as no user requested change has
|
|
|
|
succeeded */
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-11 07:03:13 -06:00
|
|
|
static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
|
|
|
|
{
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
*kterm = tty->termios;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2009-06-11 07:03:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
|
|
|
|
{
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
*kterm = tty->termios_locked;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2009-06-11 07:03:13 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int get_termio(struct tty_struct *tty, struct termio __user *termio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-06-11 07:03:13 -06:00
|
|
|
struct ktermios kterm;
|
|
|
|
copy_termios(tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termio(termio, &kterm))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-13 03:38:18 -06:00
|
|
|
|
|
|
|
#ifdef TCGETX
|
|
|
|
|
|
|
|
/**
|
|
|
|
* set_termiox - set termiox fields if possible
|
|
|
|
* @tty: terminal
|
|
|
|
* @arg: termiox structure from user
|
|
|
|
* @opt: option flags for ioctl type
|
|
|
|
*
|
|
|
|
* Implement the device calling points for the SYS5 termiox ioctl
|
|
|
|
* interface in Linux
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
|
|
|
|
{
|
|
|
|
struct termiox tnew;
|
|
|
|
struct tty_ldisc *ld;
|
|
|
|
|
|
|
|
if (tty->termiox == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
ld = tty_ldisc_ref(tty);
|
|
|
|
if (ld != NULL) {
|
|
|
|
if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
|
|
|
|
ld->ops->flush_buffer(tty);
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
|
|
|
if (opt & TERMIOS_WAIT) {
|
|
|
|
tty_wait_until_sent(tty, 0);
|
|
|
|
if (signal_pending(current))
|
2013-01-29 12:07:41 -07:00
|
|
|
return -ERESTARTSYS;
|
2008-10-13 03:38:18 -06:00
|
|
|
}
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2008-10-13 03:38:18 -06:00
|
|
|
if (tty->ops->set_termiox)
|
|
|
|
tty->ops->set_termiox(tty, &tnew);
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2008-10-13 03:38:18 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef TIOCGETP
|
|
|
|
/*
|
|
|
|
* These are deprecated, but there is limited support..
|
|
|
|
*
|
|
|
|
* The "sg_flags" translation is a joke..
|
|
|
|
*/
|
2008-02-08 05:18:48 -07:00
|
|
|
static int get_sgflags(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int flags = 0;
|
|
|
|
|
2016-01-10 21:36:15 -07:00
|
|
|
if (!L_ICANON(tty)) {
|
|
|
|
if (L_ISIG(tty))
|
2005-04-16 16:20:36 -06:00
|
|
|
flags |= 0x02; /* cbreak */
|
|
|
|
else
|
|
|
|
flags |= 0x20; /* raw */
|
|
|
|
}
|
2016-01-10 21:36:15 -07:00
|
|
|
if (L_ECHO(tty))
|
2005-04-16 16:20:36 -06:00
|
|
|
flags |= 0x08; /* echo */
|
2016-01-10 21:36:15 -07:00
|
|
|
if (O_OPOST(tty))
|
|
|
|
if (O_ONLCR(tty))
|
2005-04-16 16:20:36 -06:00
|
|
|
flags |= 0x10; /* crmod */
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sgttyb tmp;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp.sg_ispeed = tty->termios.c_ispeed;
|
|
|
|
tmp.sg_ospeed = tty->termios.c_ospeed;
|
|
|
|
tmp.sg_erase = tty->termios.c_cc[VERASE];
|
|
|
|
tmp.sg_kill = tty->termios.c_cc[VKILL];
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp.sg_flags = get_sgflags(tty);
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static void set_sgflags(struct ktermios *termios, int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-17 10:05:40 -06:00
|
|
|
termios->c_iflag = ICRNL | IXON;
|
|
|
|
termios->c_oflag = 0;
|
|
|
|
termios->c_lflag = ISIG | ICANON;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (flags & 0x02) { /* cbreak */
|
2012-07-17 10:05:40 -06:00
|
|
|
termios->c_iflag = 0;
|
|
|
|
termios->c_lflag &= ~ICANON;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (flags & 0x08) { /* echo */
|
2012-07-17 10:05:40 -06:00
|
|
|
termios->c_lflag |= ECHO | ECHOE | ECHOK |
|
2005-04-16 16:20:36 -06:00
|
|
|
ECHOCTL | ECHOKE | IEXTEN;
|
|
|
|
}
|
|
|
|
if (flags & 0x10) { /* crmod */
|
2012-07-17 10:05:40 -06:00
|
|
|
termios->c_oflag |= OPOST | ONLCR;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (flags & 0x20) { /* raw */
|
2012-07-17 10:05:40 -06:00
|
|
|
termios->c_iflag = 0;
|
|
|
|
termios->c_lflag &= ~(ISIG | ICANON);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-07-17 10:05:40 -06:00
|
|
|
if (!(termios->c_lflag & ICANON)) {
|
|
|
|
termios->c_cc[VMIN] = 1;
|
|
|
|
termios->c_cc[VTIME] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-27 02:24:01 -06:00
|
|
|
/**
|
|
|
|
* set_sgttyb - set legacy terminal values
|
|
|
|
* @tty: tty structure
|
|
|
|
* @sgttyb: pointer to old style terminal structure
|
|
|
|
*
|
|
|
|
* Updates a terminal from the legacy BSD style terminal information
|
|
|
|
* structure.
|
|
|
|
*
|
2013-06-15 07:14:23 -06:00
|
|
|
* Locking: termios_rwsem
|
2006-08-27 02:24:01 -06:00
|
|
|
*/
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
struct sgttyb tmp;
|
2006-12-08 03:38:44 -07:00
|
|
|
struct ktermios termios;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2008-02-08 05:18:48 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
termios = tty->termios;
|
2005-04-16 16:20:36 -06:00
|
|
|
termios.c_cc[VERASE] = tmp.sg_erase;
|
|
|
|
termios.c_cc[VKILL] = tmp.sg_kill;
|
|
|
|
set_sgflags(&termios, tmp.sg_flags);
|
2006-12-08 03:38:44 -07:00
|
|
|
/* Try and encode into Bfoo format */
|
|
|
|
#ifdef BOTHER
|
2008-02-08 05:18:48 -07:00
|
|
|
tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
|
|
|
|
termios.c_ospeed);
|
2006-12-08 03:38:44 -07:00
|
|
|
#endif
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2011-02-14 09:27:53 -07:00
|
|
|
tty_set_termios(tty, &termios);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TIOCGETC
|
2008-02-08 05:18:48 -07:00
|
|
|
static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct tchars tmp;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp.t_intrc = tty->termios.c_cc[VINTR];
|
|
|
|
tmp.t_quitc = tty->termios.c_cc[VQUIT];
|
|
|
|
tmp.t_startc = tty->termios.c_cc[VSTART];
|
|
|
|
tmp.t_stopc = tty->termios.c_cc[VSTOP];
|
|
|
|
tmp.t_eofc = tty->termios.c_cc[VEOF];
|
|
|
|
tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2005-04-16 16:20:36 -06:00
|
|
|
return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct tchars tmp;
|
|
|
|
|
|
|
|
if (copy_from_user(&tmp, tchars, sizeof(tmp)))
|
|
|
|
return -EFAULT;
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tty->termios.c_cc[VINTR] = tmp.t_intrc;
|
|
|
|
tty->termios.c_cc[VQUIT] = tmp.t_quitc;
|
|
|
|
tty->termios.c_cc[VSTART] = tmp.t_startc;
|
|
|
|
tty->termios.c_cc[VSTOP] = tmp.t_stopc;
|
|
|
|
tty->termios.c_cc[VEOF] = tmp.t_eofc;
|
|
|
|
tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TIOCGLTC
|
2008-02-08 05:18:48 -07:00
|
|
|
static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ltchars tmp;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp.t_suspc = tty->termios.c_cc[VSUSP];
|
2008-02-08 05:18:48 -07:00
|
|
|
/* what is dsuspc anyway? */
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
|
|
|
|
tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
|
2008-02-08 05:18:48 -07:00
|
|
|
/* what is flushc anyway? */
|
2012-07-14 08:31:47 -06:00
|
|
|
tmp.t_flushc = tty->termios.c_cc[VEOL2];
|
|
|
|
tmp.t_werasc = tty->termios.c_cc[VWERASE];
|
|
|
|
tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&tty->termios_rwsem);
|
2005-04-16 16:20:36 -06:00
|
|
|
return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ltchars tmp;
|
|
|
|
|
|
|
|
if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
tty->termios.c_cc[VSUSP] = tmp.t_suspc;
|
2008-02-08 05:18:48 -07:00
|
|
|
/* what is dsuspc anyway? */
|
2012-07-14 08:31:47 -06:00
|
|
|
tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
|
|
|
|
tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
|
2008-02-08 05:18:48 -07:00
|
|
|
/* what is flushc anyway? */
|
2012-07-14 08:31:47 -06:00
|
|
|
tty->termios.c_cc[VEOL2] = tmp.t_flushc;
|
|
|
|
tty->termios.c_cc[VWERASE] = tmp.t_werasc;
|
|
|
|
tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-04-30 01:53:34 -06:00
|
|
|
/**
|
|
|
|
* tty_change_softcar - carrier change ioctl helper
|
|
|
|
* @tty: tty to update
|
|
|
|
* @arg: enable/disable CLOCAL
|
|
|
|
*
|
|
|
|
* Perform a change to the CLOCAL state and call into the driver
|
2013-06-15 07:14:23 -06:00
|
|
|
* layer to make it visible. All done with the termios rwsem
|
2008-04-30 01:53:34 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int tty_change_softcar(struct tty_struct *tty, int arg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int bit = arg ? CLOCAL : 0;
|
2008-04-30 01:54:13 -06:00
|
|
|
struct ktermios old;
|
2008-04-30 01:53:34 -06:00
|
|
|
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
old = tty->termios;
|
|
|
|
tty->termios.c_cflag &= ~CLOCAL;
|
|
|
|
tty->termios.c_cflag |= bit;
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->set_termios)
|
|
|
|
tty->ops->set_termios(tty, &old);
|
2016-01-10 21:36:15 -07:00
|
|
|
if (C_CLOCAL(tty) != bit)
|
2008-04-30 01:53:34 -06:00
|
|
|
ret = -EINVAL;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&tty->termios_rwsem);
|
2008-04-30 01:53:34 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-11-07 02:24:56 -07:00
|
|
|
/**
|
|
|
|
* tty_mode_ioctl - mode related ioctls
|
|
|
|
* @tty: tty for the ioctl
|
|
|
|
* @file: file pointer for the tty
|
|
|
|
* @cmd: command
|
|
|
|
* @arg: ioctl argument
|
|
|
|
*
|
|
|
|
* Perform non line discipline specific mode control ioctls. This
|
|
|
|
* is designed to be called by line disciplines to ensure they provide
|
|
|
|
* consistent mode setting.
|
|
|
|
*/
|
|
|
|
|
2008-02-08 05:18:48 -07:00
|
|
|
int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
|
2007-11-07 02:24:56 -07:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-08 05:18:48 -07:00
|
|
|
struct tty_struct *real_tty;
|
2005-04-16 16:20:36 -06:00
|
|
|
void __user *p = (void __user *)arg;
|
2008-10-13 03:38:46 -06:00
|
|
|
int ret = 0;
|
2009-06-11 07:03:13 -06:00
|
|
|
struct ktermios kterm;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-02-14 09:27:53 -07:00
|
|
|
BUG_ON(file == NULL);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_MASTER)
|
|
|
|
real_tty = tty->link;
|
|
|
|
else
|
|
|
|
real_tty = tty;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
#ifdef TIOCGETP
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGETP:
|
|
|
|
return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
|
|
|
|
case TIOCSETP:
|
|
|
|
case TIOCSETN:
|
|
|
|
return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
#ifdef TIOCGETC
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGETC:
|
|
|
|
return get_tchars(real_tty, p);
|
|
|
|
case TIOCSETC:
|
|
|
|
return set_tchars(real_tty, p);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
#ifdef TIOCGLTC
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGLTC:
|
|
|
|
return get_ltchars(real_tty, p);
|
|
|
|
case TIOCSLTC:
|
|
|
|
return set_ltchars(real_tty, p);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCSETSF:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
|
|
|
|
case TCSETSW:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
|
|
|
|
case TCSETS:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_OLD);
|
2006-12-08 03:38:44 -07:00
|
|
|
#ifndef TCGETS2
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCGETS:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios(real_tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
|
2008-10-13 03:38:46 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
return ret;
|
2006-12-08 03:38:44 -07:00
|
|
|
#else
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCGETS:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios(real_tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
|
2008-10-13 03:38:46 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
return ret;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCGETS2:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios(real_tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
|
2008-10-13 03:38:46 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
return ret;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCSETSF2:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
|
|
|
|
case TCSETSW2:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_WAIT);
|
|
|
|
case TCSETS2:
|
|
|
|
return set_termios(real_tty, p, 0);
|
2006-12-08 03:38:44 -07:00
|
|
|
#endif
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCGETA:
|
|
|
|
return get_termio(real_tty, p);
|
|
|
|
case TCSETAF:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
|
|
|
|
case TCSETAW:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
|
|
|
|
case TCSETA:
|
|
|
|
return set_termios(real_tty, p, TERMIOS_TERMIO);
|
2007-11-07 02:24:56 -07:00
|
|
|
#ifndef TCGETS2
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGLCKTRMIOS:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios_locked(real_tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
|
2008-10-13 03:38:46 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
return ret;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCSLCKTRMIOS:
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios_locked(real_tty, &kterm);
|
|
|
|
if (user_termios_to_kernel_termios(&kterm,
|
2008-02-08 05:18:48 -07:00
|
|
|
(struct termios __user *) arg))
|
2009-06-11 07:03:13 -06:00
|
|
|
return -EFAULT;
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&real_tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
real_tty->termios_locked = kterm;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&real_tty->termios_rwsem);
|
2009-06-11 07:03:13 -06:00
|
|
|
return 0;
|
2007-11-07 02:24:56 -07:00
|
|
|
#else
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGLCKTRMIOS:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios_locked(real_tty, &kterm);
|
|
|
|
if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
|
2008-10-13 03:38:46 -06:00
|
|
|
ret = -EFAULT;
|
|
|
|
return ret;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCSLCKTRMIOS:
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
2009-06-11 07:03:13 -06:00
|
|
|
return -EPERM;
|
|
|
|
copy_termios_locked(real_tty, &kterm);
|
|
|
|
if (user_termios_to_kernel_termios_1(&kterm,
|
2008-02-08 05:18:48 -07:00
|
|
|
(struct termios __user *) arg))
|
2009-06-11 07:03:13 -06:00
|
|
|
return -EFAULT;
|
2013-06-15 07:14:23 -06:00
|
|
|
down_write(&real_tty->termios_rwsem);
|
2012-07-14 08:31:47 -06:00
|
|
|
real_tty->termios_locked = kterm;
|
2013-06-15 07:14:23 -06:00
|
|
|
up_write(&real_tty->termios_rwsem);
|
2008-10-13 03:38:46 -06:00
|
|
|
return ret;
|
2007-11-07 02:24:56 -07:00
|
|
|
#endif
|
2008-10-13 03:38:18 -06:00
|
|
|
#ifdef TCGETX
|
2009-06-16 10:01:02 -06:00
|
|
|
case TCGETX: {
|
|
|
|
struct termiox ktermx;
|
2008-10-13 03:38:18 -06:00
|
|
|
if (real_tty->termiox == NULL)
|
|
|
|
return -EINVAL;
|
2013-06-15 07:14:23 -06:00
|
|
|
down_read(&real_tty->termios_rwsem);
|
2009-06-11 07:03:13 -06:00
|
|
|
memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
|
2013-06-15 07:14:23 -06:00
|
|
|
up_read(&real_tty->termios_rwsem);
|
2009-06-11 07:03:13 -06:00
|
|
|
if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
|
|
|
|
ret = -EFAULT;
|
2008-10-13 03:38:46 -06:00
|
|
|
return ret;
|
2009-06-16 10:01:02 -06:00
|
|
|
}
|
2008-10-13 03:38:18 -06:00
|
|
|
case TCSETX:
|
|
|
|
return set_termiox(real_tty, p, 0);
|
|
|
|
case TCSETXW:
|
|
|
|
return set_termiox(real_tty, p, TERMIOS_WAIT);
|
|
|
|
case TCSETXF:
|
|
|
|
return set_termiox(real_tty, p, TERMIOS_FLUSH);
|
|
|
|
#endif
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCGSOFTCAR:
|
2009-06-11 07:03:13 -06:00
|
|
|
copy_termios(real_tty, &kterm);
|
|
|
|
ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
|
2008-02-08 05:18:48 -07:00
|
|
|
(int __user *)arg);
|
2008-10-13 03:38:46 -06:00
|
|
|
return ret;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TIOCSSOFTCAR:
|
|
|
|
if (get_user(arg, (unsigned int __user *) arg))
|
|
|
|
return -EFAULT;
|
2008-08-26 12:52:47 -06:00
|
|
|
return tty_change_softcar(real_tty, arg);
|
2008-02-08 05:18:48 -07:00
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
2007-11-07 02:24:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_mode_ioctl);
|
|
|
|
|
2013-03-11 14:44:45 -06:00
|
|
|
|
|
|
|
/* Caller guarantees ldisc reference is held */
|
|
|
|
static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
|
2007-11-07 02:24:56 -07:00
|
|
|
{
|
2013-03-11 14:44:45 -06:00
|
|
|
struct tty_ldisc *ld = tty->ldisc;
|
2007-11-07 02:24:56 -07:00
|
|
|
|
|
|
|
switch (arg) {
|
|
|
|
case TCIFLUSH:
|
tty: Add driver unthrottle in ioctl(...,TCFLSH,..).
Regression 'tty: fix "IRQ45: nobody cared"'
Regression commit 7b292b4bf9a9d6098440d85616d6ca4c608b8304
Function reset_buffer_flags() also invoked during the ioctl(...,TCFLSH,..).
At the time of request we can have full buffers and throttled driver too.
If we don't unthrottle driver, we can get forever throttled driver, because,
after request, we will have empty buffers and throttled driver and
there is no place to unthrottle driver.
It simple reproduce with "pty" pair then one side sleep on tty->write_wait,
and other side do ioctl(...,TCFLSH,..). Then there is no place to do writers wake up.
Signed-off-by: Ilya Zykov <ilya@ilyx.ru>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-01-16 02:07:50 -07:00
|
|
|
if (ld && ld->ops->flush_buffer) {
|
2008-07-16 14:53:12 -06:00
|
|
|
ld->ops->flush_buffer(tty);
|
tty: Add driver unthrottle in ioctl(...,TCFLSH,..).
Regression 'tty: fix "IRQ45: nobody cared"'
Regression commit 7b292b4bf9a9d6098440d85616d6ca4c608b8304
Function reset_buffer_flags() also invoked during the ioctl(...,TCFLSH,..).
At the time of request we can have full buffers and throttled driver too.
If we don't unthrottle driver, we can get forever throttled driver, because,
after request, we will have empty buffers and throttled driver and
there is no place to unthrottle driver.
It simple reproduce with "pty" pair then one side sleep on tty->write_wait,
and other side do ioctl(...,TCFLSH,..). Then there is no place to do writers wake up.
Signed-off-by: Ilya Zykov <ilya@ilyx.ru>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-01-16 02:07:50 -07:00
|
|
|
tty_unthrottle(tty);
|
|
|
|
}
|
2007-11-07 02:24:56 -07:00
|
|
|
break;
|
|
|
|
case TCIOFLUSH:
|
tty: Add driver unthrottle in ioctl(...,TCFLSH,..).
Regression 'tty: fix "IRQ45: nobody cared"'
Regression commit 7b292b4bf9a9d6098440d85616d6ca4c608b8304
Function reset_buffer_flags() also invoked during the ioctl(...,TCFLSH,..).
At the time of request we can have full buffers and throttled driver too.
If we don't unthrottle driver, we can get forever throttled driver, because,
after request, we will have empty buffers and throttled driver and
there is no place to unthrottle driver.
It simple reproduce with "pty" pair then one side sleep on tty->write_wait,
and other side do ioctl(...,TCFLSH,..). Then there is no place to do writers wake up.
Signed-off-by: Ilya Zykov <ilya@ilyx.ru>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-01-16 02:07:50 -07:00
|
|
|
if (ld && ld->ops->flush_buffer) {
|
2008-07-16 14:53:12 -06:00
|
|
|
ld->ops->flush_buffer(tty);
|
tty: Add driver unthrottle in ioctl(...,TCFLSH,..).
Regression 'tty: fix "IRQ45: nobody cared"'
Regression commit 7b292b4bf9a9d6098440d85616d6ca4c608b8304
Function reset_buffer_flags() also invoked during the ioctl(...,TCFLSH,..).
At the time of request we can have full buffers and throttled driver too.
If we don't unthrottle driver, we can get forever throttled driver, because,
after request, we will have empty buffers and throttled driver and
there is no place to unthrottle driver.
It simple reproduce with "pty" pair then one side sleep on tty->write_wait,
and other side do ioctl(...,TCFLSH,..). Then there is no place to do writers wake up.
Signed-off-by: Ilya Zykov <ilya@ilyx.ru>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-01-16 02:07:50 -07:00
|
|
|
tty_unthrottle(tty);
|
|
|
|
}
|
2007-11-07 02:24:56 -07:00
|
|
|
/* fall through */
|
|
|
|
case TCOFLUSH:
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_driver_flush_buffer(tty);
|
2007-11-07 02:24:56 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-11 14:44:45 -06:00
|
|
|
|
|
|
|
int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct tty_ldisc *ld;
|
|
|
|
int retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
|
|
|
retval = __tty_perform_flush(tty, arg);
|
|
|
|
if (ld)
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
return retval;
|
|
|
|
}
|
2007-11-07 02:24:56 -07:00
|
|
|
EXPORT_SYMBOL_GPL(tty_perform_flush);
|
|
|
|
|
2008-10-13 03:44:17 -06:00
|
|
|
int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
|
2007-11-07 02:24:56 -07:00
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
switch (cmd) {
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCXONC:
|
|
|
|
retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
switch (arg) {
|
|
|
|
case TCOOFF:
|
2014-09-10 13:06:33 -06:00
|
|
|
spin_lock_irq(&tty->flow_lock);
|
2008-02-08 05:18:48 -07:00
|
|
|
if (!tty->flow_stopped) {
|
|
|
|
tty->flow_stopped = 1;
|
2014-09-10 13:06:33 -06:00
|
|
|
__stop_tty(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-09-10 13:06:33 -06:00
|
|
|
spin_unlock_irq(&tty->flow_lock);
|
2008-02-08 05:18:48 -07:00
|
|
|
break;
|
|
|
|
case TCOON:
|
2014-09-10 13:06:33 -06:00
|
|
|
spin_lock_irq(&tty->flow_lock);
|
2008-02-08 05:18:48 -07:00
|
|
|
if (tty->flow_stopped) {
|
|
|
|
tty->flow_stopped = 0;
|
2014-09-10 13:06:33 -06:00
|
|
|
__start_tty(tty);
|
2008-02-08 05:18:48 -07:00
|
|
|
}
|
2014-09-10 13:06:33 -06:00
|
|
|
spin_unlock_irq(&tty->flow_lock);
|
2008-02-08 05:18:48 -07:00
|
|
|
break;
|
|
|
|
case TCIOFF:
|
|
|
|
if (STOP_CHAR(tty) != __DISABLED_CHAR)
|
2014-09-10 13:06:35 -06:00
|
|
|
retval = tty_send_xchar(tty, STOP_CHAR(tty));
|
2008-02-08 05:18:48 -07:00
|
|
|
break;
|
|
|
|
case TCION:
|
|
|
|
if (START_CHAR(tty) != __DISABLED_CHAR)
|
2014-09-10 13:06:35 -06:00
|
|
|
retval = tty_send_xchar(tty, START_CHAR(tty));
|
2008-02-08 05:18:48 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
2008-02-08 05:18:48 -07:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2014-09-10 13:06:35 -06:00
|
|
|
return retval;
|
2008-02-08 05:18:48 -07:00
|
|
|
case TCFLSH:
|
2013-09-25 18:13:04 -06:00
|
|
|
retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
2013-03-11 14:44:45 -06:00
|
|
|
return __tty_perform_flush(tty, arg);
|
2008-02-08 05:18:48 -07:00
|
|
|
default:
|
|
|
|
/* Try the mode commands */
|
|
|
|
return tty_mode_ioctl(tty, file, cmd, arg);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-13 03:44:17 -06:00
|
|
|
EXPORT_SYMBOL(n_tty_ioctl_helper);
|
2011-10-05 15:13:13 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCGLCKTRMIOS:
|
|
|
|
case TIOCSLCKTRMIOS:
|
|
|
|
return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
|
|
|
|
#endif
|
|
|
|
|