2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* linux/drivers/char/tty_io.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
|
|
|
|
* or rs-channels. It also implements echoing, cooked mode etc.
|
|
|
|
*
|
|
|
|
* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
|
|
|
|
*
|
|
|
|
* Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
|
|
|
|
* tty_struct and tty_queue structures. Previously there was an array
|
|
|
|
* of 256 tty_struct's which was statically allocated, and the
|
|
|
|
* tty_queue structures were allocated at boot time. Both are now
|
|
|
|
* dynamically allocated only when the tty is open.
|
|
|
|
*
|
|
|
|
* Also restructured routines so that there is more of a separation
|
|
|
|
* between the high-level tty routines (tty_io.c and tty_ioctl.c) and
|
|
|
|
* the low-level tty routines (serial.c, pty.c, console.c). This
|
2008-02-08 13:18:47 +01:00
|
|
|
* makes for cleaner and more compact code. -TYT, 9/17/92
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
|
|
|
|
* which can be dynamically activated and de-activated by the line
|
|
|
|
* discipline handling modules (like SLIP).
|
|
|
|
*
|
|
|
|
* NOTE: pay no attention to the line discipline code (yet); its
|
|
|
|
* interface is still subject to change in this version...
|
|
|
|
* -- TYT, 1/31/92
|
|
|
|
*
|
|
|
|
* Added functionality to the OPOST tty handling. No delays, but all
|
|
|
|
* other bits should be there.
|
|
|
|
* -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
|
|
|
|
*
|
|
|
|
* Rewrote canonical mode and added more termios flags.
|
|
|
|
* -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
|
|
|
|
*
|
|
|
|
* Reorganized FASYNC support so mouse code can share it.
|
|
|
|
* -- ctm@ardi.com, 9Sep95
|
|
|
|
*
|
|
|
|
* New TIOCLINUX variants added.
|
|
|
|
* -- mj@k332.feld.cvut.cz, 19-Nov-95
|
2008-02-08 13:18:47 +01:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* Restrict vt switching via ioctl()
|
|
|
|
* -- grif@cs.ucr.edu, 5-Dec-95
|
|
|
|
*
|
|
|
|
* Move console and virtual terminal code to more appropriate files,
|
|
|
|
* implement CONFIG_VT and generalize console device interface.
|
|
|
|
* -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
|
|
|
|
*
|
|
|
|
* Rewrote init_dev and release_dev to eliminate races.
|
|
|
|
* -- Bill Hawes <whawes@star.net>, June 97
|
|
|
|
*
|
|
|
|
* Added devfs support.
|
|
|
|
* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
|
|
|
|
*
|
|
|
|
* Added support for a Unix98-style ptmx device.
|
|
|
|
* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
|
|
|
|
*
|
|
|
|
* Reduced memory usage for older ARM systems
|
|
|
|
* -- Russell King <rmk@arm.linux.org.uk>
|
|
|
|
*
|
|
|
|
* Move do_SAK() into process context. Less stack use in devfs functions.
|
2008-02-08 13:18:47 +01:00
|
|
|
* alloc_tty_struct() always uses kmalloc()
|
|
|
|
* -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#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/tty_driver.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <linux/devpts_fs.h>
|
|
|
|
#include <linux/file.h>
|
2008-04-24 13:44:08 +02:00
|
|
|
#include <linux/fdtable.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/kd.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/bitops.h>
|
2005-06-25 23:58:42 +02:00
|
|
|
#include <linux/delay.h>
|
2008-07-16 22:53:12 +02:00
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-16 22:53:12 +02:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/system.h>
|
|
|
|
|
|
|
|
#include <linux/kbd_kern.h>
|
|
|
|
#include <linux/vt_kern.h>
|
|
|
|
#include <linux/selection.h>
|
|
|
|
|
|
|
|
#include <linux/kmod.h>
|
2007-10-19 08:40:14 +02:00
|
|
|
#include <linux/nsproxy.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#undef TTY_DEBUG_HANGUP
|
|
|
|
|
|
|
|
#define TTY_PARANOIA_CHECK 1
|
|
|
|
#define CHECK_TTY_COUNT 1
|
|
|
|
|
2006-12-08 11:38:44 +01:00
|
|
|
struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
|
2005-04-17 00:20:36 +02:00
|
|
|
.c_iflag = ICRNL | IXON,
|
|
|
|
.c_oflag = OPOST | ONLCR,
|
|
|
|
.c_cflag = B38400 | CS8 | CREAD | HUPCL,
|
|
|
|
.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
|
|
|
|
ECHOCTL | ECHOKE | IEXTEN,
|
2006-12-08 11:38:44 +01:00
|
|
|
.c_cc = INIT_C_CC,
|
|
|
|
.c_ispeed = 38400,
|
|
|
|
.c_ospeed = 38400
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_std_termios);
|
|
|
|
|
|
|
|
/* This list gets poked at by procfs and various bits of boot up code. This
|
|
|
|
could do with some rationalisation such as pulling the tty proc function
|
|
|
|
into this file */
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
LIST_HEAD(tty_drivers); /* linked list of tty drivers */
|
|
|
|
|
2006-12-08 11:36:04 +01:00
|
|
|
/* Mutex to protect creating and releasing a tty. This is shared with
|
2005-04-17 00:20:36 +02:00
|
|
|
vt.c for deeply disgusting hack reasons */
|
2006-03-23 12:00:31 +01:00
|
|
|
DEFINE_MUTEX(tty_mutex);
|
2006-09-29 11:00:57 +02:00
|
|
|
EXPORT_SYMBOL(tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_UNIX98_PTYS
|
|
|
|
extern struct tty_driver *ptm_driver; /* Unix98 pty masters; for /dev/ptmx */
|
|
|
|
static int ptmx_open(struct inode *, struct file *);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void initialize_tty_struct(struct tty_struct *tty);
|
|
|
|
|
|
|
|
static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
|
|
|
|
static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
|
2008-02-08 13:18:47 +01:00
|
|
|
ssize_t redirected_tty_write(struct file *, const char __user *,
|
|
|
|
size_t, loff_t *);
|
2005-04-17 00:20:36 +02:00
|
|
|
static unsigned int tty_poll(struct file *, poll_table *);
|
|
|
|
static int tty_open(struct inode *, struct file *);
|
|
|
|
static int tty_release(struct inode *, struct file *);
|
2008-04-30 09:53:29 +02:00
|
|
|
long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
|
2007-05-11 07:22:50 +02:00
|
|
|
#ifdef CONFIG_COMPAT
|
2008-02-08 13:18:47 +01:00
|
|
|
static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
2007-05-11 07:22:50 +02:00
|
|
|
unsigned long arg);
|
|
|
|
#else
|
|
|
|
#define tty_compat_ioctl NULL
|
|
|
|
#endif
|
2008-02-08 13:18:47 +01:00
|
|
|
static int tty_fasync(int fd, struct file *filp, int on);
|
2007-02-10 10:46:46 +01:00
|
|
|
static void release_tty(struct tty_struct *tty, int idx);
|
2007-05-08 09:26:53 +02:00
|
|
|
static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
|
2007-05-08 09:26:56 +02:00
|
|
|
static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* alloc_tty_struct - allocate a tty object
|
|
|
|
*
|
|
|
|
* Return a new empty tty structure. The data fields have not
|
|
|
|
* been initialized in any way but has been zeroed
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static struct tty_struct *alloc_tty_struct(void)
|
|
|
|
{
|
2006-09-29 11:00:40 +02:00
|
|
|
return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
|
2005-04-17 00:20:36 +02: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-10 05:54:13 +01:00
|
|
|
static void tty_buffer_free_all(struct tty_struct *);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* free_tty_struct - free a disused tty
|
|
|
|
* @tty: tty struct to free
|
|
|
|
*
|
|
|
|
* Free the write buffers, tty queue and tty memory itself.
|
|
|
|
*
|
|
|
|
* Locking: none. Must be called after tty is definitely unused
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline void free_tty_struct(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
kfree(tty->write_buf);
|
[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-10 05:54:13 +01:00
|
|
|
tty_buffer_free_all(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_name - return tty naming
|
|
|
|
* @tty: tty structure
|
|
|
|
* @buf: buffer for output
|
|
|
|
*
|
|
|
|
* Convert a tty structure into a name. The name reflects the kernel
|
|
|
|
* naming policy and if udev is in use may not reflect user space
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
char *tty_name(struct tty_struct *tty, char *buf)
|
|
|
|
{
|
|
|
|
if (!tty) /* Hmm. NULL pointer. That's fun. */
|
|
|
|
strcpy(buf, "NULL tty");
|
|
|
|
else
|
|
|
|
strcpy(buf, tty->name);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_name);
|
|
|
|
|
2005-05-06 01:15:50 +02:00
|
|
|
int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
|
2005-04-17 00:20:36 +02:00
|
|
|
const char *routine)
|
|
|
|
{
|
|
|
|
#ifdef TTY_PARANOIA_CHECK
|
|
|
|
if (!tty) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"null TTY for (%d:%d) in %s\n",
|
|
|
|
imajor(inode), iminor(inode), routine);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (tty->magic != TTY_MAGIC) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"bad magic number for tty struct (%d:%d) in %s\n",
|
|
|
|
imajor(inode), iminor(inode), routine);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_tty_count(struct tty_struct *tty, const char *routine)
|
|
|
|
{
|
|
|
|
#ifdef CHECK_TTY_COUNT
|
|
|
|
struct list_head *p;
|
|
|
|
int count = 0;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
file_list_lock();
|
|
|
|
list_for_each(p, &tty->tty_files) {
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
file_list_unlock();
|
|
|
|
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_SLAVE &&
|
|
|
|
tty->link && tty->link->count)
|
|
|
|
count++;
|
|
|
|
if (tty->count != count) {
|
|
|
|
printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
|
|
|
|
"!= #fd's(%d) in %s\n",
|
|
|
|
tty->name, tty->count, count, routine);
|
|
|
|
return count;
|
2006-12-08 11:36:04 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
return 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-10 05:54:13 +01:00
|
|
|
/*
|
|
|
|
* Tty buffer allocation management
|
|
|
|
*/
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_free_all - free buffers used by a tty
|
|
|
|
* @tty: tty to free from
|
|
|
|
*
|
|
|
|
* Remove all the buffers pending on a tty whether queued with data
|
|
|
|
* or in the free ring. Must be called when the tty is no longer in use
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
[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-10 05:54:13 +01:00
|
|
|
static void tty_buffer_free_all(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct tty_buffer *thead;
|
2008-02-08 13:18:47 +01:00
|
|
|
while ((thead = tty->buf.head) != NULL) {
|
[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-10 05:54:13 +01:00
|
|
|
tty->buf.head = thead->next;
|
|
|
|
kfree(thead);
|
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
while ((thead = tty->buf.free) != NULL) {
|
[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-10 05:54:13 +01:00
|
|
|
tty->buf.free = thead->next;
|
|
|
|
kfree(thead);
|
|
|
|
}
|
|
|
|
tty->buf.tail = NULL;
|
2006-08-27 10:24:02 +02:00
|
|
|
tty->buf.memory_used = 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-10 05:54:13 +01:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:02 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_init - prepare a tty buffer structure
|
|
|
|
* @tty: tty to initialise
|
|
|
|
*
|
|
|
|
* Set up the initial state of the buffer management for a tty device.
|
|
|
|
* Must be called before the other tty buffer functions are used.
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
[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-10 05:54:13 +01:00
|
|
|
static void tty_buffer_init(struct tty_struct *tty)
|
|
|
|
{
|
2006-02-03 12:04:41 +01:00
|
|
|
spin_lock_init(&tty->buf.lock);
|
[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-10 05:54:13 +01:00
|
|
|
tty->buf.head = NULL;
|
|
|
|
tty->buf.tail = NULL;
|
|
|
|
tty->buf.free = NULL;
|
2006-08-27 10:24:02 +02:00
|
|
|
tty->buf.memory_used = 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-10 05:54:13 +01:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:02 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_alloc - allocate a tty buffer
|
|
|
|
* @tty: tty device
|
|
|
|
* @size: desired size (characters)
|
|
|
|
*
|
|
|
|
* Allocate a new tty buffer to hold the desired number of characters.
|
|
|
|
* Return NULL if out of memory or the allocation would exceed the
|
|
|
|
* per device queue
|
|
|
|
*
|
|
|
|
* Locking: Caller must hold tty->buf.lock
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
|
[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-10 05:54:13 +01:00
|
|
|
{
|
2006-08-27 10:24:02 +02:00
|
|
|
struct tty_buffer *p;
|
|
|
|
|
|
|
|
if (tty->buf.memory_used + size > 65536)
|
|
|
|
return NULL;
|
|
|
|
p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
|
2008-02-08 13:18:47 +01:00
|
|
|
if (p == NULL)
|
[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-10 05:54:13 +01:00
|
|
|
return NULL;
|
|
|
|
p->used = 0;
|
|
|
|
p->size = size;
|
|
|
|
p->next = NULL;
|
2006-02-10 10:51:14 +01:00
|
|
|
p->commit = 0;
|
|
|
|
p->read = 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-10 05:54:13 +01:00
|
|
|
p->char_buf_ptr = (char *)(p->data);
|
|
|
|
p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
|
2006-08-27 10:24:02 +02:00
|
|
|
tty->buf.memory_used += size;
|
[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-10 05:54:13 +01:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:02 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_free - free a tty buffer
|
|
|
|
* @tty: tty owning the buffer
|
|
|
|
* @b: the buffer to free
|
|
|
|
*
|
|
|
|
* Free a tty buffer, or add it to the free list according to our
|
|
|
|
* internal strategy
|
|
|
|
*
|
|
|
|
* Locking: Caller must hold tty->buf.lock
|
|
|
|
*/
|
[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-10 05:54:13 +01:00
|
|
|
|
|
|
|
static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
|
|
|
|
{
|
|
|
|
/* Dumb strategy for now - should keep some stats */
|
2006-08-27 10:24:02 +02:00
|
|
|
tty->buf.memory_used -= b->size;
|
|
|
|
WARN_ON(tty->buf.memory_used < 0);
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
if (b->size >= 512)
|
[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-10 05:54:13 +01:00
|
|
|
kfree(b);
|
|
|
|
else {
|
|
|
|
b->next = tty->buf.free;
|
|
|
|
tty->buf.free = b;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-12 19:36:55 +02:00
|
|
|
/**
|
2007-08-10 22:01:05 +02:00
|
|
|
* __tty_buffer_flush - flush full tty buffers
|
2007-05-12 19:36:55 +02:00
|
|
|
* @tty: tty to flush
|
|
|
|
*
|
2007-08-10 22:01:05 +02:00
|
|
|
* flush all the buffers containing receive data. Caller must
|
|
|
|
* hold the buffer lock and must have ensured no parallel flush to
|
|
|
|
* ldisc is running.
|
2007-05-12 19:36:55 +02:00
|
|
|
*
|
2007-08-10 22:01:05 +02:00
|
|
|
* Locking: Caller must hold tty->buf.lock
|
2007-05-12 19:36:55 +02:00
|
|
|
*/
|
|
|
|
|
2007-08-10 22:01:05 +02:00
|
|
|
static void __tty_buffer_flush(struct tty_struct *tty)
|
2007-05-12 19:36:55 +02:00
|
|
|
{
|
|
|
|
struct tty_buffer *thead;
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
while ((thead = tty->buf.head) != NULL) {
|
2007-05-12 19:36:55 +02:00
|
|
|
tty->buf.head = thead->next;
|
|
|
|
tty_buffer_free(tty, thead);
|
|
|
|
}
|
|
|
|
tty->buf.tail = NULL;
|
2007-08-10 22:01:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_buffer_flush - flush full tty buffers
|
|
|
|
* @tty: tty to flush
|
|
|
|
*
|
|
|
|
* flush all the buffers containing receive data. If the buffer is
|
|
|
|
* being processed by flush_to_ldisc then we defer the processing
|
|
|
|
* to that function
|
|
|
|
*
|
|
|
|
* Locking: none
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void tty_buffer_flush(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->buf.lock, flags);
|
|
|
|
|
|
|
|
/* If the data is being pushed to the tty layer then we can't
|
|
|
|
process it here. Instead set a flag and the flush_to_ldisc
|
|
|
|
path will process the flush request before it exits */
|
|
|
|
if (test_bit(TTY_FLUSHING, &tty->flags)) {
|
|
|
|
set_bit(TTY_FLUSHPENDING, &tty->flags);
|
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
|
|
|
wait_event(tty->read_wait,
|
|
|
|
test_bit(TTY_FLUSHPENDING, &tty->flags) == 0);
|
|
|
|
return;
|
|
|
|
} else
|
|
|
|
__tty_buffer_flush(tty);
|
2007-05-12 19:36:55 +02:00
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:02 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_find - find a free tty buffer
|
|
|
|
* @tty: tty owning the buffer
|
|
|
|
* @size: characters wanted
|
|
|
|
*
|
|
|
|
* Locate an existing suitable tty buffer or if we are lacking one then
|
|
|
|
* allocate a new one. We round our buffers off in 256 character chunks
|
|
|
|
* to get better allocation behaviour.
|
|
|
|
*
|
|
|
|
* Locking: Caller must hold tty->buf.lock
|
|
|
|
*/
|
|
|
|
|
[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-10 05:54:13 +01:00
|
|
|
static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
|
|
|
|
{
|
|
|
|
struct tty_buffer **tbh = &tty->buf.free;
|
2008-02-08 13:18:47 +01:00
|
|
|
while ((*tbh) != NULL) {
|
[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-10 05:54:13 +01:00
|
|
|
struct tty_buffer *t = *tbh;
|
2008-02-08 13:18:47 +01:00
|
|
|
if (t->size >= size) {
|
[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-10 05:54:13 +01:00
|
|
|
*tbh = t->next;
|
|
|
|
t->next = NULL;
|
|
|
|
t->used = 0;
|
2006-02-10 10:51:14 +01:00
|
|
|
t->commit = 0;
|
|
|
|
t->read = 0;
|
2006-08-27 10:24:02 +02:00
|
|
|
tty->buf.memory_used += t->size;
|
[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-10 05:54:13 +01:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
tbh = &((*tbh)->next);
|
|
|
|
}
|
|
|
|
/* Round the buffer size out */
|
2008-02-08 13:18:47 +01:00
|
|
|
size = (size + 0xFF) & ~0xFF;
|
2006-08-27 10:24:02 +02:00
|
|
|
return tty_buffer_alloc(tty, size);
|
[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-10 05:54:13 +01:00
|
|
|
/* Should possibly check if this fails for the largest buffer we
|
|
|
|
have queued and recycle that ? */
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:02 +02:00
|
|
|
/**
|
|
|
|
* tty_buffer_request_room - grow tty buffer if needed
|
|
|
|
* @tty: tty structure
|
|
|
|
* @size: size desired
|
|
|
|
*
|
|
|
|
* Make at least size bytes of linear space available for the tty
|
|
|
|
* buffer. If we fail return the size we managed to find.
|
|
|
|
*
|
|
|
|
* Locking: Takes tty->buf.lock
|
|
|
|
*/
|
[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-10 05:54:13 +01:00
|
|
|
int tty_buffer_request_room(struct tty_struct *tty, size_t size)
|
|
|
|
{
|
2006-02-03 12:04:41 +01:00
|
|
|
struct tty_buffer *b, *n;
|
|
|
|
int left;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tty->buf.lock, 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-10 05:54:13 +01:00
|
|
|
|
|
|
|
/* OPTIMISATION: We could keep a per tty "zero" sized buffer to
|
|
|
|
remove this conditional if its worth it. This would be invisible
|
|
|
|
to the callers */
|
2006-06-28 13:26:49 +02:00
|
|
|
if ((b = tty->buf.tail) != NULL)
|
[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-10 05:54:13 +01:00
|
|
|
left = b->size - b->used;
|
2006-06-28 13:26:49 +02:00
|
|
|
else
|
2006-02-03 12:04:41 +01:00
|
|
|
left = 0;
|
|
|
|
|
|
|
|
if (left < size) {
|
|
|
|
/* This is the slow path - looking for new buffers to use */
|
|
|
|
if ((n = tty_buffer_find(tty, size)) != NULL) {
|
|
|
|
if (b != NULL) {
|
|
|
|
b->next = n;
|
2006-02-10 10:51:14 +01:00
|
|
|
b->commit = b->used;
|
2006-02-03 12:04:41 +01:00
|
|
|
} else
|
|
|
|
tty->buf.head = n;
|
|
|
|
tty->buf.tail = n;
|
|
|
|
} else
|
|
|
|
size = left;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, 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-10 05:54:13 +01:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_buffer_request_room);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_insert_flip_string - Add characters to the tty buffer
|
|
|
|
* @tty: tty structure
|
|
|
|
* @chars: characters
|
|
|
|
* @size: size
|
|
|
|
*
|
|
|
|
* Queue a series of bytes to the tty buffering. All the characters
|
|
|
|
* passed are marked as without error. Returns the number added.
|
|
|
|
*
|
|
|
|
* Locking: Called functions may take tty->buf.lock
|
|
|
|
*/
|
|
|
|
|
2006-04-11 07:54:05 +02:00
|
|
|
int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
|
|
|
|
size_t size)
|
[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-10 05:54:13 +01:00
|
|
|
{
|
|
|
|
int copied = 0;
|
|
|
|
do {
|
|
|
|
int space = tty_buffer_request_room(tty, size - copied);
|
|
|
|
struct tty_buffer *tb = tty->buf.tail;
|
|
|
|
/* If there is no space then tb may be NULL */
|
2008-02-08 13:18:47 +01:00
|
|
|
if (unlikely(space == 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-10 05:54:13 +01:00
|
|
|
break;
|
|
|
|
memcpy(tb->char_buf_ptr + tb->used, chars, space);
|
|
|
|
memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
|
|
|
|
tb->used += space;
|
|
|
|
copied += space;
|
|
|
|
chars += space;
|
2006-09-29 10:59:50 +02:00
|
|
|
/* There is a small chance that we need to split the data over
|
|
|
|
several buffers. If this is the case we must loop */
|
|
|
|
} while (unlikely(size > copied));
|
[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-10 05:54:13 +01:00
|
|
|
return copied;
|
|
|
|
}
|
2006-03-31 12:30:35 +02:00
|
|
|
EXPORT_SYMBOL(tty_insert_flip_string);
|
[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-10 05:54:13 +01:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_insert_flip_string_flags - Add characters to the tty buffer
|
|
|
|
* @tty: tty structure
|
|
|
|
* @chars: characters
|
|
|
|
* @flags: flag bytes
|
|
|
|
* @size: size
|
|
|
|
*
|
|
|
|
* Queue a series of bytes to the tty buffering. For each character
|
|
|
|
* the flags array indicates the status of the character. Returns the
|
|
|
|
* number added.
|
|
|
|
*
|
|
|
|
* Locking: Called functions may take tty->buf.lock
|
|
|
|
*/
|
|
|
|
|
2006-04-11 07:54:05 +02:00
|
|
|
int tty_insert_flip_string_flags(struct tty_struct *tty,
|
|
|
|
const unsigned char *chars, const char *flags, size_t size)
|
[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-10 05:54:13 +01:00
|
|
|
{
|
|
|
|
int copied = 0;
|
|
|
|
do {
|
|
|
|
int space = tty_buffer_request_room(tty, size - copied);
|
|
|
|
struct tty_buffer *tb = tty->buf.tail;
|
|
|
|
/* If there is no space then tb may be NULL */
|
2008-02-08 13:18:47 +01:00
|
|
|
if (unlikely(space == 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-10 05:54:13 +01:00
|
|
|
break;
|
|
|
|
memcpy(tb->char_buf_ptr + tb->used, chars, space);
|
|
|
|
memcpy(tb->flag_buf_ptr + tb->used, flags, space);
|
|
|
|
tb->used += space;
|
|
|
|
copied += space;
|
|
|
|
chars += space;
|
|
|
|
flags += space;
|
2006-09-29 10:59:50 +02:00
|
|
|
/* There is a small chance that we need to split the data over
|
|
|
|
several buffers. If this is the case we must loop */
|
|
|
|
} while (unlikely(size > copied));
|
[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-10 05:54:13 +01:00
|
|
|
return copied;
|
|
|
|
}
|
2006-05-23 07:35:28 +02:00
|
|
|
EXPORT_SYMBOL(tty_insert_flip_string_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-10 05:54:13 +01:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_schedule_flip - push characters to ldisc
|
|
|
|
* @tty: tty to push from
|
|
|
|
*
|
|
|
|
* Takes any pending buffers and transfers their ownership to the
|
|
|
|
* ldisc side of the queue. It then schedules those characters for
|
|
|
|
* processing by the line discipline.
|
|
|
|
*
|
|
|
|
* Locking: Takes tty->buf.lock
|
|
|
|
*/
|
|
|
|
|
2006-04-11 07:54:05 +02:00
|
|
|
void tty_schedule_flip(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->buf.lock, flags);
|
2006-06-28 13:26:49 +02:00
|
|
|
if (tty->buf.tail != NULL)
|
2006-04-11 07:54:05 +02:00
|
|
|
tty->buf.tail->commit = tty->buf.tail->used;
|
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
|
|
|
schedule_delayed_work(&tty->buf.work, 1);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_schedule_flip);
|
[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-10 05:54:13 +01:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_prepare_flip_string - make room for characters
|
|
|
|
* @tty: tty
|
|
|
|
* @chars: return pointer for character write area
|
|
|
|
* @size: desired size
|
|
|
|
*
|
[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-10 05:54:13 +01:00
|
|
|
* Prepare a block of space in the buffer for data. Returns the length
|
|
|
|
* available and buffer pointer to the space which is now allocated and
|
|
|
|
* accounted for as ready for normal characters. This is used for drivers
|
|
|
|
* that need their own block copy routines into the buffer. There is no
|
|
|
|
* guarantee the buffer is a DMA target!
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* Locking: May call functions taking tty->buf.lock
|
[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-10 05:54:13 +01:00
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,
|
|
|
|
size_t size)
|
[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-10 05:54:13 +01:00
|
|
|
{
|
|
|
|
int space = tty_buffer_request_room(tty, size);
|
2006-02-03 12:04:41 +01:00
|
|
|
if (likely(space)) {
|
|
|
|
struct tty_buffer *tb = tty->buf.tail;
|
|
|
|
*chars = tb->char_buf_ptr + tb->used;
|
|
|
|
memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
|
|
|
|
tb->used += space;
|
|
|
|
}
|
[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-10 05:54:13 +01:00
|
|
|
return space;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_prepare_flip_string_flags - make room for characters
|
|
|
|
* @tty: tty
|
|
|
|
* @chars: return pointer for character write area
|
|
|
|
* @flags: return pointer for status flag write area
|
|
|
|
* @size: desired size
|
|
|
|
*
|
[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-10 05:54:13 +01:00
|
|
|
* Prepare a block of space in the buffer for data. Returns the length
|
|
|
|
* available and buffer pointer to the space which is now allocated and
|
|
|
|
* accounted for as ready for characters. This is used for drivers
|
|
|
|
* that need their own block copy routines into the buffer. There is no
|
|
|
|
* guarantee the buffer is a DMA target!
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* Locking: May call functions taking tty->buf.lock
|
[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-10 05:54:13 +01:00
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
int tty_prepare_flip_string_flags(struct tty_struct *tty,
|
|
|
|
unsigned char **chars, char **flags, size_t size)
|
[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-10 05:54:13 +01:00
|
|
|
{
|
|
|
|
int space = tty_buffer_request_room(tty, size);
|
2006-02-03 12:04:41 +01:00
|
|
|
if (likely(space)) {
|
|
|
|
struct tty_buffer *tb = tty->buf.tail;
|
|
|
|
*chars = tb->char_buf_ptr + tb->used;
|
|
|
|
*flags = tb->flag_buf_ptr + tb->used;
|
|
|
|
tb->used += space;
|
|
|
|
}
|
[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-10 05:54:13 +01:00
|
|
|
return space;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* get_tty_driver - find device of a tty
|
|
|
|
* @dev_t: device identifier
|
|
|
|
* @index: returns the index of the tty
|
|
|
|
*
|
|
|
|
* This routine returns a tty driver structure, given a device number
|
|
|
|
* and also passes back the index number.
|
|
|
|
*
|
|
|
|
* Locking: caller must hold tty_mutex
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct tty_driver *get_tty_driver(dev_t device, int *index)
|
|
|
|
{
|
|
|
|
struct tty_driver *p;
|
|
|
|
|
|
|
|
list_for_each_entry(p, &tty_drivers, tty_drivers) {
|
|
|
|
dev_t base = MKDEV(p->major, p->minor_start);
|
|
|
|
if (device < base || device >= base + p->num)
|
|
|
|
continue;
|
|
|
|
*index = device - base;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-04-17 20:05:37 +02:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_find_polling_driver - find device of a polled tty
|
|
|
|
* @name: name string to match
|
|
|
|
* @line: pointer to resulting tty line nr
|
|
|
|
*
|
|
|
|
* This routine returns a tty driver structure, given a name
|
|
|
|
* and the condition that the tty driver is capable of polled
|
|
|
|
* operation.
|
|
|
|
*/
|
|
|
|
struct tty_driver *tty_find_polling_driver(char *name, int *line)
|
|
|
|
{
|
|
|
|
struct tty_driver *p, *res = NULL;
|
|
|
|
int tty_line = 0;
|
2008-09-26 17:36:42 +02:00
|
|
|
int len;
|
2008-04-17 20:05:37 +02:00
|
|
|
char *str;
|
|
|
|
|
2008-09-26 17:36:42 +02:00
|
|
|
for (str = name; *str; str++)
|
|
|
|
if ((*str >= '0' && *str <= '9') || *str == ',')
|
|
|
|
break;
|
|
|
|
if (!*str)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
len = str - name;
|
|
|
|
tty_line = simple_strtoul(str, &str, 10);
|
|
|
|
|
2008-04-17 20:05:37 +02:00
|
|
|
mutex_lock(&tty_mutex);
|
|
|
|
/* Search through the tty devices to look for a match */
|
|
|
|
list_for_each_entry(p, &tty_drivers, tty_drivers) {
|
2008-09-26 17:36:42 +02:00
|
|
|
if (strncmp(name, p->name, len) != 0)
|
|
|
|
continue;
|
2008-04-17 20:05:37 +02:00
|
|
|
if (*str == ',')
|
|
|
|
str++;
|
|
|
|
if (*str == '\0')
|
2008-04-28 23:13:20 +02:00
|
|
|
str = NULL;
|
2008-04-17 20:05:37 +02:00
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty_line >= 0 && tty_line <= p->num && p->ops &&
|
|
|
|
p->ops->poll_init && !p->ops->poll_init(p, tty_line, str)) {
|
2008-04-17 20:05:37 +02:00
|
|
|
res = p;
|
|
|
|
*line = tty_line;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&tty_mutex);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_find_polling_driver);
|
|
|
|
#endif
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_check_change - check for POSIX terminal changes
|
|
|
|
* @tty: tty to check
|
|
|
|
*
|
|
|
|
* If we try to write to, or set the state of, a terminal and we're
|
|
|
|
* not in the foreground, send a SIGTTOU. If the signal is blocked or
|
|
|
|
* ignored, go ahead and perform the operation. (POSIX 7.2)
|
|
|
|
*
|
2008-04-30 09:53:59 +02:00
|
|
|
* Locking: ctrl_lock
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
int tty_check_change(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (current->signal->tty != tty)
|
|
|
|
return 0;
|
2008-04-30 09:53:30 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
|
|
|
|
2007-02-12 09:53:00 +01:00
|
|
|
if (!tty->pgrp) {
|
|
|
|
printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
|
2008-05-15 01:05:58 +02:00
|
|
|
goto out_unlock;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-02-12 09:53:00 +01:00
|
|
|
if (task_pgrp(current) == tty->pgrp)
|
2008-05-15 01:05:58 +02:00
|
|
|
goto out_unlock;
|
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (is_ignored(SIGTTOU))
|
2008-04-30 09:53:30 +02:00
|
|
|
goto out;
|
|
|
|
if (is_current_pgrp_orphaned()) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2007-06-01 09:46:53 +02:00
|
|
|
kill_pgrp(task_pgrp(current), SIGTTOU, 1);
|
|
|
|
set_thread_flag(TIF_SIGPENDING);
|
2008-04-30 09:53:30 +02:00
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
out:
|
2008-05-15 01:05:58 +02:00
|
|
|
return ret;
|
|
|
|
out_unlock:
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_check_change);
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
|
2005-04-17 00:20:36 +02:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
|
2005-04-17 00:20:36 +02:00
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No kernel lock held - none needed ;) */
|
2008-02-08 13:18:47 +01:00
|
|
|
static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:29 +02:00
|
|
|
static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2007-06-16 19:15:55 +02:00
|
|
|
{
|
|
|
|
return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static long hung_up_tty_compat_ioctl(struct file *file,
|
2007-06-16 19:15:55 +02:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
|
|
|
|
}
|
|
|
|
|
2006-07-03 09:24:21 +02:00
|
|
|
static const struct file_operations tty_fops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = tty_read,
|
|
|
|
.write = tty_write,
|
|
|
|
.poll = tty_poll,
|
2008-04-30 09:53:29 +02:00
|
|
|
.unlocked_ioctl = tty_ioctl,
|
2007-05-11 07:22:50 +02:00
|
|
|
.compat_ioctl = tty_compat_ioctl,
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = tty_open,
|
|
|
|
.release = tty_release,
|
|
|
|
.fasync = tty_fasync,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_UNIX98_PTYS
|
2006-07-03 09:24:21 +02:00
|
|
|
static const struct file_operations ptmx_fops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = tty_read,
|
|
|
|
.write = tty_write,
|
|
|
|
.poll = tty_poll,
|
2008-04-30 09:53:29 +02:00
|
|
|
.unlocked_ioctl = tty_ioctl,
|
2007-05-11 07:22:50 +02:00
|
|
|
.compat_ioctl = tty_compat_ioctl,
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = ptmx_open,
|
|
|
|
.release = tty_release,
|
|
|
|
.fasync = tty_fasync,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2006-07-03 09:24:21 +02:00
|
|
|
static const struct file_operations console_fops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = tty_read,
|
|
|
|
.write = redirected_tty_write,
|
|
|
|
.poll = tty_poll,
|
2008-04-30 09:53:29 +02:00
|
|
|
.unlocked_ioctl = tty_ioctl,
|
2007-05-11 07:22:50 +02:00
|
|
|
.compat_ioctl = tty_compat_ioctl,
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = tty_open,
|
|
|
|
.release = tty_release,
|
|
|
|
.fasync = tty_fasync,
|
|
|
|
};
|
|
|
|
|
2006-07-03 09:24:21 +02:00
|
|
|
static const struct file_operations hung_up_tty_fops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = hung_up_tty_read,
|
|
|
|
.write = hung_up_tty_write,
|
|
|
|
.poll = hung_up_tty_poll,
|
2008-04-30 09:53:29 +02:00
|
|
|
.unlocked_ioctl = hung_up_tty_ioctl,
|
2007-06-16 19:15:55 +02:00
|
|
|
.compat_ioctl = hung_up_tty_compat_ioctl,
|
2005-04-17 00:20:36 +02:00
|
|
|
.release = tty_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(redirect_lock);
|
|
|
|
static struct file *redirect;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_wakeup - request more data
|
|
|
|
* @tty: terminal
|
|
|
|
*
|
|
|
|
* Internal and external helper for wakeups of tty. This function
|
|
|
|
* informs the line discipline if present that the driver is ready
|
|
|
|
* to receive more output data.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void tty_wakeup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct tty_ldisc *ld;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
|
|
|
|
ld = tty_ldisc_ref(tty);
|
2008-02-08 13:18:47 +01:00
|
|
|
if (ld) {
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->write_wakeup)
|
|
|
|
ld->ops->write_wakeup(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
wake_up_interruptible(&tty->write_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(tty_wakeup);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_ldisc_flush - flush line discipline queue
|
|
|
|
* @tty: tty
|
|
|
|
*
|
|
|
|
* Flush the line discipline queue (if any) for this tty. If there
|
|
|
|
* is no line discipline active this is a no-op.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void tty_ldisc_flush(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct tty_ldisc *ld = tty_ldisc_ref(tty);
|
2008-02-08 13:18:47 +01:00
|
|
|
if (ld) {
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->flush_buffer)
|
|
|
|
ld->ops->flush_buffer(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
2007-05-12 19:36:55 +02:00
|
|
|
tty_buffer_flush(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(tty_ldisc_flush);
|
2006-12-08 11:38:44 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_reset_termios - reset terminal state
|
|
|
|
* @tty: tty to reset
|
|
|
|
*
|
|
|
|
* Restore a terminal to the driver default state
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void tty_reset_termios(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
mutex_lock(&tty->termios_mutex);
|
|
|
|
*tty->termios = tty->driver->init_termios;
|
|
|
|
tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
|
|
|
|
tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
|
|
|
|
mutex_unlock(&tty->termios_mutex);
|
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* do_tty_hangup - actual handler for hangup events
|
2006-11-22 15:55:48 +01:00
|
|
|
* @work: tty device
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
2008-07-23 00:38:04 +02:00
|
|
|
* This can be called by the "eventd" kernel thread. That is process
|
2006-08-27 10:24:01 +02:00
|
|
|
* synchronous but doesn't hold any locks, so we need to make sure we
|
|
|
|
* have the appropriate locks for what we're doing.
|
|
|
|
*
|
|
|
|
* The hangup event clears any pending redirections onto the hung up
|
|
|
|
* device. It ensures future writes will error and it does the needed
|
|
|
|
* line discipline hangup and signal delivery. The tty object itself
|
|
|
|
* remains intact.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* BKL
|
2006-12-08 11:36:04 +01:00
|
|
|
* redirect lock for undoing redirection
|
|
|
|
* file list lock for manipulating list of ttys
|
|
|
|
* tty_ldisc_lock from called functions
|
|
|
|
* termios_mutex resetting termios data
|
|
|
|
* tasklist_lock to walk task list for hangup event
|
|
|
|
* ->siglock to protect ->signal/->sighand
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-11-22 15:55:48 +01:00
|
|
|
static void do_tty_hangup(struct work_struct *work)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-11-22 15:55:48 +01:00
|
|
|
struct tty_struct *tty =
|
|
|
|
container_of(work, struct tty_struct, hangup_work);
|
2008-02-08 13:18:47 +01:00
|
|
|
struct file *cons_filp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct file *filp, *f = NULL;
|
|
|
|
struct task_struct *p;
|
|
|
|
struct tty_ldisc *ld;
|
|
|
|
int closecount = 0, n;
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!tty)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* inuse_filps is protected by the single kernel lock */
|
|
|
|
lock_kernel();
|
|
|
|
|
|
|
|
spin_lock(&redirect_lock);
|
|
|
|
if (redirect && redirect->private_data == tty) {
|
|
|
|
f = redirect;
|
|
|
|
redirect = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&redirect_lock);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
check_tty_count(tty, "do_tty_hangup");
|
|
|
|
file_list_lock();
|
|
|
|
/* This breaks for file handles being sent over AF_UNIX sockets ? */
|
2005-10-31 00:02:16 +01:00
|
|
|
list_for_each_entry(filp, &tty->tty_files, f_u.fu_list) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (filp->f_op->write == redirected_tty_write)
|
|
|
|
cons_filp = filp;
|
|
|
|
if (filp->f_op->write != tty_write)
|
|
|
|
continue;
|
|
|
|
closecount++;
|
|
|
|
tty_fasync(-1, filp, 0); /* can't block */
|
|
|
|
filp->f_op = &hung_up_tty_fops;
|
|
|
|
}
|
|
|
|
file_list_unlock();
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
|
|
|
* FIXME! What are the locking issues here? This may me overdoing
|
|
|
|
* things... This question is especially important now that we've
|
|
|
|
* removed the irqlock.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
ld = tty_ldisc_ref(tty);
|
2008-02-08 13:18:47 +01:00
|
|
|
if (ld != NULL) {
|
|
|
|
/* We may have no line discipline at this point */
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->flush_buffer)
|
|
|
|
ld->ops->flush_buffer(tty);
|
2008-04-30 09:54:13 +02:00
|
|
|
tty_driver_flush_buffer(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
|
2008-07-16 22:53:12 +02:00
|
|
|
ld->ops->write_wakeup)
|
|
|
|
ld->ops->write_wakeup(tty);
|
|
|
|
if (ld->ops->hangup)
|
|
|
|
ld->ops->hangup(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
|
|
|
* FIXME: Once we trust the LDISC code better we can wait here for
|
|
|
|
* ldisc completion and fix the driver call race
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
wake_up_interruptible(&tty->write_wait);
|
|
|
|
wake_up_interruptible(&tty->read_wait);
|
|
|
|
/*
|
|
|
|
* Shutdown the current line discipline, and reset it to
|
|
|
|
* N_TTY.
|
|
|
|
*/
|
|
|
|
if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
|
2006-12-08 11:38:44 +01:00
|
|
|
tty_reset_termios(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Defer ldisc switch */
|
|
|
|
/* tty_deferred_ldisc_switch(N_TTY);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
This should get done automatically when the port closes and
|
|
|
|
tty_release is called */
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
read_lock(&tasklist_lock);
|
2007-02-12 09:53:00 +01:00
|
|
|
if (tty->session) {
|
|
|
|
do_each_pid_task(tty->session, PIDTYPE_SID, p) {
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_lock_irq(&p->sighand->siglock);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (p->signal->tty == tty)
|
|
|
|
p->signal->tty = NULL;
|
2006-12-08 11:36:04 +01:00
|
|
|
if (!p->signal->leader) {
|
|
|
|
spin_unlock_irq(&p->sighand->siglock);
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
2006-12-08 11:36:04 +01:00
|
|
|
}
|
|
|
|
__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
|
|
|
|
__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
|
2007-02-12 09:53:00 +01:00
|
|
|
put_pid(p->signal->tty_old_pgrp); /* A noop */
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2007-02-12 09:53:00 +01:00
|
|
|
if (tty->pgrp)
|
|
|
|
p->signal->tty_old_pgrp = get_pid(tty->pgrp);
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_unlock_irq(&p->sighand->siglock);
|
2007-02-12 09:53:00 +01:00
|
|
|
} while_each_pid_task(tty->session, PIDTYPE_SID, p);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
read_unlock(&tasklist_lock);
|
|
|
|
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->flags = 0;
|
2007-03-18 19:45:44 +01:00
|
|
|
put_pid(tty->session);
|
|
|
|
put_pid(tty->pgrp);
|
2007-02-12 09:53:00 +01:00
|
|
|
tty->session = NULL;
|
|
|
|
tty->pgrp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->ctrl_status = 0;
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2008-02-08 13:18:47 +01:00
|
|
|
* If one of the devices matches a console pointer, we
|
|
|
|
* cannot just call hangup() because that will cause
|
|
|
|
* tty->count and state->count to go out of sync.
|
|
|
|
* So we just call close() the right number of times.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
if (cons_filp) {
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->close)
|
2005-04-17 00:20:36 +02:00
|
|
|
for (n = 0; n < closecount; n++)
|
2008-04-30 09:54:13 +02:00
|
|
|
tty->ops->close(tty, cons_filp);
|
|
|
|
} else if (tty->ops->hangup)
|
|
|
|
(tty->ops->hangup)(tty);
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
|
|
|
* We don't want to have driver/ldisc interactions beyond
|
|
|
|
* the ones we did here. The driver layer expects no
|
|
|
|
* calls after ->hangup() from the ldisc side. However we
|
|
|
|
* can't yet guarantee all that.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
set_bit(TTY_HUPPED, &tty->flags);
|
|
|
|
if (ld) {
|
|
|
|
tty_ldisc_enable(tty);
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
|
|
|
unlock_kernel();
|
|
|
|
if (f)
|
|
|
|
fput(f);
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_hangup - trigger a hangup event
|
|
|
|
* @tty: tty to hangup
|
|
|
|
*
|
|
|
|
* A carrier loss (virtual or otherwise) has occurred on this like
|
|
|
|
* schedule a hangup sequence to run after this event.
|
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
void tty_hangup(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
char buf[64];
|
|
|
|
printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
|
|
|
|
#endif
|
|
|
|
schedule_work(&tty->hangup_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_hangup);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_vhangup - process vhangup
|
|
|
|
* @tty: tty to hangup
|
|
|
|
*
|
|
|
|
* The user has asked via system call for the terminal to be hung up.
|
|
|
|
* We do this synchronously so that when the syscall returns the process
|
2007-10-19 23:10:43 +02:00
|
|
|
* is complete. That guarantee is necessary for security reasons.
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
void tty_vhangup(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
|
|
|
|
#endif
|
2006-11-22 15:55:48 +01:00
|
|
|
do_tty_hangup(&tty->hangup_work);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL(tty_vhangup);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_hung_up_p - was tty hung up
|
|
|
|
* @filp: file pointer of tty
|
|
|
|
*
|
|
|
|
* Return true if the tty has been subject to a vhangup or a carrier
|
|
|
|
* loss
|
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
int tty_hung_up_p(struct file *filp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return (filp->f_op == &hung_up_tty_fops);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_hung_up_p);
|
|
|
|
|
2007-02-12 09:53:00 +01:00
|
|
|
static void session_clear_tty(struct pid *session)
|
2006-12-08 11:36:04 +01:00
|
|
|
{
|
|
|
|
struct task_struct *p;
|
2007-02-12 09:53:00 +01:00
|
|
|
do_each_pid_task(session, PIDTYPE_SID, p) {
|
2006-12-08 11:36:04 +01:00
|
|
|
proc_clear_tty(p);
|
2007-02-12 09:53:00 +01:00
|
|
|
} while_each_pid_task(session, PIDTYPE_SID, p);
|
2006-12-08 11:36:04 +01:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* disassociate_ctty - disconnect controlling tty
|
|
|
|
* @on_exit: true if exiting so need to "hang up" the session
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* This function is typically called only by the session leader, when
|
|
|
|
* it wants to disassociate itself from its controlling tty.
|
|
|
|
*
|
|
|
|
* It performs the following functions:
|
2005-04-17 00:20:36 +02:00
|
|
|
* (1) Sends a SIGHUP and SIGCONT to the foreground process group
|
|
|
|
* (2) Clears the tty from being controlling the session
|
|
|
|
* (3) Clears the controlling tty for all processes in the
|
|
|
|
* session group.
|
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* The argument on_exit is set to 1 if called when a process is
|
|
|
|
* exiting; it is 0 if called by the ioctl TIOCNOTTY.
|
|
|
|
*
|
2006-12-08 11:36:04 +01:00
|
|
|
* Locking:
|
2006-08-27 10:24:01 +02:00
|
|
|
* BKL is taken for hysterical raisins
|
2006-12-08 11:36:04 +01:00
|
|
|
* tty_mutex is taken to protect tty
|
|
|
|
* ->siglock is taken to protect ->signal/->sighand
|
|
|
|
* tasklist_lock is taken to walk process list for sessions
|
|
|
|
* ->siglock is taken to protect ->signal/->sighand
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void disassociate_ctty(int on_exit)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty;
|
2007-02-12 09:53:00 +01:00
|
|
|
struct pid *tty_pgrp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_lock(&tty_mutex);
|
2006-12-08 11:36:04 +01:00
|
|
|
tty = get_current_tty();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty) {
|
2007-02-12 09:53:00 +01:00
|
|
|
tty_pgrp = get_pid(tty->pgrp);
|
2008-04-30 09:53:29 +02:00
|
|
|
lock_kernel();
|
Fix race/oops in tty layer after BKL pushdown
While testing our KVM code for s390 (starting and killall kvm in a loop)
I can reproduce the following oops:
Unable to handle kernel pointer dereference at virtual kernel address 6b6b6b6b6b6b6000 Oops: 0038 [#1] SMP
Modules linked in: dm_multipath sunrpc qeth_l3 qeth_l2 dm_mod qeth
ccwgroup CPU: 1 Not tainted 2.6.27-rc1 #54
Process kuli (pid: 4409, task: 00000000b6aa5940, ksp: 00000000b7343e10)
Krnl PSW : 0704e00180000000 00000000002e0b8c
(disassociate_ctty+0x1c0/0x288) R:0 T:1 IO:1 EX:1 Key:0 M:1 W:0 P:0 AS:3
CC:2 PM:0 EA:3 Krnl GPRS: 0000000000000000 6b6b6b6b6b6b6b6b
0000000000000001 00000000000003a6 00000000002e0a46 00000000004b4160
0000000000000001 00000000bbd79758 00000000b7343e58 00000000b8854148
00000000bd34dea0 00000000b7343c20 0000000000000001 00000000004b6d08
00000000002e0a46 00000000b7343c20 Krnl Code: 00000000002e0b7e:
eb9fb0a00004 lmg %r9,%r15,160(%r11) 00000000002e0b84:
07f4 bcr 15,%r4 00000000002e0b86:
e31090080004 lg %r1,8(%r9) >00000000002e0b8c:
d501109cd000 clc 156(2,%r1),0(%r13) 00000000002e0b92:
a784ff5d brc 8,2e0a4c 00000000002e0b96:
b9040029 lgr %r2,%r9 00000000002e0b9a:
c0e5fffff9c3 brasl %r14,2dff20 00000000002e0ba0:
a7f4ff56 brc 15,2e0a4c Call Trace:
([<00000000002e0a46>] disassociate_ctty+0x7a/0x288)
[<0000000000141fe6>] do_exit+0x212/0x8d4
[<0000000000142708>] do_group_exit+0x60/0xcc
[<0000000000150660>] get_signal_to_deliver+0x270/0x3ac
[<000000000010bfd6>] do_signal+0x8e/0x8dc
[<0000000000113772>] sysc_sigpending+0xe/0x22
[<000001ff0000b134>] 0x1ff0000b134
INFO: lockdep is turned off.
Last Breaking-Event-Address:
[<00000000002e0a48>] disassociate_ctty+0x7c/0x288
Kernel panic - not syncing: Fatal exception: panic_on_oops
It seems that tty was already free in disassocate_ctty when it tries
to dereference tty->driver.
After moving the lock_kernel before the mutex_unlock, I can no longer
reproduce the problem.
[ This is a temporary partial fix for the documented and long standing
race in disassociate_tty. This stops most problem cases for now.
For the next release the -next tree has an initial implementation of
kref counting for tty structures and this quickfix will be dropped.
- Alan ]
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by; Alan Cox <alan@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-08-11 10:02:49 +02:00
|
|
|
mutex_unlock(&tty_mutex);
|
2006-12-08 11:36:04 +01:00
|
|
|
/* XXX: here we race, there is nothing protecting tty */
|
2005-04-17 00:20:36 +02:00
|
|
|
if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
|
|
|
|
tty_vhangup(tty);
|
2008-04-30 09:53:29 +02:00
|
|
|
unlock_kernel();
|
2007-02-12 09:52:52 +01:00
|
|
|
} else if (on_exit) {
|
2007-02-12 09:53:00 +01:00
|
|
|
struct pid *old_pgrp;
|
2007-02-12 09:52:52 +01:00
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
|
|
|
old_pgrp = current->signal->tty_old_pgrp;
|
2007-02-12 09:53:00 +01:00
|
|
|
current->signal->tty_old_pgrp = NULL;
|
2007-02-12 09:52:52 +01:00
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
2006-12-08 11:36:04 +01:00
|
|
|
if (old_pgrp) {
|
2007-02-12 09:53:00 +01:00
|
|
|
kill_pgrp(old_pgrp, SIGHUP, on_exit);
|
|
|
|
kill_pgrp(old_pgrp, SIGCONT, on_exit);
|
|
|
|
put_pid(old_pgrp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
}
|
2007-02-12 09:53:00 +01:00
|
|
|
if (tty_pgrp) {
|
|
|
|
kill_pgrp(tty_pgrp, SIGHUP, on_exit);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!on_exit)
|
2007-02-12 09:53:00 +01:00
|
|
|
kill_pgrp(tty_pgrp, SIGCONT, on_exit);
|
|
|
|
put_pid(tty_pgrp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
2007-05-08 09:26:53 +02:00
|
|
|
put_pid(current->signal->tty_old_pgrp);
|
2007-02-20 22:58:05 +01:00
|
|
|
current->signal->tty_old_pgrp = NULL;
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
|
|
|
|
mutex_lock(&tty_mutex);
|
|
|
|
/* It is possible that do_tty_hangup has free'd this tty */
|
|
|
|
tty = get_current_tty();
|
|
|
|
if (tty) {
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2007-02-12 09:53:00 +01:00
|
|
|
put_pid(tty->session);
|
|
|
|
put_pid(tty->pgrp);
|
|
|
|
tty->session = NULL;
|
|
|
|
tty->pgrp = NULL;
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2006-12-08 11:36:04 +01:00
|
|
|
} else {
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
|
|
|
|
" = NULL", tty);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Now clear signal->tty under the lock */
|
|
|
|
read_lock(&tasklist_lock);
|
2007-02-12 09:53:00 +01:00
|
|
|
session_clear_tty(task_session(current));
|
2005-04-17 00:20:36 +02:00
|
|
|
read_unlock(&tasklist_lock);
|
|
|
|
}
|
|
|
|
|
2007-05-08 09:26:56 +02:00
|
|
|
/**
|
|
|
|
*
|
|
|
|
* no_tty - Ensure the current process does not have a controlling tty
|
|
|
|
*/
|
|
|
|
void no_tty(void)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = current;
|
2008-04-30 09:53:29 +02:00
|
|
|
lock_kernel();
|
2007-05-08 09:26:56 +02:00
|
|
|
if (tsk->signal->leader)
|
|
|
|
disassociate_ctty(0);
|
2008-04-30 09:53:29 +02:00
|
|
|
unlock_kernel();
|
2007-05-08 09:26:56 +02:00
|
|
|
proc_clear_tty(tsk);
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
|
|
|
|
/**
|
2007-05-09 07:14:03 +02:00
|
|
|
* stop_tty - propagate flow control
|
2006-08-27 10:24:01 +02:00
|
|
|
* @tty: tty to stop
|
|
|
|
*
|
|
|
|
* Perform flow control to the driver. For PTY/TTY pairs we
|
2007-05-09 07:14:03 +02:00
|
|
|
* must also propagate the TIOCKPKT status. May be called
|
2006-08-27 10:24:01 +02:00
|
|
|
* on an already stopped device and will not re-call the driver
|
|
|
|
* method.
|
|
|
|
*
|
|
|
|
* This functionality is used by both the line disciplines for
|
|
|
|
* halting incoming flow and by the driver. It may therefore be
|
|
|
|
* called from any context, may be under the tty atomic_write_lock
|
|
|
|
* but not always.
|
|
|
|
*
|
|
|
|
* Locking:
|
2008-04-30 09:53:29 +02:00
|
|
|
* Uses the tty control lock internally
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void stop_tty(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:29 +02:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
|
|
|
if (tty->stopped) {
|
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
2008-04-30 09:53:29 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->stopped = 1;
|
|
|
|
if (tty->link && tty->link->packet) {
|
|
|
|
tty->ctrl_status &= ~TIOCPKT_START;
|
|
|
|
tty->ctrl_status |= TIOCPKT_STOP;
|
|
|
|
wake_up_interruptible(&tty->link->read_wait);
|
|
|
|
}
|
2008-04-30 09:53:29 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->stop)
|
|
|
|
(tty->ops->stop)(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(stop_tty);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
2007-05-09 07:14:03 +02:00
|
|
|
* start_tty - propagate flow control
|
2006-08-27 10:24:01 +02:00
|
|
|
* @tty: tty to start
|
|
|
|
*
|
|
|
|
* Start a tty that has been stopped if at all possible. Perform
|
2007-10-19 23:10:43 +02:00
|
|
|
* any necessary wakeups and propagate the TIOCPKT status. If this
|
2006-08-27 10:24:01 +02:00
|
|
|
* is the tty was previous stopped and is being started then the
|
|
|
|
* driver start method is invoked and the line discipline woken.
|
|
|
|
*
|
|
|
|
* Locking:
|
2008-04-30 09:53:29 +02:00
|
|
|
* ctrl_lock
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void start_tty(struct tty_struct *tty)
|
|
|
|
{
|
2008-04-30 09:53:29 +02:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
|
|
|
if (!tty->stopped || tty->flow_stopped) {
|
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
2008-04-30 09:53:29 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->stopped = 0;
|
|
|
|
if (tty->link && tty->link->packet) {
|
|
|
|
tty->ctrl_status &= ~TIOCPKT_STOP;
|
|
|
|
tty->ctrl_status |= TIOCPKT_START;
|
|
|
|
wake_up_interruptible(&tty->link->read_wait);
|
|
|
|
}
|
2008-04-30 09:53:29 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->start)
|
|
|
|
(tty->ops->start)(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* If we have a running line discipline it may need kicking */
|
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(start_tty);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_read - read method for tty device files
|
|
|
|
* @file: pointer to tty file
|
|
|
|
* @buf: user buffer
|
|
|
|
* @count: size of user buffer
|
|
|
|
* @ppos: unused
|
|
|
|
*
|
|
|
|
* Perform the read system call function on this terminal device. Checks
|
|
|
|
* for hung up devices before calling the line discipline method.
|
|
|
|
*
|
|
|
|
* Locking:
|
2008-04-30 09:53:30 +02:00
|
|
|
* Locks the line discipline internally while needed. Multiple
|
|
|
|
* read calls may be outstanding in parallel.
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
|
2005-04-17 00:20:36 +02:00
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
int i;
|
2008-02-08 13:18:47 +01:00
|
|
|
struct tty_struct *tty;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode;
|
|
|
|
struct tty_ldisc *ld;
|
|
|
|
|
|
|
|
tty = (struct tty_struct *)file->private_data;
|
2006-12-08 11:36:55 +01:00
|
|
|
inode = file->f_path.dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty_paranoia_check(tty, inode, "tty_read"))
|
|
|
|
return -EIO;
|
|
|
|
if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* We want to wait for the line discipline to sort out in this
|
|
|
|
situation */
|
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->read)
|
|
|
|
i = (ld->ops->read)(tty, file, buf, count);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
i = -EIO;
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
if (i > 0)
|
|
|
|
inode->i_atime = current_fs_time(inode->i_sb);
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2007-07-16 08:39:43 +02:00
|
|
|
void tty_write_unlock(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
mutex_unlock(&tty->atomic_write_lock);
|
|
|
|
wake_up_interruptible(&tty->write_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
int tty_write_lock(struct tty_struct *tty, int ndelay)
|
|
|
|
{
|
|
|
|
if (!mutex_trylock(&tty->atomic_write_lock)) {
|
|
|
|
if (ndelay)
|
|
|
|
return -EAGAIN;
|
|
|
|
if (mutex_lock_interruptible(&tty->atomic_write_lock))
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Split writes up in sane blocksizes to avoid
|
|
|
|
* denial-of-service type attacks
|
|
|
|
*/
|
|
|
|
static inline ssize_t do_tty_write(
|
|
|
|
ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
|
|
|
|
struct tty_struct *tty,
|
|
|
|
struct file *file,
|
|
|
|
const char __user *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
2007-07-16 08:39:43 +02:00
|
|
|
ssize_t ret, written = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int chunk;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2007-07-16 08:39:43 +02:00
|
|
|
ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We chunk up writes into a temporary buffer. This
|
|
|
|
* simplifies low-level drivers immensely, since they
|
|
|
|
* don't have locking issues and user mode accesses.
|
|
|
|
*
|
|
|
|
* But if TTY_NO_WRITE_SPLIT is set, we should use a
|
|
|
|
* big chunk-size..
|
|
|
|
*
|
|
|
|
* The default chunk-size is 2kB, because the NTTY
|
|
|
|
* layer has problems with bigger chunks. It will
|
|
|
|
* claim to be able to handle more characters than
|
|
|
|
* it actually does.
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* FIXME: This can probably go away now except that 64K chunks
|
|
|
|
* are too likely to fail unless switched to vmalloc...
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
chunk = 2048;
|
|
|
|
if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
|
|
|
|
chunk = 65536;
|
|
|
|
if (count < chunk)
|
|
|
|
chunk = count;
|
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
/* write_buf/write_cnt is protected by the atomic_write_lock mutex */
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty->write_cnt < chunk) {
|
|
|
|
unsigned char *buf;
|
|
|
|
|
|
|
|
if (chunk < 1024)
|
|
|
|
chunk = 1024;
|
|
|
|
|
|
|
|
buf = kmalloc(chunk, GFP_KERNEL);
|
|
|
|
if (!buf) {
|
2007-07-16 08:39:43 +02:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
kfree(tty->write_buf);
|
|
|
|
tty->write_cnt = chunk;
|
|
|
|
tty->write_buf = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do the write .. */
|
|
|
|
for (;;) {
|
|
|
|
size_t size = count;
|
|
|
|
if (size > chunk)
|
|
|
|
size = chunk;
|
|
|
|
ret = -EFAULT;
|
|
|
|
if (copy_from_user(tty->write_buf, buf, size))
|
|
|
|
break;
|
|
|
|
ret = write(tty, file, tty->write_buf, size);
|
|
|
|
if (ret <= 0)
|
|
|
|
break;
|
|
|
|
written += ret;
|
|
|
|
buf += ret;
|
|
|
|
count -= ret;
|
|
|
|
if (!count)
|
|
|
|
break;
|
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
if (signal_pending(current))
|
|
|
|
break;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
if (written) {
|
2006-12-08 11:36:55 +01:00
|
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
inode->i_mtime = current_fs_time(inode->i_sb);
|
|
|
|
ret = written;
|
|
|
|
}
|
2007-07-16 08:39:43 +02:00
|
|
|
out:
|
|
|
|
tty_write_unlock(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_write - write method for tty device file
|
|
|
|
* @file: tty file pointer
|
|
|
|
* @buf: user data to write
|
|
|
|
* @count: bytes to write
|
|
|
|
* @ppos: unused
|
|
|
|
*
|
|
|
|
* Write data to a tty device via the line discipline.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* Locks the line discipline as required
|
|
|
|
* Writes to the tty driver are serialized by the atomic_write_lock
|
|
|
|
* and are then processed in chunks to the device. The line discipline
|
|
|
|
* write method will not be involked in parallel for each device
|
|
|
|
* The line discipline write method is called under the big
|
|
|
|
* kernel lock for historical reasons. New code should not rely on this.
|
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static ssize_t tty_write(struct file *file, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:47 +01:00
|
|
|
struct tty_struct *tty;
|
2006-12-08 11:36:55 +01:00
|
|
|
struct inode *inode = file->f_path.dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
ssize_t ret;
|
|
|
|
struct tty_ldisc *ld;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tty = (struct tty_struct *)file->private_data;
|
|
|
|
if (tty_paranoia_check(tty, inode, "tty_write"))
|
|
|
|
return -EIO;
|
2008-04-30 09:54:13 +02:00
|
|
|
if (!tty || !tty->ops->write ||
|
2008-02-08 13:18:47 +01:00
|
|
|
(test_bit(TTY_IO_ERROR, &tty->flags)))
|
|
|
|
return -EIO;
|
2008-04-30 09:54:13 +02:00
|
|
|
/* Short term debug to catch buggy drivers */
|
|
|
|
if (tty->ops->write_room == NULL)
|
|
|
|
printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
|
|
|
|
tty->driver->name);
|
2008-02-08 13:18:47 +01:00
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
2008-07-16 22:53:12 +02:00
|
|
|
if (!ld->ops->write)
|
2005-04-17 00:20:36 +02:00
|
|
|
ret = -EIO;
|
|
|
|
else
|
2008-07-16 22:53:12 +02:00
|
|
|
ret = do_tty_write(ld->ops->write, tty, file, buf, count);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
ssize_t redirected_tty_write(struct file *file, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct file *p = NULL;
|
|
|
|
|
|
|
|
spin_lock(&redirect_lock);
|
|
|
|
if (redirect) {
|
|
|
|
get_file(redirect);
|
|
|
|
p = redirect;
|
|
|
|
}
|
|
|
|
spin_unlock(&redirect_lock);
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
ssize_t res;
|
|
|
|
res = vfs_write(p, buf, count, &p->f_pos);
|
|
|
|
fput(p);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
return tty_write(file, buf, count, ppos);
|
|
|
|
}
|
|
|
|
|
2008-07-16 22:53:41 +02:00
|
|
|
void tty_port_init(struct tty_port *port)
|
|
|
|
{
|
|
|
|
memset(port, 0, sizeof(*port));
|
|
|
|
init_waitqueue_head(&port->open_wait);
|
|
|
|
init_waitqueue_head(&port->close_wait);
|
|
|
|
mutex_init(&port->mutex);
|
2008-07-16 22:57:18 +02:00
|
|
|
port->close_delay = (50 * HZ) / 100;
|
|
|
|
port->closing_wait = (3000 * HZ) / 100;
|
2008-07-16 22:53:41 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_port_init);
|
|
|
|
|
|
|
|
int tty_port_alloc_xmit_buf(struct tty_port *port)
|
|
|
|
{
|
|
|
|
/* We may sleep in get_zeroed_page() */
|
|
|
|
mutex_lock(&port->mutex);
|
|
|
|
if (port->xmit_buf == NULL)
|
|
|
|
port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
|
|
|
|
mutex_unlock(&port->mutex);
|
|
|
|
if (port->xmit_buf == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
|
|
|
|
|
|
|
|
void tty_port_free_xmit_buf(struct tty_port *port)
|
|
|
|
{
|
|
|
|
mutex_lock(&port->mutex);
|
|
|
|
if (port->xmit_buf != NULL) {
|
|
|
|
free_page((unsigned long)port->xmit_buf);
|
|
|
|
port->xmit_buf = NULL;
|
|
|
|
}
|
|
|
|
mutex_unlock(&port->mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_port_free_xmit_buf);
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static char ptychar[] = "pqrstuvwxyzabcde";
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* pty_line_name - generate name for a pty
|
|
|
|
* @driver: the tty driver in use
|
|
|
|
* @index: the minor number
|
|
|
|
* @p: output buffer of at least 6 bytes
|
|
|
|
*
|
|
|
|
* Generate a name from a driver reference and write it to the output
|
|
|
|
* buffer.
|
|
|
|
*
|
|
|
|
* Locking: None
|
|
|
|
*/
|
|
|
|
static void pty_line_name(struct tty_driver *driver, int index, char *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i = index + driver->name_base;
|
|
|
|
/* ->name is initialized to "ttyp", but "tty" is expected */
|
|
|
|
sprintf(p, "%s%c%x",
|
2008-02-08 13:18:47 +01:00
|
|
|
driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
|
|
|
|
ptychar[i >> 4 & 0xf], i & 0xf);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* pty_line_name - generate name for a tty
|
|
|
|
* @driver: the tty driver in use
|
|
|
|
* @index: the minor number
|
|
|
|
* @p: output buffer of at least 7 bytes
|
|
|
|
*
|
|
|
|
* Generate a name from a driver reference and write it to the output
|
|
|
|
* buffer.
|
|
|
|
*
|
|
|
|
* Locking: None
|
|
|
|
*/
|
|
|
|
static void tty_line_name(struct tty_driver *driver, int index, char *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
sprintf(p, "%s%d", driver->name, index + driver->name_base);
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* init_dev - initialise a tty device
|
|
|
|
* @driver: tty driver we are opening a device on
|
|
|
|
* @idx: device index
|
|
|
|
* @tty: returned tty structure
|
|
|
|
*
|
|
|
|
* Prepare a tty device. This may not be a "new" clean device but
|
|
|
|
* could also be an active device. The pty drivers require special
|
|
|
|
* handling because of this.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* The function is called under the tty_mutex, which
|
|
|
|
* protects us from the tty struct or driver itself going away.
|
|
|
|
*
|
|
|
|
* On exit the tty device has the line discipline attached and
|
|
|
|
* a reference count of 1. If a pair was created for pty/tty use
|
|
|
|
* and the other was a pty master then it too has a reference count of 1.
|
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* WSH 06/09/97: Rewritten to remove races and properly clean up after a
|
2006-03-23 12:00:31 +01:00
|
|
|
* failed open. The new code protects the open with a mutex, so it's
|
|
|
|
* really quite straightforward. The mutex locking can probably be
|
2005-04-17 00:20:36 +02:00
|
|
|
* relaxed for the (most common) case of reopening a tty.
|
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int init_dev(struct tty_driver *driver, int idx,
|
|
|
|
struct tty_struct **ret_tty)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty, *o_tty;
|
2006-12-08 11:38:44 +01:00
|
|
|
struct ktermios *tp, **tp_loc, *o_tp, **o_tp_loc;
|
|
|
|
struct ktermios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
|
2006-08-27 10:24:01 +02:00
|
|
|
int retval = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* check whether we're reopening an existing tty */
|
|
|
|
if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
|
|
|
|
tty = devpts_get_tty(idx);
|
[PATCH] tty_io: fix race in master pty close/slave pty close path
This patch fixes a possible race that leads to double freeing an idr index.
When the master begin to close, release_dev() is called and then
pty_close() is called:
if (tty->driver->close)
tty->driver->close(tty, filp);
This is done without helding any locks other than BKL. Inside pty_close(),
being a master close, the devpts entry will be removed:
#ifdef CONFIG_UNIX98_PTYS
if (tty->driver == ptm_driver)
devpts_pty_kill(tty->index);
#endif
But devpts_pty_kill() will call get_node() that may sleep while waiting for
&devpts_root->d_inode->i_sem. When this happens and the slave is being
opened, tty_open() just found the driver and index:
driver = get_tty_driver(device, &index);
if (!driver) {
mutex_unlock(&tty_mutex);
return -ENODEV;
}
This part of the code is already protected under tty_mute. The problem is
that the slave close already got an index. Then init_dev() is called and
blocks waiting for the same &devpts_root->d_inode->i_sem.
When the master close resumes, it removes the devpts entry, and the
relation between idr index and the tty is gone. The master then sleeps
waiting for the tty_mutex on release_dev().
Slave open resumes and found no tty for that index. As result, a NULL tty
is returned and init_dev() doesn't flow to fast_track:
/* check whether we're reopening an existing tty */
if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
tty = devpts_get_tty(idx);
if (tty && driver->subtype == PTY_TYPE_MASTER)
tty = tty->link;
} else {
tty = driver->ttys[idx];
}
if (tty) goto fast_track;
The result of this, is that a new tty will be created and init_dev() returns
sucessfull. After returning, tty_mutex is dropped and master close may resume.
Master close finds it's the only use and both sides are closing, then releases
the tty and the index. At this point, the idr index is free, but slave still
has it.
Slave open then calls pty_open() and finds that tty->link->count is 0,
because there's no master and returns error. Then tty_open() calls
release_dev() which executes without any warning, as it was a case of last
slave close when the master is already closed (master->count == 0,
slave->count == 1). The tty is then released with the already released idr
index.
This normally would only issue a warning on idr_remove() but in case of a
customer's critical application, it's never too simple:
thread1: opens master, gets index X
thread1: begin closing master
thread2: begin opening slave with index X
thread1: finishes closing master, index X released
thread3: opens master, gets index X, just released
thread2: fails opening slave, releases index X <----
thread4: opens master, gets index X, init_dev() then find an already in use
and healthy tty and fails
If no more indexes are released, ptmx_open() will keep failing, as the
first free index available is X, and it will make init_dev() fail because
you're trying to "reopen a master" which isn't valid.
The patch notices when this race happens and make init_dev() fail
imediately. The init_dev() function is called with tty_mutex held, so it's
safe to continue with tty till the end of function because release_dev()
won't make any further changes without grabbing the tty_mutex.
Without the patch, on some machines it's possible get easily idr warnings
like this one:
idr_remove called for id=15 which is not allocated.
[<c02555b9>] idr_remove+0x139/0x170
[<c02a1b62>] release_mem+0x182/0x230
[<c02a28e7>] release_dev+0x4b7/0x700
[<c02a0ea7>] tty_ldisc_enable+0x27/0x30
[<c02a1e64>] init_dev+0x254/0x580
[<c02a0d64>] check_tty_count+0x14/0xb0
[<c02a4f05>] tty_open+0x1c5/0x340
[<c02a4d40>] tty_open+0x0/0x340
[<c017388f>] chrdev_open+0xaf/0x180
[<c017c2ac>] open_namei+0x8c/0x760
[<c01737e0>] chrdev_open+0x0/0x180
[<c0167bc9>] __dentry_open+0xc9/0x210
[<c0167e2c>] do_filp_open+0x5c/0x70
[<c0167a91>] get_unused_fd+0x61/0xd0
[<c0167e93>] do_sys_open+0x53/0x100
[<c0167f97>] sys_open+0x27/0x30
[<c010303b>] syscall_call+0x7/0xb
using this test application available on:
http://www.ruivo.org/~aris/pty_sodomizer.c
Signed-off-by: Aristeu Sergio Rozanski Filho <aris@ruivo.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Chuck Ebbert <cebbert@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-03-01 05:13:53 +01:00
|
|
|
/*
|
|
|
|
* If we don't have a tty here on a slave open, it's because
|
|
|
|
* the master already started the close process and there's
|
|
|
|
* no relation between devpts file and tty anymore.
|
|
|
|
*/
|
|
|
|
if (!tty && driver->subtype == PTY_TYPE_SLAVE) {
|
|
|
|
retval = -EIO;
|
|
|
|
goto end_init;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* It's safe from now on because init_dev() is called with
|
|
|
|
* tty_mutex held and release_dev() won't change tty->count
|
|
|
|
* or tty->flags without having to grab tty_mutex
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty && driver->subtype == PTY_TYPE_MASTER)
|
|
|
|
tty = tty->link;
|
|
|
|
} else {
|
|
|
|
tty = driver->ttys[idx];
|
|
|
|
}
|
|
|
|
if (tty) goto fast_track;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First time open is complex, especially for PTY devices.
|
|
|
|
* This code guarantees that either everything succeeds and the
|
|
|
|
* TTY is ready for operation, or else the table slots are vacated
|
2008-02-08 13:18:47 +01:00
|
|
|
* and the allocated memory released. (Except that the termios
|
2005-04-17 00:20:36 +02:00
|
|
|
* and locked termios may be retained.)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!try_module_get(driver->owner)) {
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto end_init;
|
|
|
|
}
|
|
|
|
|
|
|
|
o_tty = NULL;
|
|
|
|
tp = o_tp = NULL;
|
|
|
|
ltp = o_ltp = NULL;
|
|
|
|
|
|
|
|
tty = alloc_tty_struct();
|
2008-02-08 13:18:47 +01:00
|
|
|
if (!tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto fail_no_mem;
|
|
|
|
initialize_tty_struct(tty);
|
|
|
|
tty->driver = driver;
|
2008-04-30 09:54:13 +02:00
|
|
|
tty->ops = driver->ops;
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->index = idx;
|
|
|
|
tty_line_name(driver, idx, tty->name);
|
|
|
|
|
|
|
|
if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
|
|
|
|
tp_loc = &tty->termios;
|
|
|
|
ltp_loc = &tty->termios_locked;
|
|
|
|
} else {
|
|
|
|
tp_loc = &driver->termios[idx];
|
|
|
|
ltp_loc = &driver->termios_locked[idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*tp_loc) {
|
2007-08-24 02:28:42 +02:00
|
|
|
tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!tp)
|
|
|
|
goto free_mem_out;
|
|
|
|
*tp = driver->init_termios;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*ltp_loc) {
|
2007-07-16 08:40:14 +02:00
|
|
|
ltp = kzalloc(sizeof(struct ktermios), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!ltp)
|
|
|
|
goto free_mem_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (driver->type == TTY_DRIVER_TYPE_PTY) {
|
|
|
|
o_tty = alloc_tty_struct();
|
|
|
|
if (!o_tty)
|
|
|
|
goto free_mem_out;
|
|
|
|
initialize_tty_struct(o_tty);
|
|
|
|
o_tty->driver = driver->other;
|
2008-04-30 09:54:13 +02:00
|
|
|
o_tty->ops = driver->ops;
|
2005-04-17 00:20:36 +02:00
|
|
|
o_tty->index = idx;
|
|
|
|
tty_line_name(driver->other, idx, o_tty->name);
|
|
|
|
|
|
|
|
if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
|
|
|
|
o_tp_loc = &o_tty->termios;
|
|
|
|
o_ltp_loc = &o_tty->termios_locked;
|
|
|
|
} else {
|
|
|
|
o_tp_loc = &driver->other->termios[idx];
|
|
|
|
o_ltp_loc = &driver->other->termios_locked[idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*o_tp_loc) {
|
2007-08-24 02:28:42 +02:00
|
|
|
o_tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!o_tp)
|
|
|
|
goto free_mem_out;
|
|
|
|
*o_tp = driver->other->init_termios;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*o_ltp_loc) {
|
2007-07-16 08:40:14 +02:00
|
|
|
o_ltp = kzalloc(sizeof(struct ktermios), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!o_ltp)
|
|
|
|
goto free_mem_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Everything allocated ... set up the o_tty structure.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM))
|
2005-04-17 00:20:36 +02:00
|
|
|
driver->other->ttys[idx] = o_tty;
|
|
|
|
if (!*o_tp_loc)
|
|
|
|
*o_tp_loc = o_tp;
|
|
|
|
if (!*o_ltp_loc)
|
|
|
|
*o_ltp_loc = o_ltp;
|
|
|
|
o_tty->termios = *o_tp_loc;
|
|
|
|
o_tty->termios_locked = *o_ltp_loc;
|
|
|
|
driver->other->refcount++;
|
|
|
|
if (driver->subtype == PTY_TYPE_MASTER)
|
|
|
|
o_tty->count++;
|
|
|
|
|
|
|
|
/* Establish the links in both directions */
|
|
|
|
tty->link = o_tty;
|
|
|
|
o_tty->link = tty;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* All structures have been allocated, so now we install them.
|
2007-02-10 10:46:46 +01:00
|
|
|
* Failures after this point use release_tty to clean up, so
|
2005-04-17 00:20:36 +02:00
|
|
|
* there's no need to null out the local pointers.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM))
|
2005-04-17 00:20:36 +02:00
|
|
|
driver->ttys[idx] = tty;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!*tp_loc)
|
|
|
|
*tp_loc = tp;
|
|
|
|
if (!*ltp_loc)
|
|
|
|
*ltp_loc = ltp;
|
|
|
|
tty->termios = *tp_loc;
|
|
|
|
tty->termios_locked = *ltp_loc;
|
2006-12-08 11:38:44 +01:00
|
|
|
/* Compatibility until drivers always set this */
|
|
|
|
tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
|
|
|
|
tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
|
2005-04-17 00:20:36 +02:00
|
|
|
driver->refcount++;
|
|
|
|
tty->count++;
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* Structures all installed ... call the ldisc open routines.
|
2007-02-10 10:46:46 +01:00
|
|
|
* If we fail here just call release_tty to clean up. No need
|
|
|
|
* to decrement the use counts, as release_tty doesn't care.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
2008-07-22 12:16:55 +02:00
|
|
|
retval = tty_ldisc_setup(tty, o_tty);
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
goto release_mem_out;
|
|
|
|
goto success;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This fast open can be used if the tty is already open.
|
|
|
|
* No memory is allocated, and the only failures are from
|
|
|
|
* attempting to open a closing tty or attempting multiple
|
|
|
|
* opens on a pty master.
|
|
|
|
*/
|
|
|
|
fast_track:
|
|
|
|
if (test_bit(TTY_CLOSING, &tty->flags)) {
|
|
|
|
retval = -EIO;
|
|
|
|
goto end_init;
|
|
|
|
}
|
|
|
|
if (driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
driver->subtype == PTY_TYPE_MASTER) {
|
|
|
|
/*
|
2008-02-08 13:18:47 +01:00
|
|
|
* special case for PTY masters: only one open permitted,
|
2005-04-17 00:20:36 +02:00
|
|
|
* and the slave side open count is incremented as well.
|
|
|
|
*/
|
|
|
|
if (tty->count) {
|
|
|
|
retval = -EIO;
|
|
|
|
goto end_init;
|
|
|
|
}
|
|
|
|
tty->link->count++;
|
|
|
|
}
|
|
|
|
tty->count++;
|
|
|
|
tty->driver = driver; /* N.B. why do this every time?? */
|
|
|
|
|
|
|
|
/* FIXME */
|
2008-02-08 13:18:47 +01:00
|
|
|
if (!test_bit(TTY_LDISC, &tty->flags))
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_ERR "init_dev but no ldisc\n");
|
|
|
|
success:
|
|
|
|
*ret_tty = tty;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
/* All paths come through here to release the mutex */
|
2005-04-17 00:20:36 +02:00
|
|
|
end_init:
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
/* Release locally allocated memory ... nothing placed in slots */
|
|
|
|
free_mem_out:
|
2005-11-07 10:01:29 +01:00
|
|
|
kfree(o_tp);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (o_tty)
|
|
|
|
free_tty_struct(o_tty);
|
2005-11-07 10:01:29 +01:00
|
|
|
kfree(ltp);
|
|
|
|
kfree(tp);
|
2005-04-17 00:20:36 +02:00
|
|
|
free_tty_struct(tty);
|
|
|
|
|
|
|
|
fail_no_mem:
|
|
|
|
module_put(driver->owner);
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto end_init;
|
|
|
|
|
2007-02-10 10:46:46 +01:00
|
|
|
/* call the tty release_tty routine to clean out this slot */
|
2005-04-17 00:20:36 +02:00
|
|
|
release_mem_out:
|
2006-09-29 11:01:27 +02:00
|
|
|
if (printk_ratelimit())
|
|
|
|
printk(KERN_INFO "init_dev: ldisc open failed, "
|
|
|
|
"clearing slot %d\n", idx);
|
2007-02-10 10:46:46 +01:00
|
|
|
release_tty(tty, idx);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto end_init;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
2007-02-10 10:46:46 +01:00
|
|
|
* release_one_tty - release tty structure memory
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* Releases memory associated with a tty structure, and clears out the
|
|
|
|
* driver table slots. This function is called when a device is no longer
|
|
|
|
* in use. It also gets called when setup of a device fails.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* tty_mutex - sometimes only
|
|
|
|
* takes the file list lock internally when working on the list
|
|
|
|
* of ttys that the driver keeps.
|
|
|
|
* FIXME: should we require tty_mutex is held here ??
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-02-10 10:46:46 +01:00
|
|
|
static void release_one_tty(struct tty_struct *tty, int idx)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
|
2007-02-10 10:46:46 +01:00
|
|
|
struct ktermios *tp;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!devpts)
|
|
|
|
tty->driver->ttys[idx] = NULL;
|
2007-02-10 10:46:46 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
|
|
|
|
tp = tty->termios;
|
|
|
|
if (!devpts)
|
|
|
|
tty->driver->termios[idx] = NULL;
|
|
|
|
kfree(tp);
|
|
|
|
|
|
|
|
tp = tty->termios_locked;
|
|
|
|
if (!devpts)
|
|
|
|
tty->driver->termios_locked[idx] = NULL;
|
|
|
|
kfree(tp);
|
|
|
|
}
|
|
|
|
|
2007-02-10 10:46:46 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->magic = 0;
|
|
|
|
tty->driver->refcount--;
|
2007-02-10 10:46:46 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
file_list_lock();
|
|
|
|
list_del_init(&tty->tty_files);
|
|
|
|
file_list_unlock();
|
2007-02-10 10:46:46 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
free_tty_struct(tty);
|
|
|
|
}
|
|
|
|
|
2007-02-10 10:46:46 +01:00
|
|
|
/**
|
|
|
|
* release_tty - release tty structure memory
|
|
|
|
*
|
|
|
|
* Release both @tty and a possible linked partner (think pty pair),
|
|
|
|
* and decrement the refcount of the backing module.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* tty_mutex - sometimes only
|
|
|
|
* takes the file list lock internally when working on the list
|
|
|
|
* of ttys that the driver keeps.
|
|
|
|
* FIXME: should we require tty_mutex is held here ??
|
|
|
|
*/
|
|
|
|
static void release_tty(struct tty_struct *tty, int idx)
|
|
|
|
{
|
|
|
|
struct tty_driver *driver = tty->driver;
|
|
|
|
|
|
|
|
if (tty->link)
|
|
|
|
release_one_tty(tty->link, idx);
|
|
|
|
release_one_tty(tty, idx);
|
|
|
|
module_put(driver->owner);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Even releasing the tty structures is a tricky business.. We have
|
|
|
|
* to be very careful that the structures are all released at the
|
|
|
|
* same time, as interrupts might otherwise get the wrong pointers.
|
|
|
|
*
|
|
|
|
* WSH 09/09/97: rewritten to avoid some nasty race conditions that could
|
|
|
|
* lead to double frees or releasing memory still in use.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
static void release_dev(struct file *filp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct tty_struct *tty, *o_tty;
|
|
|
|
int pty_master, tty_closing, o_tty_closing, do_sleep;
|
2006-04-11 07:54:19 +02:00
|
|
|
int devpts;
|
2005-04-17 00:20:36 +02:00
|
|
|
int idx;
|
|
|
|
char buf[64];
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tty = (struct tty_struct *)filp->private_data;
|
2008-02-08 13:18:47 +01:00
|
|
|
if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode,
|
|
|
|
"release_dev"))
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
check_tty_count(tty, "release_dev");
|
|
|
|
|
|
|
|
tty_fasync(-1, filp, 0);
|
|
|
|
|
|
|
|
idx = tty->index;
|
|
|
|
pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_MASTER);
|
|
|
|
devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
|
|
|
|
o_tty = tty->link;
|
|
|
|
|
|
|
|
#ifdef TTY_PARANOIA_CHECK
|
|
|
|
if (idx < 0 || idx >= tty->driver->num) {
|
|
|
|
printk(KERN_DEBUG "release_dev: bad idx when trying to "
|
|
|
|
"free (%s)\n", tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
|
|
|
|
if (tty != tty->driver->ttys[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
|
|
|
|
"for (%s)\n", idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (tty->termios != tty->driver->termios[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
|
|
|
|
"for (%s)\n",
|
|
|
|
idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (tty->termios_locked != tty->driver->termios_locked[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
|
|
|
|
"termios_locked for (%s)\n",
|
|
|
|
idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
|
|
|
|
tty_name(tty, buf), tty->count);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef TTY_PARANOIA_CHECK
|
|
|
|
if (tty->driver->other &&
|
|
|
|
!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
|
|
|
|
if (o_tty != tty->driver->other->ttys[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: other->table[%d] "
|
|
|
|
"not o_tty for (%s)\n",
|
|
|
|
idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (o_tty->termios != tty->driver->other->termios[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: other->termios[%d] "
|
|
|
|
"not o_termios for (%s)\n",
|
|
|
|
idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
if (o_tty->termios_locked !=
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->driver->other->termios_locked[idx]) {
|
|
|
|
printk(KERN_DEBUG "release_dev: other->termios_locked["
|
|
|
|
"%d] not o_termios_locked for (%s)\n",
|
|
|
|
idx, tty->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (o_tty->link != tty) {
|
|
|
|
printk(KERN_DEBUG "release_dev: bad pty pointers\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->close)
|
|
|
|
tty->ops->close(tty, filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sanity check: if tty->count is going to zero, there shouldn't be
|
|
|
|
* any waiters on tty->read_wait or tty->write_wait. We test the
|
|
|
|
* wait queues and kick everyone out _before_ actually starting to
|
|
|
|
* close. This ensures that we won't block while releasing the tty
|
|
|
|
* structure.
|
|
|
|
*
|
|
|
|
* The test for the o_tty closing is necessary, since the master and
|
|
|
|
* slave sides may close in any order. If the slave side closes out
|
|
|
|
* first, its count will be one, since the master side holds an open.
|
|
|
|
* Thus this test wouldn't be triggered at the time the slave closes,
|
|
|
|
* so we do it now.
|
|
|
|
*
|
|
|
|
* Note that it's possible for the tty to be opened again while we're
|
|
|
|
* flushing out waiters. By recalculating the closing flags before
|
|
|
|
* each iteration we avoid any problems.
|
|
|
|
*/
|
|
|
|
while (1) {
|
|
|
|
/* Guard against races with tty->count changes elsewhere and
|
|
|
|
opens on /dev/tty */
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_closing = tty->count <= 1;
|
|
|
|
o_tty_closing = o_tty &&
|
|
|
|
(o_tty->count <= (pty_master ? 1 : 0));
|
|
|
|
do_sleep = 0;
|
|
|
|
|
|
|
|
if (tty_closing) {
|
|
|
|
if (waitqueue_active(&tty->read_wait)) {
|
|
|
|
wake_up(&tty->read_wait);
|
|
|
|
do_sleep++;
|
|
|
|
}
|
|
|
|
if (waitqueue_active(&tty->write_wait)) {
|
|
|
|
wake_up(&tty->write_wait);
|
|
|
|
do_sleep++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (o_tty_closing) {
|
|
|
|
if (waitqueue_active(&o_tty->read_wait)) {
|
|
|
|
wake_up(&o_tty->read_wait);
|
|
|
|
do_sleep++;
|
|
|
|
}
|
|
|
|
if (waitqueue_active(&o_tty->write_wait)) {
|
|
|
|
wake_up(&o_tty->write_wait);
|
|
|
|
do_sleep++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!do_sleep)
|
|
|
|
break;
|
|
|
|
|
|
|
|
printk(KERN_WARNING "release_dev: %s: read/write wait queue "
|
|
|
|
"active!\n", tty_name(tty, buf));
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
schedule();
|
2008-02-08 13:18:47 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2008-02-08 13:18:47 +01:00
|
|
|
* The closing flags are now consistent with the open counts on
|
|
|
|
* both sides, and we've completed the last operation that could
|
2005-04-17 00:20:36 +02:00
|
|
|
* block, so it's safe to proceed with closing.
|
|
|
|
*/
|
|
|
|
if (pty_master) {
|
|
|
|
if (--o_tty->count < 0) {
|
|
|
|
printk(KERN_WARNING "release_dev: bad pty slave count "
|
|
|
|
"(%d) for %s\n",
|
|
|
|
o_tty->count, tty_name(o_tty, buf));
|
|
|
|
o_tty->count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (--tty->count < 0) {
|
|
|
|
printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
|
|
|
|
tty->count, tty_name(tty, buf));
|
|
|
|
tty->count = 0;
|
|
|
|
}
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* We've decremented tty->count, so we need to remove this file
|
|
|
|
* descriptor off the tty->tty_files list; this serves two
|
|
|
|
* purposes:
|
|
|
|
* - check_tty_count sees the correct number of file descriptors
|
|
|
|
* associated with this tty.
|
|
|
|
* - do_tty_hangup no longer sees this file descriptor as
|
|
|
|
* something that needs to be handled for hangups.
|
|
|
|
*/
|
|
|
|
file_kill(filp);
|
|
|
|
filp->private_data = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform some housekeeping before deciding whether to return.
|
|
|
|
*
|
|
|
|
* Set the TTY_CLOSING flag if this was the last open. In the
|
|
|
|
* case of a pty we may have to wait around for the other side
|
|
|
|
* to close, and TTY_CLOSING makes sure we can't be reopened.
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
if (tty_closing)
|
2005-04-17 00:20:36 +02:00
|
|
|
set_bit(TTY_CLOSING, &tty->flags);
|
2008-02-08 13:18:47 +01:00
|
|
|
if (o_tty_closing)
|
2005-04-17 00:20:36 +02:00
|
|
|
set_bit(TTY_CLOSING, &o_tty->flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If _either_ side is closing, make sure there aren't any
|
|
|
|
* processes that still think tty or o_tty is their controlling
|
|
|
|
* tty.
|
|
|
|
*/
|
|
|
|
if (tty_closing || o_tty_closing) {
|
|
|
|
read_lock(&tasklist_lock);
|
2006-12-08 11:36:04 +01:00
|
|
|
session_clear_tty(tty->session);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (o_tty)
|
2006-12-08 11:36:04 +01:00
|
|
|
session_clear_tty(o_tty->session);
|
2005-04-17 00:20:36 +02:00
|
|
|
read_unlock(&tasklist_lock);
|
|
|
|
}
|
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2006-02-14 22:53:00 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* check whether both sides are closing ... */
|
|
|
|
if (!tty_closing || (o_tty && !o_tty_closing))
|
|
|
|
return;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
printk(KERN_DEBUG "freeing tty structure...");
|
|
|
|
#endif
|
|
|
|
/*
|
2008-07-22 12:16:55 +02:00
|
|
|
* Ask the line discipline code to release its structures
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-07-22 12:16:55 +02:00
|
|
|
tty_ldisc_release(tty, o_tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2007-02-10 10:46:46 +01:00
|
|
|
* The release_tty function takes care of the details of clearing
|
2005-04-17 00:20:36 +02:00
|
|
|
* the slots and preserving the termios structure.
|
|
|
|
*/
|
2007-02-10 10:46:46 +01:00
|
|
|
release_tty(tty, idx);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Make this pty number available for reallocation */
|
2008-04-30 09:54:21 +02:00
|
|
|
if (devpts)
|
|
|
|
devpts_kill_index(idx);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_open - open a tty device
|
|
|
|
* @inode: inode of device file
|
|
|
|
* @filp: file pointer to tty
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* tty_open and tty_release keep up the tty count that contains the
|
|
|
|
* number of opens done on a tty. We cannot use the inode-count, as
|
|
|
|
* different inodes might point to the same tty.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* Open-counting is needed for pty masters, as well as for keeping
|
|
|
|
* track of serial lines: DTR is dropped when the last close happens.
|
|
|
|
* (This is not done solely through tty->count, now. - Ted 1/27/92)
|
|
|
|
*
|
|
|
|
* The termios state of a pty is reset on first open so that
|
|
|
|
* settings don't persist across reuse.
|
|
|
|
*
|
2006-12-08 11:36:04 +01:00
|
|
|
* Locking: tty_mutex protects tty, get_tty_driver and init_dev work.
|
|
|
|
* tty->count should protect the rest.
|
|
|
|
* ->siglock protects ->signal/->sighand
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2008-05-16 17:10:50 +02:00
|
|
|
static int __tty_open(struct inode *inode, struct file *filp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct tty_struct *tty;
|
|
|
|
int noctty, retval;
|
|
|
|
struct tty_driver *driver;
|
|
|
|
int index;
|
|
|
|
dev_t device = inode->i_rdev;
|
|
|
|
unsigned short saved_flags = filp->f_flags;
|
|
|
|
|
|
|
|
nonseekable_open(inode, filp);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
retry_open:
|
|
|
|
noctty = filp->f_flags & O_NOCTTY;
|
|
|
|
index = -1;
|
|
|
|
retval = 0;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
if (device == MKDEV(TTYAUX_MAJOR, 0)) {
|
2006-12-08 11:36:04 +01:00
|
|
|
tty = get_current_tty();
|
|
|
|
if (!tty) {
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
2006-12-08 11:36:04 +01:00
|
|
|
driver = tty->driver;
|
|
|
|
index = tty->index;
|
2005-04-17 00:20:36 +02:00
|
|
|
filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
|
|
|
|
/* noctty = 1; */
|
|
|
|
goto got_driver;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_VT
|
2008-02-08 13:18:47 +01:00
|
|
|
if (device == MKDEV(TTY_MAJOR, 0)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
extern struct tty_driver *console_driver;
|
|
|
|
driver = console_driver;
|
|
|
|
index = fg_console;
|
|
|
|
noctty = 1;
|
|
|
|
goto got_driver;
|
|
|
|
}
|
|
|
|
#endif
|
2008-02-08 13:18:47 +01:00
|
|
|
if (device == MKDEV(TTYAUX_MAJOR, 1)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
driver = console_device(&index);
|
|
|
|
if (driver) {
|
|
|
|
/* Don't let /dev/console block */
|
|
|
|
filp->f_flags |= O_NONBLOCK;
|
|
|
|
noctty = 1;
|
|
|
|
goto got_driver;
|
|
|
|
}
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
driver = get_tty_driver(device, &index);
|
|
|
|
if (!driver) {
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
got_driver:
|
|
|
|
retval = init_dev(driver, index, &tty);
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
filp->private_data = tty;
|
|
|
|
file_move(filp, &tty->tty_files);
|
|
|
|
check_tty_count(tty, "tty_open");
|
|
|
|
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_MASTER)
|
|
|
|
noctty = 1;
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
printk(KERN_DEBUG "opening %s...", tty->name);
|
|
|
|
#endif
|
|
|
|
if (!retval) {
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->open)
|
|
|
|
retval = tty->ops->open(tty, filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
retval = -ENODEV;
|
|
|
|
}
|
|
|
|
filp->f_flags = saved_flags;
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
|
|
|
|
!capable(CAP_SYS_ADMIN))
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = -EBUSY;
|
|
|
|
|
|
|
|
if (retval) {
|
|
|
|
#ifdef TTY_DEBUG_HANGUP
|
|
|
|
printk(KERN_DEBUG "error %d in opening %s...", retval,
|
|
|
|
tty->name);
|
|
|
|
#endif
|
|
|
|
release_dev(filp);
|
|
|
|
if (retval != -ERESTARTSYS)
|
|
|
|
return retval;
|
|
|
|
if (signal_pending(current))
|
|
|
|
return retval;
|
|
|
|
schedule();
|
|
|
|
/*
|
|
|
|
* Need to reset f_op in case a hangup happened.
|
|
|
|
*/
|
|
|
|
if (filp->f_op == &hung_up_tty_fops)
|
|
|
|
filp->f_op = &tty_fops;
|
|
|
|
goto retry_open;
|
|
|
|
}
|
2006-12-08 11:36:04 +01:00
|
|
|
|
|
|
|
mutex_lock(&tty_mutex);
|
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!noctty &&
|
|
|
|
current->signal->leader &&
|
|
|
|
!current->signal->tty &&
|
2007-02-12 09:53:00 +01:00
|
|
|
tty->session == NULL)
|
2007-05-08 09:26:53 +02:00
|
|
|
__proc_set_tty(current, tty);
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-16 17:10:50 +02:00
|
|
|
/* BKL pushdown: scary code avoidance wrapper */
|
|
|
|
static int tty_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
ret = __tty_open(inode, filp);
|
|
|
|
unlock_kernel();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_UNIX98_PTYS
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* ptmx_open - open a unix 98 pty master
|
|
|
|
* @inode: inode of device file
|
|
|
|
* @filp: file pointer to tty
|
|
|
|
*
|
|
|
|
* Allocate a unix98 pty master device from the ptmx driver.
|
|
|
|
*
|
|
|
|
* Locking: tty_mutex protects theinit_dev work. tty->count should
|
2008-02-08 13:18:47 +01:00
|
|
|
* protect the rest.
|
2006-08-27 10:24:01 +02:00
|
|
|
* allocated_ptys_lock handles the list of free pty numbers
|
|
|
|
*/
|
|
|
|
|
2008-05-16 17:10:50 +02:00
|
|
|
static int __ptmx_open(struct inode *inode, struct file *filp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct tty_struct *tty;
|
|
|
|
int retval;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
nonseekable_open(inode, filp);
|
|
|
|
|
|
|
|
/* find a device that is not in use. */
|
2008-04-30 09:54:21 +02:00
|
|
|
index = devpts_new_index();
|
|
|
|
if (index < 0)
|
|
|
|
return index;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = init_dev(ptm_driver, index, &tty);
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_unlock(&tty_mutex);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
|
|
|
|
filp->private_data = tty;
|
|
|
|
file_move(filp, &tty->tty_files);
|
|
|
|
|
2008-04-30 09:54:20 +02:00
|
|
|
retval = devpts_pty_new(tty->link);
|
|
|
|
if (retval)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out1;
|
|
|
|
|
2008-04-30 09:54:20 +02:00
|
|
|
check_tty_count(tty, "ptmx_open");
|
2008-04-30 09:54:13 +02:00
|
|
|
retval = ptm_driver->ops->open(tty, filp);
|
2008-04-18 22:30:14 +02:00
|
|
|
if (!retval)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
out1:
|
|
|
|
release_dev(filp);
|
2006-04-11 07:54:18 +02:00
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-04-30 09:54:21 +02:00
|
|
|
devpts_kill_index(index);
|
2005-04-17 00:20:36 +02:00
|
|
|
return retval;
|
|
|
|
}
|
2008-05-16 17:10:50 +02:00
|
|
|
|
|
|
|
static int ptmx_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
ret = __ptmx_open(inode, filp);
|
|
|
|
unlock_kernel();
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_release - vfs callback for close
|
|
|
|
* @inode: inode of tty
|
|
|
|
* @filp: file pointer for handle to tty
|
|
|
|
*
|
|
|
|
* Called the last time each file handle is closed that references
|
|
|
|
* this tty. There may however be several such references.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* Takes bkl. See release_dev
|
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static int tty_release(struct inode *inode, struct file *filp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
lock_kernel();
|
|
|
|
release_dev(filp);
|
|
|
|
unlock_kernel();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tty_poll - check tty status
|
|
|
|
* @filp: file being polled
|
|
|
|
* @wait: poll wait structures to update
|
|
|
|
*
|
|
|
|
* Call the line discipline polling method to obtain the poll
|
|
|
|
* status of the device.
|
|
|
|
*
|
|
|
|
* Locking: locks called line discipline but ldisc poll method
|
|
|
|
* may be re-entered freely by other callers.
|
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static unsigned int tty_poll(struct file *filp, poll_table *wait)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:47 +01:00
|
|
|
struct tty_struct *tty;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct tty_ldisc *ld;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
tty = (struct tty_struct *)filp->private_data;
|
2006-12-08 11:36:55 +01:00
|
|
|
if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->poll)
|
|
|
|
ret = (ld->ops->poll)(tty, filp, wait);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static int tty_fasync(int fd, struct file *filp, int on)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-08 13:18:47 +01:00
|
|
|
struct tty_struct *tty;
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
2008-06-20 00:04:53 +02:00
|
|
|
int retval = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-20 00:04:53 +02:00
|
|
|
lock_kernel();
|
2005-04-17 00:20:36 +02:00
|
|
|
tty = (struct tty_struct *)filp->private_data;
|
2006-12-08 11:36:55 +01:00
|
|
|
if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
|
2008-06-20 00:04:53 +02:00
|
|
|
goto out;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = fasync_helper(fd, filp, on, &tty->fasync);
|
|
|
|
if (retval <= 0)
|
2008-06-20 00:04:53 +02:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (on) {
|
2007-02-12 09:53:00 +01:00
|
|
|
enum pid_type type;
|
|
|
|
struct pid *pid;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!waitqueue_active(&tty->read_wait))
|
|
|
|
tty->minimum_to_wake = 1;
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2007-02-12 09:53:00 +01:00
|
|
|
if (tty->pgrp) {
|
|
|
|
pid = tty->pgrp;
|
|
|
|
type = PIDTYPE_PGID;
|
|
|
|
} else {
|
|
|
|
pid = task_pid(current);
|
|
|
|
type = PIDTYPE_PID;
|
|
|
|
}
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2007-02-12 09:53:00 +01:00
|
|
|
retval = __f_setown(filp, pid, type, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retval)
|
2008-06-20 00:04:53 +02:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
if (!tty->fasync && !waitqueue_active(&tty->read_wait))
|
|
|
|
tty->minimum_to_wake = N_TTY_BUF_SIZE;
|
|
|
|
}
|
2008-06-20 00:04:53 +02:00
|
|
|
retval = 0;
|
|
|
|
out:
|
|
|
|
unlock_kernel();
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocsti - fake input character
|
|
|
|
* @tty: tty to fake input into
|
|
|
|
* @p: pointer to character
|
|
|
|
*
|
2007-10-19 23:10:43 +02:00
|
|
|
* Fake input to a tty device. Does the necessary locking and
|
2006-08-27 10:24:01 +02:00
|
|
|
* input management.
|
|
|
|
*
|
|
|
|
* FIXME: does not honour flow control ??
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* Called functions take tty_ldisc_lock
|
|
|
|
* current->signal->tty check is safe without locks
|
2006-09-29 11:00:58 +02:00
|
|
|
*
|
|
|
|
* FIXME: may race normal receive processing
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocsti(struct tty_struct *tty, char __user *p)
|
|
|
|
{
|
|
|
|
char ch, mbz = 0;
|
|
|
|
struct tty_ldisc *ld;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
if (get_user(ch, p))
|
|
|
|
return -EFAULT;
|
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
2008-07-16 22:53:12 +02:00
|
|
|
ld->ops->receive_buf(tty, &ch, &mbz, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocgwinsz - implement window query ioctl
|
|
|
|
* @tty; tty
|
|
|
|
* @arg: user buffer for result
|
|
|
|
*
|
2006-09-29 11:00:40 +02:00
|
|
|
* Copies the kernel idea of the window size into the user buffer.
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
2006-12-08 11:36:04 +01:00
|
|
|
* Locking: tty->termios_mutex is taken to ensure the winsize data
|
2006-09-29 11:00:40 +02:00
|
|
|
* is consistent.
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2008-02-08 13:18:47 +01:00
|
|
|
static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-09-29 11:00:40 +02:00
|
|
|
int err;
|
|
|
|
|
2006-09-29 11:00:43 +02:00
|
|
|
mutex_lock(&tty->termios_mutex);
|
2006-09-29 11:00:40 +02:00
|
|
|
err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
|
2006-09-29 11:00:43 +02:00
|
|
|
mutex_unlock(&tty->termios_mutex);
|
2006-09-29 11:00:40 +02:00
|
|
|
|
|
|
|
return err ? -EFAULT: 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
2008-08-15 11:39:38 +02:00
|
|
|
* tty_do_resize - resize event
|
|
|
|
* @tty: tty being resized
|
2008-08-26 20:55:58 +02:00
|
|
|
* @real_tty: real tty (not the same as tty if using a pty/tty pair)
|
2008-08-15 11:39:38 +02:00
|
|
|
* @rows: rows (character)
|
|
|
|
* @cols: cols (character)
|
|
|
|
*
|
|
|
|
* Update the termios variables and send the neccessary signals to
|
|
|
|
* peform a terminal resize correctly
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2008-08-15 11:39:38 +02:00
|
|
|
int tty_do_resize(struct tty_struct *tty, struct tty_struct *real_tty,
|
|
|
|
struct winsize *ws)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:53:30 +02:00
|
|
|
struct pid *pgrp, *rpgrp;
|
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-08-26 20:55:58 +02:00
|
|
|
/* For a PTY we need to lock the tty side */
|
|
|
|
mutex_lock(&real_tty->termios_mutex);
|
2008-08-15 11:39:38 +02:00
|
|
|
if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
|
2006-09-29 11:00:03 +02:00
|
|
|
goto done;
|
2008-04-30 09:53:30 +02:00
|
|
|
/* Get the PID values and reference them so we can
|
|
|
|
avoid holding the tty ctrl lock while sending signals */
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
|
|
|
pgrp = get_pid(tty->pgrp);
|
|
|
|
rpgrp = get_pid(real_tty->pgrp);
|
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
|
|
|
|
|
|
|
if (pgrp)
|
|
|
|
kill_pgrp(pgrp, SIGWINCH, 1);
|
|
|
|
if (rpgrp != pgrp && rpgrp)
|
|
|
|
kill_pgrp(rpgrp, SIGWINCH, 1);
|
|
|
|
|
|
|
|
put_pid(pgrp);
|
|
|
|
put_pid(rpgrp);
|
|
|
|
|
2008-08-15 11:39:38 +02:00
|
|
|
tty->winsize = *ws;
|
|
|
|
real_tty->winsize = *ws;
|
2006-09-29 11:00:03 +02:00
|
|
|
done:
|
2008-08-26 20:55:58 +02:00
|
|
|
mutex_unlock(&real_tty->termios_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-15 11:39:38 +02:00
|
|
|
/**
|
|
|
|
* tiocswinsz - implement window size set ioctl
|
|
|
|
* @tty; tty
|
|
|
|
* @arg: user buffer for result
|
|
|
|
*
|
|
|
|
* Copies the user idea of the window size to the kernel. Traditionally
|
|
|
|
* this is just advisory information but for the Linux console it
|
|
|
|
* actually has driver level meaning and triggers a VC resize.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* Driver dependant. The default do_resize method takes the
|
|
|
|
* tty termios mutex and ctrl_lock. The console takes its own lock
|
|
|
|
* then calls into the default method.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
|
|
|
|
struct winsize __user *arg)
|
|
|
|
{
|
|
|
|
struct winsize tmp_ws;
|
|
|
|
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (tty->ops->resize)
|
|
|
|
return tty->ops->resize(tty, real_tty, &tmp_ws);
|
|
|
|
else
|
|
|
|
return tty_do_resize(tty, real_tty, &tmp_ws);
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tioccons - allow admin to move logical console
|
|
|
|
* @file: the file to become console
|
|
|
|
*
|
|
|
|
* Allow the adminstrator to move the redirected console device
|
|
|
|
*
|
|
|
|
* Locking: uses redirect_lock to guard the redirect information
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tioccons(struct file *file)
|
|
|
|
{
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
if (file->f_op->write == redirected_tty_write) {
|
|
|
|
struct file *f;
|
|
|
|
spin_lock(&redirect_lock);
|
|
|
|
f = redirect;
|
|
|
|
redirect = NULL;
|
|
|
|
spin_unlock(&redirect_lock);
|
|
|
|
if (f)
|
|
|
|
fput(f);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
spin_lock(&redirect_lock);
|
|
|
|
if (redirect) {
|
|
|
|
spin_unlock(&redirect_lock);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
get_file(file);
|
|
|
|
redirect = file;
|
|
|
|
spin_unlock(&redirect_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* fionbio - non blocking ioctl
|
|
|
|
* @file: file to set blocking value
|
|
|
|
* @p: user parameter
|
|
|
|
*
|
|
|
|
* Historical tty interfaces had a blocking control ioctl before
|
|
|
|
* the generic functionality existed. This piece of history is preserved
|
|
|
|
* in the expected tty API of posix OS's.
|
|
|
|
*
|
|
|
|
* Locking: none, the open fle handle ensures it won't go away.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static int fionbio(struct file *file, int __user *p)
|
|
|
|
{
|
|
|
|
int nonblock;
|
|
|
|
|
|
|
|
if (get_user(nonblock, p))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2008-04-30 09:53:29 +02:00
|
|
|
/* file->f_flags is still BKL protected in the fs layer - vomit */
|
|
|
|
lock_kernel();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (nonblock)
|
|
|
|
file->f_flags |= O_NONBLOCK;
|
|
|
|
else
|
|
|
|
file->f_flags &= ~O_NONBLOCK;
|
2008-04-30 09:53:29 +02:00
|
|
|
unlock_kernel();
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocsctty - set controlling tty
|
|
|
|
* @tty: tty structure
|
|
|
|
* @arg: user argument
|
|
|
|
*
|
|
|
|
* This ioctl is used to manage job control. It permits a session
|
|
|
|
* leader to set this tty as the controlling tty for the session.
|
|
|
|
*
|
|
|
|
* Locking:
|
2006-09-29 11:00:58 +02:00
|
|
|
* Takes tty_mutex() to protect tty instance
|
2006-12-08 11:36:04 +01:00
|
|
|
* Takes tasklist_lock internally to walk sessions
|
|
|
|
* Takes ->siglock() when updating signal->tty
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocsctty(struct tty_struct *tty, int arg)
|
|
|
|
{
|
2006-12-08 11:36:04 +01:00
|
|
|
int ret = 0;
|
2007-02-12 09:53:00 +01:00
|
|
|
if (current->signal->leader && (task_session(current) == tty->session))
|
2006-12-08 11:36:04 +01:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* The process must be a session leader and
|
|
|
|
* not have a controlling tty already.
|
|
|
|
*/
|
2006-12-08 11:36:04 +01:00
|
|
|
if (!current->signal->leader || current->signal->tty) {
|
|
|
|
ret = -EPERM;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2007-02-12 09:53:00 +01:00
|
|
|
if (tty->session) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* This tty is already the controlling
|
|
|
|
* tty for another session group!
|
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
if (arg == 1 && capable(CAP_SYS_ADMIN)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Steal it away
|
|
|
|
*/
|
|
|
|
read_lock(&tasklist_lock);
|
2006-12-08 11:36:04 +01:00
|
|
|
session_clear_tty(tty->session);
|
2005-04-17 00:20:36 +02:00
|
|
|
read_unlock(&tasklist_lock);
|
2006-12-08 11:36:04 +01:00
|
|
|
} else {
|
|
|
|
ret = -EPERM;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-12-08 11:36:04 +01:00
|
|
|
proc_set_tty(current, tty);
|
|
|
|
unlock:
|
2006-09-29 11:00:58 +02:00
|
|
|
mutex_unlock(&tty_mutex);
|
2006-12-08 11:36:04 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:31 +02:00
|
|
|
/**
|
|
|
|
* tty_get_pgrp - return a ref counted pgrp pid
|
|
|
|
* @tty: tty to read
|
|
|
|
*
|
|
|
|
* Returns a refcounted instance of the pid struct for the process
|
|
|
|
* group controlling the tty.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct pid *tty_get_pgrp(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct pid *pgrp;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
|
|
|
pgrp = get_pid(tty->pgrp);
|
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
|
|
|
|
|
|
|
return pgrp;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(tty_get_pgrp);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocgpgrp - get process group
|
|
|
|
* @tty: tty passed by user
|
|
|
|
* @real_tty: tty side of the tty pased by the user if a pty else the tty
|
|
|
|
* @p: returned pid
|
|
|
|
*
|
|
|
|
* Obtain the process group of the tty. If there is no process group
|
|
|
|
* return an error.
|
|
|
|
*
|
2006-12-08 11:36:04 +01:00
|
|
|
* Locking: none. Reference to current->signal->tty is safe.
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
|
|
|
|
{
|
2008-04-30 09:53:31 +02:00
|
|
|
struct pid *pid;
|
|
|
|
int ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* (tty == real_tty) is a cheap way of
|
|
|
|
* testing if the tty is NOT a master pty.
|
|
|
|
*/
|
|
|
|
if (tty == real_tty && current->signal->tty != real_tty)
|
|
|
|
return -ENOTTY;
|
2008-04-30 09:53:31 +02:00
|
|
|
pid = tty_get_pgrp(real_tty);
|
|
|
|
ret = put_user(pid_vnr(pid), p);
|
|
|
|
put_pid(pid);
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocspgrp - attempt to set process group
|
|
|
|
* @tty: tty passed by user
|
|
|
|
* @real_tty: tty side device matching tty passed by user
|
|
|
|
* @p: pid pointer
|
|
|
|
*
|
|
|
|
* Set the process group of the tty to the session passed. Only
|
|
|
|
* permitted where the tty session is our session.
|
|
|
|
*
|
2008-04-30 09:53:30 +02:00
|
|
|
* Locking: RCU, ctrl lock
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
|
|
|
|
{
|
2007-02-12 09:52:56 +01:00
|
|
|
struct pid *pgrp;
|
|
|
|
pid_t pgrp_nr;
|
2005-04-17 00:20:36 +02:00
|
|
|
int retval = tty_check_change(real_tty);
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (retval == -EIO)
|
|
|
|
return -ENOTTY;
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
if (!current->signal->tty ||
|
|
|
|
(current->signal->tty != real_tty) ||
|
2007-02-12 09:53:00 +01:00
|
|
|
(real_tty->session != task_session(current)))
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOTTY;
|
2007-02-12 09:52:56 +01:00
|
|
|
if (get_user(pgrp_nr, p))
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EFAULT;
|
2007-02-12 09:52:56 +01:00
|
|
|
if (pgrp_nr < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
2007-02-12 09:52:56 +01:00
|
|
|
rcu_read_lock();
|
2007-10-19 08:40:14 +02:00
|
|
|
pgrp = find_vpid(pgrp_nr);
|
2007-02-12 09:52:56 +01:00
|
|
|
retval = -ESRCH;
|
|
|
|
if (!pgrp)
|
|
|
|
goto out_unlock;
|
|
|
|
retval = -EPERM;
|
|
|
|
if (session_of_pgrp(pgrp) != task_session(current))
|
|
|
|
goto out_unlock;
|
|
|
|
retval = 0;
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2007-02-12 09:53:00 +01:00
|
|
|
put_pid(real_tty->pgrp);
|
|
|
|
real_tty->pgrp = get_pid(pgrp);
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
2007-02-12 09:52:56 +01:00
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocgsid - get session id
|
|
|
|
* @tty: tty passed by user
|
|
|
|
* @real_tty: tty side of the tty pased by the user if a pty else the tty
|
|
|
|
* @p: pointer to returned session id
|
|
|
|
*
|
|
|
|
* Obtain the session id of the tty. If there is no session
|
|
|
|
* return an error.
|
|
|
|
*
|
2006-12-08 11:36:04 +01:00
|
|
|
* Locking: none. Reference to current->signal->tty is safe.
|
2006-08-27 10:24:01 +02:00
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* (tty == real_tty) is a cheap way of
|
|
|
|
* testing if the tty is NOT a master pty.
|
|
|
|
*/
|
|
|
|
if (tty == real_tty && current->signal->tty != real_tty)
|
|
|
|
return -ENOTTY;
|
2007-02-12 09:53:00 +01:00
|
|
|
if (!real_tty->session)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOTTY;
|
2007-10-19 08:40:14 +02:00
|
|
|
return put_user(pid_vnr(real_tty->session), p);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* tiocsetd - set line discipline
|
|
|
|
* @tty: tty device
|
|
|
|
* @p: pointer to user data
|
|
|
|
*
|
|
|
|
* Set the line discipline according to user request.
|
|
|
|
*
|
|
|
|
* Locking: see tty_set_ldisc, this function is just a helper
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int tiocsetd(struct tty_struct *tty, int __user *p)
|
|
|
|
{
|
|
|
|
int ldisc;
|
2008-04-30 09:53:29 +02:00
|
|
|
int ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (get_user(ldisc, p))
|
|
|
|
return -EFAULT;
|
2008-04-30 09:53:29 +02:00
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
ret = tty_set_ldisc(tty, ldisc);
|
|
|
|
unlock_kernel();
|
|
|
|
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* send_break - performed time break
|
|
|
|
* @tty: device to break on
|
|
|
|
* @duration: timeout in mS
|
|
|
|
*
|
|
|
|
* Perform a timed break on hardware that lacks its own driver level
|
|
|
|
* timed break functionality.
|
|
|
|
*
|
|
|
|
* Locking:
|
2006-09-29 11:00:58 +02:00
|
|
|
* atomic_write_lock serializes
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-06-25 23:58:42 +02:00
|
|
|
static int send_break(struct tty_struct *tty, unsigned int duration)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-22 12:18:03 +02:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (tty->ops->break_ctl == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
|
|
|
|
retval = tty->ops->break_ctl(tty, duration);
|
|
|
|
else {
|
|
|
|
/* Do the work ourselves */
|
|
|
|
if (tty_write_lock(tty, 0) < 0)
|
|
|
|
return -EINTR;
|
|
|
|
retval = tty->ops->break_ctl(tty, -1);
|
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
if (!signal_pending(current))
|
|
|
|
msleep_interruptible(duration);
|
|
|
|
retval = tty->ops->break_ctl(tty, 0);
|
|
|
|
out:
|
|
|
|
tty_write_unlock(tty);
|
|
|
|
if (signal_pending(current))
|
|
|
|
retval = -EINTR;
|
|
|
|
}
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
2008-04-30 09:54:13 +02:00
|
|
|
* tty_tiocmget - get modem status
|
2006-08-27 10:24:01 +02:00
|
|
|
* @tty: tty device
|
|
|
|
* @file: user file pointer
|
|
|
|
* @p: pointer to result
|
|
|
|
*
|
|
|
|
* Obtain the modem status bits from the tty driver if the feature
|
|
|
|
* is supported. Return -EINVAL if it is not available.
|
|
|
|
*
|
|
|
|
* Locking: none (up to the driver)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int retval = -EINVAL;
|
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->tiocmget) {
|
|
|
|
retval = tty->ops->tiocmget(tty, file);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (retval >= 0)
|
|
|
|
retval = put_user(retval, p);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
2008-04-30 09:54:13 +02:00
|
|
|
* tty_tiocmset - set modem status
|
2006-08-27 10:24:01 +02:00
|
|
|
* @tty: tty device
|
|
|
|
* @file: user file pointer
|
|
|
|
* @cmd: command - clear bits, set bits or set all
|
|
|
|
* @p: pointer to desired bits
|
|
|
|
*
|
|
|
|
* Set the modem status bits from the tty driver if the feature
|
|
|
|
* is supported. Return -EINVAL if it is not available.
|
|
|
|
*
|
|
|
|
* Locking: none (up to the driver)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned __user *p)
|
|
|
|
{
|
2008-07-16 22:56:54 +02:00
|
|
|
int retval;
|
|
|
|
unsigned int set, clear, val;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-16 22:56:54 +02:00
|
|
|
if (tty->ops->tiocmset == NULL)
|
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-16 22:56:54 +02:00
|
|
|
retval = get_user(val, p);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
set = clear = 0;
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCMBIS:
|
|
|
|
set = val;
|
|
|
|
break;
|
|
|
|
case TIOCMBIC:
|
|
|
|
clear = val;
|
|
|
|
break;
|
|
|
|
case TIOCMSET:
|
|
|
|
set = val;
|
|
|
|
clear = ~val;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
|
|
|
|
clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
|
|
|
|
return tty->ops->tiocmset(tty, file, set, clear);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Split this up, as gcc can choke on it otherwise..
|
|
|
|
*/
|
2008-04-30 09:53:29 +02:00
|
|
|
long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct tty_struct *tty, *real_tty;
|
|
|
|
void __user *p = (void __user *)arg;
|
|
|
|
int retval;
|
|
|
|
struct tty_ldisc *ld;
|
2008-04-30 09:53:29 +02:00
|
|
|
struct inode *inode = file->f_dentry->d_inode;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tty = (struct tty_struct *)file->private_data;
|
|
|
|
if (tty_paranoia_check(tty, inode, "tty_ioctl"))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
real_tty = tty;
|
|
|
|
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
|
|
|
|
tty->driver->subtype == PTY_TYPE_MASTER)
|
|
|
|
real_tty = tty->link;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Factor out some common prep work
|
|
|
|
*/
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCSETD:
|
|
|
|
case TIOCSBRK:
|
|
|
|
case TIOCCBRK:
|
|
|
|
case TCSBRK:
|
2008-02-08 13:18:47 +01:00
|
|
|
case TCSBRKP:
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = tty_check_change(tty);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
if (cmd != TIOCCBRK) {
|
|
|
|
tty_wait_until_sent(tty, 0);
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -EINTR;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-07-22 12:18:03 +02:00
|
|
|
/*
|
|
|
|
* Now do the stuff.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (cmd) {
|
2008-02-08 13:18:47 +01:00
|
|
|
case TIOCSTI:
|
|
|
|
return tiocsti(tty, p);
|
|
|
|
case TIOCGWINSZ:
|
|
|
|
return tiocgwinsz(tty, p);
|
|
|
|
case TIOCSWINSZ:
|
|
|
|
return tiocswinsz(tty, real_tty, p);
|
|
|
|
case TIOCCONS:
|
|
|
|
return real_tty != tty ? -EINVAL : tioccons(file);
|
|
|
|
case FIONBIO:
|
|
|
|
return fionbio(file, p);
|
|
|
|
case TIOCEXCL:
|
|
|
|
set_bit(TTY_EXCLUSIVE, &tty->flags);
|
|
|
|
return 0;
|
|
|
|
case TIOCNXCL:
|
|
|
|
clear_bit(TTY_EXCLUSIVE, &tty->flags);
|
|
|
|
return 0;
|
|
|
|
case TIOCNOTTY:
|
|
|
|
if (current->signal->tty != tty)
|
|
|
|
return -ENOTTY;
|
|
|
|
no_tty();
|
|
|
|
return 0;
|
|
|
|
case TIOCSCTTY:
|
|
|
|
return tiocsctty(tty, arg);
|
|
|
|
case TIOCGPGRP:
|
|
|
|
return tiocgpgrp(tty, real_tty, p);
|
|
|
|
case TIOCSPGRP:
|
|
|
|
return tiocspgrp(tty, real_tty, p);
|
|
|
|
case TIOCGSID:
|
|
|
|
return tiocgsid(tty, real_tty, p);
|
|
|
|
case TIOCGETD:
|
2008-07-16 22:53:12 +02:00
|
|
|
return put_user(tty->ldisc.ops->num, (int __user *)p);
|
2008-02-08 13:18:47 +01:00
|
|
|
case TIOCSETD:
|
|
|
|
return tiocsetd(tty, p);
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_VT
|
2008-02-08 13:18:47 +01:00
|
|
|
case TIOCLINUX:
|
|
|
|
return tioclinux(tty, arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
2008-02-08 13:18:47 +01:00
|
|
|
/*
|
|
|
|
* Break handling
|
|
|
|
*/
|
|
|
|
case TIOCSBRK: /* Turn break on, unconditionally */
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->break_ctl)
|
2008-07-22 12:18:03 +02:00
|
|
|
return tty->ops->break_ctl(tty, -1);
|
2008-02-08 13:18:47 +01:00
|
|
|
return 0;
|
|
|
|
case TIOCCBRK: /* Turn break off, unconditionally */
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->break_ctl)
|
2008-07-22 12:18:03 +02:00
|
|
|
return tty->ops->break_ctl(tty, 0);
|
2008-02-08 13:18:47 +01:00
|
|
|
return 0;
|
|
|
|
case TCSBRK: /* SVID version: non-zero arg --> no break */
|
|
|
|
/* non-zero arg means wait for all output data
|
|
|
|
* to be sent (performed above) but don't send break.
|
|
|
|
* This is used by the tcdrain() termios function.
|
|
|
|
*/
|
|
|
|
if (!arg)
|
|
|
|
return send_break(tty, 250);
|
|
|
|
return 0;
|
|
|
|
case TCSBRKP: /* support for POSIX tcsendbreak() */
|
|
|
|
return send_break(tty, arg ? arg*100 : 250);
|
|
|
|
|
|
|
|
case TIOCMGET:
|
|
|
|
return tty_tiocmget(tty, file, p);
|
|
|
|
case TIOCMSET:
|
|
|
|
case TIOCMBIC:
|
|
|
|
case TIOCMBIS:
|
|
|
|
return tty_tiocmset(tty, file, cmd, p);
|
|
|
|
case TCFLSH:
|
|
|
|
switch (arg) {
|
|
|
|
case TCIFLUSH:
|
|
|
|
case TCIOFLUSH:
|
|
|
|
/* flush tty buffer and allow ldisc to process ioctl */
|
|
|
|
tty_buffer_flush(tty);
|
2007-05-12 19:36:55 +02:00
|
|
|
break;
|
2008-02-08 13:18:47 +01:00
|
|
|
}
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->ioctl) {
|
|
|
|
retval = (tty->ops->ioctl)(tty, file, cmd, arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retval != -ENOIOCTLCMD)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
|
|
|
retval = -EINVAL;
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->ioctl) {
|
|
|
|
retval = ld->ops->ioctl(tty, file, cmd, arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (retval == -ENOIOCTLCMD)
|
|
|
|
retval = -EINVAL;
|
|
|
|
}
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-05-11 07:22:50 +02:00
|
|
|
#ifdef CONFIG_COMPAT
|
2008-02-08 13:18:47 +01:00
|
|
|
static long tty_compat_ioctl(struct file *file, unsigned int cmd,
|
2007-05-11 07:22:50 +02:00
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
struct inode *inode = file->f_dentry->d_inode;
|
|
|
|
struct tty_struct *tty = file->private_data;
|
|
|
|
struct tty_ldisc *ld;
|
|
|
|
int retval = -ENOIOCTLCMD;
|
|
|
|
|
|
|
|
if (tty_paranoia_check(tty, inode, "tty_ioctl"))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->compat_ioctl) {
|
|
|
|
retval = (tty->ops->compat_ioctl)(tty, file, cmd, arg);
|
2007-05-11 07:22:50 +02:00
|
|
|
if (retval != -ENOIOCTLCMD)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
ld = tty_ldisc_ref_wait(tty);
|
2008-07-16 22:53:12 +02:00
|
|
|
if (ld->ops->compat_ioctl)
|
|
|
|
retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
|
2007-05-11 07:22:50 +02:00
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This implements the "Secure Attention Key" --- the idea is to
|
|
|
|
* prevent trojan horses by killing all processes associated with this
|
|
|
|
* tty when the user hits the "Secure Attention Key". Required for
|
|
|
|
* super-paranoid applications --- see the Orange Book for more details.
|
2008-02-08 13:18:47 +01:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* This code could be nicer; ideally it should send a HUP, wait a few
|
|
|
|
* seconds, then send a INT, and then a KILL signal. But you then
|
|
|
|
* have to coordinate with the init process, since all processes associated
|
|
|
|
* with the current tty must be dead before the new getty is allowed
|
|
|
|
* to spawn.
|
|
|
|
*
|
|
|
|
* Now, if it would be correct ;-/ The current code has a nasty hole -
|
|
|
|
* it doesn't catch files in flight. We may send the descriptor to ourselves
|
|
|
|
* via AF_UNIX socket, close it and later fetch from socket. FIXME.
|
|
|
|
*
|
|
|
|
* Nasty bug: do_SAK is being called in interrupt context. This can
|
|
|
|
* deadlock. We punt it up to process context. AKPM - 16Mar2001
|
|
|
|
*/
|
2007-02-10 10:44:34 +01:00
|
|
|
void __do_SAK(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
#ifdef TTY_SOFT_SAK
|
|
|
|
tty_hangup(tty);
|
|
|
|
#else
|
2006-03-29 02:11:02 +02:00
|
|
|
struct task_struct *g, *p;
|
2007-02-12 09:53:00 +01:00
|
|
|
struct pid *session;
|
2005-04-17 00:20:36 +02:00
|
|
|
int i;
|
|
|
|
struct file *filp;
|
2005-09-09 22:04:10 +02:00
|
|
|
struct fdtable *fdt;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!tty)
|
|
|
|
return;
|
2006-12-08 11:36:04 +01:00
|
|
|
session = tty->session;
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-12-13 09:35:09 +01:00
|
|
|
tty_ldisc_flush(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
tty_driver_flush_buffer(tty);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
read_lock(&tasklist_lock);
|
2006-03-29 02:11:02 +02:00
|
|
|
/* Kill the entire session */
|
2007-02-12 09:53:00 +01:00
|
|
|
do_each_pid_task(session, PIDTYPE_SID, p) {
|
2006-03-29 02:11:02 +02:00
|
|
|
printk(KERN_NOTICE "SAK: killed process %d"
|
2007-10-19 08:39:46 +02:00
|
|
|
" (%s): task_session_nr(p)==tty->session\n",
|
2007-10-19 08:40:40 +02:00
|
|
|
task_pid_nr(p), p->comm);
|
2006-03-29 02:11:02 +02:00
|
|
|
send_sig(SIGKILL, p, 1);
|
2007-02-12 09:53:00 +01:00
|
|
|
} while_each_pid_task(session, PIDTYPE_SID, p);
|
2006-03-29 02:11:02 +02:00
|
|
|
/* Now kill any processes that happen to have the
|
|
|
|
* tty open.
|
|
|
|
*/
|
|
|
|
do_each_thread(g, p) {
|
|
|
|
if (p->signal->tty == tty) {
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_NOTICE "SAK: killed process %d"
|
2007-10-19 08:39:46 +02:00
|
|
|
" (%s): task_session_nr(p)==tty->session\n",
|
2007-10-19 08:40:40 +02:00
|
|
|
task_pid_nr(p), p->comm);
|
2005-04-17 00:20:36 +02:00
|
|
|
send_sig(SIGKILL, p, 1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
task_lock(p);
|
|
|
|
if (p->files) {
|
2006-04-19 07:21:46 +02:00
|
|
|
/*
|
|
|
|
* We don't take a ref to the file, so we must
|
|
|
|
* hold ->file_lock instead.
|
|
|
|
*/
|
|
|
|
spin_lock(&p->files->file_lock);
|
2005-09-09 22:04:10 +02:00
|
|
|
fdt = files_fdtable(p->files);
|
2008-02-08 13:18:47 +01:00
|
|
|
for (i = 0; i < fdt->max_fds; i++) {
|
2005-04-17 00:20:36 +02:00
|
|
|
filp = fcheck_files(p->files, i);
|
|
|
|
if (!filp)
|
|
|
|
continue;
|
|
|
|
if (filp->f_op->read == tty_read &&
|
|
|
|
filp->private_data == tty) {
|
|
|
|
printk(KERN_NOTICE "SAK: killed process %d"
|
|
|
|
" (%s): fd#%d opened to the tty\n",
|
2007-10-19 08:40:40 +02:00
|
|
|
task_pid_nr(p), p->comm, i);
|
2006-04-13 12:49:07 +02:00
|
|
|
force_sig(SIGKILL, p);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-04-19 07:21:46 +02:00
|
|
|
spin_unlock(&p->files->file_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
task_unlock(p);
|
2006-03-29 02:11:02 +02:00
|
|
|
} while_each_thread(g, p);
|
2005-04-17 00:20:36 +02:00
|
|
|
read_unlock(&tasklist_lock);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-02-10 10:44:34 +01:00
|
|
|
static void do_SAK_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty =
|
|
|
|
container_of(work, struct tty_struct, SAK_work);
|
|
|
|
__do_SAK(tty);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* The tq handling here is a little racy - tty->SAK_work may already be queued.
|
|
|
|
* Fortunately we don't need to worry, because if ->SAK_work is already queued,
|
|
|
|
* the values which we write to it will be identical to the values which it
|
|
|
|
* already has. --akpm
|
|
|
|
*/
|
|
|
|
void do_SAK(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
if (!tty)
|
|
|
|
return;
|
|
|
|
schedule_work(&tty->SAK_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(do_SAK);
|
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* flush_to_ldisc
|
2006-11-22 15:55:48 +01:00
|
|
|
* @work: tty structure passed from work queue.
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* This routine is called out of the software interrupt to flush data
|
|
|
|
* from the buffer chain to the line discipline.
|
|
|
|
*
|
|
|
|
* Locking: holds tty->buf.lock to guard buffer list. Drops the lock
|
|
|
|
* while invoking the line discipline receive_buf method. The
|
|
|
|
* receive_buf method is single threaded for each tty instance.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-02-08 13:18:47 +01:00
|
|
|
|
2006-11-22 15:55:48 +01:00
|
|
|
static void flush_to_ldisc(struct work_struct *work)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-11-22 15:55:48 +01:00
|
|
|
struct tty_struct *tty =
|
|
|
|
container_of(work, struct tty_struct, buf.work.work);
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long flags;
|
|
|
|
struct tty_ldisc *disc;
|
2006-06-28 13:26:48 +02:00
|
|
|
struct tty_buffer *tbuf, *head;
|
2006-02-10 10:51:14 +01:00
|
|
|
char *char_buf;
|
|
|
|
unsigned char *flag_buf;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
disc = tty_ldisc_ref(tty);
|
|
|
|
if (disc == NULL) /* !TTY_LDISC */
|
|
|
|
return;
|
|
|
|
|
2006-02-03 12:04:41 +01:00
|
|
|
spin_lock_irqsave(&tty->buf.lock, flags);
|
2008-02-08 13:18:47 +01:00
|
|
|
/* So we know a flush is running */
|
|
|
|
set_bit(TTY_FLUSHING, &tty->flags);
|
2006-06-28 13:26:48 +02:00
|
|
|
head = tty->buf.head;
|
|
|
|
if (head != NULL) {
|
|
|
|
tty->buf.head = NULL;
|
|
|
|
for (;;) {
|
|
|
|
int count = head->commit - head->read;
|
|
|
|
if (!count) {
|
|
|
|
if (head->next == NULL)
|
|
|
|
break;
|
|
|
|
tbuf = head;
|
|
|
|
head = head->next;
|
|
|
|
tty_buffer_free(tty, tbuf);
|
|
|
|
continue;
|
|
|
|
}
|
2007-08-10 22:01:05 +02:00
|
|
|
/* Ldisc or user is trying to flush the buffers
|
|
|
|
we are feeding to the ldisc, stop feeding the
|
|
|
|
line discipline as we want to empty the queue */
|
|
|
|
if (test_bit(TTY_FLUSHPENDING, &tty->flags))
|
|
|
|
break;
|
2006-06-28 13:26:48 +02:00
|
|
|
if (!tty->receive_room) {
|
|
|
|
schedule_delayed_work(&tty->buf.work, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (count > tty->receive_room)
|
|
|
|
count = tty->receive_room;
|
|
|
|
char_buf = head->char_buf_ptr + head->read;
|
|
|
|
flag_buf = head->flag_buf_ptr + head->read;
|
|
|
|
head->read += count;
|
2006-02-10 10:51:14 +01:00
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
2008-07-16 22:53:12 +02:00
|
|
|
disc->ops->receive_buf(tty, char_buf,
|
|
|
|
flag_buf, count);
|
2006-02-10 10:51:14 +01:00
|
|
|
spin_lock_irqsave(&tty->buf.lock, flags);
|
|
|
|
}
|
2007-08-10 22:01:05 +02:00
|
|
|
/* Restore the queue head */
|
2006-06-28 13:26:48 +02:00
|
|
|
tty->buf.head = head;
|
[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-10 05:54:13 +01:00
|
|
|
}
|
2007-08-10 22:01:05 +02:00
|
|
|
/* We may have a deferred request to flush the input buffer,
|
|
|
|
if so pull the chain under the lock and empty the queue */
|
|
|
|
if (test_bit(TTY_FLUSHPENDING, &tty->flags)) {
|
|
|
|
__tty_buffer_flush(tty);
|
|
|
|
clear_bit(TTY_FLUSHPENDING, &tty->flags);
|
|
|
|
wake_up(&tty->read_wait);
|
|
|
|
}
|
|
|
|
clear_bit(TTY_FLUSHING, &tty->flags);
|
2006-02-03 12:04:41 +01:00
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
2006-06-28 13:26:47 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_ldisc_deref(disc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tty_flip_buffer_push - terminal
|
|
|
|
* @tty: tty to push
|
|
|
|
*
|
|
|
|
* Queue a push of the terminal flip buffers to the line discipline. This
|
|
|
|
* function must not be called from IRQ context if tty->low_latency is set.
|
|
|
|
*
|
|
|
|
* In the event of the queue being busy for flipping the work will be
|
|
|
|
* held off and retried later.
|
2006-08-27 10:24:01 +02:00
|
|
|
*
|
|
|
|
* Locking: tty buffer lock. Driver locks in low latency mode.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
void tty_flip_buffer_push(struct tty_struct *tty)
|
|
|
|
{
|
2006-02-03 12:04:41 +01:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tty->buf.lock, flags);
|
2006-06-28 13:26:49 +02:00
|
|
|
if (tty->buf.tail != NULL)
|
2006-02-10 10:51:14 +01:00
|
|
|
tty->buf.tail->commit = tty->buf.tail->used;
|
2006-02-03 12:04:41 +01:00
|
|
|
spin_unlock_irqrestore(&tty->buf.lock, flags);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty->low_latency)
|
2006-11-22 15:55:48 +01:00
|
|
|
flush_to_ldisc(&tty->buf.work.work);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
[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-10 05:54:13 +01:00
|
|
|
schedule_delayed_work(&tty->buf.work, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_flip_buffer_push);
|
|
|
|
|
[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-10 05:54:13 +01:00
|
|
|
|
2006-08-27 10:24:01 +02:00
|
|
|
/**
|
|
|
|
* initialize_tty_struct
|
|
|
|
* @tty: tty to initialize
|
|
|
|
*
|
|
|
|
* This subroutine initializes a tty structure that has been newly
|
|
|
|
* allocated.
|
|
|
|
*
|
|
|
|
* Locking: none - tty in question must not be exposed at this point
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static void initialize_tty_struct(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
memset(tty, 0, sizeof(struct tty_struct));
|
|
|
|
tty->magic = TTY_MAGIC;
|
2008-07-22 12:16:55 +02:00
|
|
|
tty_ldisc_init(tty);
|
2007-02-12 09:53:00 +01:00
|
|
|
tty->session = NULL;
|
|
|
|
tty->pgrp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->overrun_time = jiffies;
|
[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-10 05:54:13 +01:00
|
|
|
tty->buf.head = tty->buf.tail = NULL;
|
|
|
|
tty_buffer_init(tty);
|
2006-11-22 15:55:48 +01:00
|
|
|
INIT_DELAYED_WORK(&tty->buf.work, flush_to_ldisc);
|
2006-09-29 11:00:43 +02:00
|
|
|
mutex_init(&tty->termios_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
init_waitqueue_head(&tty->write_wait);
|
|
|
|
init_waitqueue_head(&tty->read_wait);
|
2006-11-22 15:55:48 +01:00
|
|
|
INIT_WORK(&tty->hangup_work, do_tty_hangup);
|
2006-03-23 12:00:31 +01:00
|
|
|
mutex_init(&tty->atomic_read_lock);
|
|
|
|
mutex_init(&tty->atomic_write_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock_init(&tty->read_lock);
|
2008-04-30 09:53:29 +02:00
|
|
|
spin_lock_init(&tty->ctrl_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&tty->tty_files);
|
2007-02-13 22:38:58 +01:00
|
|
|
INIT_WORK(&tty->SAK_work, do_SAK_work);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
/**
|
|
|
|
* tty_put_char - write one character to a tty
|
|
|
|
* @tty: tty
|
|
|
|
* @ch: character
|
|
|
|
*
|
|
|
|
* Write one byte to the tty using the provided put_char method
|
|
|
|
* if present. Returns the number of characters successfully output.
|
|
|
|
*
|
|
|
|
* Note: the specific put_char operation in the driver layer may go
|
|
|
|
* away soon. Don't call it directly, use this method
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
int tty_put_char(struct tty_struct *tty, unsigned char ch)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:54:13 +02:00
|
|
|
if (tty->ops->put_char)
|
|
|
|
return tty->ops->put_char(tty, ch);
|
|
|
|
return tty->ops->write(tty, &ch, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-04-30 09:54:13 +02:00
|
|
|
EXPORT_SYMBOL_GPL(tty_put_char);
|
|
|
|
|
2005-03-15 23:23:15 +01:00
|
|
|
static struct class *tty_class;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
2006-08-27 10:24:01 +02:00
|
|
|
* tty_register_device - register a tty device
|
|
|
|
* @driver: the tty driver that describes the tty device
|
|
|
|
* @index: the index in the tty driver for this tty device
|
|
|
|
* @device: a struct device that is associated with this tty device.
|
|
|
|
* This field is optional, if there is no known struct device
|
|
|
|
* for this tty device it can be set to NULL safely.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2006-08-08 07:19:37 +02:00
|
|
|
* Returns a pointer to the struct device for this tty device
|
|
|
|
* (or ERR_PTR(-EFOO) on error).
|
2006-04-22 18:36:53 +02:00
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* This call is required to be made to register an individual tty device
|
|
|
|
* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
|
|
|
|
* that bit is not set, this function should not be called by a tty
|
|
|
|
* driver.
|
|
|
|
*
|
|
|
|
* Locking: ??
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2006-08-08 07:19:37 +02:00
|
|
|
struct device *tty_register_device(struct tty_driver *driver, unsigned index,
|
|
|
|
struct device *device)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
char name[64];
|
|
|
|
dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
|
|
|
|
|
|
|
|
if (index >= driver->num) {
|
|
|
|
printk(KERN_ERR "Attempt to register invalid tty line number "
|
|
|
|
" (%d).\n", index);
|
2006-04-22 18:36:53 +02:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (driver->type == TTY_DRIVER_TYPE_PTY)
|
|
|
|
pty_line_name(driver, index, name);
|
|
|
|
else
|
|
|
|
tty_line_name(driver, index, name);
|
2006-04-22 18:36:53 +02:00
|
|
|
|
2008-05-21 21:52:33 +02:00
|
|
|
return device_create_drvdata(tty_class, device, dev, NULL, name);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-08-27 10:24:01 +02:00
|
|
|
* tty_unregister_device - unregister a tty device
|
|
|
|
* @driver: the tty driver that describes the tty device
|
|
|
|
* @index: the index in the tty driver for this tty device
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2006-08-27 10:24:01 +02:00
|
|
|
* If a tty device is registered with a call to tty_register_device() then
|
|
|
|
* this function must be called when the tty device is gone.
|
|
|
|
*
|
|
|
|
* Locking: ??
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-08-27 10:24:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void tty_unregister_device(struct tty_driver *driver, unsigned index)
|
|
|
|
{
|
2008-02-08 13:18:47 +01:00
|
|
|
device_destroy(tty_class,
|
|
|
|
MKDEV(driver->major, driver->minor_start) + index);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_register_device);
|
|
|
|
EXPORT_SYMBOL(tty_unregister_device);
|
|
|
|
|
|
|
|
struct tty_driver *alloc_tty_driver(int lines)
|
|
|
|
{
|
|
|
|
struct tty_driver *driver;
|
|
|
|
|
2007-07-16 08:40:14 +02:00
|
|
|
driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (driver) {
|
|
|
|
driver->magic = TTY_DRIVER_MAGIC;
|
|
|
|
driver->num = lines;
|
|
|
|
/* later we'll move allocation of tables here */
|
|
|
|
}
|
|
|
|
return driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
void put_tty_driver(struct tty_driver *driver)
|
|
|
|
{
|
|
|
|
kfree(driver);
|
|
|
|
}
|
|
|
|
|
2006-10-02 11:17:18 +02:00
|
|
|
void tty_set_operations(struct tty_driver *driver,
|
|
|
|
const struct tty_operations *op)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-04-30 09:54:13 +02:00
|
|
|
driver->ops = op;
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
EXPORT_SYMBOL(alloc_tty_driver);
|
|
|
|
EXPORT_SYMBOL(put_tty_driver);
|
|
|
|
EXPORT_SYMBOL(tty_set_operations);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called by a tty driver to register itself.
|
|
|
|
*/
|
|
|
|
int tty_register_driver(struct tty_driver *driver)
|
|
|
|
{
|
|
|
|
int error;
|
2008-02-08 13:18:47 +01:00
|
|
|
int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
dev_t dev;
|
|
|
|
void **p = NULL;
|
|
|
|
|
|
|
|
if (driver->flags & TTY_DRIVER_INSTALLED)
|
|
|
|
return 0;
|
|
|
|
|
2007-05-06 23:49:33 +02:00
|
|
|
if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {
|
|
|
|
p = kzalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!driver->major) {
|
2008-02-08 13:18:47 +01:00
|
|
|
error = alloc_chrdev_region(&dev, driver->minor_start,
|
|
|
|
driver->num, driver->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!error) {
|
|
|
|
driver->major = MAJOR(dev);
|
|
|
|
driver->minor_start = MINOR(dev);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dev = MKDEV(driver->major, driver->minor_start);
|
2007-02-20 15:45:21 +01:00
|
|
|
error = register_chrdev_region(dev, driver->num, driver->name);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (error < 0) {
|
|
|
|
kfree(p);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
driver->ttys = (struct tty_struct **)p;
|
2006-12-08 11:38:44 +01:00
|
|
|
driver->termios = (struct ktermios **)(p + driver->num);
|
2008-02-08 13:18:47 +01:00
|
|
|
driver->termios_locked = (struct ktermios **)
|
|
|
|
(p + driver->num * 2);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
driver->ttys = NULL;
|
|
|
|
driver->termios = NULL;
|
|
|
|
driver->termios_locked = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cdev_init(&driver->cdev, &tty_fops);
|
|
|
|
driver->cdev.owner = driver->owner;
|
|
|
|
error = cdev_add(&driver->cdev, dev, driver->num);
|
|
|
|
if (error) {
|
|
|
|
unregister_chrdev_region(dev, driver->num);
|
|
|
|
driver->ttys = NULL;
|
|
|
|
driver->termios = driver->termios_locked = NULL;
|
|
|
|
kfree(p);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-08 09:27:12 +02:00
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_add(&driver->tty_drivers, &tty_drivers);
|
2007-05-08 09:27:12 +02:00
|
|
|
mutex_unlock(&tty_mutex);
|
2008-02-08 13:18:47 +01:00
|
|
|
|
|
|
|
if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
|
|
|
|
for (i = 0; i < driver->num; i++)
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_register_device(driver, i, NULL);
|
|
|
|
}
|
|
|
|
proc_tty_register_driver(driver);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(tty_register_driver);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called by a tty driver to unregister itself.
|
|
|
|
*/
|
|
|
|
int tty_unregister_driver(struct tty_driver *driver)
|
|
|
|
{
|
|
|
|
int i;
|
2006-12-08 11:38:44 +01:00
|
|
|
struct ktermios *tp;
|
2005-04-17 00:20:36 +02:00
|
|
|
void *p;
|
|
|
|
|
|
|
|
if (driver->refcount)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
|
|
|
|
driver->num);
|
2007-05-08 09:27:12 +02:00
|
|
|
mutex_lock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_del(&driver->tty_drivers);
|
2007-05-08 09:27:12 +02:00
|
|
|
mutex_unlock(&tty_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the termios and termios_locked structures because
|
|
|
|
* we don't want to get memory leaks when modular tty
|
|
|
|
* drivers are removed from the kernel.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < driver->num; i++) {
|
|
|
|
tp = driver->termios[i];
|
|
|
|
if (tp) {
|
|
|
|
driver->termios[i] = NULL;
|
|
|
|
kfree(tp);
|
|
|
|
}
|
|
|
|
tp = driver->termios_locked[i];
|
|
|
|
if (tp) {
|
|
|
|
driver->termios_locked[i] = NULL;
|
|
|
|
kfree(tp);
|
|
|
|
}
|
2005-06-21 06:15:16 +02:00
|
|
|
if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
|
2005-04-17 00:20:36 +02:00
|
|
|
tty_unregister_device(driver, i);
|
|
|
|
}
|
|
|
|
p = driver->ttys;
|
|
|
|
proc_tty_unregister_driver(driver);
|
|
|
|
driver->ttys = NULL;
|
|
|
|
driver->termios = driver->termios_locked = NULL;
|
|
|
|
kfree(p);
|
|
|
|
cdev_del(&driver->cdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_unregister_driver);
|
|
|
|
|
2006-12-08 11:36:04 +01:00
|
|
|
dev_t tty_devnum(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(tty_devnum);
|
|
|
|
|
|
|
|
void proc_clear_tty(struct task_struct *p)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&p->sighand->siglock);
|
|
|
|
p->signal->tty = NULL;
|
|
|
|
spin_unlock_irq(&p->sighand->siglock);
|
|
|
|
}
|
|
|
|
|
2008-04-30 09:53:30 +02:00
|
|
|
/* Called under the sighand lock */
|
|
|
|
|
2007-05-08 09:26:53 +02:00
|
|
|
static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
|
2006-12-08 11:36:04 +01:00
|
|
|
{
|
|
|
|
if (tty) {
|
2008-04-30 09:53:30 +02:00
|
|
|
unsigned long flags;
|
|
|
|
/* We should not have a session or pgrp to put here but.... */
|
|
|
|
spin_lock_irqsave(&tty->ctrl_lock, flags);
|
2007-03-18 19:45:44 +01:00
|
|
|
put_pid(tty->session);
|
|
|
|
put_pid(tty->pgrp);
|
2007-02-12 09:53:00 +01:00
|
|
|
tty->pgrp = get_pid(task_pgrp(tsk));
|
2008-04-30 09:53:30 +02:00
|
|
|
spin_unlock_irqrestore(&tty->ctrl_lock, flags);
|
|
|
|
tty->session = get_pid(task_session(tsk));
|
2006-12-08 11:36:04 +01:00
|
|
|
}
|
2007-05-08 09:26:53 +02:00
|
|
|
put_pid(tsk->signal->tty_old_pgrp);
|
2006-12-08 11:36:04 +01:00
|
|
|
tsk->signal->tty = tty;
|
2007-02-12 09:53:00 +01:00
|
|
|
tsk->signal->tty_old_pgrp = NULL;
|
2006-12-08 11:36:04 +01:00
|
|
|
}
|
|
|
|
|
2007-05-08 09:26:56 +02:00
|
|
|
static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
|
2006-12-08 11:36:04 +01:00
|
|
|
{
|
|
|
|
spin_lock_irq(&tsk->sighand->siglock);
|
2007-05-08 09:26:53 +02:00
|
|
|
__proc_set_tty(tsk, tty);
|
2006-12-08 11:36:04 +01:00
|
|
|
spin_unlock_irq(&tsk->sighand->siglock);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct tty_struct *get_current_tty(void)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty;
|
|
|
|
WARN_ON_ONCE(!mutex_is_locked(&tty_mutex));
|
|
|
|
tty = current->signal->tty;
|
|
|
|
/*
|
|
|
|
* session->tty can be changed/cleared from under us, make sure we
|
|
|
|
* issue the load. The obtained pointer, when not NULL, is valid as
|
|
|
|
* long as we hold tty_mutex.
|
|
|
|
*/
|
|
|
|
barrier();
|
|
|
|
return tty;
|
|
|
|
}
|
2006-12-13 09:33:41 +01:00
|
|
|
EXPORT_SYMBOL_GPL(get_current_tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the console device. This is called *early*, so
|
|
|
|
* we can't necessarily depend on lots of kernel help here.
|
|
|
|
* Just do some early initializations, and do the complex setup
|
|
|
|
* later.
|
|
|
|
*/
|
|
|
|
void __init console_init(void)
|
|
|
|
{
|
|
|
|
initcall_t *call;
|
|
|
|
|
|
|
|
/* Setup the default TTY line discipline. */
|
2008-07-22 12:16:55 +02:00
|
|
|
tty_ldisc_begin();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2008-02-08 13:18:47 +01:00
|
|
|
* set up the console device so that later boot sequences can
|
2005-04-17 00:20:36 +02:00
|
|
|
* inform about problems etc..
|
|
|
|
*/
|
|
|
|
call = __con_initcall_start;
|
|
|
|
while (call < __con_initcall_end) {
|
|
|
|
(*call)();
|
|
|
|
call++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init tty_class_init(void)
|
|
|
|
{
|
2005-03-15 23:23:15 +01:00
|
|
|
tty_class = class_create(THIS_MODULE, "tty");
|
2005-04-17 00:20:36 +02:00
|
|
|
if (IS_ERR(tty_class))
|
|
|
|
return PTR_ERR(tty_class);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
postcore_initcall(tty_class_init);
|
|
|
|
|
|
|
|
/* 3/2004 jmc: why do these devices exist? */
|
|
|
|
|
|
|
|
static struct cdev tty_cdev, console_cdev;
|
|
|
|
#ifdef CONFIG_UNIX98_PTYS
|
|
|
|
static struct cdev ptmx_cdev;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_VT
|
|
|
|
static struct cdev vc0_cdev;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, now we can initialize the rest of the tty devices and can count
|
|
|
|
* on memory allocations, interrupts etc..
|
|
|
|
*/
|
|
|
|
static int __init tty_init(void)
|
|
|
|
{
|
|
|
|
cdev_init(&tty_cdev, &tty_fops);
|
|
|
|
if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
|
|
|
|
register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
|
|
|
|
panic("Couldn't register /dev/tty driver\n");
|
2008-05-21 21:52:33 +02:00
|
|
|
device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
|
|
|
|
"tty");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
cdev_init(&console_cdev, &console_fops);
|
|
|
|
if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
|
|
|
|
register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
|
|
|
|
panic("Couldn't register /dev/console driver\n");
|
2008-05-21 21:52:33 +02:00
|
|
|
device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
|
|
|
|
"console");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_UNIX98_PTYS
|
|
|
|
cdev_init(&ptmx_cdev, &ptmx_fops);
|
|
|
|
if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
|
|
|
|
register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
|
|
|
|
panic("Couldn't register /dev/ptmx driver\n");
|
2008-05-21 21:52:33 +02:00
|
|
|
device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_VT
|
|
|
|
cdev_init(&vc0_cdev, &console_fops);
|
|
|
|
if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
|
|
|
|
register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
|
|
|
|
panic("Couldn't register /dev/tty0 driver\n");
|
2008-05-21 21:52:33 +02:00
|
|
|
device_create_drvdata(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
vty_init();
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
module_init(tty_init);
|