[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
|
|
|
|
* Licensed under the GPL
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include "chan_kern.h"
|
|
|
|
#include "user_util.h"
|
|
|
|
#include "kern.h"
|
|
|
|
#include "irq_user.h"
|
|
|
|
#include "sigio.h"
|
|
|
|
#include "line.h"
|
|
|
|
#include "os.h"
|
|
|
|
|
2005-09-22 22:44:22 -06:00
|
|
|
#ifdef CONFIG_NOCONFIG_CHAN
|
2007-02-10 02:43:53 -07:00
|
|
|
static void *not_configged_init(char *str, int device,
|
|
|
|
const struct chan_opts *opts)
|
2005-09-22 22:44:22 -06:00
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int not_configged_open(int input, int output, int primary, void *data,
|
|
|
|
char **dev_out)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void not_configged_close(int fd, void *data)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int not_configged_read(int fd, char *c_out, void *data)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int not_configged_write(int fd, const char *buf, int len, void *data)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-11-13 17:07:11 -07:00
|
|
|
static int not_configged_console_write(int fd, const char *buf, int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int not_configged_window_size(int fd, void *data, unsigned short *rows,
|
|
|
|
unsigned short *cols)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
2006-01-06 01:18:50 -07:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void not_configged_free(void *data)
|
|
|
|
{
|
2007-02-10 02:43:53 -07:00
|
|
|
printk("Using a channel type which is configured out of "
|
2005-04-16 16:20:36 -06:00
|
|
|
"UML\n");
|
|
|
|
}
|
|
|
|
|
2006-09-27 02:50:33 -06:00
|
|
|
static const struct chan_ops not_configged_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.init = not_configged_init,
|
|
|
|
.open = not_configged_open,
|
|
|
|
.close = not_configged_close,
|
|
|
|
.read = not_configged_read,
|
|
|
|
.write = not_configged_write,
|
|
|
|
.console_write = not_configged_console_write,
|
|
|
|
.window_size = not_configged_window_size,
|
|
|
|
.free = not_configged_free,
|
|
|
|
.winch = 0,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_NOCONFIG_CHAN */
|
|
|
|
|
|
|
|
void generic_close(int fd, void *unused)
|
|
|
|
{
|
|
|
|
os_close_file(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
int generic_read(int fd, char *c_out, void *unused)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
n = os_read_file(fd, c_out, sizeof(*c_out));
|
|
|
|
|
|
|
|
if(n == -EAGAIN)
|
2006-01-06 01:18:50 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
else if(n == 0)
|
2006-01-06 01:18:50 -07:00
|
|
|
return -EIO;
|
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX Trivial wrapper around os_write_file */
|
|
|
|
|
|
|
|
int generic_write(int fd, const char *buf, int n, void *unused)
|
|
|
|
{
|
2006-01-06 01:18:50 -07:00
|
|
|
return os_write_file(fd, buf, n);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int generic_window_size(int fd, void *unused, unsigned short *rows_out,
|
|
|
|
unsigned short *cols_out)
|
|
|
|
{
|
|
|
|
int rows, cols;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = os_window_size(fd, &rows, &cols);
|
|
|
|
if(ret < 0)
|
2006-01-06 01:18:50 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ret = ((*rows_out != rows) || (*cols_out != cols));
|
|
|
|
|
|
|
|
*rows_out = rows;
|
|
|
|
*cols_out = cols;
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void generic_free(void *data)
|
|
|
|
{
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tty_receive_char(struct tty_struct *tty, char ch)
|
|
|
|
{
|
|
|
|
if(tty == NULL) return;
|
|
|
|
|
|
|
|
if(I_IXON(tty) && !I_IXOFF(tty) && !tty->raw) {
|
|
|
|
if(ch == STOP_CHAR(tty)){
|
|
|
|
stop_tty(tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if(ch == START_CHAR(tty)){
|
|
|
|
start_tty(tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tty_insert_flip_char(tty, ch, TTY_NORMAL);
|
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
static int open_one_chan(struct chan *chan)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
if(chan->opened)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if(chan->ops->open == NULL)
|
|
|
|
fd = 0;
|
|
|
|
else fd = (*chan->ops->open)(chan->input, chan->output, chan->primary,
|
|
|
|
chan->data, &chan->dev);
|
|
|
|
if(fd < 0)
|
|
|
|
return fd;
|
2005-04-16 16:20:36 -06:00
|
|
|
chan->fd = fd;
|
|
|
|
|
|
|
|
chan->opened = 1;
|
2006-01-06 01:18:50 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int open_chan(struct list_head *chans)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
int ret, err = 0;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
2006-01-06 01:18:50 -07:00
|
|
|
ret = open_one_chan(chan);
|
|
|
|
if(chan->primary)
|
|
|
|
err = ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void chan_enable_winch(struct list_head *chans, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(chan->primary && chan->output && chan->ops->winch){
|
|
|
|
register_winch(chan->fd, tty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
void enable_chan(struct line *line)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
list_for_each(ele, &line->chan_list){
|
2005-04-16 16:20:36 -06:00
|
|
|
chan = list_entry(ele, struct chan, list);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
if(open_one_chan(chan))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if(chan->enabled)
|
|
|
|
continue;
|
|
|
|
line_setup_irq(chan->fd, chan->input, chan->output, line,
|
|
|
|
chan);
|
|
|
|
chan->enabled = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-10 02:43:55 -07:00
|
|
|
/* Items are added in IRQ context, when free_irq can't be called, and
|
|
|
|
* removed in process context, when it can.
|
|
|
|
* This handles interrupt sources which disappear, and which need to
|
|
|
|
* be permanently disabled. This is discovered in IRQ context, but
|
|
|
|
* the freeing of the IRQ must be done later.
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(irqs_to_free_lock);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
static LIST_HEAD(irqs_to_free);
|
|
|
|
|
|
|
|
void free_irqs(void)
|
|
|
|
{
|
|
|
|
struct chan *chan;
|
2007-02-10 02:43:55 -07:00
|
|
|
LIST_HEAD(list);
|
|
|
|
struct list_head *ele;
|
|
|
|
|
|
|
|
spin_lock_irq(&irqs_to_free_lock);
|
|
|
|
list_splice_init(&irqs_to_free, &list);
|
|
|
|
INIT_LIST_HEAD(&irqs_to_free);
|
|
|
|
spin_unlock_irq(&irqs_to_free_lock);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
|
2007-02-10 02:43:55 -07:00
|
|
|
list_for_each(ele, &list){
|
|
|
|
chan = list_entry(ele, struct chan, free_list);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
|
|
|
|
if(chan->input)
|
|
|
|
free_irq(chan->line->driver->read_irq, chan);
|
|
|
|
if(chan->output)
|
|
|
|
free_irq(chan->line->driver->write_irq, chan);
|
|
|
|
chan->enabled = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void close_one_chan(struct chan *chan, int delay_free_irq)
|
|
|
|
{
|
|
|
|
if(!chan->opened)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
if(delay_free_irq){
|
2007-02-10 02:43:55 -07:00
|
|
|
spin_lock_irq(&irqs_to_free_lock);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
list_add(&chan->free_list, &irqs_to_free);
|
2007-02-10 02:43:55 -07:00
|
|
|
spin_unlock_irq(&irqs_to_free_lock);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if(chan->input)
|
|
|
|
free_irq(chan->line->driver->read_irq, chan);
|
|
|
|
if(chan->output)
|
|
|
|
free_irq(chan->line->driver->write_irq, chan);
|
|
|
|
chan->enabled = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
if(chan->ops->close != NULL)
|
|
|
|
(*chan->ops->close)(chan->fd, chan->data);
|
|
|
|
|
|
|
|
chan->opened = 0;
|
|
|
|
chan->fd = -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
void close_chan(struct list_head *chans, int delay_free_irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
/* Close in reverse order as open in case more than one of them
|
|
|
|
* refers to the same device and they save and restore that device's
|
|
|
|
* state. Then, the first one opened will have the original state,
|
|
|
|
* so it must be the last closed.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_reverse(chan, chans, list) {
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
close_one_chan(chan, delay_free_irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:58 -07:00
|
|
|
void deactivate_chan(struct list_head *chans, int irq)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
|
|
|
|
struct chan *chan;
|
|
|
|
list_for_each(ele, chans) {
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
|
|
|
|
if(chan->enabled && chan->input)
|
|
|
|
deactivate_fd(chan->fd, irq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void reactivate_chan(struct list_head *chans, int irq)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
list_for_each(ele, chans) {
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
|
|
|
|
if(chan->enabled && chan->input)
|
|
|
|
reactivate_fd(chan->fd, irq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
int write_chan(struct list_head *chans, const char *buf, int len,
|
2005-04-16 16:20:36 -06:00
|
|
|
int write_irq)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan = NULL;
|
|
|
|
int n, ret = 0;
|
|
|
|
|
|
|
|
list_for_each(ele, chans) {
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if (!chan->output || (chan->ops->write == NULL))
|
|
|
|
continue;
|
|
|
|
n = chan->ops->write(chan->fd, buf, len, chan->data);
|
|
|
|
if (chan->primary) {
|
|
|
|
ret = n;
|
|
|
|
if ((ret == -EAGAIN) || ((ret >= 0) && (ret < len)))
|
|
|
|
reactivate_fd(chan->fd, write_irq);
|
|
|
|
}
|
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int console_write_chan(struct list_head *chans, const char *buf, int len)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
int n, ret = 0;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(!chan->output || (chan->ops->console_write == NULL))
|
|
|
|
continue;
|
2005-11-13 17:07:11 -07:00
|
|
|
n = chan->ops->console_write(chan->fd, buf, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
if(chan->primary) ret = n;
|
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-10 02:44:06 -07:00
|
|
|
int console_open_chan(struct line *line, struct console *co)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-06 01:18:55 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = open_chan(&line->chan_list);
|
|
|
|
if(err)
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-10 02:44:06 -07:00
|
|
|
printk("Console initialized on /dev/%s%d\n", co->name, co->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int chan_window_size(struct list_head *chans, unsigned short *rows_out,
|
|
|
|
unsigned short *cols_out)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(chan->primary){
|
2006-01-06 01:18:50 -07:00
|
|
|
if(chan->ops->window_size == NULL)
|
|
|
|
return 0;
|
|
|
|
return chan->ops->window_size(chan->fd, chan->data,
|
|
|
|
rows_out, cols_out);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-02-01 04:06:29 -07:00
|
|
|
static void free_one_chan(struct chan *chan, int delay_free_irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
list_del(&chan->list);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
|
|
|
|
close_one_chan(chan, delay_free_irq);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if(chan->ops->free != NULL)
|
|
|
|
(*chan->ops->free)(chan->data);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if(chan->primary && chan->output) ignore_sigio_fd(chan->fd);
|
|
|
|
kfree(chan);
|
|
|
|
}
|
|
|
|
|
2006-02-01 04:06:29 -07:00
|
|
|
static void free_chan(struct list_head *chans, int delay_free_irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct list_head *ele, *next;
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
list_for_each_safe(ele, next, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
free_one_chan(chan, delay_free_irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int one_chan_config_string(struct chan *chan, char *str, int size,
|
|
|
|
char **error_out)
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
if(chan == NULL){
|
|
|
|
CONFIG_CHUNK(str, size, n, "none", 1);
|
2006-01-06 01:18:50 -07:00
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
|
|
|
|
|
|
|
|
if(chan->dev == NULL){
|
|
|
|
CONFIG_CHUNK(str, size, n, "", 1);
|
2006-01-06 01:18:50 -07:00
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
CONFIG_CHUNK(str, size, n, ":", 0);
|
|
|
|
CONFIG_CHUNK(str, size, n, chan->dev, 0);
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
static int chan_pair_config_string(struct chan *in, struct chan *out,
|
2005-04-16 16:20:36 -06:00
|
|
|
char *str, int size, char **error_out)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
n = one_chan_config_string(in, str, size, error_out);
|
|
|
|
str += n;
|
|
|
|
size -= n;
|
|
|
|
|
|
|
|
if(in == out){
|
|
|
|
CONFIG_CHUNK(str, size, n, "", 1);
|
2006-01-06 01:18:50 -07:00
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
CONFIG_CHUNK(str, size, n, ",", 1);
|
|
|
|
n = one_chan_config_string(out, str, size, error_out);
|
|
|
|
str += n;
|
|
|
|
size -= n;
|
|
|
|
CONFIG_CHUNK(str, size, n, "", 1);
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
return n;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
int chan_config_string(struct list_head *chans, char *str, int size,
|
2005-04-16 16:20:36 -06:00
|
|
|
char **error_out)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan, *in = NULL, *out = NULL;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(!chan->primary)
|
|
|
|
continue;
|
|
|
|
if(chan->input)
|
|
|
|
in = chan;
|
|
|
|
if(chan->output)
|
|
|
|
out = chan;
|
|
|
|
}
|
|
|
|
|
2006-01-06 01:18:50 -07:00
|
|
|
return chan_pair_config_string(in, out, str, size, error_out);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
struct chan_type {
|
|
|
|
char *key;
|
2006-09-27 02:50:33 -06:00
|
|
|
const struct chan_ops *ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-09-27 02:50:33 -06:00
|
|
|
static const struct chan_type chan_table[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{ "fd", &fd_ops },
|
|
|
|
|
|
|
|
#ifdef CONFIG_NULL_CHAN
|
|
|
|
{ "null", &null_ops },
|
|
|
|
#else
|
|
|
|
{ "null", ¬_configged_ops },
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PORT_CHAN
|
|
|
|
{ "port", &port_ops },
|
|
|
|
#else
|
|
|
|
{ "port", ¬_configged_ops },
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PTY_CHAN
|
|
|
|
{ "pty", &pty_ops },
|
|
|
|
{ "pts", &pts_ops },
|
|
|
|
#else
|
|
|
|
{ "pty", ¬_configged_ops },
|
|
|
|
{ "pts", ¬_configged_ops },
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_TTY_CHAN
|
|
|
|
{ "tty", &tty_ops },
|
|
|
|
#else
|
|
|
|
{ "tty", ¬_configged_ops },
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_XTERM_CHAN
|
|
|
|
{ "xterm", &xterm_ops },
|
|
|
|
#else
|
|
|
|
{ "xterm", ¬_configged_ops },
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
static struct chan *parse_chan(struct line *line, char *str, int device,
|
2007-02-10 02:43:53 -07:00
|
|
|
const struct chan_opts *opts, char **error_out)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-27 02:50:33 -06:00
|
|
|
const struct chan_type *entry;
|
|
|
|
const struct chan_ops *ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct chan *chan;
|
|
|
|
void *data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ops = NULL;
|
|
|
|
data = NULL;
|
2006-09-26 00:33:00 -06:00
|
|
|
for(i = 0; i < ARRAY_SIZE(chan_table); i++){
|
2005-04-16 16:20:36 -06:00
|
|
|
entry = &chan_table[i];
|
|
|
|
if(!strncmp(str, entry->key, strlen(entry->key))){
|
|
|
|
ops = entry->ops;
|
|
|
|
str += strlen(entry->key);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(ops == NULL){
|
2007-02-10 02:43:53 -07:00
|
|
|
*error_out = "No match for configured backends";
|
2006-01-06 01:18:50 -07:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-02-10 02:43:53 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
data = (*ops->init)(str, device, opts);
|
2007-02-10 02:43:53 -07:00
|
|
|
if(data == NULL){
|
|
|
|
*error_out = "Configuration failed";
|
2006-01-06 01:18:50 -07:00
|
|
|
return NULL;
|
2007-02-10 02:43:53 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-22 22:44:21 -06:00
|
|
|
chan = kmalloc(sizeof(*chan), GFP_ATOMIC);
|
2007-02-10 02:43:53 -07:00
|
|
|
if(chan == NULL){
|
|
|
|
*error_out = "Memory allocation failed";
|
2006-01-06 01:18:50 -07:00
|
|
|
return NULL;
|
2007-02-10 02:43:53 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
*chan = ((struct chan) { .list = LIST_HEAD_INIT(chan->list),
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
.free_list =
|
|
|
|
LIST_HEAD_INIT(chan->free_list),
|
|
|
|
.line = line,
|
2005-04-16 16:20:36 -06:00
|
|
|
.primary = 1,
|
|
|
|
.input = 0,
|
|
|
|
.output = 0,
|
|
|
|
.opened = 0,
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
.enabled = 0,
|
2005-04-16 16:20:36 -06:00
|
|
|
.fd = -1,
|
|
|
|
.ops = ops,
|
|
|
|
.data = data });
|
2006-01-06 01:18:50 -07:00
|
|
|
return chan;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
int parse_chan_pair(char *str, struct line *line, int device,
|
2007-02-10 02:43:53 -07:00
|
|
|
const struct chan_opts *opts, char **error_out)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
struct list_head *chans = &line->chan_list;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct chan *new, *chan;
|
|
|
|
char *in, *out;
|
|
|
|
|
|
|
|
if(!list_empty(chans)){
|
|
|
|
chan = list_entry(chans->next, struct chan, list);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
free_chan(chans, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
INIT_LIST_HEAD(chans);
|
|
|
|
}
|
|
|
|
|
|
|
|
out = strchr(str, ',');
|
|
|
|
if(out != NULL){
|
|
|
|
in = str;
|
|
|
|
*out = '\0';
|
|
|
|
out++;
|
2007-02-10 02:43:53 -07:00
|
|
|
new = parse_chan(line, in, device, opts, error_out);
|
2006-01-06 01:18:50 -07:00
|
|
|
if(new == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
new->input = 1;
|
|
|
|
list_add(&new->list, chans);
|
|
|
|
|
2007-02-10 02:43:53 -07:00
|
|
|
new = parse_chan(line, out, device, opts, error_out);
|
2006-01-06 01:18:50 -07:00
|
|
|
if(new == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
list_add(&new->list, chans);
|
|
|
|
new->output = 1;
|
|
|
|
}
|
|
|
|
else {
|
2007-02-10 02:43:53 -07:00
|
|
|
new = parse_chan(line, str, device, opts, error_out);
|
2006-01-06 01:18:50 -07:00
|
|
|
if(new == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
list_add(&new->list, chans);
|
|
|
|
new->input = 1;
|
|
|
|
new->output = 1;
|
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int chan_out_fd(struct list_head *chans)
|
|
|
|
{
|
|
|
|
struct list_head *ele;
|
|
|
|
struct chan *chan;
|
|
|
|
|
|
|
|
list_for_each(ele, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(chan->primary && chan->output)
|
2006-01-06 01:18:50 -07:00
|
|
|
return chan->fd;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-06 01:18:50 -07:00
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-12-05 12:36:26 -07:00
|
|
|
void chan_interrupt(struct list_head *chans, struct delayed_work *task,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct tty_struct *tty, int irq)
|
|
|
|
{
|
|
|
|
struct list_head *ele, *next;
|
|
|
|
struct chan *chan;
|
|
|
|
int err;
|
|
|
|
char c;
|
|
|
|
|
|
|
|
list_for_each_safe(ele, next, chans){
|
|
|
|
chan = list_entry(ele, struct chan, list);
|
|
|
|
if(!chan->input || (chan->ops->read == NULL)) continue;
|
|
|
|
do {
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-09 21:54:13 -07:00
|
|
|
if (tty && !tty_buffer_request_room(tty, 1)) {
|
2006-01-06 01:18:58 -07:00
|
|
|
schedule_delayed_work(task, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
err = chan->ops->read(chan->fd, &c, chan->data);
|
|
|
|
if(err > 0)
|
|
|
|
tty_receive_char(tty, c);
|
|
|
|
} while(err > 0);
|
|
|
|
|
|
|
|
if(err == 0) reactivate_fd(chan->fd, irq);
|
|
|
|
if(err == -EIO){
|
|
|
|
if(chan->primary){
|
|
|
|
if(tty != NULL)
|
|
|
|
tty_hangup(tty);
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
close_chan(chans, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
[PATCH] uml: Simplify console opening/closing and irq registration
This patch simplifies the opening and closing of host console devices and the
registration and deregistration of IRQs. The intent is to make it obvious
that an IRQ can't exist without an open file descriptor.
chan_enable will now open the channel, and when both opening and IRQ
registration are desired, this should be used. Opening only is done for the
initial console, so that interface still needs to exist.
The free_irqs_later interface is now gone. It was intended to avoid freeing
an IRQ while it was being processed. It did this, but it didn't eliminate the
possiblity of free_irq being called from an interrupt, which is bad. In its
place is a list of irqs to be freed, which is processed by the signal handler
just before exiting. close_one_chan now disables irqs.
When a host device disappears, it is just closed, and that disables IRQs.
The device id registered with the IRQ is now the chan structure, not the tty.
This is because the interrupt arrives on a descriptor associated with the
channel. This caused equivalent changes in the arguments to line_timer_cb.
line_disable is gone since it is not used any more.
The count field in the line structure is gone. tty->count is used instead.
The complicated logic in sigio_handler with freeing IRQs when necessary and
making sure its idea of the next irq is correct is now much simpler. The irq
list can't be rearranged underneath it, so it is now a simple list walk.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-06 01:18:57 -07:00
|
|
|
else close_one_chan(chan, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
if(tty) tty_flip_buffer_push(tty);
|
|
|
|
}
|