2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* n_tty.c --- implements the N_TTY line discipline.
|
2008-02-08 05:18:44 -07:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* This code used to be in tty_io.c, but things are getting hairy
|
|
|
|
* enough that it made sense to split things off. (The N_TTY
|
|
|
|
* processing has changed so much that it's hardly recognizable,
|
|
|
|
* anyway...)
|
|
|
|
*
|
|
|
|
* Note that the open routine for N_TTY is guaranteed never to return
|
|
|
|
* an error. This is because Linux will fall back to setting a line
|
2008-02-08 05:18:44 -07:00
|
|
|
* to N_TTY if it can not switch to any other line discipline.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Written by Theodore Ts'o, Copyright 1994.
|
2008-02-08 05:18:44 -07:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* This file also contains code originally written by Linus Torvalds,
|
|
|
|
* Copyright 1991, 1992, 1993, and by Julian Cowley, Copyright 1994.
|
2008-02-08 05:18:44 -07:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* This file may be redistributed under the terms of the GNU General Public
|
|
|
|
* License.
|
|
|
|
*
|
|
|
|
* Reduced memory usage for older ARM systems - Russell King.
|
|
|
|
*
|
2008-02-08 05:18:44 -07:00
|
|
|
* 2000/01/20 Fixed SMP locking on put_tty_queue using bits of
|
2005-04-16 16:20:36 -06:00
|
|
|
* the patch by Andrew J. Kroll <ag784@freenet.buffalo.edu>
|
|
|
|
* who actually finally proved there really was a race.
|
|
|
|
*
|
|
|
|
* 2002/03/18 Implemented n_tty_wakeup to send SIGIO POLL_OUTs to
|
|
|
|
* waiting writing processes-Sapan Bhatia <sapan@corewars.org>.
|
|
|
|
* Also fixed a bug in BLOCKING mode where write_chan returns
|
|
|
|
* EAGAIN
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/bitops.h>
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
#include <linux/audit.h>
|
|
|
|
#include <linux/file.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
|
|
|
|
/* number of characters left in xmit buffer before select has we have room */
|
|
|
|
#define WAKEUP_CHARS 256
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This defines the low- and high-watermarks for throttling and
|
|
|
|
* unthrottling the TTY driver. These watermarks are used for
|
|
|
|
* controlling the space in the read buffer.
|
|
|
|
*/
|
|
|
|
#define TTY_THRESHOLD_THROTTLE 128 /* now based on remaining room */
|
|
|
|
#define TTY_THRESHOLD_UNTHROTTLE 128
|
|
|
|
|
|
|
|
static inline unsigned char *alloc_buf(void)
|
|
|
|
{
|
2005-10-21 01:22:34 -06:00
|
|
|
gfp_t prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (PAGE_SIZE != N_TTY_BUF_SIZE)
|
|
|
|
return kmalloc(N_TTY_BUF_SIZE, prio);
|
|
|
|
else
|
|
|
|
return (unsigned char *)__get_free_page(prio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void free_buf(unsigned char *buf)
|
|
|
|
{
|
|
|
|
if (PAGE_SIZE != N_TTY_BUF_SIZE)
|
|
|
|
kfree(buf);
|
|
|
|
else
|
|
|
|
free_page((unsigned long) buf);
|
|
|
|
}
|
|
|
|
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
|
|
|
|
unsigned char __user *ptr)
|
|
|
|
{
|
|
|
|
tty_audit_add_data(tty, &x, 1);
|
|
|
|
return put_user(x, ptr);
|
|
|
|
}
|
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
/**
|
|
|
|
* n_tty_set__room - receive space
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Called by the driver to find out how much data it is
|
|
|
|
* permitted to feed to the line discipline without any being lost
|
|
|
|
* and thus to manage flow control. Not serialized. Answers for the
|
|
|
|
* "instant".
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void n_tty_set_room(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
int left = N_TTY_BUF_SIZE - tty->read_cnt - 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are doing input canonicalization, and there are no
|
|
|
|
* pending newlines, let characters through without limit, so
|
|
|
|
* that erase characters will be handled. Other excess
|
|
|
|
* characters will be beeped.
|
|
|
|
*/
|
|
|
|
if (left <= 0)
|
|
|
|
left = tty->icanon && !tty->canon_data;
|
|
|
|
tty->receive_room = left;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_tty_queue_nolock(unsigned char c, struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (tty->read_cnt < N_TTY_BUF_SIZE) {
|
|
|
|
tty->read_buf[tty->read_head] = c;
|
|
|
|
tty->read_head = (tty->read_head + 1) & (N_TTY_BUF_SIZE-1);
|
|
|
|
tty->read_cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
static void put_tty_queue(unsigned char c, struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
/*
|
|
|
|
* The problem of stomping on the buffers ends here.
|
|
|
|
* Why didn't anyone see this one coming? --AJK
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
put_tty_queue_nolock(c, tty);
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* check_unthrottle - allow new receive data
|
|
|
|
* @tty; tty device
|
|
|
|
*
|
|
|
|
* Check whether to call the driver.unthrottle function.
|
|
|
|
* We test the TTY_THROTTLED bit first so that it always
|
|
|
|
* indicates the current state. The decision about whether
|
|
|
|
* it is worth allowing more input has been taken by the caller.
|
2006-03-23 04:00:31 -07:00
|
|
|
* Can sleep, may be called under the atomic_read_lock mutex but
|
2005-04-16 16:20:36 -06:00
|
|
|
* this is not guaranteed.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static void check_unthrottle(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-30 01:54:18 -06:00
|
|
|
if (tty->count)
|
|
|
|
tty_unthrottle(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* reset_buffer_flags - reset buffer state
|
|
|
|
* @tty: terminal to reset
|
|
|
|
*
|
2008-02-08 05:18:44 -07:00
|
|
|
* Reset the read buffer counters, clear the flags,
|
2005-04-16 16:20:36 -06:00
|
|
|
* and make sure the driver is unthrottled. Called
|
|
|
|
* from n_tty_open() and n_tty_flush_buffer().
|
|
|
|
*/
|
|
|
|
static void reset_buffer_flags(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_head = tty->read_tail = tty->read_cnt = 0;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
tty->canon_head = tty->canon_data = tty->erasing = 0;
|
|
|
|
memset(&tty->read_flags, 0, sizeof tty->read_flags);
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
check_unthrottle(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_flush_buffer - clean input queue
|
|
|
|
* @tty: terminal device
|
|
|
|
*
|
|
|
|
* Flush the input buffer. Called when the line discipline is
|
|
|
|
* being closed, when the tty layer wants the buffer flushed (eg
|
|
|
|
* at hangup) or when the N_TTY line discipline internally has to
|
|
|
|
* clean the pending queue (for example some signals).
|
|
|
|
*
|
2008-04-30 01:53:29 -06:00
|
|
|
* Locking: ctrl_lock
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static void n_tty_flush_buffer(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-30 01:53:29 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* clear everything and unthrottle the driver */
|
|
|
|
reset_buffer_flags(tty);
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!tty->link)
|
|
|
|
return;
|
|
|
|
|
2008-04-30 01:53:29 -06:00
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->link->packet) {
|
|
|
|
tty->ctrl_status |= TIOCPKT_FLUSHREAD;
|
|
|
|
wake_up_interruptible(&tty->link->read_wait);
|
|
|
|
}
|
2008-04-30 01:53:29 -06:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_chars_in_buffer - report available bytes
|
|
|
|
* @tty: tty device
|
|
|
|
*
|
|
|
|
* Report the number of characters buffered to be delivered to user
|
2008-02-08 05:18:44 -07:00
|
|
|
* at this instant in time.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t n_tty_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
ssize_t n = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
if (!tty->icanon) {
|
|
|
|
n = tty->read_cnt;
|
|
|
|
} else if (tty->canon_data) {
|
|
|
|
n = (tty->canon_head > tty->read_tail) ?
|
|
|
|
tty->canon_head - tty->read_tail :
|
|
|
|
tty->canon_head + (N_TTY_BUF_SIZE - tty->read_tail);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* is_utf8_continuation - utf8 multibyte check
|
|
|
|
* @c: byte to check
|
|
|
|
*
|
|
|
|
* Returns true if the utf8 character 'c' is a multibyte continuation
|
|
|
|
* character. We use this to correctly compute the on screen size
|
|
|
|
* of the character when printing
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline int is_utf8_continuation(unsigned char c)
|
|
|
|
{
|
|
|
|
return (c & 0xc0) == 0x80;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* is_continuation - multibyte check
|
|
|
|
* @c: byte to check
|
|
|
|
*
|
|
|
|
* Returns true if the utf8 character 'c' is a multibyte continuation
|
|
|
|
* character and the terminal is in unicode mode.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline int is_continuation(unsigned char c, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
return I_IUTF8(tty) && is_utf8_continuation(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* opost - output post processor
|
|
|
|
* @c: character (or partial unicode symbol)
|
|
|
|
* @tty: terminal device
|
|
|
|
*
|
|
|
|
* Perform OPOST processing. Returns -1 when the output device is
|
|
|
|
* full and the character must be retried. Note that Linux currently
|
|
|
|
* ignores TABDLY, CRDLY, VTDLY, FFDLY and NLDLY. They simply aren't
|
|
|
|
* relevant in the world today. If you ever need them, add them here.
|
|
|
|
*
|
|
|
|
* Called from both the receive and transmit sides and can be called
|
2008-04-30 01:53:29 -06:00
|
|
|
* re-entrantly. Relies on lock_kernel() for tty->column state.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int opost(unsigned char c, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
int space, spaces;
|
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
space = tty_write_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!space)
|
|
|
|
return -1;
|
|
|
|
|
2008-04-30 01:53:29 -06:00
|
|
|
lock_kernel();
|
2005-04-16 16:20:36 -06:00
|
|
|
if (O_OPOST(tty)) {
|
|
|
|
switch (c) {
|
|
|
|
case '\n':
|
|
|
|
if (O_ONLRET(tty))
|
|
|
|
tty->column = 0;
|
|
|
|
if (O_ONLCR(tty)) {
|
|
|
|
if (space < 2)
|
|
|
|
return -1;
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\r');
|
2005-04-16 16:20:36 -06:00
|
|
|
tty->column = 0;
|
|
|
|
}
|
|
|
|
tty->canon_column = tty->column;
|
|
|
|
break;
|
|
|
|
case '\r':
|
|
|
|
if (O_ONOCR(tty) && tty->column == 0)
|
|
|
|
return 0;
|
|
|
|
if (O_OCRNL(tty)) {
|
|
|
|
c = '\n';
|
|
|
|
if (O_ONLRET(tty))
|
|
|
|
tty->canon_column = tty->column = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tty->canon_column = tty->column = 0;
|
|
|
|
break;
|
|
|
|
case '\t':
|
|
|
|
spaces = 8 - (tty->column & 7);
|
|
|
|
if (O_TABDLY(tty) == XTABS) {
|
|
|
|
if (space < spaces)
|
|
|
|
return -1;
|
|
|
|
tty->column += spaces;
|
2008-04-30 01:54:13 -06:00
|
|
|
tty->ops->write(tty, " ", spaces);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
tty->column += spaces;
|
|
|
|
break;
|
|
|
|
case '\b':
|
|
|
|
if (tty->column > 0)
|
|
|
|
tty->column--;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (O_OLCUC(tty))
|
|
|
|
c = toupper(c);
|
|
|
|
if (!iscntrl(c) && !is_continuation(c, tty))
|
|
|
|
tty->column++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, c);
|
2008-04-30 01:53:29 -06:00
|
|
|
unlock_kernel();
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* opost_block - block postprocess
|
|
|
|
* @tty: terminal device
|
|
|
|
* @inbuf: user buffer
|
|
|
|
* @nr: number of bytes
|
|
|
|
*
|
|
|
|
* This path is used to speed up block console writes, among other
|
|
|
|
* things when processing blocks of output data. It handles only
|
|
|
|
* the simple cases normally found and helps to generate blocks of
|
|
|
|
* symbols for the console driver and thus improve performance.
|
|
|
|
*
|
2008-04-30 01:53:29 -06:00
|
|
|
* Called from write_chan under the tty layer write lock. Relies
|
|
|
|
* on lock_kernel for the tty->column state.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static ssize_t opost_block(struct tty_struct *tty,
|
|
|
|
const unsigned char *buf, unsigned int nr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int space;
|
|
|
|
int i;
|
|
|
|
const unsigned char *cp;
|
|
|
|
|
2008-04-30 01:54:13 -06:00
|
|
|
space = tty_write_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!space)
|
|
|
|
return 0;
|
|
|
|
if (nr > space)
|
|
|
|
nr = space;
|
|
|
|
|
2008-04-30 01:53:29 -06:00
|
|
|
lock_kernel();
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0, cp = buf; i < nr; i++, cp++) {
|
|
|
|
switch (*cp) {
|
|
|
|
case '\n':
|
|
|
|
if (O_ONLRET(tty))
|
|
|
|
tty->column = 0;
|
|
|
|
if (O_ONLCR(tty))
|
|
|
|
goto break_out;
|
|
|
|
tty->canon_column = tty->column;
|
|
|
|
break;
|
|
|
|
case '\r':
|
|
|
|
if (O_ONOCR(tty) && tty->column == 0)
|
|
|
|
goto break_out;
|
|
|
|
if (O_OCRNL(tty))
|
|
|
|
goto break_out;
|
|
|
|
tty->canon_column = tty->column = 0;
|
|
|
|
break;
|
|
|
|
case '\t':
|
|
|
|
goto break_out;
|
|
|
|
case '\b':
|
|
|
|
if (tty->column > 0)
|
|
|
|
tty->column--;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (O_OLCUC(tty))
|
|
|
|
goto break_out;
|
|
|
|
if (!iscntrl(*cp))
|
|
|
|
tty->column++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break_out:
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->flush_chars)
|
|
|
|
tty->ops->flush_chars(tty);
|
|
|
|
i = tty->ops->write(tty, buf, i);
|
2008-04-30 01:53:29 -06:00
|
|
|
unlock_kernel();
|
2005-04-16 16:20:36 -06:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* echo_char - echo characters
|
|
|
|
* @c: unicode byte to echo
|
|
|
|
* @tty: terminal device
|
|
|
|
*
|
2008-02-08 05:18:44 -07:00
|
|
|
* Echo user input back onto the screen. This must be called only when
|
2005-04-16 16:20:36 -06:00
|
|
|
* L_ECHO(tty) is true. Called from the driver receive_buf path.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void echo_char(unsigned char c, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t') {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '^');
|
|
|
|
tty_put_char(tty, c ^ 0100);
|
2005-04-16 16:20:36 -06:00
|
|
|
tty->column += 2;
|
|
|
|
} else
|
|
|
|
opost(c, tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void finish_erasing(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (tty->erasing) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '/');
|
2005-04-16 16:20:36 -06:00
|
|
|
tty->column++;
|
|
|
|
tty->erasing = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* eraser - handle erase function
|
|
|
|
* @c: character input
|
|
|
|
* @tty: terminal device
|
|
|
|
*
|
2007-10-19 15:10:43 -06:00
|
|
|
* Perform erase and necessary output when an erase character is
|
2005-04-16 16:20:36 -06:00
|
|
|
* present in the stream from the driver layer. Handles the complexities
|
|
|
|
* of UTF-8 multibyte symbols.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void eraser(unsigned char c, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
enum { ERASE, WERASE, KILL } kill_type;
|
|
|
|
int head, seen_alnums, cnt;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (tty->read_head == tty->canon_head) {
|
|
|
|
/* opost('\a', tty); */ /* what do you think? */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == ERASE_CHAR(tty))
|
|
|
|
kill_type = ERASE;
|
|
|
|
else if (c == WERASE_CHAR(tty))
|
|
|
|
kill_type = WERASE;
|
|
|
|
else {
|
|
|
|
if (!L_ECHO(tty)) {
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_cnt -= ((tty->read_head - tty->canon_head) &
|
|
|
|
(N_TTY_BUF_SIZE - 1));
|
|
|
|
tty->read_head = tty->canon_head;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!L_ECHOK(tty) || !L_ECHOKE(tty) || !L_ECHOE(tty)) {
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_cnt -= ((tty->read_head - tty->canon_head) &
|
|
|
|
(N_TTY_BUF_SIZE - 1));
|
|
|
|
tty->read_head = tty->canon_head;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
finish_erasing(tty);
|
|
|
|
echo_char(KILL_CHAR(tty), tty);
|
|
|
|
/* Add a newline if ECHOK is on and ECHOKE is off. */
|
|
|
|
if (L_ECHOK(tty))
|
|
|
|
opost('\n', tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
kill_type = KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
seen_alnums = 0;
|
|
|
|
while (tty->read_head != tty->canon_head) {
|
|
|
|
head = tty->read_head;
|
|
|
|
|
|
|
|
/* erase a single possibly multibyte character */
|
|
|
|
do {
|
|
|
|
head = (head - 1) & (N_TTY_BUF_SIZE-1);
|
|
|
|
c = tty->read_buf[head];
|
|
|
|
} while (is_continuation(c, tty) && head != tty->canon_head);
|
|
|
|
|
|
|
|
/* do not partially erase */
|
|
|
|
if (is_continuation(c, tty))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (kill_type == WERASE) {
|
|
|
|
/* Equivalent to BSD's ALTWERASE. */
|
|
|
|
if (isalnum(c) || c == '_')
|
|
|
|
seen_alnums++;
|
|
|
|
else if (seen_alnums)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cnt = (tty->read_head - head) & (N_TTY_BUF_SIZE-1);
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_head = head;
|
|
|
|
tty->read_cnt -= cnt;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
if (L_ECHO(tty)) {
|
|
|
|
if (L_ECHOPRT(tty)) {
|
|
|
|
if (!tty->erasing) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\\');
|
2005-04-16 16:20:36 -06:00
|
|
|
tty->column++;
|
|
|
|
tty->erasing = 1;
|
|
|
|
}
|
|
|
|
/* if cnt > 1, output a multi-byte character */
|
|
|
|
echo_char(c, tty);
|
|
|
|
while (--cnt > 0) {
|
|
|
|
head = (head+1) & (N_TTY_BUF_SIZE-1);
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, tty->read_buf[head]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else if (kill_type == ERASE && !L_ECHOE(tty)) {
|
|
|
|
echo_char(ERASE_CHAR(tty), tty);
|
|
|
|
} else if (c == '\t') {
|
|
|
|
unsigned int col = tty->canon_column;
|
|
|
|
unsigned long tail = tty->canon_head;
|
|
|
|
|
|
|
|
/* Find the column of the last char. */
|
|
|
|
while (tail != tty->read_head) {
|
|
|
|
c = tty->read_buf[tail];
|
|
|
|
if (c == '\t')
|
|
|
|
col = (col | 7) + 1;
|
|
|
|
else if (iscntrl(c)) {
|
|
|
|
if (L_ECHOCTL(tty))
|
|
|
|
col += 2;
|
|
|
|
} else if (!is_continuation(c, tty))
|
|
|
|
col++;
|
|
|
|
tail = (tail+1) & (N_TTY_BUF_SIZE-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should never happen */
|
|
|
|
if (tty->column > 0x80000000)
|
2008-02-08 05:18:44 -07:00
|
|
|
tty->column = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Now backup to that column. */
|
|
|
|
while (tty->column > col) {
|
|
|
|
/* Can't use opost here. */
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\b');
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->column > 0)
|
|
|
|
tty->column--;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (iscntrl(c) && L_ECHOCTL(tty)) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\b');
|
|
|
|
tty_put_char(tty, ' ');
|
|
|
|
tty_put_char(tty, '\b');
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->column > 0)
|
|
|
|
tty->column--;
|
|
|
|
}
|
|
|
|
if (!iscntrl(c) || L_ECHOCTL(tty)) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\b');
|
|
|
|
tty_put_char(tty, ' ');
|
|
|
|
tty_put_char(tty, '\b');
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->column > 0)
|
|
|
|
tty->column--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (kill_type == ERASE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (tty->read_head == tty->canon_head)
|
|
|
|
finish_erasing(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* isig - handle the ISIG optio
|
|
|
|
* @sig: signal
|
|
|
|
* @tty: terminal
|
|
|
|
* @flush: force flush
|
|
|
|
*
|
|
|
|
* Called when a signal is being sent due to terminal input. This
|
|
|
|
* may caus terminal flushing to take place according to the termios
|
|
|
|
* settings and character used. Called from the driver receive_buf
|
|
|
|
* path so serialized.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline void isig(int sig, struct tty_struct *tty, int flush)
|
|
|
|
{
|
2007-02-12 01:53:00 -07:00
|
|
|
if (tty->pgrp)
|
|
|
|
kill_pgrp(tty->pgrp, sig, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (flush || !L_NOFLSH(tty)) {
|
|
|
|
n_tty_flush_buffer(tty);
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_driver_flush_buffer(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_receive_break - handle break
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* An RS232 break event has been hit in the incoming bitstream. This
|
|
|
|
* can cause a variety of events depending upon the termios settings.
|
|
|
|
*
|
|
|
|
* Called from the receive_buf path so single threaded.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline void n_tty_receive_break(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (I_IGNBRK(tty))
|
|
|
|
return;
|
|
|
|
if (I_BRKINT(tty)) {
|
|
|
|
isig(SIGINT, tty, 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (I_PARMRK(tty)) {
|
|
|
|
put_tty_queue('\377', tty);
|
|
|
|
put_tty_queue('\0', tty);
|
|
|
|
}
|
|
|
|
put_tty_queue('\0', tty);
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_receive_overrun - handle overrun reporting
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Data arrived faster than we could process it. While the tty
|
|
|
|
* driver has flagged this the bits that were missed are gone
|
|
|
|
* forever.
|
|
|
|
*
|
|
|
|
* Called from the receive_buf path so single threaded. Does not
|
|
|
|
* need locking as num_overrun and overrun_time are function
|
|
|
|
* private.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline void n_tty_receive_overrun(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
tty->num_overrun++;
|
|
|
|
if (time_before(tty->overrun_time, jiffies - HZ) ||
|
|
|
|
time_after(tty->overrun_time, jiffies)) {
|
|
|
|
printk(KERN_WARNING "%s: %d input overrun(s)\n",
|
|
|
|
tty_name(tty, buf),
|
|
|
|
tty->num_overrun);
|
|
|
|
tty->overrun_time = jiffies;
|
|
|
|
tty->num_overrun = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_receive_parity_error - error notifier
|
|
|
|
* @tty: terminal device
|
|
|
|
* @c: character
|
|
|
|
*
|
|
|
|
* Process a parity error and queue the right data to indicate
|
2007-10-19 15:10:43 -06:00
|
|
|
* the error case if necessary. Locking as per n_tty_receive_buf.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static inline void n_tty_receive_parity_error(struct tty_struct *tty,
|
|
|
|
unsigned char c)
|
|
|
|
{
|
2008-02-08 05:18:44 -07:00
|
|
|
if (I_IGNPAR(tty))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
if (I_PARMRK(tty)) {
|
|
|
|
put_tty_queue('\377', tty);
|
|
|
|
put_tty_queue('\0', tty);
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
} else if (I_INPCK(tty))
|
|
|
|
put_tty_queue('\0', tty);
|
|
|
|
else
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_receive_char - perform processing
|
|
|
|
* @tty: terminal device
|
|
|
|
* @c: character
|
|
|
|
*
|
|
|
|
* Process an individual character of input received from the driver.
|
2008-02-08 05:18:44 -07:00
|
|
|
* This is serialized with respect to itself by the rules for the
|
2005-04-16 16:20:36 -06:00
|
|
|
* driver above.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline void n_tty_receive_char(struct tty_struct *tty, unsigned char c)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (tty->raw) {
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
return;
|
|
|
|
}
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (I_ISTRIP(tty))
|
|
|
|
c &= 0x7f;
|
|
|
|
if (I_IUCLC(tty) && L_IEXTEN(tty))
|
|
|
|
c=tolower(c);
|
|
|
|
|
2008-02-06 02:37:59 -07:00
|
|
|
if (tty->stopped && !tty->flow_stopped && I_IXON(tty) &&
|
|
|
|
((I_IXANY(tty) && c != START_CHAR(tty) && c != STOP_CHAR(tty)) ||
|
2008-04-30 01:53:30 -06:00
|
|
|
c == INTR_CHAR(tty) || c == QUIT_CHAR(tty) || c == SUSP_CHAR(tty)))
|
2008-02-06 02:37:59 -07:00
|
|
|
start_tty(tty);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->closing) {
|
|
|
|
if (I_IXON(tty)) {
|
|
|
|
if (c == START_CHAR(tty))
|
|
|
|
start_tty(tty);
|
|
|
|
else if (c == STOP_CHAR(tty))
|
|
|
|
stop_tty(tty);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the previous character was LNEXT, or we know that this
|
|
|
|
* character is not one of the characters that we'll have to
|
|
|
|
* handle specially, do shortcut processing to speed things
|
|
|
|
* up.
|
|
|
|
*/
|
|
|
|
if (!test_bit(c, tty->process_char_map) || tty->lnext) {
|
|
|
|
finish_erasing(tty);
|
|
|
|
tty->lnext = 0;
|
|
|
|
if (L_ECHO(tty)) {
|
|
|
|
if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\a'); /* beep if no space */
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Record the column of first canon char. */
|
|
|
|
if (tty->canon_head == tty->read_head)
|
|
|
|
tty->canon_column = tty->column;
|
|
|
|
echo_char(c, tty);
|
|
|
|
}
|
|
|
|
if (I_PARMRK(tty) && c == (unsigned char) '\377')
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
return;
|
|
|
|
}
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (I_IXON(tty)) {
|
|
|
|
if (c == START_CHAR(tty)) {
|
|
|
|
start_tty(tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == STOP_CHAR(tty)) {
|
|
|
|
stop_tty(tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 01:53:30 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (L_ISIG(tty)) {
|
|
|
|
int signal;
|
|
|
|
signal = SIGINT;
|
|
|
|
if (c == INTR_CHAR(tty))
|
|
|
|
goto send_signal;
|
|
|
|
signal = SIGQUIT;
|
|
|
|
if (c == QUIT_CHAR(tty))
|
|
|
|
goto send_signal;
|
|
|
|
signal = SIGTSTP;
|
|
|
|
if (c == SUSP_CHAR(tty)) {
|
|
|
|
send_signal:
|
2008-02-06 02:37:38 -07:00
|
|
|
/*
|
|
|
|
* Echo character, and then send the signal.
|
|
|
|
* Note that we do not use isig() here because we want
|
|
|
|
* the order to be:
|
|
|
|
* 1) flush, 2) echo, 3) signal
|
|
|
|
*/
|
|
|
|
if (!L_NOFLSH(tty)) {
|
|
|
|
n_tty_flush_buffer(tty);
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_driver_flush_buffer(tty);
|
2008-02-06 02:37:38 -07:00
|
|
|
}
|
|
|
|
if (L_ECHO(tty))
|
|
|
|
echo_char(c, tty);
|
|
|
|
if (tty->pgrp)
|
|
|
|
kill_pgrp(tty->pgrp, signal, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 01:53:30 -06:00
|
|
|
|
|
|
|
if (c == '\r') {
|
|
|
|
if (I_IGNCR(tty))
|
|
|
|
return;
|
|
|
|
if (I_ICRNL(tty))
|
|
|
|
c = '\n';
|
|
|
|
} else if (c == '\n' && I_INLCR(tty))
|
|
|
|
c = '\r';
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tty->icanon) {
|
|
|
|
if (c == ERASE_CHAR(tty) || c == KILL_CHAR(tty) ||
|
|
|
|
(c == WERASE_CHAR(tty) && L_IEXTEN(tty))) {
|
|
|
|
eraser(c, tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == LNEXT_CHAR(tty) && L_IEXTEN(tty)) {
|
|
|
|
tty->lnext = 1;
|
|
|
|
if (L_ECHO(tty)) {
|
|
|
|
finish_erasing(tty);
|
|
|
|
if (L_ECHOCTL(tty)) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '^');
|
|
|
|
tty_put_char(tty, '\b');
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == REPRINT_CHAR(tty) && L_ECHO(tty) &&
|
|
|
|
L_IEXTEN(tty)) {
|
|
|
|
unsigned long tail = tty->canon_head;
|
|
|
|
|
|
|
|
finish_erasing(tty);
|
|
|
|
echo_char(c, tty);
|
|
|
|
opost('\n', tty);
|
|
|
|
while (tail != tty->read_head) {
|
|
|
|
echo_char(tty->read_buf[tail], tty);
|
|
|
|
tail = (tail+1) & (N_TTY_BUF_SIZE-1);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == '\n') {
|
|
|
|
if (L_ECHO(tty) || L_ECHONL(tty)) {
|
2005-07-07 18:56:55 -06:00
|
|
|
if (tty->read_cnt >= N_TTY_BUF_SIZE-1)
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\a');
|
2005-04-16 16:20:36 -06:00
|
|
|
opost('\n', tty);
|
|
|
|
}
|
|
|
|
goto handle_newline;
|
|
|
|
}
|
|
|
|
if (c == EOF_CHAR(tty)) {
|
2008-02-08 05:18:44 -07:00
|
|
|
if (tty->canon_head != tty->read_head)
|
|
|
|
set_bit(TTY_PUSH, &tty->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
c = __DISABLED_CHAR;
|
|
|
|
goto handle_newline;
|
|
|
|
}
|
|
|
|
if ((c == EOL_CHAR(tty)) ||
|
|
|
|
(c == EOL2_CHAR(tty) && L_IEXTEN(tty))) {
|
|
|
|
/*
|
|
|
|
* XXX are EOL_CHAR and EOL2_CHAR echoed?!?
|
|
|
|
*/
|
|
|
|
if (L_ECHO(tty)) {
|
2005-07-07 18:56:55 -06:00
|
|
|
if (tty->read_cnt >= N_TTY_BUF_SIZE-1)
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\a');
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Record the column of first canon char. */
|
|
|
|
if (tty->canon_head == tty->read_head)
|
|
|
|
tty->canon_column = tty->column;
|
|
|
|
echo_char(c, tty);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* XXX does PARMRK doubling happen for
|
|
|
|
* EOL_CHAR and EOL2_CHAR?
|
|
|
|
*/
|
|
|
|
if (I_PARMRK(tty) && c == (unsigned char) '\377')
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
|
2008-02-08 05:18:44 -07:00
|
|
|
handle_newline:
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
set_bit(tty->read_head, tty->read_flags);
|
|
|
|
put_tty_queue_nolock(c, tty);
|
|
|
|
tty->canon_head = tty->read_head;
|
|
|
|
tty->canon_data++;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
kill_fasync(&tty->fasync, SIGIO, POLL_IN);
|
|
|
|
if (waitqueue_active(&tty->read_wait))
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
finish_erasing(tty);
|
|
|
|
if (L_ECHO(tty)) {
|
|
|
|
if (tty->read_cnt >= N_TTY_BUF_SIZE-1) {
|
2008-04-30 01:54:13 -06:00
|
|
|
tty_put_char(tty, '\a'); /* beep if no space */
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == '\n')
|
|
|
|
opost('\n', tty);
|
|
|
|
else {
|
|
|
|
/* Record the column of first canon char. */
|
|
|
|
if (tty->canon_head == tty->read_head)
|
|
|
|
tty->canon_column = tty->column;
|
|
|
|
echo_char(c, tty);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (I_PARMRK(tty) && c == (unsigned char) '\377')
|
|
|
|
put_tty_queue(c, tty);
|
|
|
|
|
|
|
|
put_tty_queue(c, tty);
|
2008-02-08 05:18:44 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_write_wakeup - asynchronous I/O notifier
|
|
|
|
* @tty: tty device
|
|
|
|
*
|
|
|
|
* Required for the ptys, serial driver etc. since processes
|
|
|
|
* that attach themselves to the master and rely on ASYNC
|
|
|
|
* IO must be woken up
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void n_tty_write_wakeup(struct tty_struct *tty)
|
|
|
|
{
|
2008-02-08 05:18:44 -07:00
|
|
|
if (tty->fasync) {
|
|
|
|
set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
kill_fasync(&tty->fasync, SIGIO, POLL_OUT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_receive_buf - data receive
|
|
|
|
* @tty: terminal device
|
|
|
|
* @cp: buffer
|
|
|
|
* @fp: flag buffer
|
|
|
|
* @count: characters
|
|
|
|
*
|
|
|
|
* Called by the terminal driver when a block of characters has
|
|
|
|
* been received. This function must be called from soft contexts
|
|
|
|
* not from interrupt context. The driver is responsible for making
|
|
|
|
* calls one at a time and in order (or using flush_to_ldisc)
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
|
|
|
|
char *fp, int count)
|
|
|
|
{
|
|
|
|
const unsigned char *p;
|
|
|
|
char *f, flags = TTY_NORMAL;
|
|
|
|
int i;
|
|
|
|
char buf[64];
|
|
|
|
unsigned long cpuflags;
|
|
|
|
|
|
|
|
if (!tty->read_buf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (tty->real_raw) {
|
|
|
|
spin_lock_irqsave(&tty->read_lock, cpuflags);
|
|
|
|
i = min(N_TTY_BUF_SIZE - tty->read_cnt,
|
|
|
|
N_TTY_BUF_SIZE - tty->read_head);
|
|
|
|
i = min(count, i);
|
|
|
|
memcpy(tty->read_buf + tty->read_head, cp, i);
|
|
|
|
tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
|
|
|
|
tty->read_cnt += i;
|
|
|
|
cp += i;
|
|
|
|
count -= i;
|
|
|
|
|
|
|
|
i = min(N_TTY_BUF_SIZE - tty->read_cnt,
|
|
|
|
N_TTY_BUF_SIZE - tty->read_head);
|
|
|
|
i = min(count, i);
|
|
|
|
memcpy(tty->read_buf + tty->read_head, cp, i);
|
|
|
|
tty->read_head = (tty->read_head + i) & (N_TTY_BUF_SIZE-1);
|
|
|
|
tty->read_cnt += i;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, cpuflags);
|
|
|
|
} else {
|
2008-02-08 05:18:44 -07:00
|
|
|
for (i = count, p = cp, f = fp; i; i--, p++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (f)
|
|
|
|
flags = *f++;
|
|
|
|
switch (flags) {
|
|
|
|
case TTY_NORMAL:
|
|
|
|
n_tty_receive_char(tty, *p);
|
|
|
|
break;
|
|
|
|
case TTY_BREAK:
|
|
|
|
n_tty_receive_break(tty);
|
|
|
|
break;
|
|
|
|
case TTY_PARITY:
|
|
|
|
case TTY_FRAME:
|
|
|
|
n_tty_receive_parity_error(tty, *p);
|
|
|
|
break;
|
|
|
|
case TTY_OVERRUN:
|
|
|
|
n_tty_receive_overrun(tty);
|
|
|
|
break;
|
|
|
|
default:
|
2008-02-08 05:18:44 -07:00
|
|
|
printk(KERN_ERR "%s: unknown flag %d\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
tty_name(tty, buf), flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->flush_chars)
|
|
|
|
tty->ops->flush_chars(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!tty->icanon && (tty->read_cnt >= tty->minimum_to_wake)) {
|
|
|
|
kill_fasync(&tty->fasync, SIGIO, POLL_IN);
|
|
|
|
if (waitqueue_active(&tty->read_wait))
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the remaining room for the input canonicalization
|
|
|
|
* mode. We don't want to throttle the driver if we're in
|
|
|
|
* canonical mode and don't have a newline yet!
|
|
|
|
*/
|
2008-04-30 01:54:18 -06:00
|
|
|
if (tty->receive_room < TTY_THRESHOLD_THROTTLE)
|
|
|
|
tty_throttle(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int is_ignored(int sig)
|
|
|
|
{
|
|
|
|
return (sigismember(¤t->blocked, sig) ||
|
2008-02-08 05:18:44 -07:00
|
|
|
current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_set_termios - termios data changed
|
|
|
|
* @tty: terminal
|
|
|
|
* @old: previous data
|
|
|
|
*
|
|
|
|
* Called by the tty layer when the user changes termios flags so
|
|
|
|
* that the line discipline can plan ahead. This function cannot sleep
|
2008-02-08 05:18:44 -07:00
|
|
|
* and is protected from re-entry by the tty layer. The user is
|
2005-04-16 16:20:36 -06:00
|
|
|
* guaranteed that this function will not be re-entered or in progress
|
|
|
|
* when the ldisc is closed.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static void n_tty_set_termios(struct tty_struct *tty, struct ktermios *old)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (!tty)
|
|
|
|
return;
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tty->icanon = (L_ICANON(tty) != 0);
|
|
|
|
if (test_bit(TTY_HW_COOK_IN, &tty->flags)) {
|
|
|
|
tty->raw = 1;
|
|
|
|
tty->real_raw = 1;
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (I_ISTRIP(tty) || I_IUCLC(tty) || I_IGNCR(tty) ||
|
|
|
|
I_ICRNL(tty) || I_INLCR(tty) || L_ICANON(tty) ||
|
|
|
|
I_IXON(tty) || L_ISIG(tty) || L_ECHO(tty) ||
|
|
|
|
I_PARMRK(tty)) {
|
|
|
|
memset(tty->process_char_map, 0, 256/8);
|
|
|
|
|
|
|
|
if (I_IGNCR(tty) || I_ICRNL(tty))
|
|
|
|
set_bit('\r', tty->process_char_map);
|
|
|
|
if (I_INLCR(tty))
|
|
|
|
set_bit('\n', tty->process_char_map);
|
|
|
|
|
|
|
|
if (L_ICANON(tty)) {
|
|
|
|
set_bit(ERASE_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit(KILL_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit(EOF_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit('\n', tty->process_char_map);
|
|
|
|
set_bit(EOL_CHAR(tty), tty->process_char_map);
|
|
|
|
if (L_IEXTEN(tty)) {
|
|
|
|
set_bit(WERASE_CHAR(tty),
|
|
|
|
tty->process_char_map);
|
|
|
|
set_bit(LNEXT_CHAR(tty),
|
|
|
|
tty->process_char_map);
|
|
|
|
set_bit(EOL2_CHAR(tty),
|
|
|
|
tty->process_char_map);
|
|
|
|
if (L_ECHO(tty))
|
|
|
|
set_bit(REPRINT_CHAR(tty),
|
|
|
|
tty->process_char_map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (I_IXON(tty)) {
|
|
|
|
set_bit(START_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit(STOP_CHAR(tty), tty->process_char_map);
|
|
|
|
}
|
|
|
|
if (L_ISIG(tty)) {
|
|
|
|
set_bit(INTR_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit(QUIT_CHAR(tty), tty->process_char_map);
|
|
|
|
set_bit(SUSP_CHAR(tty), tty->process_char_map);
|
|
|
|
}
|
|
|
|
clear_bit(__DISABLED_CHAR, tty->process_char_map);
|
|
|
|
tty->raw = 0;
|
|
|
|
tty->real_raw = 0;
|
|
|
|
} else {
|
|
|
|
tty->raw = 1;
|
|
|
|
if ((I_IGNBRK(tty) || (!I_BRKINT(tty) && !I_PARMRK(tty))) &&
|
|
|
|
(I_IGNPAR(tty) || !I_INPCK(tty)) &&
|
|
|
|
(tty->driver->flags & TTY_DRIVER_REAL_RAW))
|
|
|
|
tty->real_raw = 1;
|
|
|
|
else
|
|
|
|
tty->real_raw = 0;
|
|
|
|
}
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
2008-04-30 01:54:13 -06:00
|
|
|
/* The termios change make the tty ready for I/O */
|
|
|
|
wake_up_interruptible(&tty->write_wait);
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_close - close the ldisc for this tty
|
|
|
|
* @tty: device
|
|
|
|
*
|
2008-02-08 05:18:44 -07:00
|
|
|
* Called from the terminal layer when this line discipline is
|
|
|
|
* being shut down, either because of a close or becsuse of a
|
2005-04-16 16:20:36 -06:00
|
|
|
* discipline change. The function will not be called while other
|
|
|
|
* ldisc methods are in progress.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void n_tty_close(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
n_tty_flush_buffer(tty);
|
|
|
|
if (tty->read_buf) {
|
|
|
|
free_buf(tty->read_buf);
|
|
|
|
tty->read_buf = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* n_tty_open - open an ldisc
|
|
|
|
* @tty: terminal to open
|
|
|
|
*
|
2008-02-08 05:18:44 -07:00
|
|
|
* Called when this line discipline is being attached to the
|
2005-04-16 16:20:36 -06:00
|
|
|
* terminal device. Can sleep. Called serialized so that no
|
|
|
|
* other events will occur in parallel. No further open will occur
|
|
|
|
* until a close.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int n_tty_open(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (!tty)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* This one is ugly. Currently a malloc failure here can panic */
|
|
|
|
if (!tty->read_buf) {
|
|
|
|
tty->read_buf = alloc_buf();
|
|
|
|
if (!tty->read_buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
|
|
|
|
reset_buffer_flags(tty);
|
|
|
|
tty->column = 0;
|
|
|
|
n_tty_set_termios(tty, NULL);
|
|
|
|
tty->minimum_to_wake = 1;
|
|
|
|
tty->closing = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int input_available_p(struct tty_struct *tty, int amt)
|
|
|
|
{
|
|
|
|
if (tty->icanon) {
|
|
|
|
if (tty->canon_data)
|
|
|
|
return 1;
|
|
|
|
} else if (tty->read_cnt >= (amt ? amt : 1))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* copy_from_read_buf - copy read data directly
|
|
|
|
* @tty: terminal device
|
|
|
|
* @b: user data
|
|
|
|
* @nr: size of data
|
|
|
|
*
|
|
|
|
* Helper function to speed up read_chan. It is only called when
|
|
|
|
* ICANON is off; it copies characters straight from the tty queue to
|
|
|
|
* user space directly. It can be profitably called twice; once to
|
|
|
|
* drain the space from the tail pointer to the (physical) end of the
|
|
|
|
* buffer, and once to drain the space from the (physical) beginning of
|
|
|
|
* the buffer to head pointer.
|
|
|
|
*
|
2006-06-28 05:26:47 -06:00
|
|
|
* Called under the tty->atomic_read_lock sem
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
static int copy_from_read_buf(struct tty_struct *tty,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char __user **b,
|
|
|
|
size_t *nr)
|
|
|
|
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
size_t n;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
retval = 0;
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
n = min(tty->read_cnt, N_TTY_BUF_SIZE - tty->read_tail);
|
|
|
|
n = min(*nr, n);
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
if (n) {
|
|
|
|
retval = copy_to_user(*b, &tty->read_buf[tty->read_tail], n);
|
|
|
|
n -= retval;
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
tty_audit_add_data(tty, &tty->read_buf[tty->read_tail], n);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_tail = (tty->read_tail + n) & (N_TTY_BUF_SIZE-1);
|
|
|
|
tty->read_cnt -= n;
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
*b += n;
|
|
|
|
*nr -= n;
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-03-28 21:08:48 -06:00
|
|
|
extern ssize_t redirected_tty_write(struct file *, const char __user *,
|
2008-02-08 05:18:44 -07:00
|
|
|
size_t, loff_t *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* job_control - check job control
|
|
|
|
* @tty: tty
|
|
|
|
* @file: file handle
|
|
|
|
*
|
|
|
|
* Perform job control management checks on this file/tty descriptor
|
2008-02-08 05:18:44 -07:00
|
|
|
* and if appropriate send any needed signals and return a negative
|
2005-04-16 16:20:36 -06:00
|
|
|
* error code if action should be taken.
|
2008-04-30 01:53:29 -06:00
|
|
|
*
|
|
|
|
* FIXME:
|
|
|
|
* Locking: None - redirected write test is safe, testing
|
|
|
|
* current->signal should possibly lock current->sighand
|
|
|
|
* pgrp locking ?
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int job_control(struct tty_struct *tty, struct file *file)
|
|
|
|
{
|
|
|
|
/* Job control check -- must be done at start and after
|
|
|
|
every sleep (POSIX.1 7.1.1.4). */
|
|
|
|
/* NOTE: not yet done after every sleep pending a thorough
|
|
|
|
check of the logic of this change. -- jlc */
|
|
|
|
/* don't stop on /dev/console */
|
|
|
|
if (file->f_op->write != redirected_tty_write &&
|
|
|
|
current->signal->tty == tty) {
|
2007-02-12 01:53:00 -07:00
|
|
|
if (!tty->pgrp)
|
2008-02-08 05:18:44 -07:00
|
|
|
printk(KERN_ERR "read_chan: no tty->pgrp!\n");
|
2007-02-12 01:53:00 -07:00
|
|
|
else if (task_pgrp(current) != tty->pgrp) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (is_ignored(SIGTTIN) ||
|
2007-02-12 01:52:58 -07:00
|
|
|
is_current_pgrp_orphaned())
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EIO;
|
2007-02-12 01:53:00 -07:00
|
|
|
kill_pgrp(task_pgrp(current), SIGTTIN, 1);
|
2007-06-01 01:46:53 -06:00
|
|
|
set_thread_flag(TIF_SIGPENDING);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ERESTARTSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* read_chan - read function for tty
|
|
|
|
* @tty: tty device
|
|
|
|
* @file: file object
|
|
|
|
* @buf: userspace buffer pointer
|
|
|
|
* @nr: size of I/O
|
|
|
|
*
|
|
|
|
* Perform reads for the line discipline. We are guaranteed that the
|
|
|
|
* line discipline will not be closed under us but we may get multiple
|
|
|
|
* parallel readers and must handle this ourselves. We may also get
|
|
|
|
* a hangup. Always called in user context, may sleep.
|
|
|
|
*
|
|
|
|
* This code must be sure never to sleep through a hangup.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static ssize_t read_chan(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned char __user *buf, size_t nr)
|
|
|
|
{
|
|
|
|
unsigned char __user *b = buf;
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
int c;
|
|
|
|
int minimum, time;
|
|
|
|
ssize_t retval = 0;
|
|
|
|
ssize_t size;
|
|
|
|
long timeout;
|
|
|
|
unsigned long flags;
|
2008-04-30 01:53:29 -06:00
|
|
|
int packet;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
do_it_again:
|
|
|
|
|
|
|
|
if (!tty->read_buf) {
|
2008-02-08 05:18:44 -07:00
|
|
|
printk(KERN_ERR "n_tty_read_chan: read_buf == NULL?!?\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
c = job_control(tty, file);
|
2008-02-08 05:18:44 -07:00
|
|
|
if (c < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return c;
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
minimum = time = 0;
|
|
|
|
timeout = MAX_SCHEDULE_TIMEOUT;
|
|
|
|
if (!tty->icanon) {
|
|
|
|
time = (HZ / 10) * TIME_CHAR(tty);
|
|
|
|
minimum = MIN_CHAR(tty);
|
|
|
|
if (minimum) {
|
|
|
|
if (time)
|
|
|
|
tty->minimum_to_wake = 1;
|
|
|
|
else if (!waitqueue_active(&tty->read_wait) ||
|
|
|
|
(tty->minimum_to_wake > minimum))
|
|
|
|
tty->minimum_to_wake = minimum;
|
|
|
|
} else {
|
|
|
|
timeout = 0;
|
|
|
|
if (time) {
|
|
|
|
timeout = time;
|
|
|
|
time = 0;
|
|
|
|
}
|
|
|
|
tty->minimum_to_wake = minimum = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal serialization of reads.
|
|
|
|
*/
|
|
|
|
if (file->f_flags & O_NONBLOCK) {
|
2006-03-23 04:00:31 -07:00
|
|
|
if (!mutex_trylock(&tty->atomic_read_lock))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EAGAIN;
|
2008-02-08 05:18:44 -07:00
|
|
|
} else {
|
2006-03-23 04:00:31 -07:00
|
|
|
if (mutex_lock_interruptible(&tty->atomic_read_lock))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ERESTARTSYS;
|
|
|
|
}
|
2008-04-30 01:53:29 -06:00
|
|
|
packet = tty->packet;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
add_wait_queue(&tty->read_wait, &wait);
|
|
|
|
while (nr) {
|
|
|
|
/* First test for status change. */
|
2008-04-30 01:53:29 -06:00
|
|
|
if (packet && tty->link->ctrl_status) {
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char cs;
|
|
|
|
if (b != buf)
|
|
|
|
break;
|
2008-04-30 01:53:29 -06:00
|
|
|
spin_lock_irqsave(&tty->link->ctrl_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
cs = tty->link->ctrl_status;
|
|
|
|
tty->link->ctrl_status = 0;
|
2008-04-30 01:53:29 -06:00
|
|
|
spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
if (tty_put_user(tty, cs, b++)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -EFAULT;
|
|
|
|
b--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nr--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* This statement must be first before checking for input
|
|
|
|
so that any interrupt will set the state back to
|
|
|
|
TASK_RUNNING. */
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (((minimum - (b - buf)) < tty->minimum_to_wake) &&
|
|
|
|
((minimum - (b - buf)) >= 1))
|
|
|
|
tty->minimum_to_wake = (minimum - (b - buf));
|
2008-02-08 05:18:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!input_available_p(tty, 0)) {
|
|
|
|
if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
|
|
|
|
retval = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (tty_hung_up_p(file))
|
|
|
|
break;
|
|
|
|
if (!timeout)
|
|
|
|
break;
|
|
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
|
|
retval = -EAGAIN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
retval = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
2008-04-30 01:53:29 -06:00
|
|
|
/* FIXME: does n_tty_set_room need locking ? */
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
timeout = schedule_timeout(timeout);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
|
|
|
|
/* Deal with packet mode. */
|
2008-04-30 01:53:29 -06:00
|
|
|
if (packet && b == buf) {
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -EFAULT;
|
|
|
|
b--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nr--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tty->icanon) {
|
|
|
|
/* N.B. avoid overrun if nr == 0 */
|
|
|
|
while (nr && tty->read_cnt) {
|
2008-02-08 05:18:44 -07:00
|
|
|
int eol;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
eol = test_and_clear_bit(tty->read_tail,
|
|
|
|
tty->read_flags);
|
|
|
|
c = tty->read_buf[tty->read_tail];
|
|
|
|
spin_lock_irqsave(&tty->read_lock, flags);
|
|
|
|
tty->read_tail = ((tty->read_tail+1) &
|
|
|
|
(N_TTY_BUF_SIZE-1));
|
|
|
|
tty->read_cnt--;
|
|
|
|
if (eol) {
|
|
|
|
/* this test should be redundant:
|
|
|
|
* we shouldn't be reading data if
|
|
|
|
* canon_data is 0
|
|
|
|
*/
|
|
|
|
if (--tty->canon_data < 0)
|
|
|
|
tty->canon_data = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&tty->read_lock, flags);
|
|
|
|
|
|
|
|
if (!eol || (c != __DISABLED_CHAR)) {
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
if (tty_put_user(tty, c, b++)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = -EFAULT;
|
|
|
|
b--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nr--;
|
|
|
|
}
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
if (eol) {
|
|
|
|
tty_audit_push(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
Audit: add TTY input auditing
Add TTY input auditing, used to audit system administrator's actions. This is
required by various security standards such as DCID 6/3 and PCI to provide
non-repudiation of administrator's actions and to allow a review of past
actions if the administrator seems to overstep their duties or if the system
becomes misconfigured for unknown reasons. These requirements do not make it
necessary to audit TTY output as well.
Compared to an user-space keylogger, this approach records TTY input using the
audit subsystem, correlated with other audit events, and it is completely
transparent to the user-space application (e.g. the console ioctls still
work).
TTY input auditing works on a higher level than auditing all system calls
within the session, which would produce an overwhelming amount of mostly
useless audit events.
Add an "audit_tty" attribute, inherited across fork (). Data read from TTYs
by process with the attribute is sent to the audit subsystem by the kernel.
The audit netlink interface is extended to allow modifying the audit_tty
attribute, and to allow sending explanatory audit events from user-space (for
example, a shell might send an event containing the final command, after the
interactive command-line editing and history expansion is performed, which
might be difficult to decipher from the TTY input alone).
Because the "audit_tty" attribute is inherited across fork (), it would be set
e.g. for sshd restarted within an audited session. To prevent this, the
audit_tty attribute is cleared when a process with no open TTY file
descriptors (e.g. after daemon startup) opens a TTY.
See https://www.redhat.com/archives/linux-audit/2007-June/msg00000.html for a
more detailed rationale document for an older version of this patch.
[akpm@linux-foundation.org: build fix]
Signed-off-by: Miloslav Trmac <mitr@redhat.com>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Paul Fulghum <paulkf@microgate.com>
Cc: Casey Schaufler <casey@schaufler-ca.com>
Cc: Steve Grubb <sgrubb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-16 00:40:56 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
int uncopied;
|
2008-04-30 01:53:29 -06:00
|
|
|
/* The copy function takes the read lock and handles
|
|
|
|
locking internally for this case */
|
2005-04-16 16:20:36 -06:00
|
|
|
uncopied = copy_from_read_buf(tty, &b, &nr);
|
|
|
|
uncopied += copy_from_read_buf(tty, &b, &nr);
|
|
|
|
if (uncopied) {
|
|
|
|
retval = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is enough space in the read buffer now, let the
|
|
|
|
* low-level driver know. We use n_tty_chars_in_buffer() to
|
|
|
|
* check the buffer, as it now knows about canonical mode.
|
|
|
|
* Otherwise, if the driver is throttled and the line is
|
|
|
|
* longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
|
|
|
|
* we won't get any more characters.
|
|
|
|
*/
|
[PATCH] Fix for the PPTP hangs that have been reported
People have been reporting that PPP connections over ptys, such as
used with PPTP, will hang randomly when transferring large amounts of
data, for instance in http://bugzilla.kernel.org/show_bug.cgi?id=6530.
I have managed to reproduce the problem, and the patch below fixes the
actual cause.
The problem is not in fact in ppp_async.c but in n_tty.c. What
happens is that when pptp reads from the pty, we call read_chan() in
drivers/char/n_tty.c on the master side of the pty. That copies all
the characters out of its buffer to userspace and then calls
check_unthrottle(), which calls the pty unthrottle routine, which
calls tty_wakeup on the slave side, which calls ppp_asynctty_wakeup,
which calls tasklet_schedule. So far so good. Since we are in
process context, the tasklet runs immediately and calls
ppp_async_process(), which calls ppp_async_push, which calls the
tty->driver->write function to send some more output.
However, tty->driver->write() returns zero, because the master
tty->receive_room is still zero. We haven't returned from
check_unthrottle() yet, and read_chan() only updates tty->receive_room
_after_ calling check_unthrottle. That means that the driver->write
call in ppp_async_process() returns 0. That would be fine if we were
going to get a subsequent wakeup call, but we aren't (we just had it,
and the buffer is now empty).
The solution is for n_tty.c to update tty->receive_room _before_
calling the driver unthrottle routine. The patch below does this.
With this patch I was able to transfer a 900MB file over a PPTP
connection (taking about 25 minutes), whereas without the patch the
connection would always stall in under a minute.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-11 20:16:26 -06:00
|
|
|
if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
|
|
|
|
n_tty_set_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
check_unthrottle(tty);
|
[PATCH] Fix for the PPTP hangs that have been reported
People have been reporting that PPP connections over ptys, such as
used with PPTP, will hang randomly when transferring large amounts of
data, for instance in http://bugzilla.kernel.org/show_bug.cgi?id=6530.
I have managed to reproduce the problem, and the patch below fixes the
actual cause.
The problem is not in fact in ppp_async.c but in n_tty.c. What
happens is that when pptp reads from the pty, we call read_chan() in
drivers/char/n_tty.c on the master side of the pty. That copies all
the characters out of its buffer to userspace and then calls
check_unthrottle(), which calls the pty unthrottle routine, which
calls tty_wakeup on the slave side, which calls ppp_asynctty_wakeup,
which calls tasklet_schedule. So far so good. Since we are in
process context, the tasklet runs immediately and calls
ppp_async_process(), which calls ppp_async_push, which calls the
tty->driver->write function to send some more output.
However, tty->driver->write() returns zero, because the master
tty->receive_room is still zero. We haven't returned from
check_unthrottle() yet, and read_chan() only updates tty->receive_room
_after_ calling check_unthrottle. That means that the driver->write
call in ppp_async_process() returns 0. That would be fine if we were
going to get a subsequent wakeup call, but we aren't (we just had it,
and the buffer is now empty).
The solution is for n_tty.c to update tty->receive_room _before_
calling the driver unthrottle routine. The patch below does this.
With this patch I was able to transfer a 900MB file over a PPTP
connection (taking about 25 minutes), whereas without the patch the
connection would always stall in under a minute.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-11 20:16:26 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (b - buf >= minimum)
|
|
|
|
break;
|
|
|
|
if (time)
|
|
|
|
timeout = time;
|
|
|
|
}
|
2006-03-23 04:00:31 -07:00
|
|
|
mutex_unlock(&tty->atomic_read_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
remove_wait_queue(&tty->read_wait, &wait);
|
|
|
|
|
|
|
|
if (!waitqueue_active(&tty->read_wait))
|
|
|
|
tty->minimum_to_wake = minimum;
|
|
|
|
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
size = b - buf;
|
|
|
|
if (size) {
|
|
|
|
retval = size;
|
|
|
|
if (nr)
|
2008-02-08 05:18:44 -07:00
|
|
|
clear_bit(TTY_PUSH, &tty->flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (test_and_clear_bit(TTY_PUSH, &tty->flags))
|
|
|
|
goto do_it_again;
|
|
|
|
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
n_tty_set_room(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* write_chan - write function for tty
|
|
|
|
* @tty: tty device
|
|
|
|
* @file: file object
|
|
|
|
* @buf: userspace buffer pointer
|
|
|
|
* @nr: size of I/O
|
|
|
|
*
|
|
|
|
* Write function of the terminal device. This is serialized with
|
|
|
|
* respect to other write callers but not to termios changes, reads
|
|
|
|
* and other such events. We must be careful with N_TTY as the receive
|
|
|
|
* code will echo characters, thus calling driver write methods.
|
|
|
|
*
|
|
|
|
* This code must be sure never to sleep through a hangup.
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static ssize_t write_chan(struct tty_struct *tty, struct file *file,
|
|
|
|
const unsigned char *buf, size_t nr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
const unsigned char *b = buf;
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
int c;
|
|
|
|
ssize_t retval = 0;
|
|
|
|
|
|
|
|
/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
|
|
|
|
if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {
|
|
|
|
retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
add_wait_queue(&tty->write_wait, &wait);
|
|
|
|
while (1) {
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
retval = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
|
|
|
|
retval = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
|
|
|
|
while (nr > 0) {
|
|
|
|
ssize_t num = opost_block(tty, b, nr);
|
|
|
|
if (num < 0) {
|
|
|
|
if (num == -EAGAIN)
|
|
|
|
break;
|
|
|
|
retval = num;
|
|
|
|
goto break_out;
|
|
|
|
}
|
|
|
|
b += num;
|
|
|
|
nr -= num;
|
|
|
|
if (nr == 0)
|
|
|
|
break;
|
|
|
|
c = *b;
|
|
|
|
if (opost(c, tty) < 0)
|
|
|
|
break;
|
|
|
|
b++; nr--;
|
|
|
|
}
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->flush_chars)
|
|
|
|
tty->ops->flush_chars(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-07-07 18:56:55 -06:00
|
|
|
while (nr > 0) {
|
2008-04-30 01:54:13 -06:00
|
|
|
c = tty->ops->write(tty, b, nr);
|
2005-07-07 18:56:55 -06:00
|
|
|
if (c < 0) {
|
|
|
|
retval = c;
|
|
|
|
goto break_out;
|
|
|
|
}
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
b += c;
|
|
|
|
nr -= c;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!nr)
|
|
|
|
break;
|
|
|
|
if (file->f_flags & O_NONBLOCK) {
|
|
|
|
retval = -EAGAIN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
schedule();
|
|
|
|
}
|
|
|
|
break_out:
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
remove_wait_queue(&tty->write_wait, &wait);
|
|
|
|
return (b - buf) ? b - buf : retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* normal_poll - poll method for N_TTY
|
|
|
|
* @tty: terminal device
|
|
|
|
* @file: file accessing it
|
|
|
|
* @wait: poll table
|
|
|
|
*
|
|
|
|
* Called when the line discipline is asked to poll() for data or
|
|
|
|
* for special events. This code is not serialized with respect to
|
|
|
|
* other events save open/close.
|
|
|
|
*
|
|
|
|
* This code must be sure never to sleep through a hangup.
|
|
|
|
* Called without the kernel lock held - fine
|
|
|
|
*/
|
2008-02-08 05:18:44 -07:00
|
|
|
|
|
|
|
static unsigned int normal_poll(struct tty_struct *tty, struct file *file,
|
|
|
|
poll_table *wait)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned int mask = 0;
|
|
|
|
|
|
|
|
poll_wait(file, &tty->read_wait, wait);
|
|
|
|
poll_wait(file, &tty->write_wait, wait);
|
|
|
|
if (input_available_p(tty, TIME_CHAR(tty) ? 0 : MIN_CHAR(tty)))
|
|
|
|
mask |= POLLIN | POLLRDNORM;
|
|
|
|
if (tty->packet && tty->link->ctrl_status)
|
|
|
|
mask |= POLLPRI | POLLIN | POLLRDNORM;
|
|
|
|
if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
|
|
|
|
mask |= POLLHUP;
|
|
|
|
if (tty_hung_up_p(file))
|
|
|
|
mask |= POLLHUP;
|
|
|
|
if (!(mask & (POLLHUP | POLLIN | POLLRDNORM))) {
|
|
|
|
if (MIN_CHAR(tty) && !TIME_CHAR(tty))
|
|
|
|
tty->minimum_to_wake = MIN_CHAR(tty);
|
|
|
|
else
|
|
|
|
tty->minimum_to_wake = 1;
|
|
|
|
}
|
2008-04-30 01:54:13 -06:00
|
|
|
if (tty->ops->write && !tty_is_writelocked(tty) &&
|
|
|
|
tty_chars_in_buffer(tty) < WAKEUP_CHARS &&
|
|
|
|
tty_write_room(tty) > 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
mask |= POLLOUT | POLLWRNORM;
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct tty_ldisc tty_ldisc_N_TTY = {
|
2007-05-10 23:22:50 -06:00
|
|
|
.magic = TTY_LDISC_MAGIC,
|
|
|
|
.name = "n_tty",
|
|
|
|
.open = n_tty_open,
|
|
|
|
.close = n_tty_close,
|
|
|
|
.flush_buffer = n_tty_flush_buffer,
|
|
|
|
.chars_in_buffer = n_tty_chars_in_buffer,
|
|
|
|
.read = read_chan,
|
|
|
|
.write = write_chan,
|
|
|
|
.ioctl = n_tty_ioctl,
|
|
|
|
.set_termios = n_tty_set_termios,
|
|
|
|
.poll = normal_poll,
|
|
|
|
.receive_buf = n_tty_receive_buf,
|
|
|
|
.write_wakeup = n_tty_write_wakeup
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|