Kernel/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-01-18 02:46:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[PATCH] uml: Formatting changes

Browse Source 
This patch makes a bunch of non-functional changes -
    return(foo); becomes return foo;
    some statements are broken across lines for readability
    some trailing whitespace is cleaned up
    open_one_chan took four arguments, three of which could be
       deduced from the first.  Accordingly, they were eliminated.
    some examples of "} else {" had a newline added
    some whitespace cleanup in the indentation
    lines_init got some control flow cleanup
    some long lines were broken
    removed another emacs-specific C formatting comment

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>
This commit is contained in:
Jeff Dike 2006-01-06 00:18:50 -08:00 committed by Linus Torvalds
parent 1b57e9c278
commit d50084a299
8 changed files with 358 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
arch/um/drivers/chan_kern.c
View File

@ -58,7 +58,7 @@ static void *not_configged_init(char *str, int device, struct chan_opts *opts)
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(NULL); return NULL;
} }
static int not_configged_open(int input, int output, int primary, void *data, static int not_configged_open(int input, int output, int primary, void *data,
@ -66,7 +66,7 @@ static int not_configged_open(int input, int output, int primary, void *data,
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(-ENODEV); return -ENODEV;
} }
static void not_configged_close(int fd, void *data) static void not_configged_close(int fd, void *data)
@ -79,21 +79,21 @@ static int not_configged_read(int fd, char *c_out, void *data)
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(-EIO); return -EIO;
} }
static int not_configged_write(int fd, const char *buf, int len, void *data) static int not_configged_write(int fd, const char *buf, int len, void *data)
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(-EIO); return -EIO;
} }
static int not_configged_console_write(int fd, const char *buf, int len) static int not_configged_console_write(int fd, const char *buf, int len)
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(-EIO); return -EIO;
} }
static int not_configged_window_size(int fd, void *data, unsigned short *rows, static int not_configged_window_size(int fd, void *data, unsigned short *rows,
@ -101,7 +101,7 @@ static int not_configged_window_size(int fd, void *data, unsigned short *rows,
{ {
my_puts("Using a channel type which is configured out of " my_puts("Using a channel type which is configured out of "
"UML\n"); "UML\n");
return(-ENODEV); return -ENODEV;
} }
static void not_configged_free(void *data) static void not_configged_free(void *data)
@ -135,17 +135,17 @@ int generic_read(int fd, char *c_out, void *unused)
n = os_read_file(fd, c_out, sizeof(*c_out)); n = os_read_file(fd, c_out, sizeof(*c_out));
if(n == -EAGAIN) if(n == -EAGAIN)
return(0); return 0;
else if(n == 0) else if(n == 0)
return(-EIO); return -EIO;
return(n); return n;
} }
/* XXX Trivial wrapper around os_write_file */ /* XXX Trivial wrapper around os_write_file */
int generic_write(int fd, const char *buf, int n, void *unused) int generic_write(int fd, const char *buf, int n, void *unused)
{ {
return(os_write_file(fd, buf, n)); return os_write_file(fd, buf, n);
} }
int generic_window_size(int fd, void *unused, unsigned short *rows_out, int generic_window_size(int fd, void *unused, unsigned short *rows_out,
@ -156,14 +156,14 @@ int generic_window_size(int fd, void *unused, unsigned short *rows_out,
ret = os_window_size(fd, &rows, &cols); ret = os_window_size(fd, &rows, &cols);
if(ret < 0) if(ret < 0)
return(ret); return ret;
ret = ((*rows_out != rows) || (*cols_out != cols)); ret = ((*rows_out != rows) || (*cols_out != cols));
*rows_out = rows; *rows_out = rows;
*cols_out = cols; *cols_out = cols;
return(ret); return ret;
} }
void generic_free(void *data) void generic_free(void *data)
@ -186,25 +186,29 @@ static void tty_receive_char(struct tty_struct *tty, char ch)
} }
} }
if((tty->flip.flag_buf_ptr == NULL) || if((tty->flip.flag_buf_ptr == NULL) ||
(tty->flip.char_buf_ptr == NULL)) (tty->flip.char_buf_ptr == NULL))
return; return;
tty_insert_flip_char(tty, ch, TTY_NORMAL); tty_insert_flip_char(tty, ch, TTY_NORMAL);
} }
static int open_one_chan(struct chan *chan, int input, int output, int primary) static int open_one_chan(struct chan *chan)
{ {
int fd; int fd;
if(chan->opened) return(0); if(chan->opened)
if(chan->ops->open == NULL) fd = 0; return 0;
else fd = (*chan->ops->open)(input, output, primary, chan->data,
&chan->dev); if(chan->ops->open == NULL)
if(fd < 0) return(fd); fd = 0;
else fd = (*chan->ops->open)(chan->input, chan->output, chan->primary,
chan->data, &chan->dev);
if(fd < 0)
return fd;
chan->fd = fd; chan->fd = fd;
chan->opened = 1; chan->opened = 1;
return(0); return 0;
} }
int open_chan(struct list_head *chans) int open_chan(struct list_head *chans)
@ -215,11 +219,11 @@ int open_chan(struct list_head *chans)
list_for_each(ele, chans){ list_for_each(ele, chans){
chan = list_entry(ele, struct chan, list); chan = list_entry(ele, struct chan, list);
ret = open_one_chan(chan, chan->input, chan->output, ret = open_one_chan(chan);
chan->primary); if(chan->primary)
if(chan->primary) err = ret; err = ret;
} }
return(err); return err;
} }
void chan_enable_winch(struct list_head *chans, struct tty_struct *tty) void chan_enable_winch(struct list_head *chans, struct tty_struct *tty)
@ -267,7 +271,7 @@ void close_chan(struct list_head *chans)
} }
} }
int write_chan(struct list_head *chans, const char *buf, int len, int write_chan(struct list_head *chans, const char *buf, int len,
int write_irq) int write_irq)
{ {
struct list_head *ele; struct list_head *ele;
@ -285,7 +289,7 @@ int write_chan(struct list_head *chans, const char *buf, int len,
reactivate_fd(chan->fd, write_irq); reactivate_fd(chan->fd, write_irq);
} }
} }
return(ret); return ret;
} }
int console_write_chan(struct list_head *chans, const char *buf, int len) int console_write_chan(struct list_head *chans, const char *buf, int len)
@ -301,10 +305,11 @@ int console_write_chan(struct list_head *chans, const char *buf, int len)
n = chan->ops->console_write(chan->fd, buf, len); n = chan->ops->console_write(chan->fd, buf, len);
if(chan->primary) ret = n; if(chan->primary) ret = n;
} }
return(ret); return ret;
} }
int console_open_chan(struct line *line, struct console *co, struct chan_opts *opts) int console_open_chan(struct line *line, struct console *co,
struct chan_opts *opts)
{ {
if (!list_empty(&line->chan_list)) if (!list_empty(&line->chan_list))
return 0; return 0;
@ -327,12 +332,13 @@ int chan_window_size(struct list_head *chans, unsigned short *rows_out,
list_for_each(ele, chans){ list_for_each(ele, chans){
chan = list_entry(ele, struct chan, list); chan = list_entry(ele, struct chan, list);
if(chan->primary){ if(chan->primary){
if(chan->ops->window_size == NULL) return(0); if(chan->ops->window_size == NULL)
return(chan->ops->window_size(chan->fd, chan->data, return 0;
rows_out, cols_out)); return chan->ops->window_size(chan->fd, chan->data,
rows_out, cols_out);
} }
} }
return(0); return 0;
} }
void free_one_chan(struct chan *chan) void free_one_chan(struct chan *chan)
@ -363,23 +369,23 @@ static int one_chan_config_string(struct chan *chan, char *str, int size,
if(chan == NULL){ if(chan == NULL){
CONFIG_CHUNK(str, size, n, "none", 1); CONFIG_CHUNK(str, size, n, "none", 1);
return(n); return n;
} }
CONFIG_CHUNK(str, size, n, chan->ops->type, 0); CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
if(chan->dev == NULL){ if(chan->dev == NULL){
CONFIG_CHUNK(str, size, n, "", 1); CONFIG_CHUNK(str, size, n, "", 1);
return(n); return n;
} }
CONFIG_CHUNK(str, size, n, ":", 0); CONFIG_CHUNK(str, size, n, ":", 0);
CONFIG_CHUNK(str, size, n, chan->dev, 0); CONFIG_CHUNK(str, size, n, chan->dev, 0);
return(n); return n;
} }
static int chan_pair_config_string(struct chan *in, struct chan *out, static int chan_pair_config_string(struct chan *in, struct chan *out,
char *str, int size, char **error_out) char *str, int size, char **error_out)
{ {
int n; int n;
@ -390,7 +396,7 @@ static int chan_pair_config_string(struct chan *in, struct chan *out,
if(in == out){ if(in == out){
CONFIG_CHUNK(str, size, n, "", 1); CONFIG_CHUNK(str, size, n, "", 1);
return(n); return n;
} }
CONFIG_CHUNK(str, size, n, ",", 1); CONFIG_CHUNK(str, size, n, ",", 1);
@ -399,10 +405,10 @@ static int chan_pair_config_string(struct chan *in, struct chan *out,
size -= n; size -= n;
CONFIG_CHUNK(str, size, n, "", 1); CONFIG_CHUNK(str, size, n, "", 1);
return(n); return n;
} }
int chan_config_string(struct list_head *chans, char *str, int size, int chan_config_string(struct list_head *chans, char *str, int size,
char **error_out) char **error_out)
{ {
struct list_head *ele; struct list_head *ele;
@ -418,7 +424,7 @@ int chan_config_string(struct list_head *chans, char *str, int size,
out = chan; out = chan;
} }
return(chan_pair_config_string(in, out, str, size, error_out)); return chan_pair_config_string(in, out, str, size, error_out);
} }
struct chan_type { struct chan_type {
@ -462,7 +468,7 @@ struct chan_type chan_table[] = {
#endif #endif
}; };
static struct chan *parse_chan(char *str, int pri, int device, static struct chan *parse_chan(char *str, int pri, int device,
struct chan_opts *opts) struct chan_opts *opts)
{ {
struct chan_type *entry; struct chan_type *entry;
@ -484,14 +490,17 @@ static struct chan *parse_chan(char *str, int pri, int device,
if(ops == NULL){ if(ops == NULL){
my_printf("parse_chan couldn't parse \"%s\"\n", my_printf("parse_chan couldn't parse \"%s\"\n",
str); str);
return(NULL); return NULL;
} }
if(ops->init == NULL) return(NULL); if(ops->init == NULL)
return NULL;
data = (*ops->init)(str, device, opts); data = (*ops->init)(str, device, opts);
if(data == NULL) return(NULL); if(data == NULL)
return NULL;
chan = kmalloc(sizeof(*chan), GFP_ATOMIC); chan = kmalloc(sizeof(*chan), GFP_ATOMIC);
if(chan == NULL) return(NULL); if(chan == NULL)
return NULL;
*chan = ((struct chan) { .list = LIST_HEAD_INIT(chan->list), *chan = ((struct chan) { .list = LIST_HEAD_INIT(chan->list),
.primary = 1, .primary = 1,
.input = 0, .input = 0,
@ -501,7 +510,7 @@ static struct chan *parse_chan(char *str, int pri, int device,
.pri = pri, .pri = pri,
.ops = ops, .ops = ops,
.data = data }); .data = data });
return(chan); return chan;
} }
int parse_chan_pair(char *str, struct list_head *chans, int pri, int device, int parse_chan_pair(char *str, struct list_head *chans, int pri, int device,
@ -512,7 +521,8 @@ int parse_chan_pair(char *str, struct list_head *chans, int pri, int device,
if(!list_empty(chans)){ if(!list_empty(chans)){
chan = list_entry(chans->next, struct chan, list); chan = list_entry(chans->next, struct chan, list);
if(chan->pri >= pri) return(0); if(chan->pri >= pri)
return 0;
free_chan(chans); free_chan(chans);
INIT_LIST_HEAD(chans); INIT_LIST_HEAD(chans);
} }
@ -523,23 +533,29 @@ int parse_chan_pair(char *str, struct list_head *chans, int pri, int device,
*out = '\0'; *out = '\0';
out++; out++;
new = parse_chan(in, pri, device, opts); new = parse_chan(in, pri, device, opts);
if(new == NULL) return(-1); if(new == NULL)
return -1;
new->input = 1; new->input = 1;
list_add(&new->list, chans); list_add(&new->list, chans);
new = parse_chan(out, pri, device, opts); new = parse_chan(out, pri, device, opts);
if(new == NULL) return(-1); if(new == NULL)
return -1;
list_add(&new->list, chans); list_add(&new->list, chans);
new->output = 1; new->output = 1;
} }
else { else {
new = parse_chan(str, pri, device, opts); new = parse_chan(str, pri, device, opts);
if(new == NULL) return(-1); if(new == NULL)
return -1;
list_add(&new->list, chans); list_add(&new->list, chans);
new->input = 1; new->input = 1;
new->output = 1; new->output = 1;
} }
return(0); return 0;
} }
int chan_out_fd(struct list_head *chans) int chan_out_fd(struct list_head *chans)
@ -550,9 +566,9 @@ int chan_out_fd(struct list_head *chans)
list_for_each(ele, chans){ list_for_each(ele, chans){
chan = list_entry(ele, struct chan, list); chan = list_entry(ele, struct chan, list);
if(chan->primary && chan->output) if(chan->primary && chan->output)
return(chan->fd); return chan->fd;
} }
return(-1); return -1;
} }
void chan_interrupt(struct list_head *chans, struct work_struct *task, void chan_interrupt(struct list_head *chans, struct work_struct *task,
@ -567,7 +583,7 @@ void chan_interrupt(struct list_head *chans, struct work_struct *task,
chan = list_entry(ele, struct chan, list); chan = list_entry(ele, struct chan, list);
if(!chan->input || (chan->ops->read == NULL)) continue; if(!chan->input || (chan->ops->read == NULL)) continue;
do { do {
if((tty != NULL) && if((tty != NULL) &&
(tty->flip.count >= TTY_FLIPBUF_SIZE)){ (tty->flip.count >= TTY_FLIPBUF_SIZE)){
schedule_work(task); schedule_work(task);
goto out; goto out;

47
arch/um/drivers/line.c
View File

@ -124,7 +124,8 @@ static int buffer_data(struct line *line, const char *buf, int len)
if (len < end){ if (len < end){
memcpy(line->tail, buf, len); memcpy(line->tail, buf, len);
line->tail += len; line->tail += len;
} else { }
else {
/* The circular buffer is wrapping */ /* The circular buffer is wrapping */
memcpy(line->tail, buf, end); memcpy(line->tail, buf, end);
buf += end; buf += end;
@ -170,7 +171,7 @@ static int flush_buffer(struct line *line)
} }
count = line->tail - line->head; count = line->tail - line->head;
n = write_chan(&line->chan_list, line->head, count, n = write_chan(&line->chan_list, line->head, count,
line->driver->write_irq); line->driver->write_irq);
if(n < 0) if(n < 0)
@ -227,7 +228,7 @@ int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
if (err <= 0 && (err != -EAGAIN || !ret)) if (err <= 0 && (err != -EAGAIN || !ret))
ret = err; ret = err;
} else { } else {
n = write_chan(&line->chan_list, buf, len, n = write_chan(&line->chan_list, buf, len,
line->driver->write_irq); line->driver->write_irq);
if (n < 0) { if (n < 0) {
ret = n; ret = n;
@ -384,13 +385,13 @@ int line_setup_irq(int fd, int input, int output, struct tty_struct *tty)
if (input) if (input)
err = um_request_irq(driver->read_irq, fd, IRQ_READ, err = um_request_irq(driver->read_irq, fd, IRQ_READ,
line_interrupt, flags, line_interrupt, flags,
driver->read_irq_name, tty); driver->read_irq_name, tty);
if (err) if (err)
return err; return err;
if (output) if (output)
err = um_request_irq(driver->write_irq, fd, IRQ_WRITE, err = um_request_irq(driver->write_irq, fd, IRQ_WRITE,
line_write_interrupt, flags, line_write_interrupt, flags,
driver->write_irq_name, tty); driver->write_irq_name, tty);
line->have_irq = 1; line->have_irq = 1;
return err; return err;
@ -512,10 +513,11 @@ int line_setup(struct line *lines, unsigned int num, char *init, int all_allowed
/* We said con=/ssl= instead of con#=, so we are configuring all /* We said con=/ssl= instead of con#=, so we are configuring all
* consoles at once.*/ * consoles at once.*/
n = -1; n = -1;
} else { }
else {
n = simple_strtoul(init, &end, 0); n = simple_strtoul(init, &end, 0);
if(*end != '='){ if(*end != '='){
printk(KERN_ERR "line_setup failed to parse \"%s\"\n", printk(KERN_ERR "line_setup failed to parse \"%s\"\n",
init); init);
return 0; return 0;
} }
@ -527,7 +529,8 @@ int line_setup(struct line *lines, unsigned int num, char *init, int all_allowed
printk("line_setup - %d out of range ((0 ... %d) allowed)\n", printk("line_setup - %d out of range ((0 ... %d) allowed)\n",
n, num - 1); n, num - 1);
return 0; return 0;
} else if (n >= 0){ }
else if (n >= 0){
if (lines[n].count > 0) { if (lines[n].count > 0) {
printk("line_setup - device %d is open\n", n); printk("line_setup - device %d is open\n", n);
return 0; return 0;
@ -541,11 +544,13 @@ int line_setup(struct line *lines, unsigned int num, char *init, int all_allowed
lines[n].valid = 1; lines[n].valid = 1;
} }
} }
} else if(!all_allowed){ }
else if(!all_allowed){
printk("line_setup - can't configure all devices from " printk("line_setup - can't configure all devices from "
"mconsole\n"); "mconsole\n");
return 0; return 0;
} else { }
else {
for(i = 0; i < num; i++){ for(i = 0; i < num; i++){
if(lines[i].init_pri <= INIT_ALL){ if(lines[i].init_pri <= INIT_ALL){
lines[i].init_pri = INIT_ALL; lines[i].init_pri = INIT_ALL;
@ -627,7 +632,7 @@ int line_remove(struct line *lines, unsigned int num, int n)
} }
struct tty_driver *line_register_devfs(struct lines *set, struct tty_driver *line_register_devfs(struct lines *set,
struct line_driver *line_driver, struct line_driver *line_driver,
struct tty_operations *ops, struct line *lines, struct tty_operations *ops, struct line *lines,
int nlines) int nlines)
{ {
@ -656,7 +661,7 @@ struct tty_driver *line_register_devfs(struct lines *set,
} }
for(i = 0; i < nlines; i++){ for(i = 0; i < nlines; i++){
if(!lines[i].valid) if(!lines[i].valid)
tty_unregister_device(driver, i); tty_unregister_device(driver, i);
} }
@ -677,11 +682,12 @@ void lines_init(struct line *lines, int nlines)
line = &lines[i]; line = &lines[i];
INIT_LIST_HEAD(&line->chan_list); INIT_LIST_HEAD(&line->chan_list);
spin_lock_init(&line->lock); spin_lock_init(&line->lock);
if(line->init_str != NULL){ if(line->init_str == NULL)
line->init_str = kstrdup(line->init_str, GFP_KERNEL); continue;
if(line->init_str == NULL)
printk("lines_init - kstrdup returned NULL\n"); line->init_str = kstrdup(line->init_str, GFP_KERNEL);
} if(line->init_str == NULL)
printk("lines_init - kstrdup returned NULL\n");
} }
} }
@ -717,8 +723,7 @@ irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
tty = winch->tty; tty = winch->tty;
if (tty != NULL) { if (tty != NULL) {
line = tty->driver_data; line = tty->driver_data;
chan_window_size(&line->chan_list, chan_window_size(&line->chan_list, &tty->winsize.ws_row,
&tty->winsize.ws_row,
&tty->winsize.ws_col); &tty->winsize.ws_col);
kill_pg(tty->pgrp, SIGWINCH, 1); kill_pg(tty->pgrp, SIGWINCH, 1);
} }
@ -749,7 +754,7 @@ void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty)
spin_unlock(&winch_handler_lock); spin_unlock(&winch_handler_lock);
if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
"winch", winch) < 0) "winch", winch) < 0)
printk("register_winch_irq - failed to register IRQ\n"); printk("register_winch_irq - failed to register IRQ\n");
} }
@ -800,7 +805,7 @@ static void winch_cleanup(void)
deactivate_fd(winch->fd, WINCH_IRQ); deactivate_fd(winch->fd, WINCH_IRQ);
os_close_file(winch->fd); os_close_file(winch->fd);
} }
if(winch->pid != -1) if(winch->pid != -1)
os_kill_process(winch->pid, 1); os_kill_process(winch->pid, 1);
} }
} }

25
arch/um/drivers/mconsole_kern.c
View File

@ -34,7 +34,7 @@
#include "irq_kern.h" #include "irq_kern.h"
#include "choose-mode.h" #include "choose-mode.h"
static int do_unlink_socket(struct notifier_block *notifier, static int do_unlink_socket(struct notifier_block *notifier,
unsigned long what, void *data) unsigned long what, void *data)
{ {
return(mconsole_unlink_socket()); return(mconsole_unlink_socket());
@ -46,7 +46,7 @@ static struct notifier_block reboot_notifier = {
.priority = 0, .priority = 0,
}; };
/* Safe without explicit locking for now. Tasklets provide their own /* Safe without explicit locking for now. Tasklets provide their own
* locking, and the interrupt handler is safe because it can't interrupt * locking, and the interrupt handler is safe because it can't interrupt
* itself and it can only happen on CPU 0. * itself and it can only happen on CPU 0.
*/ */
@ -60,7 +60,7 @@ static void mc_work_proc(void *unused)
while(!list_empty(&mc_requests)){ while(!list_empty(&mc_requests)){
local_save_flags(flags); local_save_flags(flags);
req = list_entry(mc_requests.next, struct mconsole_entry, req = list_entry(mc_requests.next, struct mconsole_entry,
list); list);
list_del(&req->list); list_del(&req->list);
local_irq_restore(flags); local_irq_restore(flags);
@ -103,8 +103,8 @@ void mconsole_version(struct mc_request *req)
{ {
char version[256]; char version[256];
sprintf(version, "%s %s %s %s %s", system_utsname.sysname, sprintf(version, "%s %s %s %s %s", system_utsname.sysname,
system_utsname.nodename, system_utsname.release, system_utsname.nodename, system_utsname.release,
system_utsname.version, system_utsname.machine); system_utsname.version, system_utsname.machine);
mconsole_reply(req, version, 0, 0); mconsole_reply(req, version, 0, 0);
} }
@ -348,7 +348,7 @@ static struct mc_device *mconsole_find_dev(char *name)
#define CONFIG_BUF_SIZE 64 #define CONFIG_BUF_SIZE 64
static void mconsole_get_config(int (*get_config)(char *, char *, int, static void mconsole_get_config(int (*get_config)(char *, char *, int,
char **), char **),
struct mc_request *req, char *name) struct mc_request *req, char *name)
{ {
@ -389,7 +389,6 @@ static void mconsole_get_config(int (*get_config)(char *, char *, int,
out: out:
if(buf != default_buf) if(buf != default_buf)
kfree(buf); kfree(buf);
} }
void mconsole_config(struct mc_request *req) void mconsole_config(struct mc_request *req)
@ -420,7 +419,7 @@ void mconsole_config(struct mc_request *req)
void mconsole_remove(struct mc_request *req) void mconsole_remove(struct mc_request *req)
{ {
struct mc_device *dev; struct mc_device *dev;
char *ptr = req->request.data, *err_msg = ""; char *ptr = req->request.data, *err_msg = "";
char error[256]; char error[256];
int err, start, end, n; int err, start, end, n;
@ -534,7 +533,7 @@ void mconsole_stack(struct mc_request *req)
/* Changed by mconsole_setup, which is __setup, and called before SMP is /* Changed by mconsole_setup, which is __setup, and called before SMP is
* active. * active.
*/ */
static char *notify_socket = NULL; static char *notify_socket = NULL;
int mconsole_init(void) int mconsole_init(void)
{ {
@ -566,13 +565,13 @@ int mconsole_init(void)
notify_socket = kstrdup(notify_socket, GFP_KERNEL); notify_socket = kstrdup(notify_socket, GFP_KERNEL);
if(notify_socket != NULL) if(notify_socket != NULL)
mconsole_notify(notify_socket, MCONSOLE_SOCKET, mconsole_notify(notify_socket, MCONSOLE_SOCKET,
mconsole_socket_name, mconsole_socket_name,
strlen(mconsole_socket_name) + 1); strlen(mconsole_socket_name) + 1);
else printk(KERN_ERR "mconsole_setup failed to strdup " else printk(KERN_ERR "mconsole_setup failed to strdup "
"string\n"); "string\n");
} }
printk("mconsole (version %d) initialized on %s\n", printk("mconsole (version %d) initialized on %s\n",
MCONSOLE_VERSION, mconsole_socket_name); MCONSOLE_VERSION, mconsole_socket_name);
return(0); return(0);
} }
@ -585,7 +584,7 @@ static int write_proc_mconsole(struct file *file, const char __user *buffer,
char *buf; char *buf;
buf = kmalloc(count + 1, GFP_KERNEL); buf = kmalloc(count + 1, GFP_KERNEL);
if(buf == NULL) if(buf == NULL)
return(-ENOMEM); return(-ENOMEM);
if(copy_from_user(buf, buffer, count)){ if(copy_from_user(buf, buffer, count)){
@ -661,7 +660,7 @@ static int notify_panic(struct notifier_block *self, unsigned long unused1,
if(notify_socket == NULL) return(0); if(notify_socket == NULL) return(0);
mconsole_notify(notify_socket, MCONSOLE_PANIC, message, mconsole_notify(notify_socket, MCONSOLE_PANIC, message,
strlen(message) + 1); strlen(message) + 1);
return(0); return(0);
} }

29
arch/um/drivers/ssl.c
View File

@ -69,7 +69,7 @@ static struct line_driver driver = {
.name = "ssl", .name = "ssl",
.config = ssl_config, .config = ssl_config,
.get_config = ssl_get_config, .get_config = ssl_get_config,
.id = line_id, .id = line_id,
.remove = ssl_remove, .remove = ssl_remove,
}, },
}; };
@ -84,21 +84,21 @@ static struct lines lines = LINES_INIT(NR_PORTS);
static int ssl_config(char *str) static int ssl_config(char *str)
{ {
return(line_config(serial_lines, return line_config(serial_lines,
sizeof(serial_lines)/sizeof(serial_lines[0]), str)); sizeof(serial_lines)/sizeof(serial_lines[0]), str);
} }
static int ssl_get_config(char *dev, char *str, int size, char **error_out) static int ssl_get_config(char *dev, char *str, int size, char **error_out)
{ {
return(line_get_config(dev, serial_lines, return line_get_config(dev, serial_lines,
sizeof(serial_lines)/sizeof(serial_lines[0]), sizeof(serial_lines)/sizeof(serial_lines[0]),
str, size, error_out)); str, size, error_out);
} }
static int ssl_remove(int n) static int ssl_remove(int n)
{ {
return line_remove(serial_lines, return line_remove(serial_lines,
sizeof(serial_lines)/sizeof(serial_lines[0]), n); sizeof(serial_lines)/sizeof(serial_lines[0]), n);
} }
int ssl_open(struct tty_struct *tty, struct file *filp) int ssl_open(struct tty_struct *tty, struct file *filp)
@ -183,7 +183,7 @@ static int ssl_console_setup(struct console *co, char *options)
{ {
struct line *line = &serial_lines[co->index]; struct line *line = &serial_lines[co->index];
return console_open_chan(line,co,&opts); return console_open_chan(line, co, &opts);
} }
static struct console ssl_cons = { static struct console ssl_cons = {
@ -199,10 +199,11 @@ int ssl_init(void)
{ {
char *new_title; char *new_title;
printk(KERN_INFO "Initializing software serial port version %d\n", printk(KERN_INFO "Initializing software serial port version %d\n",
ssl_version); ssl_version);
ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops, ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops,
serial_lines, ARRAY_SIZE(serial_lines)); serial_lines,
ARRAY_SIZE(serial_lines));
lines_init(serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0])); lines_init(serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0]));
@ -212,7 +213,7 @@ int ssl_init(void)
ssl_init_done = 1; ssl_init_done = 1;
register_console(&ssl_cons); register_console(&ssl_cons);
return(0); return 0;
} }
late_initcall(ssl_init); late_initcall(ssl_init);
@ -227,9 +228,9 @@ __uml_exitcall(ssl_exit);
static int ssl_chan_setup(char *str) static int ssl_chan_setup(char *str)
{ {
return(line_setup(serial_lines, return line_setup(serial_lines,
sizeof(serial_lines)/sizeof(serial_lines[0]), sizeof(serial_lines)/sizeof(serial_lines[0]),
str, 1)); str, 1);
} }
__setup("ssl", ssl_chan_setup); __setup("ssl", ssl_chan_setup);

26
arch/um/drivers/stdio_console.c
View File

@ -75,7 +75,7 @@ static struct line_driver driver = {
.name = "con", .name = "con",
.config = con_config, .config = con_config,
.get_config = con_get_config, .get_config = con_get_config,
.id = line_id, .id = line_id,
.remove = con_remove, .remove = con_remove,
}, },
}; };
@ -86,23 +86,23 @@ static struct lines console_lines = LINES_INIT(MAX_TTYS);
* individual elements are protected by individual semaphores. * individual elements are protected by individual semaphores.
*/ */
struct line vts[MAX_TTYS] = { LINE_INIT(CONFIG_CON_ZERO_CHAN, &driver), struct line vts[MAX_TTYS] = { LINE_INIT(CONFIG_CON_ZERO_CHAN, &driver),
[ 1 ... MAX_TTYS - 1 ] = [ 1 ... MAX_TTYS - 1 ] =
LINE_INIT(CONFIG_CON_CHAN, &driver) }; LINE_INIT(CONFIG_CON_CHAN, &driver) };
static int con_config(char *str) static int con_config(char *str)
{ {
return(line_config(vts, sizeof(vts)/sizeof(vts[0]), str)); return line_config(vts, sizeof(vts)/sizeof(vts[0]), str);
} }
static int con_get_config(char *dev, char *str, int size, char **error_out) static int con_get_config(char *dev, char *str, int size, char **error_out)
{ {
return(line_get_config(dev, vts, sizeof(vts)/sizeof(vts[0]), str, return line_get_config(dev, vts, sizeof(vts)/sizeof(vts[0]), str,
size, error_out)); size, error_out);
} }
static int con_remove(int n) static int con_remove(int n)
{ {
return line_remove(vts, sizeof(vts)/sizeof(vts[0]), n); return line_remove(vts, sizeof(vts)/sizeof(vts[0]), n);
} }
static int con_open(struct tty_struct *tty, struct file *filp) static int con_open(struct tty_struct *tty, struct file *filp)
@ -117,7 +117,7 @@ static struct tty_operations console_ops = {
.close = line_close, .close = line_close,
.write = line_write, .write = line_write,
.put_char = line_put_char, .put_char = line_put_char,
.write_room = line_write_room, .write_room = line_write_room,
.chars_in_buffer = line_chars_in_buffer, .chars_in_buffer = line_chars_in_buffer,
.flush_buffer = line_flush_buffer, .flush_buffer = line_flush_buffer,
.flush_chars = line_flush_chars, .flush_chars = line_flush_chars,
@ -126,7 +126,7 @@ static struct tty_operations console_ops = {
}; };
static void uml_console_write(struct console *console, const char *string, static void uml_console_write(struct console *console, const char *string,
unsigned len) unsigned len)
{ {
struct line *line = &vts[console->index]; struct line *line = &vts[console->index];
unsigned long flags; unsigned long flags;
@ -146,7 +146,7 @@ static int uml_console_setup(struct console *co, char *options)
{ {
struct line *line = &vts[co->index]; struct line *line = &vts[co->index];
return console_open_chan(line,co,&opts); return console_open_chan(line, co, &opts);
} }
static struct console stdiocons = { static struct console stdiocons = {
@ -156,7 +156,7 @@ static struct console stdiocons = {
.setup = uml_console_setup, .setup = uml_console_setup,
.flags = CON_PRINTBUFFER, .flags = CON_PRINTBUFFER,
.index = -1, .index = -1,
.data = &vts, .data = &vts,
}; };
int stdio_init(void) int stdio_init(void)
@ -166,7 +166,7 @@ int stdio_init(void)
console_driver = line_register_devfs(&console_lines, &driver, console_driver = line_register_devfs(&console_lines, &driver,
&console_ops, vts, &console_ops, vts,
ARRAY_SIZE(vts)); ARRAY_SIZE(vts));
if (NULL == console_driver) if (console_driver == NULL)
return -1; return -1;
printk(KERN_INFO "Initialized stdio console driver\n"); printk(KERN_INFO "Initialized stdio console driver\n");
@ -178,7 +178,7 @@ int stdio_init(void)
con_init_done = 1; con_init_done = 1;
register_console(&stdiocons); register_console(&stdiocons);
return(0); return 0;
} }
late_initcall(stdio_init); late_initcall(stdio_init);
@ -192,7 +192,7 @@ __uml_exitcall(console_exit);
static int console_chan_setup(char *str) static int console_chan_setup(char *str)
{ {
return(line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1)); return line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1);
} }
__setup("con", console_chan_setup); __setup("con", console_chan_setup);
__channel_help(console_chan_setup, "con"); __channel_help(console_chan_setup, "con");

11
arch/um/include/chan_kern.h
View File

@ -47,14 +47,3 @@ extern int chan_config_string(struct list_head *chans, char *str, int size,
char **error_out); char **error_out);
#endif #endif
/*
* Overrides for Emacs so that we follow Linus's tabbing style.
* Emacs will notice this stuff at the end of the file and automatically
* adjust the settings for this buffer only. This must remain at the end
* of the file.
* ---------------------------------------------------------------------------
* Local variables:
* c-file-style: "linux"
* End:
*/

22
arch/um/include/line.h
View File

@ -64,8 +64,8 @@ struct line {
head : NULL, \ head : NULL, \
tail : NULL, \ tail : NULL, \
sigio : 0, \ sigio : 0, \
driver : d, \ driver : d, \
have_irq : 0 } have_irq : 0 }
struct lines { struct lines {
int num; int num;
@ -74,11 +74,12 @@ struct lines {
#define LINES_INIT(n) { num : n } #define LINES_INIT(n) { num : n }
extern void line_close(struct tty_struct *tty, struct file * filp); extern void line_close(struct tty_struct *tty, struct file * filp);
extern int line_open(struct line *lines, struct tty_struct *tty, extern int line_open(struct line *lines, struct tty_struct *tty,
struct chan_opts *opts); struct chan_opts *opts);
extern int line_setup(struct line *lines, unsigned int sizeof_lines, char *init, extern int line_setup(struct line *lines, unsigned int sizeof_lines, char *init,
int all_allowed); int all_allowed);
extern int line_write(struct tty_struct *tty, const unsigned char *buf, int len); extern int line_write(struct tty_struct *tty, const unsigned char *buf,
int len);
extern void line_put_char(struct tty_struct *tty, unsigned char ch); extern void line_put_char(struct tty_struct *tty, unsigned char ch);
extern void line_set_termios(struct tty_struct *tty, struct termios * old); extern void line_set_termios(struct tty_struct *tty, struct termios * old);
extern int line_chars_in_buffer(struct tty_struct *tty); extern int line_chars_in_buffer(struct tty_struct *tty);
@ -89,21 +90,24 @@ extern int line_ioctl(struct tty_struct *tty, struct file * file,
unsigned int cmd, unsigned long arg); unsigned int cmd, unsigned long arg);
extern char *add_xterm_umid(char *base); extern char *add_xterm_umid(char *base);
extern int line_setup_irq(int fd, int input, int output, struct tty_struct *tty); extern int line_setup_irq(int fd, int input, int output,
struct tty_struct *tty);
extern void line_close_chan(struct line *line); extern void line_close_chan(struct line *line);
extern void line_disable(struct tty_struct *tty, int current_irq); extern void line_disable(struct tty_struct *tty, int current_irq);
extern struct tty_driver * line_register_devfs(struct lines *set, extern struct tty_driver * line_register_devfs(struct lines *set,
struct line_driver *line_driver, struct line_driver *line_driver,
struct tty_operations *driver, struct tty_operations *driver,
struct line *lines, struct line *lines,
int nlines); int nlines);
extern void lines_init(struct line *lines, int nlines); extern void lines_init(struct line *lines, int nlines);
extern void close_lines(struct line *lines, int nlines); extern void close_lines(struct line *lines, int nlines);
extern int line_config(struct line *lines, unsigned int sizeof_lines, char *str); extern int line_config(struct line *lines, unsigned int sizeof_lines,
char *str);
extern int line_id(char **str, int *start_out, int *end_out); extern int line_id(char **str, int *start_out, int *end_out);
extern int line_remove(struct line *lines, unsigned int sizeof_lines, int n); extern int line_remove(struct line *lines, unsigned int sizeof_lines, int n);
extern int line_get_config(char *dev, struct line *lines, unsigned int sizeof_lines, char *str, extern int line_get_config(char *dev, struct line *lines,
unsigned int sizeof_lines, char *str,
int size, char **error_out); int size, char **error_out);
#endif #endif

419
arch/um/os-Linux/aio.c
View File

@ -16,12 +16,12 @@
#include "mode.h" #include "mode.h"
struct aio_thread_req { struct aio_thread_req {
enum aio_type type; enum aio_type type;
int io_fd; int io_fd;
unsigned long long offset; unsigned long long offset;
char *buf; char *buf;
int len; int len;
struct aio_context *aio; struct aio_context *aio;
}; };
static int aio_req_fd_r = -1; static int aio_req_fd_r = -1;
@ -38,18 +38,18 @@ static int aio_req_fd_w = -1;
static long io_setup(int n, aio_context_t *ctxp) static long io_setup(int n, aio_context_t *ctxp)
{ {
return syscall(__NR_io_setup, n, ctxp); return syscall(__NR_io_setup, n, ctxp);
} }
static long io_submit(aio_context_t ctx, long nr, struct iocb **iocbpp) static long io_submit(aio_context_t ctx, long nr, struct iocb **iocbpp)
{ {
return syscall(__NR_io_submit, ctx, nr, iocbpp); return syscall(__NR_io_submit, ctx, nr, iocbpp);
} }
static long io_getevents(aio_context_t ctx_id, long min_nr, long nr, static long io_getevents(aio_context_t ctx_id, long min_nr, long nr,
struct io_event *events, struct timespec *timeout) struct io_event *events, struct timespec *timeout)
{ {
return syscall(__NR_io_getevents, ctx_id, min_nr, nr, events, timeout); return syscall(__NR_io_getevents, ctx_id, min_nr, nr, events, timeout);
} }
#endif #endif
@ -66,150 +66,150 @@ static long io_getevents(aio_context_t ctx_id, long min_nr, long nr,
*/ */
static int do_aio(aio_context_t ctx, enum aio_type type, int fd, char *buf, static int do_aio(aio_context_t ctx, enum aio_type type, int fd, char *buf,
int len, unsigned long long offset, struct aio_context *aio) int len, unsigned long long offset, struct aio_context *aio)
{ {
struct iocb iocb, *iocbp = &iocb; struct iocb iocb, *iocbp = &iocb;
char c; char c;
int err; int err;
iocb = ((struct iocb) { .aio_data = (unsigned long) aio, iocb = ((struct iocb) { .aio_data = (unsigned long) aio,
.aio_reqprio = 0, .aio_reqprio = 0,
.aio_fildes = fd, .aio_fildes = fd,
.aio_buf = (unsigned long) buf, .aio_buf = (unsigned long) buf,
.aio_nbytes = len, .aio_nbytes = len,
.aio_offset = offset, .aio_offset = offset,
.aio_reserved1 = 0, .aio_reserved1 = 0,
.aio_reserved2 = 0, .aio_reserved2 = 0,
.aio_reserved3 = 0 }); .aio_reserved3 = 0 });
switch(type){ switch(type){
case AIO_READ: case AIO_READ:
iocb.aio_lio_opcode = IOCB_CMD_PREAD; iocb.aio_lio_opcode = IOCB_CMD_PREAD;
err = io_submit(ctx, 1, &iocbp); err = io_submit(ctx, 1, &iocbp);
break; break;
case AIO_WRITE: case AIO_WRITE:
iocb.aio_lio_opcode = IOCB_CMD_PWRITE; iocb.aio_lio_opcode = IOCB_CMD_PWRITE;
err = io_submit(ctx, 1, &iocbp); err = io_submit(ctx, 1, &iocbp);
break; break;
case AIO_MMAP: case AIO_MMAP:
iocb.aio_lio_opcode = IOCB_CMD_PREAD; iocb.aio_lio_opcode = IOCB_CMD_PREAD;
iocb.aio_buf = (unsigned long) &c; iocb.aio_buf = (unsigned long) &c;
iocb.aio_nbytes = sizeof(c); iocb.aio_nbytes = sizeof(c);
err = io_submit(ctx, 1, &iocbp); err = io_submit(ctx, 1, &iocbp);
break; break;
default: default:
printk("Bogus op in do_aio - %d\n", type); printk("Bogus op in do_aio - %d\n", type);
err = -EINVAL; err = -EINVAL;
break; break;
} }
if(err > 0) if(err > 0)
err = 0; err = 0;
else else
err = -errno; err = -errno;
return err; return err;
} }
static aio_context_t ctx = 0; static aio_context_t ctx = 0;
static int aio_thread(void *arg) static int aio_thread(void *arg)
{ {
struct aio_thread_reply reply; struct aio_thread_reply reply;
struct io_event event; struct io_event event;
int err, n, reply_fd; int err, n, reply_fd;
signal(SIGWINCH, SIG_IGN); signal(SIGWINCH, SIG_IGN);
while(1){ while(1){
n = io_getevents(ctx, 1, 1, &event, NULL); n = io_getevents(ctx, 1, 1, &event, NULL);
if(n < 0){ if(n < 0){
if(errno == EINTR) if(errno == EINTR)
continue; continue;
printk("aio_thread - io_getevents failed, " printk("aio_thread - io_getevents failed, "
"errno = %d\n", errno); "errno = %d\n", errno);
} }
else { else {
reply = ((struct aio_thread_reply) reply = ((struct aio_thread_reply)
{ .data = (void *) (long) event.data, { .data = (void *) (long) event.data,
.err = event.res }); .err = event.res });
reply_fd = ((struct aio_context *) reply.data)->reply_fd; reply_fd = ((struct aio_context *) reply.data)->reply_fd;
err = os_write_file(reply_fd, &reply, sizeof(reply)); err = os_write_file(reply_fd, &reply, sizeof(reply));
if(err != sizeof(reply)) if(err != sizeof(reply))
printk("aio_thread - write failed, fd = %d, " printk("aio_thread - write failed, fd = %d, "
"err = %d\n", aio_req_fd_r, -err); "err = %d\n", aio_req_fd_r, -err);
} }
} }
return 0; return 0;
} }
#endif #endif
static int do_not_aio(struct aio_thread_req *req) static int do_not_aio(struct aio_thread_req *req)
{ {
char c; char c;
int err; int err;
switch(req->type){ switch(req->type){
case AIO_READ: case AIO_READ:
err = os_seek_file(req->io_fd, req->offset); err = os_seek_file(req->io_fd, req->offset);
if(err) if(err)
goto out; goto out;
err = os_read_file(req->io_fd, req->buf, req->len); err = os_read_file(req->io_fd, req->buf, req->len);
break; break;
case AIO_WRITE: case AIO_WRITE:
err = os_seek_file(req->io_fd, req->offset); err = os_seek_file(req->io_fd, req->offset);
if(err) if(err)
goto out; goto out;
err = os_write_file(req->io_fd, req->buf, req->len); err = os_write_file(req->io_fd, req->buf, req->len);
break; break;
case AIO_MMAP: case AIO_MMAP:
err = os_seek_file(req->io_fd, req->offset); err = os_seek_file(req->io_fd, req->offset);
if(err) if(err)
goto out; goto out;
err = os_read_file(req->io_fd, &c, sizeof(c)); err = os_read_file(req->io_fd, &c, sizeof(c));
break; break;
default: default:
printk("do_not_aio - bad request type : %d\n", req->type); printk("do_not_aio - bad request type : %d\n", req->type);
err = -EINVAL; err = -EINVAL;
break; break;
} }
out: out:
return err; return err;
} }
static int not_aio_thread(void *arg) static int not_aio_thread(void *arg)
{ {
struct aio_thread_req req; struct aio_thread_req req;
struct aio_thread_reply reply; struct aio_thread_reply reply;
int err; int err;
signal(SIGWINCH, SIG_IGN); signal(SIGWINCH, SIG_IGN);
while(1){ while(1){
err = os_read_file(aio_req_fd_r, &req, sizeof(req)); err = os_read_file(aio_req_fd_r, &req, sizeof(req));
if(err != sizeof(req)){ if(err != sizeof(req)){
if(err < 0) if(err < 0)
printk("not_aio_thread - read failed, " printk("not_aio_thread - read failed, "
"fd = %d, err = %d\n", aio_req_fd_r, "fd = %d, err = %d\n", aio_req_fd_r,
-err); -err);
else { else {
printk("not_aio_thread - short read, fd = %d, " printk("not_aio_thread - short read, fd = %d, "
"length = %d\n", aio_req_fd_r, err); "length = %d\n", aio_req_fd_r, err);
} }
continue; continue;
} }
err = do_not_aio(&req); err = do_not_aio(&req);
reply = ((struct aio_thread_reply) { .data = req.aio, reply = ((struct aio_thread_reply) { .data = req.aio,
.err = err }); .err = err });
err = os_write_file(req.aio->reply_fd, &reply, sizeof(reply)); err = os_write_file(req.aio->reply_fd, &reply, sizeof(reply));
if(err != sizeof(reply)) if(err != sizeof(reply))
printk("not_aio_thread - write failed, fd = %d, " printk("not_aio_thread - write failed, fd = %d, "
"err = %d\n", aio_req_fd_r, -err); "err = %d\n", aio_req_fd_r, -err);
} }
return 0; return 0;
} }
@ -218,93 +218,93 @@ static int aio_pid = -1;
static int init_aio_24(void) static int init_aio_24(void)
{ {
unsigned long stack; unsigned long stack;
int fds[2], err; int fds[2], err;
err = os_pipe(fds, 1, 1); err = os_pipe(fds, 1, 1);
if(err) if(err)
goto out; goto out;
aio_req_fd_w = fds[0]; aio_req_fd_w = fds[0];
aio_req_fd_r = fds[1]; aio_req_fd_r = fds[1];
err = run_helper_thread(not_aio_thread, NULL, err = run_helper_thread(not_aio_thread, NULL,
CLONE_FILES | CLONE_VM | SIGCHLD, &stack, 0); CLONE_FILES | CLONE_VM | SIGCHLD, &stack, 0);
if(err < 0) if(err < 0)
goto out_close_pipe; goto out_close_pipe;
aio_pid = err; aio_pid = err;
goto out; goto out;
out_close_pipe: out_close_pipe:
os_close_file(fds[0]); os_close_file(fds[0]);
os_close_file(fds[1]); os_close_file(fds[1]);
aio_req_fd_w = -1; aio_req_fd_w = -1;
aio_req_fd_r = -1; aio_req_fd_r = -1;
out: out:
#ifndef HAVE_AIO_ABI #ifndef HAVE_AIO_ABI
printk("/usr/include/linux/aio_abi.h not present during build\n"); printk("/usr/include/linux/aio_abi.h not present during build\n");
#endif #endif
printk("2.6 host AIO support not used - falling back to I/O " printk("2.6 host AIO support not used - falling back to I/O "
"thread\n"); "thread\n");
return 0; return 0;
} }
#ifdef HAVE_AIO_ABI #ifdef HAVE_AIO_ABI
#define DEFAULT_24_AIO 0 #define DEFAULT_24_AIO 0
static int init_aio_26(void) static int init_aio_26(void)
{ {
unsigned long stack; unsigned long stack;
int err; int err;
if(io_setup(256, &ctx)){ if(io_setup(256, &ctx)){
err = -errno; err = -errno;
printk("aio_thread failed to initialize context, err = %d\n", printk("aio_thread failed to initialize context, err = %d\n",
errno); errno);
return err; return err;
} }
err = run_helper_thread(aio_thread, NULL, err = run_helper_thread(aio_thread, NULL,
CLONE_FILES | CLONE_VM | SIGCHLD, &stack, 0); CLONE_FILES | CLONE_VM | SIGCHLD, &stack, 0);
if(err < 0) if(err < 0)
return err; return err;
aio_pid = err; aio_pid = err;
printk("Using 2.6 host AIO\n"); printk("Using 2.6 host AIO\n");
return 0; return 0;
} }
static int submit_aio_26(enum aio_type type, int io_fd, char *buf, int len, static int submit_aio_26(enum aio_type type, int io_fd, char *buf, int len,
unsigned long long offset, struct aio_context *aio) unsigned long long offset, struct aio_context *aio)
{ {
struct aio_thread_reply reply; struct aio_thread_reply reply;
int err; int err;
err = do_aio(ctx, type, io_fd, buf, len, offset, aio); err = do_aio(ctx, type, io_fd, buf, len, offset, aio);
if(err){ if(err){
reply = ((struct aio_thread_reply) { .data = aio, reply = ((struct aio_thread_reply) { .data = aio,
.err = err }); .err = err });
err = os_write_file(aio->reply_fd, &reply, sizeof(reply)); err = os_write_file(aio->reply_fd, &reply, sizeof(reply));
if(err != sizeof(reply)) if(err != sizeof(reply))
printk("submit_aio_26 - write failed, " printk("submit_aio_26 - write failed, "
"fd = %d, err = %d\n", aio->reply_fd, -err); "fd = %d, err = %d\n", aio->reply_fd, -err);
else err = 0; else err = 0;
} }
return err; return err;
} }
#else #else
#define DEFAULT_24_AIO 1 #define DEFAULT_24_AIO 1
static int init_aio_26(void) static int init_aio_26(void)
{ {
return -ENOSYS; return -ENOSYS;
} }
static int submit_aio_26(enum aio_type type, int io_fd, char *buf, int len, static int submit_aio_26(enum aio_type type, int io_fd, char *buf, int len,
unsigned long long offset, struct aio_context *aio) unsigned long long offset, struct aio_context *aio)
{ {
return -ENOSYS; return -ENOSYS;
} }
#endif #endif
@ -312,8 +312,8 @@ static int aio_24 = DEFAULT_24_AIO;
static int __init set_aio_24(char *name, int *add) static int __init set_aio_24(char *name, int *add)
{ {
aio_24 = 1; aio_24 = 1;
return 0; return 0;
} }
__uml_setup("aio=2.4", set_aio_24, __uml_setup("aio=2.4", set_aio_24,
@ -330,28 +330,27 @@ __uml_setup("aio=2.4", set_aio_24,
static int init_aio(void) static int init_aio(void)
{ {
int err; int err;
CHOOSE_MODE(({ CHOOSE_MODE(({ if(!aio_24){
if(!aio_24){ printk("Disabling 2.6 AIO in tt mode\n");
printk("Disabling 2.6 AIO in tt mode\n"); aio_24 = 1;
aio_24 = 1; } }), (void) 0);
} }), (void) 0);
if(!aio_24){ if(!aio_24){
err = init_aio_26(); err = init_aio_26();
if(err && (errno == ENOSYS)){ if(err && (errno == ENOSYS)){
printk("2.6 AIO not supported on the host - " printk("2.6 AIO not supported on the host - "
"reverting to 2.4 AIO\n"); "reverting to 2.4 AIO\n");
aio_24 = 1; aio_24 = 1;
} }
else return err; else return err;
} }
if(aio_24) if(aio_24)
return init_aio_24(); return init_aio_24();
return 0; return 0;
} }
/* The reason for the __initcall/__uml_exitcall asymmetry is that init_aio /* The reason for the __initcall/__uml_exitcall asymmetry is that init_aio
@ -364,8 +363,8 @@ __initcall(init_aio);
static void exit_aio(void) static void exit_aio(void)
{ {
if(aio_pid != -1) if(aio_pid != -1)
os_kill_process(aio_pid, 1); os_kill_process(aio_pid, 1);
} }
__uml_exitcall(exit_aio); __uml_exitcall(exit_aio);
@ -373,30 +372,30 @@ __uml_exitcall(exit_aio);
static int submit_aio_24(enum aio_type type, int io_fd, char *buf, int len, static int submit_aio_24(enum aio_type type, int io_fd, char *buf, int len,
unsigned long long offset, struct aio_context *aio) unsigned long long offset, struct aio_context *aio)
{ {
struct aio_thread_req req = { .type = type, struct aio_thread_req req = { .type = type,
.io_fd = io_fd, .io_fd = io_fd,
.offset = offset, .offset = offset,
.buf = buf, .buf = buf,
.len = len, .len = len,
.aio = aio, .aio = aio,
}; };
int err; int err;
err = os_write_file(aio_req_fd_w, &req, sizeof(req)); err = os_write_file(aio_req_fd_w, &req, sizeof(req));
if(err == sizeof(req)) if(err == sizeof(req))
err = 0; err = 0;
return err; return err;
} }
int submit_aio(enum aio_type type, int io_fd, char *buf, int len, int submit_aio(enum aio_type type, int io_fd, char *buf, int len,
unsigned long long offset, int reply_fd, unsigned long long offset, int reply_fd,
struct aio_context *aio) struct aio_context *aio)
{ {
aio->reply_fd = reply_fd; aio->reply_fd = reply_fd;
if(aio_24) if(aio_24)
return submit_aio_24(type, io_fd, buf, len, offset, aio); return submit_aio_24(type, io_fd, buf, len, offset, aio);
else { else {
return submit_aio_26(type, io_fd, buf, len, offset, aio); return submit_aio_26(type, io_fd, buf, len, offset, aio);
} }
} }