Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

49 files changed, 10430 insertions, 0 deletions

diff --git a/arch/um/drivers/Makefile b/arch/um/drivers/Makefile
new file mode 100644
index 000000000000..323f72c64cd2
--- /dev/null
+++ b/arch/um/drivers/Makefile
@@ -0,0 +1,46 @@
+# 
+# Copyright (C) 2000, 2002, 2003 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+# pcap is broken in 2.5 because kbuild doesn't allow pcap.a to be linked
+# in to pcap.o
+
+slip-objs := slip_kern.o slip_user.o
+slirp-objs := slirp_kern.o slirp_user.o
+daemon-objs := daemon_kern.o daemon_user.o
+mcast-objs := mcast_kern.o mcast_user.o
+#pcap-objs := pcap_kern.o pcap_user.o $(PCAP)
+net-objs := net_kern.o net_user.o
+mconsole-objs := mconsole_kern.o mconsole_user.o
+hostaudio-objs := hostaudio_kern.o
+ubd-objs := ubd_kern.o ubd_user.o
+port-objs := port_kern.o port_user.o
+harddog-objs := harddog_kern.o harddog_user.o
+
+obj-y := stdio_console.o fd.o chan_kern.o chan_user.o line.o
+obj-$(CONFIG_SSL) += ssl.o
+obj-$(CONFIG_STDERR_CONSOLE) += stderr_console.o
+
+obj-$(CONFIG_UML_NET_SLIP) += slip.o
+obj-$(CONFIG_UML_NET_SLIRP) += slirp.o
+obj-$(CONFIG_UML_NET_DAEMON) += daemon.o 
+obj-$(CONFIG_UML_NET_MCAST) += mcast.o 
+#obj-$(CONFIG_UML_NET_PCAP) += pcap.o $(PCAP)
+obj-$(CONFIG_UML_NET) += net.o 
+obj-$(CONFIG_MCONSOLE) += mconsole.o
+obj-$(CONFIG_MMAPPER) += mmapper_kern.o 
+obj-$(CONFIG_BLK_DEV_UBD) += ubd.o 
+obj-$(CONFIG_HOSTAUDIO) += hostaudio.o
+obj-$(CONFIG_NULL_CHAN) += null.o 
+obj-$(CONFIG_PORT_CHAN) += port.o
+obj-$(CONFIG_PTY_CHAN) += pty.o
+obj-$(CONFIG_TTY_CHAN) += tty.o 
+obj-$(CONFIG_XTERM_CHAN) += xterm.o xterm_kern.o
+obj-$(CONFIG_UML_WATCHDOG) += harddog.o
+obj-$(CONFIG_BLK_DEV_COW_COMMON) += cow_user.o
+obj-$(CONFIG_UML_RANDOM) += random.o
+
+USER_OBJS := fd.o null.o pty.o tty.o xterm.o
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
new file mode 100644
index 000000000000..1f77deb3fd23
--- /dev/null
+++ b/arch/um/drivers/chan_kern.c
@@ -0,0 +1,577 @@
+/* 
+ * 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"
+
+#ifdef CONFIG_NOCONFIG_CHAN
+static void *not_configged_init(char *str, int device, struct chan_opts *opts)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(NULL);
+}
+
+static int not_configged_open(int input, int output, int primary, void *data,
+                              char **dev_out)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-ENODEV);
+}
+
+static void not_configged_close(int fd, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+}
+
+static int not_configged_read(int fd, char *c_out, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_write(int fd, const char *buf, int len, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_console_write(int fd, const char *buf, int len,
+                                       void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_window_size(int fd, void *data, unsigned short *rows,
+                                     unsigned short *cols)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-ENODEV);
+}
+
+static void not_configged_free(void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+}
+
+static struct chan_ops not_configged_ops = {
+        .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)
+                return(0);
+        else if(n == 0)
+                return(-EIO);
+        return(n);
+}
+
+/* XXX Trivial wrapper around os_write_file */
+
+int generic_write(int fd, const char *buf, int n, void *unused)
+{
+        return(os_write_file(fd, buf, n));
+}
+
+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)
+                return(ret);
+
+        ret = ((*rows_out != rows) || (*cols_out != cols));
+
+        *rows_out = rows;
+        *cols_out = cols;
+
+        return(ret);
+}
+
+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;
+                }
+        }
+
+        if((tty->flip.flag_buf_ptr == NULL) || 
+           (tty->flip.char_buf_ptr == NULL))
+                return;
+        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+}
+
+static int open_one_chan(struct chan *chan, int input, int output, int primary)
+{
+        int fd;
+
+        if(chan->opened) return(0);
+        if(chan->ops->open == NULL) fd = 0;
+        else fd = (*chan->ops->open)(input, output, primary, chan->data,
+                                     &chan->dev);
+        if(fd < 0) return(fd);
+        chan->fd = fd;
+
+        chan->opened = 1;
+        return(0);
+}
+
+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);
+                ret = open_one_chan(chan, chan->input, chan->output,
+                                    chan->primary);
+                if(chan->primary) err = ret;
+        }
+        return(err);
+}
+
+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;
+                }
+        }
+}
+
+void enable_chan(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->opened) continue;
+
+                line_setup_irq(chan->fd, chan->input, chan->output, tty);
+        }
+}
+
+void close_chan(struct list_head *chans)
+{
+        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) {
+                if(!chan->opened) continue;
+                if(chan->ops->close != NULL)
+                        (*chan->ops->close)(chan->fd, chan->data);
+                chan->opened = 0;
+                chan->fd = -1;
+        }
+}
+
+int write_chan(struct list_head *chans, const char *buf, int len, 
+               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);
+                }
+        }
+        return(ret);
+}
+
+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;
+                n = chan->ops->console_write(chan->fd, buf, len, chan->data);
+                if(chan->primary) ret = n;
+        }
+        return(ret);
+}
+
+int console_open_chan(struct line *line, struct console *co, struct chan_opts *opts)
+{
+        if (!list_empty(&line->chan_list))
+                return 0;
+
+        if (0 != parse_chan_pair(line->init_str, &line->chan_list,
+                                 line->init_pri, co->index, opts))
+                return -1;
+        if (0 != open_chan(&line->chan_list))
+                return -1;
+        printk("Console initialized on /dev/%s%d\n",co->name,co->index);
+        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){
+                        if(chan->ops->window_size == NULL) return(0);
+                        return(chan->ops->window_size(chan->fd, chan->data,
+                                                      rows_out, cols_out));
+                }
+        }
+        return(0);
+}
+
+void free_one_chan(struct chan *chan)
+{
+        list_del(&chan->list);
+        if(chan->ops->free != NULL)
+                (*chan->ops->free)(chan->data);
+        free_irq_by_fd(chan->fd);
+        if(chan->primary && chan->output) ignore_sigio_fd(chan->fd);
+        kfree(chan);
+}
+
+void free_chan(struct list_head *chans)
+{
+        struct list_head *ele, *next;
+        struct chan *chan;
+
+        list_for_each_safe(ele, next, chans){
+                chan = list_entry(ele, struct chan, list);
+                free_one_chan(chan);
+        }
+}
+
+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);
+                return(n);
+        }
+
+        CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
+
+        if(chan->dev == NULL){
+                CONFIG_CHUNK(str, size, n, "", 1);
+                return(n);
+        }
+
+        CONFIG_CHUNK(str, size, n, ":", 0);
+        CONFIG_CHUNK(str, size, n, chan->dev, 0);
+
+        return(n);
+}
+
+static int chan_pair_config_string(struct chan *in, struct chan *out, 
+                                   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);
+                return(n);
+        }
+
+        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);
+
+        return(n);
+}
+
+int chan_config_string(struct list_head *chans, char *str, int size, 
+                       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;
+        }
+
+        return(chan_pair_config_string(in, out, str, size, error_out));
+}
+
+struct chan_type {
+        char *key;
+        struct chan_ops *ops;
+};
+
+struct chan_type chan_table[] = {
+        { "fd", &fd_ops },
+
+#ifdef CONFIG_NULL_CHAN
+        { "null", &null_ops },
+#else
+        { "null", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_PORT_CHAN
+        { "port", &port_ops },
+#else
+        { "port", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_PTY_CHAN
+        { "pty", &pty_ops },
+        { "pts", &pts_ops },
+#else
+        { "pty", &not_configged_ops },
+        { "pts", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_TTY_CHAN
+        { "tty", &tty_ops },
+#else
+        { "tty", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_XTERM_CHAN
+        { "xterm", &xterm_ops },
+#else
+        { "xterm", &not_configged_ops },
+#endif
+};
+
+static struct chan *parse_chan(char *str, int pri, int device, 
+                               struct chan_opts *opts)
+{
+        struct chan_type *entry;
+        struct chan_ops *ops;
+        struct chan *chan;
+        void *data;
+        int i;
+
+        ops = NULL;
+        data = NULL;
+        for(i = 0; i < sizeof(chan_table)/sizeof(chan_table[0]); i++){
+                entry = &chan_table[i];
+                if(!strncmp(str, entry->key, strlen(entry->key))){
+                        ops = entry->ops;
+                        str += strlen(entry->key);
+                        break;
+                }
+        }
+        if(ops == NULL){
+                printk(KERN_ERR "parse_chan couldn't parse \"%s\"\n", 
+                       str);
+                return(NULL);
+        }
+        if(ops->init == NULL) return(NULL); 
+        data = (*ops->init)(str, device, opts);
+        if(data == NULL) return(NULL);
+
+        chan = kmalloc(sizeof(*chan), GFP_KERNEL);
+        if(chan == NULL) return(NULL);
+        *chan = ((struct chan) { .list          = LIST_HEAD_INIT(chan->list),
+                                 .primary       = 1,
+                                 .input         = 0,
+                                 .output        = 0,
+                                 .opened        = 0,
+                                 .fd            = -1,
+                                 .pri           = pri,
+                                 .ops           = ops,
+                                 .data          = data });
+        return(chan);
+}
+
+int parse_chan_pair(char *str, struct list_head *chans, int pri, int device,
+                    struct chan_opts *opts)
+{
+        struct chan *new, *chan;
+        char *in, *out;
+
+        if(!list_empty(chans)){
+                chan = list_entry(chans->next, struct chan, list);
+                if(chan->pri >= pri) return(0);
+                free_chan(chans);
+                INIT_LIST_HEAD(chans);
+        }
+
+        out = strchr(str, ',');
+        if(out != NULL){
+                in = str;
+                *out = '\0';
+                out++;
+                new = parse_chan(in, pri, device, opts);
+                if(new == NULL) return(-1);
+                new->input = 1;
+                list_add(&new->list, chans);
+
+                new = parse_chan(out, pri, device, opts);
+                if(new == NULL) return(-1);
+                list_add(&new->list, chans);
+                new->output = 1;
+        }
+        else {
+                new = parse_chan(str, pri, device, opts);
+                if(new == NULL) return(-1);
+                list_add(&new->list, chans);
+                new->input = 1;
+                new->output = 1;
+        }
+        return(0);
+}
+
+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)
+                        return(chan->fd);
+        }
+        return(-1);
+}
+
+void chan_interrupt(struct list_head *chans, struct work_struct *task,
+                    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 {
+                        if((tty != NULL) && 
+                           (tty->flip.count >= TTY_FLIPBUF_SIZE)){
+                                schedule_work(task);
+                                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);
+                                line_disable(tty, irq);
+                                close_chan(chans);
+                                free_chan(chans);
+                                return;
+                        }
+                        else {
+                                if(chan->ops->close != NULL)
+                                        chan->ops->close(chan->fd, chan->data);
+                                free_one_chan(chan);
+                        }
+                }
+        }
+ out:
+        if(tty) tty_flip_buffer_push(tty);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
new file mode 100644
index 000000000000..583b8e137c33
--- /dev/null
+++ b/arch/um/drivers/chan_user.c
@@ -0,0 +1,210 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <termios.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include "kern_util.h"
+#include "user_util.h"
+#include "chan_user.h"
+#include "user.h"
+#include "helper.h"
+#include "os.h"
+#include "choose-mode.h"
+#include "mode.h"
+
+int generic_console_write(int fd, const char *buf, int n, void *unused)
+{
+        struct termios save, new;
+        int err;
+
+        if(isatty(fd)){
+                CATCH_EINTR(err = tcgetattr(fd, &save));
+                if (err)
+                        goto error;
+                new = save;
+                /* The terminal becomes a bit less raw, to handle \n also as
+                 * "Carriage Return", not only as "New Line". Otherwise, the new
+                 * line won't start at the first column.*/
+                new.c_oflag |= OPOST;
+                CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &new));
+                if (err)
+                        goto error;
+        }
+        err = generic_write(fd, buf, n, NULL);
+        /* Restore raw mode, in any case; we *must* ignore any error apart
+         * EINTR, except for debug.*/
+        if(isatty(fd))
+                CATCH_EINTR(tcsetattr(fd, TCSAFLUSH, &save));
+        return(err);
+error:
+        return(-errno);
+}
+
+/*
+ * UML SIGWINCH handling
+ *
+ * The point of this is to handle SIGWINCH on consoles which have host ttys and
+ * relay them inside UML to whatever might be running on the console and cares
+ * about the window size (since SIGWINCH notifies about terminal size changes).
+ *
+ * So, we have a separate thread for each host tty attached to a UML device
+ * (side-issue - I'm annoyed that one thread can't have multiple controlling
+ * ttys for purposed of handling SIGWINCH, but I imagine there are other reasons
+ * that doesn't make any sense).
+ *
+ * SIGWINCH can't be received synchronously, so you have to set up to receive it
+ * as a signal.  That being the case, if you are going to wait for it, it is
+ * convenient to sit in a pause() and wait for the signal to bounce you out of
+ * it (see below for how we make sure to exit only on SIGWINCH).
+ */
+
+static void winch_handler(int sig)
+{
+}
+
+struct winch_data {
+        int pty_fd;
+        int pipe_fd;
+        int close_me;
+};
+
+static int winch_thread(void *arg)
+{
+        struct winch_data *data = arg;
+        sigset_t sigs;
+        int pty_fd, pipe_fd;
+        int count, err;
+        char c = 1;
+
+        os_close_file(data->close_me);
+        pty_fd = data->pty_fd;
+        pipe_fd = data->pipe_fd;
+        count = os_write_file(pipe_fd, &c, sizeof(c));
+        if(count != sizeof(c))
+                printk("winch_thread : failed to write synchronization "
+                       "byte, err = %d\n", -count);
+
+        /* We are not using SIG_IGN on purpose, so don't fix it as I thought to
+         * do! If using SIG_IGN, the pause() call below would not stop on
+         * SIGWINCH. */
+
+        signal(SIGWINCH, winch_handler);
+        sigfillset(&sigs);
+        sigdelset(&sigs, SIGWINCH);
+        /* Block anything else than SIGWINCH. */
+        if(sigprocmask(SIG_SETMASK, &sigs, NULL) < 0){
+                printk("winch_thread : sigprocmask failed, errno = %d\n", 
+                       errno);
+                exit(1);
+        }
+
+        if(setsid() < 0){
+                printk("winch_thread : setsid failed, errno = %d\n", errno);
+                exit(1);
+        }
+
+        err = os_new_tty_pgrp(pty_fd, os_getpid());
+        if(err < 0){
+                printk("winch_thread : new_tty_pgrp failed, err = %d\n", -err);
+                exit(1);
+        }
+
+        /* These are synchronization calls between various UML threads on the
+         * host - since they are not different kernel threads, we cannot use
+         * kernel semaphores. We don't use SysV semaphores because they are
+         * persistant. */
+        count = os_read_file(pipe_fd, &c, sizeof(c));
+        if(count != sizeof(c))
+                printk("winch_thread : failed to read synchronization byte, "
+                       "err = %d\n", -count);
+
+        while(1){
+                /* This will be interrupted by SIGWINCH only, since other signals
+                 * are blocked.*/
+                pause();
+
+                count = os_write_file(pipe_fd, &c, sizeof(c));
+                if(count != sizeof(c))
+                        printk("winch_thread : write failed, err = %d\n",
+                               -count);
+        }
+}
+
+static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out)
+{
+        struct winch_data data;
+        unsigned long stack;
+        int fds[2], pid, n, err;
+        char c;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("winch_tramp : os_pipe failed, err = %d\n", -err);
+                return(err);
+        }
+
+        data = ((struct winch_data) { .pty_fd           = fd,
+                                      .pipe_fd          = fds[1],
+                                      .close_me         = fds[0] } );
+        pid = run_helper_thread(winch_thread, &data, 0, &stack, 0);
+        if(pid < 0){
+                printk("fork of winch_thread failed - errno = %d\n", errno);
+                return(pid);
+        }
+
+        os_close_file(fds[1]);
+        *fd_out = fds[0];
+        n = os_read_file(fds[0], &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("winch_tramp : failed to read synchronization byte\n");
+                printk("read failed, err = %d\n", -n);
+                printk("fd %d will not support SIGWINCH\n", fd);
+                *fd_out = -1;
+        }
+        return(pid);
+}
+
+void register_winch(int fd, struct tty_struct *tty)
+{
+        int pid, thread, thread_fd;
+        int count;
+        char c = 1;
+
+        if(!isatty(fd))
+                return;
+
+        pid = tcgetpgrp(fd);
+        if(!CHOOSE_MODE_PROC(is_tracer_winch, is_skas_winch, pid, fd,
+                             tty) && (pid == -1)){
+                thread = winch_tramp(fd, tty, &thread_fd);
+                if(fd != -1){
+                        register_winch_irq(thread_fd, fd, thread, tty);
+
+                        count = os_write_file(thread_fd, &c, sizeof(c));
+                        if(count != sizeof(c))
+                                printk("register_winch : failed to write "
+                                       "synchronization byte, err = %d\n",
+                                        -count);
+                }
+        }
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/cow.h b/arch/um/drivers/cow.h
new file mode 100644
index 000000000000..4fcbe8b1b77e
--- /dev/null
+++ b/arch/um/drivers/cow.h
@@ -0,0 +1,42 @@
+#ifndef __COW_H__
+#define __COW_H__
+
+#include <asm/types.h>
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+# define ntohll(x) (x)
+# define htonll(x) (x)
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+# define ntohll(x)  bswap_64(x)
+# define htonll(x)  bswap_64(x)
+#else
+#error "__BYTE_ORDER not defined"
+#endif
+
+extern int init_cow_file(int fd, char *cow_file, char *backing_file,
+                         int sectorsize, int alignment, int *bitmap_offset_out,
+                         unsigned long *bitmap_len_out, int *data_offset_out);
+
+extern int file_reader(__u64 offset, char *buf, int len, void *arg);
+extern int read_cow_header(int (*reader)(__u64, char *, int, void *),
+                           void *arg, __u32 *version_out,
+                           char **backing_file_out, time_t *mtime_out,
+                           unsigned long long *size_out, int *sectorsize_out,
+                           __u32 *align_out, int *bitmap_offset_out);
+
+extern int write_cow_header(char *cow_file, int fd, char *backing_file,
+                            int sectorsize, int alignment,
+                            unsigned long long *size);
+
+extern void cow_sizes(int version, __u64 size, int sectorsize, int align,
+                      int bitmap_offset, unsigned long *bitmap_len_out,
+                      int *data_offset_out);
+
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
new file mode 100644
index 000000000000..c83fc5d68936
--- /dev/null
+++ b/arch/um/drivers/cow_sys.h
@@ -0,0 +1,48 @@
+#ifndef __COW_SYS_H__
+#define __COW_SYS_H__
+
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+#include "user.h"
+
+static inline void *cow_malloc(int size)
+{
+        return(um_kmalloc(size));
+}
+
+static inline void cow_free(void *ptr)
+{
+        kfree(ptr);
+}
+
+#define cow_printf printk
+
+static inline char *cow_strdup(char *str)
+{
+        return(uml_strdup(str));
+}
+
+static inline int cow_seek_file(int fd, unsigned long long offset)
+{
+        return(os_seek_file(fd, offset));
+}
+
+static inline int cow_file_size(char *file, unsigned long long *size_out)
+{
+        return(os_file_size(file, size_out));
+}
+
+static inline int cow_write_file(int fd, char *buf, int size)
+{
+        return(os_write_file(fd, buf, size));
+}
+
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/cow_user.c b/arch/um/drivers/cow_user.c
new file mode 100644
index 000000000000..a8ce6fc3ef26
--- /dev/null
+++ b/arch/um/drivers/cow_user.c
@@ -0,0 +1,378 @@
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+/* _XOPEN_SOURCE is needed for pread, but we define _GNU_SOURCE, which defines
+ * that.
+ */
+#include <unistd.h>
+#include <byteswap.h>
+#include <sys/time.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <netinet/in.h>
+
+#include "os.h"
+
+#include "cow.h"
+#include "cow_sys.h"
+
+#define PATH_LEN_V1 256
+
+struct cow_header_v1 {
+        int magic;
+        int version;
+        char backing_file[PATH_LEN_V1];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+#define PATH_LEN_V2 MAXPATHLEN
+
+struct cow_header_v2 {
+        __u32 magic;
+        __u32 version;
+        char backing_file[PATH_LEN_V2];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+/* Define PATH_LEN_V3 as the usual value of MAXPATHLEN, just hard-code it in
+ * case other systems have different values for MAXPATHLEN
+ */
+#define PATH_LEN_V3 4096
+
+/* Changes from V2 -
+ *      PATH_LEN_V3 as described above
+ *      Explicitly specify field bit lengths for systems with different
+ *              lengths for the usual C types.  Not sure whether char or
+ *              time_t should be changed, this can be changed later without
+ *              breaking compatibility
+ *      Add alignment field so that different alignments can be used for the
+ *              bitmap and data
+ *      Add cow_format field to allow for the possibility of different ways
+ *              of specifying the COW blocks.  For now, the only value is 0,
+ *              for the traditional COW bitmap.
+ *      Move the backing_file field to the end of the header.  This allows
+ *              for the possibility of expanding it into the padding required
+ *              by the bitmap alignment.
+ *      The bitmap and data portions of the file will be aligned as specified
+ *              by the alignment field.  This is to allow COW files to be
+ *              put on devices with restrictions on access alignments, such as
+ *              /dev/raw, with a 512 byte alignment restriction.  This also
+ *              allows the data to be more aligned more strictly than on
+ *              sector boundaries.  This is needed for ubd-mmap, which needs
+ *              the data to be page aligned.
+ *      Fixed (finally!) the rounding bug
+ */
+
+struct cow_header_v3 {
+        __u32 magic;
+        __u32 version;
+        __u32 mtime;
+        __u64 size;
+        __u32 sectorsize;
+        __u32 alignment;
+        __u32 cow_format;
+        char backing_file[PATH_LEN_V3];
+};
+
+/* COW format definitions - for now, we have only the usual COW bitmap */
+#define COW_BITMAP 0
+
+union cow_header {
+        struct cow_header_v1 v1;
+        struct cow_header_v2 v2;
+        struct cow_header_v3 v3;
+};
+
+#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
+#define COW_VERSION 3
+
+#define DIV_ROUND(x, len) (((x) + (len) - 1) / (len))
+#define ROUND_UP(x, align) DIV_ROUND(x, align) * (align)
+
+void cow_sizes(int version, __u64 size, int sectorsize, int align,
+               int bitmap_offset, unsigned long *bitmap_len_out,
+               int *data_offset_out)
+{
+        if(version < 3){
+                *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = (*data_offset_out + sectorsize - 1) /
+                        sectorsize;
+                *data_offset_out *= sectorsize;
+        }
+        else {
+                *bitmap_len_out = DIV_ROUND(size, sectorsize);
+                *bitmap_len_out = DIV_ROUND(*bitmap_len_out, 8);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = ROUND_UP(*data_offset_out, align);
+        }
+}
+
+static int absolutize(char *to, int size, char *from)
+{
+        char save_cwd[256], *slash;
+        int remaining;
+
+        if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) {
+                cow_printf("absolutize : unable to get cwd - errno = %d\n",
+                           errno);
+                return(-1);
+        }
+        slash = strrchr(from, '/');
+        if(slash != NULL){
+                *slash = '\0';
+                if(chdir(from)){
+                        *slash = '/';
+                        cow_printf("absolutize : Can't cd to '%s' - "
+                                   "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                *slash = '/';
+                if(getcwd(to, size) == NULL){
+                        cow_printf("absolutize : unable to get cwd of '%s' - "
+                               "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                remaining = size - strlen(to);
+                if(strlen(slash) + 1 > remaining){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcat(to, slash);
+        }
+        else {
+                if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcpy(to, save_cwd);
+                strcat(to, "/");
+                strcat(to, from);
+        }
+        chdir(save_cwd);
+        return(0);
+}
+
+int write_cow_header(char *cow_file, int fd, char *backing_file,
+                     int sectorsize, int alignment, unsigned long long *size)
+{
+        struct cow_header_v3 *header;
+        unsigned long modtime;
+        int err;
+
+        err = cow_seek_file(fd, 0);
+        if(err < 0){
+                cow_printf("write_cow_header - lseek failed, err = %d\n", -err);
+                goto out;
+        }
+
+        err = -ENOMEM;
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("Failed to allocate COW V3 header\n");
+                goto out;
+        }
+        header->magic = htonl(COW_MAGIC);
+        header->version = htonl(COW_VERSION);
+
+        err = -EINVAL;
+        if(strlen(backing_file) > sizeof(header->backing_file) - 1){
+                cow_printf("Backing file name \"%s\" is too long - names are "
+                           "limited to %d characters\n", backing_file,
+                           sizeof(header->backing_file) - 1);
+                goto out_free;
+        }
+
+        if(absolutize(header->backing_file, sizeof(header->backing_file),
+                      backing_file))
+                goto out_free;
+
+        err = os_file_modtime(header->backing_file, &modtime);
+        if(err < 0){
+                cow_printf("Backing file '%s' mtime request failed, "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        err = cow_file_size(header->backing_file, size);
+        if(err < 0){
+                cow_printf("Couldn't get size of backing file '%s', "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        header->mtime = htonl(modtime);
+        header->size = htonll(*size);
+        header->sectorsize = htonl(sectorsize);
+        header->alignment = htonl(alignment);
+        header->cow_format = COW_BITMAP;
+
+        err = os_write_file(fd, header, sizeof(*header));
+        if(err != sizeof(*header)){
+                cow_printf("Write of header to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                goto out_free;
+        }
+        err = 0;
+ out_free:
+        cow_free(header);
+ out:
+        return(err);
+}
+
+int file_reader(__u64 offset, char *buf, int len, void *arg)
+{
+        int fd = *((int *) arg);
+
+        return(pread(fd, buf, len, offset));
+}
+
+/* XXX Need to sanity-check the values read from the header */
+
+int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
+                    __u32 *version_out, char **backing_file_out,
+                    time_t *mtime_out, unsigned long long *size_out,
+                    int *sectorsize_out, __u32 *align_out,
+                    int *bitmap_offset_out)
+{
+        union cow_header *header;
+        char *file;
+        int err, n;
+        unsigned long version, magic;
+
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("read_cow_header - Failed to allocate header\n");
+                return(-ENOMEM);
+        }
+        err = -EINVAL;
+        n = (*reader)(0, (char *) header, sizeof(*header), arg);
+        if(n < offsetof(typeof(header->v1), backing_file)){
+                cow_printf("read_cow_header - short header\n");
+                goto out;
+        }
+
+        magic = header->v1.magic;
+        if(magic == COW_MAGIC) {
+                version = header->v1.version;
+        }
+        else if(magic == ntohl(COW_MAGIC)){
+                version = ntohl(header->v1.version);
+        }
+        /* No error printed because the non-COW case comes through here */
+        else goto out;
+
+        *version_out = version;
+
+        if(version == 1){
+                if(n < sizeof(header->v1)){
+                        cow_printf("read_cow_header - failed to read V1 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = header->v1.mtime;
+                *size_out = header->v1.size;
+                *sectorsize_out = header->v1.sectorsize;
+                *bitmap_offset_out = sizeof(header->v1);
+                *align_out = *sectorsize_out;
+                file = header->v1.backing_file;
+        }
+        else if(version == 2){
+                if(n < sizeof(header->v2)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v2.mtime);
+                *size_out = ntohll(header->v2.size);
+                *sectorsize_out = ntohl(header->v2.sectorsize);
+                *bitmap_offset_out = sizeof(header->v2);
+                *align_out = *sectorsize_out;
+                file = header->v2.backing_file;
+        }
+        else if(version == 3){
+                if(n < sizeof(header->v3)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v3.mtime);
+                *size_out = ntohll(header->v3.size);
+                *sectorsize_out = ntohl(header->v3.sectorsize);
+                *align_out = ntohl(header->v3.alignment);
+                *bitmap_offset_out = ROUND_UP(sizeof(header->v3), *align_out);
+                file = header->v3.backing_file;
+        }
+        else {
+                cow_printf("read_cow_header - invalid COW version\n");
+                goto out;
+        }
+        err = -ENOMEM;
+        *backing_file_out = cow_strdup(file);
+        if(*backing_file_out == NULL){
+                cow_printf("read_cow_header - failed to allocate backing "
+                           "file\n");
+                goto out;
+        }
+        err = 0;
+ out:
+        cow_free(header);
+        return(err);
+}
+
+int init_cow_file(int fd, char *cow_file, char *backing_file, int sectorsize,
+                  int alignment, int *bitmap_offset_out,
+                  unsigned long *bitmap_len_out, int *data_offset_out)
+{
+        unsigned long long size, offset;
+        char zero = 0;
+        int err;
+
+        err = write_cow_header(cow_file, fd, backing_file, sectorsize,
+                               alignment, &size);
+        if(err)
+                goto out;
+
+        *bitmap_offset_out = ROUND_UP(sizeof(struct cow_header_v3), alignment);
+        cow_sizes(COW_VERSION, size, sectorsize, alignment, *bitmap_offset_out,
+                  bitmap_len_out, data_offset_out);
+
+        offset = *data_offset_out + size - sizeof(zero);
+        err = cow_seek_file(fd, offset);
+        if(err < 0){
+                cow_printf("cow bitmap lseek failed : err = %d\n", -err);
+                goto out;
+        }
+
+        /* does not really matter how much we write it is just to set EOF
+         * this also sets the entire COW bitmap
+         * to zero without having to allocate it
+         */
+        err = cow_write_file(fd, &zero, sizeof(zero));
+        if(err != sizeof(zero)){
+                cow_printf("Write of bitmap to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                err = -EINVAL;
+                goto out;
+        }
+
+        return(0);
+
+ out:
+        return(err);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/daemon.h b/arch/um/drivers/daemon.h
new file mode 100644
index 000000000000..7326c42f7ef9
--- /dev/null
+++ b/arch/um/drivers/daemon.h
@@ -0,0 +1,35 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+#define SWITCH_VERSION 3
+
+struct daemon_data {
+        char *sock_type;
+        char *ctl_sock;
+        void *ctl_addr;
+        void *data_addr;
+        void *local_addr;
+        int fd;
+        int control;
+        void *dev;
+};
+
+extern struct net_user_info daemon_user_info;
+
+extern int daemon_user_write(int fd, void *buf, int len, 
+                             struct daemon_data *pri);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/daemon_kern.c b/arch/um/drivers/daemon_kern.c
new file mode 100644
index 000000000000..30d285b266af
--- /dev/null
+++ b/arch/um/drivers/daemon_kern.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include "linux/kernel.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "daemon.h"
+
+struct daemon_init {
+        char *sock_type;
+        char *ctl_sock;
+};
+
+void daemon_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct daemon_data *dpri;
+        struct daemon_init *init = data;
+
+        pri = dev->priv;
+        dpri = (struct daemon_data *) pri->user;
+        dpri->sock_type = init->sock_type;
+        dpri->ctl_sock = init->ctl_sock;
+        dpri->fd = -1;
+        dpri->control = -1;
+        dpri->dev = dev;
+
+        printk("daemon backend (uml_switch version %d) - %s:%s", 
+               SWITCH_VERSION, dpri->sock_type, dpri->ctl_sock);
+        printk("\n");
+}
+
+static int daemon_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(net_recvfrom(fd, (*skb)->mac.raw, 
+                            (*skb)->dev->mtu + ETH_HEADER_OTHER));
+}
+
+static int daemon_write(int fd, struct sk_buff **skb,
+                        struct uml_net_private *lp)
+{
+        return(daemon_user_write(fd, (*skb)->data, (*skb)->len, 
+                                 (struct daemon_data *) &lp->user));
+}
+
+static struct net_kern_info daemon_kern_info = {
+        .init                   = daemon_init,
+        .protocol               = eth_protocol,
+        .read                   = daemon_read,
+        .write                  = daemon_write,
+};
+
+int daemon_setup(char *str, char **mac_out, void *data)
+{
+        struct daemon_init *init = data;
+        char *remain;
+
+        *init = ((struct daemon_init)
+                { .sock_type            = "unix",
+                  .ctl_sock             = "/tmp/uml.ctl" });
+        
+        remain = split_if_spec(str, mac_out, &init->sock_type, &init->ctl_sock,
+                               NULL);
+        if(remain != NULL)
+                printk(KERN_WARNING "daemon_setup : Ignoring data socket "
+                       "specification\n");
+        
+        return(1);
+}
+
+static struct transport daemon_transport = {
+        .list           = LIST_HEAD_INIT(daemon_transport.list),
+        .name           = "daemon",
+        .setup          = daemon_setup,
+        .user           = &daemon_user_info,
+        .kern           = &daemon_kern_info,
+        .private_size   = sizeof(struct daemon_data),
+        .setup_size     = sizeof(struct daemon_init),
+};
+
+static int register_daemon(void)
+{
+        register_transport(&daemon_transport);
+        return(1);
+}
+
+__initcall(register_daemon);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
new file mode 100644
index 000000000000..cf15b4a8b517
--- /dev/null
+++ b/arch/um/drivers/daemon_user.c
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/time.h>
+#include "net_user.h"
+#include "daemon.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+enum request_type { REQ_NEW_CONTROL };
+
+#define SWITCH_MAGIC 0xfeedface
+
+struct request_v3 {
+        uint32_t magic;
+        uint32_t version;
+        enum request_type type;
+        struct sockaddr_un sock;
+};
+
+static struct sockaddr_un *new_addr(void *name, int len)
+{
+        struct sockaddr_un *sun;
+
+        sun = um_kmalloc(sizeof(struct sockaddr_un));
+        if(sun == NULL){
+                printk("new_addr: allocation of sockaddr_un failed\n");
+                return(NULL);
+        }
+        sun->sun_family = AF_UNIX;
+        memcpy(sun->sun_path, name, len);
+        return(sun);
+}
+
+static int connect_to_switch(struct daemon_data *pri)
+{
+        struct sockaddr_un *ctl_addr = pri->ctl_addr;
+        struct sockaddr_un *local_addr = pri->local_addr;
+        struct sockaddr_un *sun;
+        struct request_v3 req;
+        int fd, n, err;
+
+        pri->control = socket(AF_UNIX, SOCK_STREAM, 0);
+        if(pri->control < 0){
+                printk("daemon_open : control socket failed, errno = %d\n", 
+                       errno);          
+                return(-errno);
+        }
+
+        if(connect(pri->control, (struct sockaddr *) ctl_addr, 
+                   sizeof(*ctl_addr)) < 0){
+                printk("daemon_open : control connect failed, errno = %d\n",
+                       errno);
+                err = -errno;
+                goto out;
+        }
+
+        fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+        if(fd < 0){
+                printk("daemon_open : data socket failed, errno = %d\n", 
+                       errno);
+                err = -errno;
+                goto out;
+        }
+        if(bind(fd, (struct sockaddr *) local_addr, sizeof(*local_addr)) < 0){
+                printk("daemon_open : data bind failed, errno = %d\n", 
+                       errno);
+                err = -errno;
+                goto out_close;
+        }
+
+        sun = um_kmalloc(sizeof(struct sockaddr_un));
+        if(sun == NULL){
+                printk("new_addr: allocation of sockaddr_un failed\n");
+                err = -ENOMEM;
+                goto out_close;
+        }
+
+        req.magic = SWITCH_MAGIC;
+        req.version = SWITCH_VERSION;
+        req.type = REQ_NEW_CONTROL;
+        req.sock = *local_addr;
+        n = os_write_file(pri->control, &req, sizeof(req));
+        if(n != sizeof(req)){
+                printk("daemon_open : control setup request failed, err = %d\n",
+                       -n);
+                err = -ENOTCONN;
+                goto out;               
+        }
+
+        n = os_read_file(pri->control, sun, sizeof(*sun));
+        if(n != sizeof(*sun)){
+                printk("daemon_open : read of data socket failed, err = %d\n",
+                       -n);
+                err = -ENOTCONN;
+                goto out_close;         
+        }
+
+        pri->data_addr = sun;
+        return(fd);
+
+ out_close:
+        os_close_file(fd);
+ out:
+        os_close_file(pri->control);
+        return(err);
+}
+
+static void daemon_user_init(void *data, void *dev)
+{
+        struct daemon_data *pri = data;
+        struct timeval tv;
+        struct {
+                char zero;
+                int pid;
+                int usecs;
+        } name;
+
+        if(!strcmp(pri->sock_type, "unix"))
+                pri->ctl_addr = new_addr(pri->ctl_sock, 
+                                         strlen(pri->ctl_sock) + 1);
+        name.zero = 0;
+        name.pid = os_getpid();
+        gettimeofday(&tv, NULL);
+        name.usecs = tv.tv_usec;
+        pri->local_addr = new_addr(&name, sizeof(name));
+        pri->dev = dev;
+        pri->fd = connect_to_switch(pri);
+        if(pri->fd < 0){
+                kfree(pri->local_addr);
+                pri->local_addr = NULL;
+        }
+}
+
+static int daemon_open(void *data)
+{
+        struct daemon_data *pri = data;
+        return(pri->fd);
+}
+
+static void daemon_remove(void *data)
+{
+        struct daemon_data *pri = data;
+
+        os_close_file(pri->fd);
+        os_close_file(pri->control);
+        if(pri->data_addr != NULL) kfree(pri->data_addr);
+        if(pri->ctl_addr != NULL) kfree(pri->ctl_addr);
+        if(pri->local_addr != NULL) kfree(pri->local_addr);
+}
+
+int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
+{
+        struct sockaddr_un *data_addr = pri->data_addr;
+
+        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+}
+
+static int daemon_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info daemon_user_info = {
+        .init           = daemon_user_init,
+        .open           = daemon_open,
+        .close          = NULL,
+        .remove         = daemon_remove,
+        .set_mtu        = daemon_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
new file mode 100644
index 000000000000..f0b888f66e05
--- /dev/null
+++ b/arch/um/drivers/fd.c
@@ -0,0 +1,108 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <termios.h>
+#include <errno.h>
+#include "user.h"
+#include "user_util.h"
+#include "chan_user.h"
+
+struct fd_chan {
+        int fd;
+        int raw;
+        struct termios tt;
+        char str[sizeof("1234567890\0")];
+};
+
+static void *fd_init(char *str, int device, struct chan_opts *opts)
+{
+        struct fd_chan *data;
+        char *end;
+        int n;
+
+        if(*str != ':'){
+                printk("fd_init : channel type 'fd' must specify a file "
+                       "descriptor\n");
+                return(NULL);
+        }
+        str++;
+        n = strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str)){
+                printk("fd_init : couldn't parse file descriptor '%s'\n", str);
+                return(NULL);
+        }
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct fd_chan) { .fd         = n,
+                                    .raw        = opts->raw });
+        return(data);
+}
+
+static int fd_open(int input, int output, int primary, void *d, char **dev_out)
+{
+        struct fd_chan *data = d;
+        int err;
+
+        if(data->raw && isatty(data->fd)){
+                CATCH_EINTR(err = tcgetattr(data->fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(data->fd);
+                if(err)
+                        return(err);
+        }
+        sprintf(data->str, "%d", data->fd);
+        *dev_out = data->str;
+        return(data->fd);
+}
+
+static void fd_close(int fd, void *d)
+{
+        struct fd_chan *data = d;
+        int err;
+
+        if(data->raw && isatty(fd)){
+                CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &data->tt));
+                if(err)
+                        printk("Failed to restore terminal state - "
+                               "errno = %d\n", -err);
+                data->raw = 0;
+        }
+}
+
+static int fd_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct fd_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops fd_ops = {
+        .type           = "fd",
+        .init           = fd_init,
+        .open           = fd_open,
+        .close          = fd_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = fd_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 1,
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/harddog_kern.c b/arch/um/drivers/harddog_kern.c
new file mode 100644
index 000000000000..147ec19f6bb9
--- /dev/null
+++ b/arch/um/drivers/harddog_kern.c
@@ -0,0 +1,190 @@
+/* UML hardware watchdog, shamelessly stolen from:
+ *
+ *      SoftDog 0.05:   A Software Watchdog Device
+ *
+ *      (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
+ *                              http://www.redhat.com
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *      
+ *      Neither Alan Cox nor CymruNet Ltd. admit liability nor provide 
+ *      warranty for any of this software. This material is provided 
+ *      "AS-IS" and at no charge.       
+ *
+ *      (c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
+ *
+ *      Software only watchdog driver. Unlike its big brother the WDT501P
+ *      driver this won't always recover a failed machine.
+ *
+ *  03/96: Angelo Haritsis <ah@doc.ic.ac.uk> :
+ *      Modularised.
+ *      Added soft_margin; use upon insmod to change the timer delay.
+ *      NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
+ *          minors.
+ *
+ *  19980911 Alan Cox
+ *      Made SMP safe for 2.3.x
+ *
+ *  20011127 Joel Becker (jlbec@evilplan.org>
+ *      Added soft_noboot; Allows testing the softdog trigger without 
+ *      requiring a recompile.
+ *      Added WDIOC_GETTIMEOUT and WDIOC_SETTIMOUT.
+ */
+ 
+#include <linux/module.h>
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/reboot.h>
+#include <linux/smp_lock.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include "helper.h"
+#include "mconsole.h"
+
+MODULE_LICENSE("GPL");
+
+/* Locked by the BKL in harddog_open and harddog_release */
+static int timer_alive;
+static int harddog_in_fd = -1;
+static int harddog_out_fd = -1;
+
+/*
+ *      Allow only one person to hold it open
+ */
+ 
+extern int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock);
+
+static int harddog_open(struct inode *inode, struct file *file)
+{
+        int err;
+        char *sock = NULL;
+
+        lock_kernel();
+        if(timer_alive)
+                return -EBUSY;
+#ifdef CONFIG_HARDDOG_NOWAYOUT   
+        __module_get(THIS_MODULE);
+#endif
+
+#ifdef CONFIG_MCONSOLE
+        sock = mconsole_notify_socket();
+#endif
+        err = start_watchdog(&harddog_in_fd, &harddog_out_fd, sock);
+        if(err) return(err);
+
+        timer_alive = 1;
+        unlock_kernel();
+        return nonseekable_open(inode, file);
+}
+
+extern void stop_watchdog(int in_fd, int out_fd);
+
+static int harddog_release(struct inode *inode, struct file *file)
+{
+        /*
+         *      Shut off the timer.
+         */
+        lock_kernel();
+
+        stop_watchdog(harddog_in_fd, harddog_out_fd);
+        harddog_in_fd = -1;
+        harddog_out_fd = -1;
+
+        timer_alive=0;
+        unlock_kernel();
+        return 0;
+}
+
+extern int ping_watchdog(int fd);
+
+static ssize_t harddog_write(struct file *file, const char *data, size_t len,
+                             loff_t *ppos)
+{
+        /*
+         *      Refresh the timer.
+         */
+        if(len)
+                return(ping_watchdog(harddog_out_fd));
+        return 0;
+}
+
+static int harddog_ioctl(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg)
+{
+        static struct watchdog_info ident = {
+                WDIOC_SETTIMEOUT,
+                0,
+                "UML Hardware Watchdog"
+        };
+        switch (cmd) {
+                default:
+                        return -ENOTTY;
+                case WDIOC_GETSUPPORT:
+                        if(copy_to_user((struct harddog_info *)arg, &ident,
+                                        sizeof(ident)))
+                                return -EFAULT;
+                        return 0;
+                case WDIOC_GETSTATUS:
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0,(int *)arg);
+                case WDIOC_KEEPALIVE:
+                        return(ping_watchdog(harddog_out_fd));
+        }
+}
+
+static struct file_operations harddog_fops = {
+        .owner          = THIS_MODULE,
+        .write          = harddog_write,
+        .ioctl          = harddog_ioctl,
+        .open           = harddog_open,
+        .release        = harddog_release,
+};
+
+static struct miscdevice harddog_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &harddog_fops,
+};
+
+static char banner[] __initdata = KERN_INFO "UML Watchdog Timer\n";
+
+static int __init harddog_init(void)
+{
+        int ret;
+
+        ret = misc_register(&harddog_miscdev);
+
+        if (ret)
+                return ret;
+
+        printk(banner);
+
+        return(0);
+}
+
+static void __exit harddog_exit(void)
+{
+        misc_deregister(&harddog_miscdev);
+}
+
+module_init(harddog_init);
+module_exit(harddog_exit);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/harddog_user.c b/arch/um/drivers/harddog_user.c
new file mode 100644
index 000000000000..d934181b8d4c
--- /dev/null
+++ b/arch/um/drivers/harddog_user.c
@@ -0,0 +1,143 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include "user_util.h"
+#include "user.h"
+#include "helper.h"
+#include "mconsole.h"
+#include "os.h"
+#include "choose-mode.h"
+#include "mode.h"
+
+struct dog_data {
+        int stdin;
+        int stdout;
+        int close_me[2];
+};
+
+static void pre_exec(void *d)
+{
+        struct dog_data *data = d;
+
+        dup2(data->stdin, 0);
+        dup2(data->stdout, 1);
+        dup2(data->stdout, 2);
+        os_close_file(data->stdin);
+        os_close_file(data->stdout);
+        os_close_file(data->close_me[0]);
+        os_close_file(data->close_me[1]);
+}
+
+int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock)
+{
+        struct dog_data data;
+        int in_fds[2], out_fds[2], pid, n, err;
+        char pid_buf[sizeof("nnnnn\0")], c;
+        char *pid_args[] = { "/usr/bin/uml_watchdog", "-pid", pid_buf, NULL };
+        char *mconsole_args[] = { "/usr/bin/uml_watchdog", "-mconsole", NULL, 
+                                  NULL };
+        char **args = NULL;
+
+        err = os_pipe(in_fds, 1, 0);
+        if(err < 0){
+                printk("harddog_open - os_pipe failed, err = %d\n", -err);
+                goto out;
+        }
+
+        err = os_pipe(out_fds, 1, 0);
+        if(err < 0){
+                printk("harddog_open - os_pipe failed, err = %d\n", -err);
+                goto out_close_in;
+        }
+
+        data.stdin = out_fds[0];
+        data.stdout = in_fds[1];
+        data.close_me[0] = out_fds[1];
+        data.close_me[1] = in_fds[0];
+
+        if(sock != NULL){
+                mconsole_args[2] = sock;
+                args = mconsole_args;
+        }
+        else {
+                /* XXX The os_getpid() is not SMP correct */
+                sprintf(pid_buf, "%d", CHOOSE_MODE(tracing_pid, os_getpid()));
+                args = pid_args;
+        }
+
+        pid = run_helper(pre_exec, &data, args, NULL);
+
+        os_close_file(out_fds[0]);
+        os_close_file(in_fds[1]);
+
+        if(pid < 0){
+                err = -pid;
+                printk("harddog_open - run_helper failed, errno = %d\n", -err);
+                goto out_close_out;
+        }
+
+        n = os_read_file(in_fds[0], &c, sizeof(c));
+        if(n == 0){
+                printk("harddog_open - EOF on watchdog pipe\n");
+                helper_wait(pid);
+                err = -EIO;
+                goto out_close_out;
+        }
+        else if(n < 0){
+                printk("harddog_open - read of watchdog pipe failed, "
+                       "err = %d\n", -n);
+                helper_wait(pid);
+                err = n;
+                goto out_close_out;
+        }
+        *in_fd_ret = in_fds[0];
+        *out_fd_ret = out_fds[1];
+        return(0);
+
+ out_close_in:
+        os_close_file(in_fds[0]);
+        os_close_file(in_fds[1]);
+ out_close_out:
+        os_close_file(out_fds[0]);
+        os_close_file(out_fds[1]);
+ out:
+        return(err);
+}
+
+void stop_watchdog(int in_fd, int out_fd)
+{
+        os_close_file(in_fd);
+        os_close_file(out_fd);
+}
+
+int ping_watchdog(int fd)
+{
+        int n;
+        char c = '\n';
+
+        n = os_write_file(fd, &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("ping_watchdog - write failed, err = %d\n", -n);
+                if(n < 0)
+                        return(n);
+                return(-EIO);
+        }
+        return 1;
+
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c
new file mode 100644
index 000000000000..d5742783e19d
--- /dev/null
+++ b/arch/um/drivers/hostaudio_kern.c
@@ -0,0 +1,352 @@
+/* 
+ * Copyright (C) 2002 Steve Schmidtke 
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/module.h"
+#include "linux/init.h"
+#include "linux/slab.h"
+#include "linux/fs.h"
+#include "linux/sound.h"
+#include "linux/soundcard.h"
+#include "asm/uaccess.h"
+#include "kern_util.h"
+#include "init.h"
+#include "os.h"
+
+struct hostaudio_state {
+  int fd;
+};
+
+struct hostmixer_state {
+  int fd;
+};
+
+#define HOSTAUDIO_DEV_DSP "/dev/sound/dsp"
+#define HOSTAUDIO_DEV_MIXER "/dev/sound/mixer"
+
+/* Only changed from linux_main at boot time */
+char *dsp = HOSTAUDIO_DEV_DSP;
+char *mixer = HOSTAUDIO_DEV_MIXER;
+
+#define DSP_HELP \
+"    This is used to specify the host dsp device to the hostaudio driver.\n" \
+"    The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"
+
+#define MIXER_HELP \
+"    This is used to specify the host mixer device to the hostaudio driver.\n"\
+"    The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"
+
+#ifndef MODULE
+static int set_dsp(char *name, int *add)
+{
+        dsp = name;
+        return(0);
+}
+
+__uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP);
+
+static int set_mixer(char *name, int *add)
+{
+        mixer = name;
+        return(0);
+}
+
+__uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP);
+
+#else /*MODULE*/
+
+MODULE_PARM(dsp, "s");
+MODULE_PARM_DESC(dsp, DSP_HELP);
+
+MODULE_PARM(mixer, "s");
+MODULE_PARM_DESC(mixer, MIXER_HELP);
+
+#endif
+
+/* /dev/dsp file operations */
+
+static ssize_t hostaudio_read(struct file *file, char *buffer, size_t count, 
+                              loff_t *ppos)
+{
+        struct hostaudio_state *state = file->private_data;
+        void *kbuf;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: read called, count = %d\n", count);
+#endif
+
+        kbuf = kmalloc(count, GFP_KERNEL);
+        if(kbuf == NULL)
+                return(-ENOMEM);
+
+        err = os_read_file(state->fd, kbuf, count);
+        if(err < 0)
+                goto out;
+
+        if(copy_to_user(buffer, kbuf, err))
+                err = -EFAULT;
+
+ out:
+        kfree(kbuf);
+        return(err);
+}
+
+static ssize_t hostaudio_write(struct file *file, const char *buffer, 
+                               size_t count, loff_t *ppos)
+{
+        struct hostaudio_state *state = file->private_data;
+        void *kbuf;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: write called, count = %d\n", count);
+#endif
+
+        kbuf = kmalloc(count, GFP_KERNEL);
+        if(kbuf == NULL)
+                return(-ENOMEM);
+
+        err = -EFAULT;
+        if(copy_from_user(kbuf, buffer, count))
+                goto out;
+
+        err = os_write_file(state->fd, kbuf, count);
+        if(err < 0)
+                goto out;
+        *ppos += err;
+
+ out:
+        kfree(kbuf);
+        return(err);
+}
+
+static unsigned int hostaudio_poll(struct file *file, 
+                                   struct poll_table_struct *wait)
+{
+        unsigned int mask = 0;
+
+#ifdef DEBUG
+        printk("hostaudio: poll called (unimplemented)\n");
+#endif
+
+        return(mask);
+}
+
+static int hostaudio_ioctl(struct inode *inode, struct file *file, 
+                           unsigned int cmd, unsigned long arg)
+{
+        struct hostaudio_state *state = file->private_data;
+        unsigned long data = 0;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: ioctl called, cmd = %u\n", cmd);
+#endif
+        switch(cmd){
+        case SNDCTL_DSP_SPEED:
+        case SNDCTL_DSP_STEREO:
+        case SNDCTL_DSP_GETBLKSIZE:
+        case SNDCTL_DSP_CHANNELS:
+        case SNDCTL_DSP_SUBDIVIDE:
+        case SNDCTL_DSP_SETFRAGMENT:
+                if(get_user(data, (int *) arg))
+                        return(-EFAULT);
+                break;
+        default:
+                break;
+        }
+
+        err = os_ioctl_generic(state->fd, cmd, (unsigned long) &data);
+
+        switch(cmd){
+        case SNDCTL_DSP_SPEED:
+        case SNDCTL_DSP_STEREO:
+        case SNDCTL_DSP_GETBLKSIZE:
+        case SNDCTL_DSP_CHANNELS:
+        case SNDCTL_DSP_SUBDIVIDE:
+        case SNDCTL_DSP_SETFRAGMENT:
+                if(put_user(data, (int *) arg))
+                        return(-EFAULT);
+                break;
+        default:
+                break;
+        }
+
+        return(err);
+}
+
+static int hostaudio_open(struct inode *inode, struct file *file)
+{
+        struct hostaudio_state *state;
+        int r = 0, w = 0;
+        int ret;
+
+#ifdef DEBUG
+        printk("hostaudio: open called (host: %s)\n", dsp);
+#endif
+
+        state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL);
+        if(state == NULL)
+                return(-ENOMEM);
+
+        if(file->f_mode & FMODE_READ) r = 1;
+        if(file->f_mode & FMODE_WRITE) w = 1;
+
+        ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
+        if(ret < 0){
+                kfree(state);
+                return(ret);
+        }
+
+        state->fd = ret;
+        file->private_data = state;
+        return(0);
+}
+
+static int hostaudio_release(struct inode *inode, struct file *file)
+{
+        struct hostaudio_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostaudio: release called\n");
+#endif
+
+                os_close_file(state->fd);
+        kfree(state);
+
+        return(0);
+}
+
+/* /dev/mixer file operations */
+
+static int hostmixer_ioctl_mixdev(struct inode *inode, struct file *file, 
+                                  unsigned int cmd, unsigned long arg)
+{
+        struct hostmixer_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostmixer: ioctl called\n");
+#endif
+
+        return(os_ioctl_generic(state->fd, cmd, arg));
+}
+
+static int hostmixer_open_mixdev(struct inode *inode, struct file *file)
+{
+        struct hostmixer_state *state;
+        int r = 0, w = 0;
+        int ret;
+
+#ifdef DEBUG
+        printk("hostmixer: open called (host: %s)\n", mixer);
+#endif
+
+        state = kmalloc(sizeof(struct hostmixer_state), GFP_KERNEL);
+        if(state == NULL) return(-ENOMEM);
+
+        if(file->f_mode & FMODE_READ) r = 1;
+        if(file->f_mode & FMODE_WRITE) w = 1;
+
+        ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
+        
+        if(ret < 0){
+                printk("hostaudio_open_mixdev failed to open '%s', err = %d\n",
+                       dsp, -ret);
+                kfree(state);
+                return(ret);
+        }
+
+        file->private_data = state;
+        return(0);
+}
+
+static int hostmixer_release(struct inode *inode, struct file *file)
+{
+        struct hostmixer_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostmixer: release called\n");
+#endif
+
+                os_close_file(state->fd);
+        kfree(state);
+
+        return(0);
+}
+
+
+/* kernel module operations */
+
+static struct file_operations hostaudio_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .read           = hostaudio_read,
+        .write          = hostaudio_write,
+        .poll           = hostaudio_poll,
+        .ioctl          = hostaudio_ioctl,
+        .mmap           = NULL,
+        .open           = hostaudio_open,
+        .release        = hostaudio_release,
+};
+
+static struct file_operations hostmixer_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .ioctl          = hostmixer_ioctl_mixdev,
+        .open           = hostmixer_open_mixdev,
+        .release        = hostmixer_release,
+};
+
+struct {
+        int dev_audio;
+        int dev_mixer;
+} module_data;
+
+MODULE_AUTHOR("Steve Schmidtke");
+MODULE_DESCRIPTION("UML Audio Relay");
+MODULE_LICENSE("GPL");
+
+static int __init hostaudio_init_module(void)
+{
+        printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
+               dsp, mixer);
+
+        module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
+        if(module_data.dev_audio < 0){
+                printk(KERN_ERR "hostaudio: couldn't register DSP device!\n");
+                return -ENODEV;
+        }
+
+        module_data.dev_mixer = register_sound_mixer(&hostmixer_fops, -1);
+        if(module_data.dev_mixer < 0){
+                printk(KERN_ERR "hostmixer: couldn't register mixer "
+                       "device!\n");
+                unregister_sound_dsp(module_data.dev_audio);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void __exit hostaudio_cleanup_module (void)
+{
+       unregister_sound_mixer(module_data.dev_mixer);
+       unregister_sound_dsp(module_data.dev_audio);
+}
+
+module_init(hostaudio_init_module);
+module_exit(hostaudio_cleanup_module);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
new file mode 100644
index 000000000000..6924f273ced9
--- /dev/null
+++ b/arch/um/drivers/line.c
@@ -0,0 +1,681 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "linux/list.h"
+#include "linux/kd.h"
+#include "linux/interrupt.h"
+#include "linux/devfs_fs_kernel.h"
+#include "asm/uaccess.h"
+#include "chan_kern.h"
+#include "irq_user.h"
+#include "line.h"
+#include "kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "os.h"
+#include "irq_kern.h"
+
+#define LINE_BUFSIZE 4096
+
+static irqreturn_t line_interrupt(int irq, void *data, struct pt_regs *unused)
+{
+        struct tty_struct *tty = data;
+        struct line *line = tty->driver_data;
+
+        if (line)
+                chan_interrupt(&line->chan_list, &line->task, tty, irq);
+        return IRQ_HANDLED;
+}
+
+static void line_timer_cb(void *arg)
+{
+        struct tty_struct *tty = arg;
+        struct line *line = tty->driver_data;
+
+        line_interrupt(line->driver->read_irq, arg, NULL);
+}
+
+static int write_room(struct line *dev)
+{
+        int n;
+
+        if (dev->buffer == NULL)
+                return (LINE_BUFSIZE - 1);
+
+        n = dev->head - dev->tail;
+        if (n <= 0)
+                n = LINE_BUFSIZE + n;
+        return (n - 1);
+}
+
+static int buffer_data(struct line *line, const char *buf, int len)
+{
+        int end, room;
+
+        if(line->buffer == NULL){
+                line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC);
+                if (line->buffer == NULL) {
+                        printk("buffer_data - atomic allocation failed\n");
+                        return(0);
+                }
+                line->head = line->buffer;
+                line->tail = line->buffer;
+        }
+
+        room = write_room(line);
+        len = (len > room) ? room : len;
+
+        end = line->buffer + LINE_BUFSIZE - line->tail;
+        if(len < end){
+                memcpy(line->tail, buf, len);
+                line->tail += len;
+        }
+        else {
+                memcpy(line->tail, buf, end);
+                buf += end;
+                memcpy(line->buffer, buf, len - end);
+                line->tail = line->buffer + len - end;
+        }
+
+        return(len);
+}
+
+static int flush_buffer(struct line *line)
+{
+        int n, count;
+
+        if ((line->buffer == NULL) || (line->head == line->tail))
+                return(1);
+
+        if (line->tail < line->head) {
+                count = line->buffer + LINE_BUFSIZE - line->head;
+                n = write_chan(&line->chan_list, line->head, count,
+                               line->driver->write_irq);
+                if (n < 0)
+                        return(n);
+                if (n == count)
+                        line->head = line->buffer;
+                else {
+                        line->head += n;
+                        return(0);
+                }
+        }
+
+        count = line->tail - line->head;
+        n = write_chan(&line->chan_list, line->head, count, 
+                       line->driver->write_irq);
+        if(n < 0) return(n);
+
+        line->head += n;
+        return(line->head == line->tail);
+}
+
+int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
+{
+        struct line *line = tty->driver_data;
+        unsigned long flags;
+        int n, err, ret = 0;
+
+        if(tty->stopped) return 0;
+
+        down(&line->sem);
+        if(line->head != line->tail){
+                local_irq_save(flags);
+                ret = buffer_data(line, buf, len);
+                err = flush_buffer(line);
+                local_irq_restore(flags);
+                if(err <= 0 && (err != -EAGAIN || !ret))
+                        ret = err;
+        }
+        else {
+                n = write_chan(&line->chan_list, buf, len, 
+                               line->driver->write_irq);
+                if(n < 0){
+                        ret = n;
+                        goto out_up;
+                }
+
+                len -= n;
+                ret += n;
+                if(len > 0)
+                        ret += buffer_data(line, buf + n, len);
+        }
+ out_up:
+        up(&line->sem);
+        return(ret);
+}
+
+void line_put_char(struct tty_struct *tty, unsigned char ch)
+{
+        line_write(tty, &ch, sizeof(ch));
+}
+
+void line_set_termios(struct tty_struct *tty, struct termios * old)
+{
+        /* nothing */
+}
+
+int line_chars_in_buffer(struct tty_struct *tty)
+{
+        return 0;
+}
+
+static struct {
+        int  cmd;
+        char *level;
+        char *name;
+} tty_ioctls[] = {
+        /* don't print these, they flood the log ... */
+        { TCGETS,      NULL,       "TCGETS"      },
+        { TCSETS,      NULL,       "TCSETS"      },
+        { TCSETSW,     NULL,       "TCSETSW"     },
+        { TCFLSH,      NULL,       "TCFLSH"      },
+        { TCSBRK,      NULL,       "TCSBRK"      },
+
+        /* general tty stuff */
+        { TCSETSF,     KERN_DEBUG, "TCSETSF"     },
+        { TCGETA,      KERN_DEBUG, "TCGETA"      },
+        { TIOCMGET,    KERN_DEBUG, "TIOCMGET"    },
+        { TCSBRKP,     KERN_DEBUG, "TCSBRKP"     },
+        { TIOCMSET,    KERN_DEBUG, "TIOCMSET"    },
+
+        /* linux-specific ones */
+        { TIOCLINUX,   KERN_INFO,  "TIOCLINUX"   },
+        { KDGKBMODE,   KERN_INFO,  "KDGKBMODE"   },
+        { KDGKBTYPE,   KERN_INFO,  "KDGKBTYPE"   },
+        { KDSIGACCEPT, KERN_INFO,  "KDSIGACCEPT" },
+};
+
+int line_ioctl(struct tty_struct *tty, struct file * file,
+               unsigned int cmd, unsigned long arg)
+{
+        int ret;
+        int i;
+
+        ret = 0;
+        switch(cmd) {
+#ifdef TIOCGETP
+        case TIOCGETP:
+        case TIOCSETP:
+        case TIOCSETN:
+#endif
+#ifdef TIOCGETC
+        case TIOCGETC:
+        case TIOCSETC:
+#endif
+#ifdef TIOCGLTC
+        case TIOCGLTC:
+        case TIOCSLTC:
+#endif
+        case TCGETS:
+        case TCSETSF:
+        case TCSETSW:
+        case TCSETS:
+        case TCGETA:
+        case TCSETAF:
+        case TCSETAW:
+        case TCSETA:
+        case TCXONC:
+        case TCFLSH:
+        case TIOCOUTQ:
+        case TIOCINQ:
+        case TIOCGLCKTRMIOS:
+        case TIOCSLCKTRMIOS:
+        case TIOCPKT:
+        case TIOCGSOFTCAR:
+        case TIOCSSOFTCAR:
+                return -ENOIOCTLCMD;
+#if 0
+        case TCwhatever:
+                /* do something */
+                break;
+#endif
+        default:
+                for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++)
+                        if (cmd == tty_ioctls[i].cmd)
+                                break;
+                if (i < ARRAY_SIZE(tty_ioctls)) {
+                        if (NULL != tty_ioctls[i].level)
+                                printk("%s%s: %s: ioctl %s called\n",
+                                       tty_ioctls[i].level, __FUNCTION__,
+                                       tty->name, tty_ioctls[i].name);
+                } else {
+                        printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n",
+                               __FUNCTION__, tty->name, cmd);
+                }
+                ret = -ENOIOCTLCMD;
+                break;
+        }
+        return(ret);
+}
+
+static irqreturn_t line_write_interrupt(int irq, void *data,
+                                        struct pt_regs *unused)
+{
+        struct tty_struct *tty = data;
+        struct line *line = tty->driver_data;
+        int err;
+
+        err = flush_buffer(line);
+        if(err == 0)
+                return(IRQ_NONE);
+        else if(err < 0){
+                line->head = line->buffer;
+                line->tail = line->buffer;
+        }
+
+        if(tty == NULL)
+                return(IRQ_NONE);
+
+        if(test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
+           (tty->ldisc.write_wakeup != NULL))
+                (tty->ldisc.write_wakeup)(tty);
+        
+        /* BLOCKING mode
+         * In blocking mode, everything sleeps on tty->write_wait.
+         * Sleeping in the console driver would break non-blocking
+         * writes.
+         */
+
+        if(waitqueue_active(&tty->write_wait))
+                wake_up_interruptible(&tty->write_wait);
+        return(IRQ_HANDLED);
+}
+
+int line_setup_irq(int fd, int input, int output, struct tty_struct *tty)
+{
+        struct line *line = tty->driver_data;
+        struct line_driver *driver = line->driver;
+        int err = 0, flags = SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM;
+
+        if(input) err = um_request_irq(driver->read_irq, fd, IRQ_READ, 
+                                       line_interrupt, flags, 
+                                       driver->read_irq_name, tty);
+        if(err) return(err);
+        if(output) err = um_request_irq(driver->write_irq, fd, IRQ_WRITE, 
+                                        line_write_interrupt, flags, 
+                                        driver->write_irq_name, tty);
+        line->have_irq = 1;
+        return(err);
+}
+
+void line_disable(struct tty_struct *tty, int current_irq)
+{
+        struct line *line = tty->driver_data;
+
+        if(!line->have_irq)
+                return;
+
+        if(line->driver->read_irq == current_irq)
+                free_irq_later(line->driver->read_irq, tty);
+        else {
+                free_irq_by_irq_and_dev(line->driver->read_irq, tty);
+                free_irq(line->driver->read_irq, tty);
+        }
+
+        if(line->driver->write_irq == current_irq)
+                free_irq_later(line->driver->write_irq, tty);
+        else {
+                free_irq_by_irq_and_dev(line->driver->write_irq, tty);
+                free_irq(line->driver->write_irq, tty);
+        }
+
+        line->have_irq = 0;
+}
+
+int line_open(struct line *lines, struct tty_struct *tty,
+              struct chan_opts *opts)
+{
+        struct line *line;
+        int err = 0;
+
+        line = &lines[tty->index];
+        tty->driver_data = line;
+
+        down(&line->sem);
+        if (tty->count == 1) {
+                if (!line->valid) {
+                        err = -ENODEV;
+                        goto out;
+                }
+                if (list_empty(&line->chan_list)) {
+                        err = parse_chan_pair(line->init_str, &line->chan_list,
+                                              line->init_pri, tty->index, opts);
+                        if(err) goto out;
+                        err = open_chan(&line->chan_list);
+                        if(err) goto out;
+                }
+                enable_chan(&line->chan_list, tty);
+                INIT_WORK(&line->task, line_timer_cb, tty);
+        }
+
+        if(!line->sigio){
+                chan_enable_winch(&line->chan_list, tty);
+                line->sigio = 1;
+        }
+        chan_window_size(&line->chan_list, &tty->winsize.ws_row,
+                         &tty->winsize.ws_col);
+        line->count++;
+
+out:
+        up(&line->sem);
+        return(err);
+}
+
+void line_close(struct tty_struct *tty, struct file * filp)
+{
+        struct line *line = tty->driver_data;
+
+        down(&line->sem);
+        line->count--;
+        if (tty->count == 1) {
+                line_disable(tty, -1);
+                tty->driver_data = NULL;
+        }
+        up(&line->sem);
+}
+
+void close_lines(struct line *lines, int nlines)
+{
+        int i;
+
+        for(i = 0; i < nlines; i++)
+                close_chan(&lines[i].chan_list);
+}
+
+int line_setup(struct line *lines, int num, char *init, int all_allowed)
+{
+        int i, n;
+        char *end;
+
+        if(*init == '=') n = -1;
+        else {
+                n = simple_strtoul(init, &end, 0);
+                if(*end != '='){
+                        printk(KERN_ERR "line_setup failed to parse \"%s\"\n", 
+                               init);
+                        return(0);
+                }
+                init = end;
+        }
+        init++;
+        if((n >= 0) && (n >= num)){
+                printk("line_setup - %d out of range ((0 ... %d) allowed)\n",
+                       n, num - 1);
+                return(0);
+        }
+        else if (n >= 0){
+                if (lines[n].count > 0) {
+                        printk("line_setup - device %d is open\n", n);
+                        return(0);
+                }
+                if (lines[n].init_pri <= INIT_ONE){
+                        lines[n].init_pri = INIT_ONE;
+                        if (!strcmp(init, "none"))
+                                lines[n].valid = 0;
+                        else {
+                                lines[n].init_str = init;
+                                lines[n].valid = 1;
+                        }       
+                }
+        }
+        else if(!all_allowed){
+                printk("line_setup - can't configure all devices from "
+                       "mconsole\n");
+                return(0);
+        }
+        else {
+                for(i = 0; i < num; i++){
+                        if(lines[i].init_pri <= INIT_ALL){
+                                lines[i].init_pri = INIT_ALL;
+                                if(!strcmp(init, "none")) lines[i].valid = 0;
+                                else {
+                                        lines[i].init_str = init;
+                                        lines[i].valid = 1;
+                                }
+                        }
+                }
+        }
+        return(1);
+}
+
+int line_config(struct line *lines, int num, char *str)
+{
+        char *new = uml_strdup(str);
+
+        if(new == NULL){
+                printk("line_config - uml_strdup failed\n");
+                return(-ENOMEM);
+        }
+        return(!line_setup(lines, num, new, 0));
+}
+
+int line_get_config(char *name, struct line *lines, int num, char *str, 
+                    int size, char **error_out)
+{
+        struct line *line;
+        char *end;
+        int dev, n = 0;
+
+        dev = simple_strtoul(name, &end, 0);
+        if((*end != '\0') || (end == name)){
+                *error_out = "line_get_config failed to parse device number";
+                return(0);
+        }
+
+        if((dev < 0) || (dev >= num)){
+                *error_out = "device number of of range";
+                return(0);
+        }
+
+        line = &lines[dev];
+
+        down(&line->sem);
+        if(!line->valid)
+                CONFIG_CHUNK(str, size, n, "none", 1);
+        else if(line->count == 0)
+                CONFIG_CHUNK(str, size, n, line->init_str, 1);
+        else n = chan_config_string(&line->chan_list, str, size, error_out);
+        up(&line->sem);
+
+        return(n);
+}
+
+int line_remove(struct line *lines, int num, char *str)
+{
+        char config[sizeof("conxxxx=none\0")];
+
+        sprintf(config, "%s=none", str);
+        return(!line_setup(lines, num, config, 0));
+}
+
+int line_write_room(struct tty_struct *tty)
+{
+        struct line *dev = tty->driver_data;
+        int room;
+
+        if (tty->stopped)
+                return 0;
+        room = write_room(dev);
+        if (0 == room)
+                printk(KERN_DEBUG "%s: %s: no room left in buffer\n",
+                       __FUNCTION__,tty->name);
+        return room;
+}
+
+struct tty_driver *line_register_devfs(struct lines *set,
+                         struct line_driver *line_driver, 
+                         struct tty_operations *ops, struct line *lines,
+                         int nlines)
+{
+        int i;
+        struct tty_driver *driver = alloc_tty_driver(nlines);
+
+        if (!driver)
+                return NULL;
+
+        driver->driver_name = line_driver->name;
+        driver->name = line_driver->device_name;
+        driver->devfs_name = line_driver->devfs_name;
+        driver->major = line_driver->major;
+        driver->minor_start = line_driver->minor_start;
+        driver->type = line_driver->type;
+        driver->subtype = line_driver->subtype;
+        driver->flags = TTY_DRIVER_REAL_RAW;
+        driver->init_termios = tty_std_termios;
+        tty_set_operations(driver, ops);
+
+        if (tty_register_driver(driver)) {
+                printk("%s: can't register %s driver\n",
+                       __FUNCTION__,line_driver->name);
+                put_tty_driver(driver);
+                return NULL;
+        }
+
+        for(i = 0; i < nlines; i++){
+                if(!lines[i].valid) 
+                        tty_unregister_device(driver, i);
+        }
+
+        mconsole_register_dev(&line_driver->mc);
+        return driver;
+}
+
+void lines_init(struct line *lines, int nlines)
+{
+        struct line *line;
+        int i;
+
+        for(i = 0; i < nlines; i++){
+                line = &lines[i];
+                INIT_LIST_HEAD(&line->chan_list);
+                sema_init(&line->sem, 1);
+                if(line->init_str != NULL){
+                        line->init_str = uml_strdup(line->init_str);
+                        if(line->init_str == NULL)
+                                printk("lines_init - uml_strdup returned "
+                                       "NULL\n");
+                }
+        }
+}
+
+struct winch {
+        struct list_head list;
+        int fd;
+        int tty_fd;
+        int pid;
+        struct tty_struct *tty;
+};
+
+irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
+{
+        struct winch *winch = data;
+        struct tty_struct *tty;
+        struct line *line;
+        int err;
+        char c;
+
+        if(winch->fd != -1){
+                err = generic_read(winch->fd, &c, NULL);
+                if(err < 0){
+                        if(err != -EAGAIN){
+                                printk("winch_interrupt : read failed, "
+                                       "errno = %d\n", -err);
+                                printk("fd %d is losing SIGWINCH support\n",
+                                       winch->tty_fd);
+                                return(IRQ_HANDLED);
+                        }
+                        goto out;
+                }
+        }
+        tty  = winch->tty;
+        if (tty != NULL) {
+                line = tty->driver_data;
+                chan_window_size(&line->chan_list,
+                                 &tty->winsize.ws_row, 
+                                 &tty->winsize.ws_col);
+                kill_pg(tty->pgrp, SIGWINCH, 1);
+        }
+ out:
+        if(winch->fd != -1)
+                reactivate_fd(winch->fd, WINCH_IRQ);
+        return(IRQ_HANDLED);
+}
+
+DECLARE_MUTEX(winch_handler_sem);
+LIST_HEAD(winch_handlers);
+
+void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty)
+{
+        struct winch *winch;
+
+        down(&winch_handler_sem);
+        winch = kmalloc(sizeof(*winch), GFP_KERNEL);
+        if (winch == NULL) {
+                printk("register_winch_irq - kmalloc failed\n");
+                goto out;
+        }
+        *winch = ((struct winch) { .list        = LIST_HEAD_INIT(winch->list),
+                                   .fd          = fd,
+                                   .tty_fd      = tty_fd,
+                                   .pid         = pid,
+                                   .tty         = tty });
+        list_add(&winch->list, &winch_handlers);
+        if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                          "winch", winch) < 0)
+                printk("register_winch_irq - failed to register IRQ\n");
+ out:
+        up(&winch_handler_sem);
+}
+
+static void winch_cleanup(void)
+{
+        struct list_head *ele;
+        struct winch *winch;
+
+        list_for_each(ele, &winch_handlers){
+                winch = list_entry(ele, struct winch, list);
+                if(winch->fd != -1){
+                        deactivate_fd(winch->fd, WINCH_IRQ);
+                        os_close_file(winch->fd);
+                }
+                if(winch->pid != -1) 
+                        os_kill_process(winch->pid, 1);
+        }
+}
+__uml_exitcall(winch_cleanup);
+
+char *add_xterm_umid(char *base)
+{
+        char *umid, *title;
+        int len;
+
+        umid = get_umid(1);
+        if(umid == NULL) return(base);
+        
+        len = strlen(base) + strlen(" ()") + strlen(umid) + 1;
+        title = kmalloc(len, GFP_KERNEL);
+        if(title == NULL){
+                printk("Failed to allocate buffer for xterm title\n");
+                return(base);
+        }
+
+        snprintf(title, len, "%s (%s)", base, umid);
+        return(title);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mcast.h b/arch/um/drivers/mcast.h
new file mode 100644
index 000000000000..a2c6db243458
--- /dev/null
+++ b/arch/um/drivers/mcast.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+struct mcast_data {
+        char *addr;
+        unsigned short port;
+        void *mcast_addr;
+        int ttl;
+        void *dev;
+};
+
+extern struct net_user_info mcast_user_info;
+
+extern int mcast_user_write(int fd, void *buf, int len, 
+                            struct mcast_data *pri);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mcast_kern.c b/arch/um/drivers/mcast_kern.c
new file mode 100644
index 000000000000..faf714e87b5b
--- /dev/null
+++ b/arch/um/drivers/mcast_kern.c
@@ -0,0 +1,143 @@
+/*
+ * user-mode-linux networking multicast transport
+ * Copyright (C) 2001 by Harald Welte <laforge@gnumonks.org>
+ *
+ * based on the existing uml-networking code, which is
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ *
+ * Licensed under the GPL.
+ */
+
+#include "linux/kernel.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "linux/in.h"
+#include "linux/inet.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "mcast.h"
+
+struct mcast_init {
+        char *addr;
+        int port;
+        int ttl;
+};
+
+void mcast_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct mcast_data *dpri;
+        struct mcast_init *init = data;
+
+        pri = dev->priv;
+        dpri = (struct mcast_data *) pri->user;
+        dpri->addr = init->addr;
+        dpri->port = init->port;
+        dpri->ttl = init->ttl;
+        dpri->dev = dev;
+
+        printk("mcast backend ");
+        printk("multicast adddress: %s:%u, TTL:%u ",
+               dpri->addr, dpri->port, dpri->ttl);
+
+        printk("\n");
+}
+
+static int mcast_read(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(net_recvfrom(fd, (*skb)->mac.raw, 
+                            (*skb)->dev->mtu + ETH_HEADER_OTHER));
+}
+
+static int mcast_write(int fd, struct sk_buff **skb,
+                        struct uml_net_private *lp)
+{
+        return mcast_user_write(fd, (*skb)->data, (*skb)->len, 
+                                 (struct mcast_data *) &lp->user);
+}
+
+static struct net_kern_info mcast_kern_info = {
+        .init                   = mcast_init,
+        .protocol               = eth_protocol,
+        .read                   = mcast_read,
+        .write                  = mcast_write,
+};
+
+int mcast_setup(char *str, char **mac_out, void *data)
+{
+        struct mcast_init *init = data;
+        char *port_str = NULL, *ttl_str = NULL, *remain;
+        char *last;
+        int n;
+
+        *init = ((struct mcast_init)
+                { .addr         = "239.192.168.1",
+                  .port         = 1102,
+                  .ttl          = 1 });
+
+        remain = split_if_spec(str, mac_out, &init->addr, &port_str, &ttl_str,
+                               NULL);
+        if(remain != NULL){
+                printk(KERN_ERR "mcast_setup - Extra garbage on "
+                       "specification : '%s'\n", remain);
+                return(0);
+        }
+        
+        if(port_str != NULL){
+                n = simple_strtoul(port_str, &last, 10);
+                if((*last != '\0') || (last == port_str)){
+                        printk(KERN_ERR "mcast_setup - Bad port : '%s'\n", 
+                               port_str);
+                        return(0);
+                }
+                init->port = htons(n);
+        }
+
+        if(ttl_str != NULL){
+                init->ttl = simple_strtoul(ttl_str, &last, 10);
+                if((*last != '\0') || (last == ttl_str)){
+                        printk(KERN_ERR "mcast_setup - Bad ttl : '%s'\n", 
+                               ttl_str);
+                        return(0);
+                }
+        }
+
+        printk(KERN_INFO "Configured mcast device: %s:%u-%u\n", init->addr,
+               init->port, init->ttl);
+
+        return(1);
+}
+
+static struct transport mcast_transport = {
+        .list           = LIST_HEAD_INIT(mcast_transport.list),
+        .name           = "mcast",
+        .setup          = mcast_setup,
+        .user           = &mcast_user_info,
+        .kern           = &mcast_kern_info,
+        .private_size   = sizeof(struct mcast_data),
+        .setup_size     = sizeof(struct mcast_init),
+};
+
+static int register_mcast(void)
+{
+        register_transport(&mcast_transport);
+        return(1);
+}
+
+__initcall(register_mcast);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mcast_user.c b/arch/um/drivers/mcast_user.c
new file mode 100644
index 000000000000..0fe1d9fa9139
--- /dev/null
+++ b/arch/um/drivers/mcast_user.c
@@ -0,0 +1,177 @@
+/*
+ * user-mode-linux networking multicast transport
+ * Copyright (C) 2001 by Harald Welte <laforge@gnumonks.org>
+ *
+ * based on the existing uml-networking code, which is
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ *
+ * Licensed under the GPL.
+ *
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <linux/inet.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include "net_user.h"
+#include "mcast.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+static struct sockaddr_in *new_addr(char *addr, unsigned short port)
+{
+        struct sockaddr_in *sin;
+
+        sin = um_kmalloc(sizeof(struct sockaddr_in));
+        if(sin == NULL){
+                printk("new_addr: allocation of sockaddr_in failed\n");
+                return(NULL);
+        }
+        sin->sin_family = AF_INET;
+        sin->sin_addr.s_addr = in_aton(addr);
+        sin->sin_port = port;
+        return(sin);
+}
+
+static void mcast_user_init(void *data, void *dev)
+{
+        struct mcast_data *pri = data;
+
+        pri->mcast_addr = new_addr(pri->addr, pri->port);
+        pri->dev = dev;
+}
+
+static int mcast_open(void *data)
+{
+        struct mcast_data *pri = data;
+        struct sockaddr_in *sin = pri->mcast_addr;
+        struct ip_mreq mreq;
+        int fd, yes = 1;
+
+
+        if ((sin->sin_addr.s_addr == 0) || (sin->sin_port == 0)) {
+                fd = -EINVAL;
+                goto out;
+        }
+
+        fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if (fd < 0){
+                printk("mcast_open : data socket failed, errno = %d\n", 
+                       errno);
+                fd = -ENOMEM;
+                goto out;
+        }
+
+        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
+                printk("mcast_open: SO_REUSEADDR failed, errno = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* set ttl according to config */
+        if (setsockopt(fd, SOL_IP, IP_MULTICAST_TTL, &pri->ttl,
+                       sizeof(pri->ttl)) < 0) {
+                printk("mcast_open: IP_MULTICAST_TTL failed, error = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* set LOOP, so data does get fed back to local sockets */
+        if (setsockopt(fd, SOL_IP, IP_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
+                printk("mcast_open: IP_MULTICAST_LOOP failed, error = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* bind socket to mcast address */
+        if (bind(fd, (struct sockaddr *) sin, sizeof(*sin)) < 0) {
+                printk("mcast_open : data bind failed, errno = %d\n", errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }               
+        
+        /* subscribe to the multicast group */
+        mreq.imr_multiaddr.s_addr = sin->sin_addr.s_addr;
+        mreq.imr_interface.s_addr = 0;
+        if (setsockopt(fd, SOL_IP, IP_ADD_MEMBERSHIP, 
+                       &mreq, sizeof(mreq)) < 0) {
+                printk("mcast_open: IP_ADD_MEMBERSHIP failed, error = %d\n",
+                        errno);
+                printk("There appears not to be a multicast-capable network "
+                       "interface on the host.\n");
+                printk("eth0 should be configured in order to use the "
+                       "multicast transport.\n");
+                os_close_file(fd);
+                fd = -EINVAL;
+        }
+
+ out:
+        return(fd);
+}
+
+static void mcast_close(int fd, void *data)
+{
+        struct ip_mreq mreq;
+        struct mcast_data *pri = data;
+        struct sockaddr_in *sin = pri->mcast_addr;
+
+        mreq.imr_multiaddr.s_addr = sin->sin_addr.s_addr;
+        mreq.imr_interface.s_addr = 0;
+        if (setsockopt(fd, SOL_IP, IP_DROP_MEMBERSHIP,
+                       &mreq, sizeof(mreq)) < 0) {
+                printk("mcast_open: IP_DROP_MEMBERSHIP failed, error = %d\n",
+                        errno);
+        }
+
+        os_close_file(fd);
+}
+
+int mcast_user_write(int fd, void *buf, int len, struct mcast_data *pri)
+{
+        struct sockaddr_in *data_addr = pri->mcast_addr;
+
+        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+}
+
+static int mcast_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info mcast_user_info = {
+        .init           = mcast_user_init,
+        .open           = mcast_open,
+        .close          = mcast_close,
+        .remove         = NULL,
+        .set_mtu        = mcast_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
new file mode 100644
index 000000000000..d7c7adcc0a67
--- /dev/null
+++ b/arch/um/drivers/mconsole_kern.c
@@ -0,0 +1,619 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/slab.h"
+#include "linux/init.h"
+#include "linux/notifier.h"
+#include "linux/reboot.h"
+#include "linux/utsname.h"
+#include "linux/ctype.h"
+#include "linux/interrupt.h"
+#include "linux/sysrq.h"
+#include "linux/workqueue.h"
+#include "linux/module.h"
+#include "linux/file.h"
+#include "linux/fs.h"
+#include "linux/namei.h"
+#include "linux/proc_fs.h"
+#include "linux/syscalls.h"
+#include "asm/irq.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mconsole.h"
+#include "mconsole_kern.h"
+#include "irq_user.h"
+#include "init.h"
+#include "os.h"
+#include "umid.h"
+#include "irq_kern.h"
+
+static int do_unlink_socket(struct notifier_block *notifier, 
+                            unsigned long what, void *data)
+{
+        return(mconsole_unlink_socket());
+}
+
+
+static struct notifier_block reboot_notifier = {
+        .notifier_call          = do_unlink_socket,
+        .priority               = 0,
+};
+
+/* Safe without explicit locking for now.  Tasklets provide their own 
+ * locking, and the interrupt handler is safe because it can't interrupt
+ * itself and it can only happen on CPU 0.
+ */
+
+LIST_HEAD(mc_requests);
+
+static void mc_work_proc(void *unused)
+{
+        struct mconsole_entry *req;
+        unsigned long flags;
+
+        while(!list_empty(&mc_requests)){
+                local_save_flags(flags);
+                req = list_entry(mc_requests.next, struct mconsole_entry, 
+                                 list);
+                list_del(&req->list);
+                local_irq_restore(flags);
+                req->request.cmd->handler(&req->request);
+                kfree(req);
+        }
+}
+
+DECLARE_WORK(mconsole_work, mc_work_proc, NULL);
+
+static irqreturn_t mconsole_interrupt(int irq, void *dev_id,
+                                      struct pt_regs *regs)
+{
+        /* long to avoid size mismatch warnings from gcc */
+        long fd;
+        struct mconsole_entry *new;
+        struct mc_request req;
+
+        fd = (long) dev_id;
+        while (mconsole_get_request(fd, &req)){
+                if(req.cmd->context == MCONSOLE_INTR)
+                        (*req.cmd->handler)(&req);
+                else {
+                        new = kmalloc(sizeof(*new), GFP_ATOMIC);
+                        if(new == NULL)
+                                mconsole_reply(&req, "Out of memory", 1, 0);
+                        else {
+                                new->request = req;
+                                list_add(&new->list, &mc_requests);
+                        }
+                }
+        }
+        if(!list_empty(&mc_requests))
+                schedule_work(&mconsole_work);
+        reactivate_fd(fd, MCONSOLE_IRQ);
+        return(IRQ_HANDLED);
+}
+
+void mconsole_version(struct mc_request *req)
+{
+        char version[256];
+
+        sprintf(version, "%s %s %s %s %s", system_utsname.sysname, 
+                system_utsname.nodename, system_utsname.release, 
+                system_utsname.version, system_utsname.machine);
+        mconsole_reply(req, version, 0, 0);
+}
+
+void mconsole_log(struct mc_request *req)
+{
+        int len;
+        char *ptr = req->request.data;
+
+        ptr += strlen("log ");
+
+        len = req->len - (ptr - req->request.data);
+        printk("%.*s", len, ptr);
+        mconsole_reply(req, "", 0, 0);
+}
+
+/* This is a more convoluted version of mconsole_proc, which has some stability
+ * problems; however, we need it fixed, because it is expected that UML users
+ * mount HPPFS instead of procfs on /proc. And we want mconsole_proc to still
+ * show the real procfs content, not the ones from hppfs.*/
+#if 0
+void mconsole_proc(struct mc_request *req)
+{
+        struct nameidata nd;
+        struct file_system_type *proc;
+        struct super_block *super;
+        struct file *file;
+        int n, err;
+        char *ptr = req->request.data, *buf;
+
+        ptr += strlen("proc");
+        while(isspace(*ptr)) ptr++;
+
+        proc = get_fs_type("proc");
+        if(proc == NULL){
+                mconsole_reply(req, "procfs not registered", 1, 0);
+                goto out;
+        }
+
+        super = (*proc->get_sb)(proc, 0, NULL, NULL);
+        put_filesystem(proc);
+        if(super == NULL){
+                mconsole_reply(req, "Failed to get procfs superblock", 1, 0);
+                goto out;
+        }
+        up_write(&super->s_umount);
+
+        nd.dentry = super->s_root;
+        nd.mnt = NULL;
+        nd.flags = O_RDONLY + 1;
+        nd.last_type = LAST_ROOT;
+
+        /* START: it was experienced that the stability problems are closed
+         * if commenting out these two calls + the below read cycle. To
+         * make UML crash again, it was enough to readd either one.*/
+        err = link_path_walk(ptr, &nd);
+        if(err){
+                mconsole_reply(req, "Failed to look up file", 1, 0);
+                goto out_kill;
+        }
+
+        file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
+        if(IS_ERR(file)){
+                mconsole_reply(req, "Failed to open file", 1, 0);
+                goto out_kill;
+        }
+        /*END*/
+
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if(buf == NULL){
+                mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                goto out_fput;
+        }
+
+        if((file->f_op != NULL) && (file->f_op->read != NULL)){
+                do {
+                        n = (*file->f_op->read)(file, buf, PAGE_SIZE - 1,
+                                                &file->f_pos);
+                        if(n >= 0){
+                                buf[n] = '\0';
+                                mconsole_reply(req, buf, 0, (n > 0));
+                        }
+                        else {
+                                mconsole_reply(req, "Read of file failed",
+                                               1, 0);
+                                goto out_free;
+                        }
+                } while(n > 0);
+        }
+        else mconsole_reply(req, "", 0, 0);
+
+ out_free:
+        kfree(buf);
+ out_fput:
+        fput(file);
+ out_kill:
+        deactivate_super(super);
+ out: ;
+}
+#endif
+
+void mconsole_proc(struct mc_request *req)
+{
+        char path[64];
+        char *buf;
+        int len;
+        int fd;
+        int first_chunk = 1;
+        char *ptr = req->request.data;
+
+        ptr += strlen("proc");
+        while(isspace(*ptr)) ptr++;
+        snprintf(path, sizeof(path), "/proc/%s", ptr);
+
+        fd = sys_open(path, 0, 0);
+        if (fd < 0) {
+                mconsole_reply(req, "Failed to open file", 1, 0);
+                printk("open %s: %d\n",path,fd);
+                goto out;
+        }
+
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if(buf == NULL){
+                mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                goto out_close;
+        }
+
+        for (;;) {
+                len = sys_read(fd, buf, PAGE_SIZE-1);
+                if (len < 0) {
+                        mconsole_reply(req, "Read of file failed", 1, 0);
+                        goto out_free;
+                }
+                /*Begin the file content on his own line.*/
+                if (first_chunk) {
+                        mconsole_reply(req, "\n", 0, 1);
+                        first_chunk = 0;
+                }
+                if (len == PAGE_SIZE-1) {
+                        buf[len] = '\0';
+                        mconsole_reply(req, buf, 0, 1);
+                } else {
+                        buf[len] = '\0';
+                        mconsole_reply(req, buf, 0, 0);
+                        break;
+                }
+        }
+
+ out_free:
+        kfree(buf);
+ out_close:
+        sys_close(fd);
+ out:
+        /* nothing */;
+}
+
+#define UML_MCONSOLE_HELPTEXT \
+"Commands: \n\
+    version - Get kernel version \n\
+    help - Print this message \n\
+    halt - Halt UML \n\
+    reboot - Reboot UML \n\
+    config <dev>=<config> - Add a new device to UML;  \n\
+        same syntax as command line \n\
+    config <dev> - Query the configuration of a device \n\
+    remove <dev> - Remove a device from UML \n\
+    sysrq <letter> - Performs the SysRq action controlled by the letter \n\
+    cad - invoke the Ctl-Alt-Del handler \n\
+    stop - pause the UML; it will do nothing until it receives a 'go' \n\
+    go - continue the UML after a 'stop' \n\
+    log <string> - make UML enter <string> into the kernel log\n\
+    proc <file> - returns the contents of the UML's /proc/<file>\n\
+"
+
+void mconsole_help(struct mc_request *req)
+{
+        mconsole_reply(req, UML_MCONSOLE_HELPTEXT, 0, 0);
+}
+
+void mconsole_halt(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        machine_halt();
+}
+
+void mconsole_reboot(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        machine_restart(NULL);
+}
+
+extern void ctrl_alt_del(void);
+
+void mconsole_cad(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        ctrl_alt_del();
+}
+
+void mconsole_go(struct mc_request *req)
+{
+        mconsole_reply(req, "Not stopped", 1, 0);
+}
+
+void mconsole_stop(struct mc_request *req)
+{
+        deactivate_fd(req->originating_fd, MCONSOLE_IRQ);
+        os_set_fd_block(req->originating_fd, 1);
+        mconsole_reply(req, "", 0, 0);
+        while(mconsole_get_request(req->originating_fd, req)){
+                if(req->cmd->handler == mconsole_go) break;
+                (*req->cmd->handler)(req);
+        }
+        os_set_fd_block(req->originating_fd, 0);
+        reactivate_fd(req->originating_fd, MCONSOLE_IRQ);
+        mconsole_reply(req, "", 0, 0);
+}
+
+/* This list is populated by __initcall routines. */
+
+LIST_HEAD(mconsole_devices);
+
+void mconsole_register_dev(struct mc_device *new)
+{
+        list_add(&new->list, &mconsole_devices);
+}
+
+static struct mc_device *mconsole_find_dev(char *name)
+{
+        struct list_head *ele;
+        struct mc_device *dev;
+
+        list_for_each(ele, &mconsole_devices){
+                dev = list_entry(ele, struct mc_device, list);
+                if(!strncmp(name, dev->name, strlen(dev->name)))
+                        return(dev);
+        }
+        return(NULL);
+}
+
+#define CONFIG_BUF_SIZE 64
+
+static void mconsole_get_config(int (*get_config)(char *, char *, int, 
+                                                  char **),
+                                struct mc_request *req, char *name)
+{
+        char default_buf[CONFIG_BUF_SIZE], *error, *buf;
+        int n, size;
+
+        if(get_config == NULL){
+                mconsole_reply(req, "No get_config routine defined", 1, 0);
+                return;
+        }
+
+        error = NULL;
+        size = sizeof(default_buf)/sizeof(default_buf[0]);
+        buf = default_buf;
+
+        while(1){
+                n = (*get_config)(name, buf, size, &error);
+                if(error != NULL){
+                        mconsole_reply(req, error, 1, 0);
+                        goto out;
+                }
+
+                if(n <= size){
+                        mconsole_reply(req, buf, 0, 0);
+                        goto out;
+                }
+
+                if(buf != default_buf)
+                        kfree(buf);
+
+                size = n;
+                buf = kmalloc(size, GFP_KERNEL);
+                if(buf == NULL){
+                        mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                        return;
+                }
+        }
+ out:
+        if(buf != default_buf)
+                kfree(buf);
+        
+}
+
+void mconsole_config(struct mc_request *req)
+{
+        struct mc_device *dev;
+        char *ptr = req->request.data, *name;
+        int err;
+
+        ptr += strlen("config");
+        while(isspace(*ptr)) ptr++;
+        dev = mconsole_find_dev(ptr);
+        if(dev == NULL){
+                mconsole_reply(req, "Bad configuration option", 1, 0);
+                return;
+        }
+
+        name = &ptr[strlen(dev->name)];
+        ptr = name;
+        while((*ptr != '=') && (*ptr != '\0'))
+                ptr++;
+
+        if(*ptr == '='){
+                err = (*dev->config)(name);
+                mconsole_reply(req, "", err, 0);
+        }
+        else mconsole_get_config(dev->get_config, req, name);
+}
+
+void mconsole_remove(struct mc_request *req)
+{
+        struct mc_device *dev;  
+        char *ptr = req->request.data;
+        int err;
+
+        ptr += strlen("remove");
+        while(isspace(*ptr)) ptr++;
+        dev = mconsole_find_dev(ptr);
+        if(dev == NULL){
+                mconsole_reply(req, "Bad remove option", 1, 0);
+                return;
+        }
+        err = (*dev->remove)(&ptr[strlen(dev->name)]);
+        mconsole_reply(req, "", err, 0);
+}
+
+#ifdef CONFIG_MAGIC_SYSRQ
+void mconsole_sysrq(struct mc_request *req)
+{
+        char *ptr = req->request.data;
+
+        ptr += strlen("sysrq");
+        while(isspace(*ptr)) ptr++;
+
+        mconsole_reply(req, "", 0, 0);
+        handle_sysrq(*ptr, &current->thread.regs, NULL);
+}
+#else
+void mconsole_sysrq(struct mc_request *req)
+{
+        mconsole_reply(req, "Sysrq not compiled in", 1, 0);
+}
+#endif
+
+/* Changed by mconsole_setup, which is __setup, and called before SMP is
+ * active.
+ */
+static char *notify_socket = NULL; 
+
+int mconsole_init(void)
+{
+        /* long to avoid size mismatch warnings from gcc */
+        long sock;
+        int err;
+        char file[256];
+
+        if(umid_file_name("mconsole", file, sizeof(file))) return(-1);
+        snprintf(mconsole_socket_name, sizeof(file), "%s", file);
+
+        sock = os_create_unix_socket(file, sizeof(file), 1);
+        if (sock < 0){
+                printk("Failed to initialize management console\n");
+                return(1);
+        }
+
+        register_reboot_notifier(&reboot_notifier);
+
+        err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
+                             SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
+                             "mconsole", (void *)sock);
+        if (err){
+                printk("Failed to get IRQ for management console\n");
+                return(1);
+        }
+
+        if(notify_socket != NULL){
+                notify_socket = uml_strdup(notify_socket);
+                if(notify_socket != NULL)
+                        mconsole_notify(notify_socket, MCONSOLE_SOCKET,
+                                        mconsole_socket_name, 
+                                        strlen(mconsole_socket_name) + 1);
+                else printk(KERN_ERR "mconsole_setup failed to strdup "
+                            "string\n");
+        }
+
+        printk("mconsole (version %d) initialized on %s\n", 
+               MCONSOLE_VERSION, mconsole_socket_name);
+        return(0);
+}
+
+__initcall(mconsole_init);
+
+static int write_proc_mconsole(struct file *file, const char __user *buffer,
+                               unsigned long count, void *data)
+{
+        char *buf;
+
+        buf = kmalloc(count + 1, GFP_KERNEL);
+        if(buf == NULL) 
+                return(-ENOMEM);
+
+        if(copy_from_user(buf, buffer, count)){
+                count = -EFAULT;
+                goto out;
+        }
+
+        buf[count] = '\0';
+
+        mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
+ out:
+        kfree(buf);
+        return(count);
+}
+
+static int create_proc_mconsole(void)
+{
+        struct proc_dir_entry *ent;
+
+        if(notify_socket == NULL) return(0);
+
+        ent = create_proc_entry("mconsole", S_IFREG | 0200, NULL);
+        if(ent == NULL){
+                printk("create_proc_mconsole : create_proc_entry failed\n");
+                return(0);
+        }
+
+        ent->read_proc = NULL;
+        ent->write_proc = write_proc_mconsole;
+        return(0);
+}
+
+static DEFINE_SPINLOCK(notify_spinlock);
+
+void lock_notify(void)
+{
+        spin_lock(&notify_spinlock);
+}
+
+void unlock_notify(void)
+{
+        spin_unlock(&notify_spinlock);
+}
+
+__initcall(create_proc_mconsole);
+
+#define NOTIFY "=notify:"
+
+static int mconsole_setup(char *str)
+{
+        if(!strncmp(str, NOTIFY, strlen(NOTIFY))){
+                str += strlen(NOTIFY);
+                notify_socket = str;
+        }
+        else printk(KERN_ERR "mconsole_setup : Unknown option - '%s'\n", str);
+        return(1);
+}
+
+__setup("mconsole", mconsole_setup);
+
+__uml_help(mconsole_setup,
+"mconsole=notify:<socket>\n"
+"    Requests that the mconsole driver send a message to the named Unix\n"
+"    socket containing the name of the mconsole socket.  This also serves\n"
+"    to notify outside processes when UML has booted far enough to respond\n"
+"    to mconsole requests.\n\n"
+);
+
+static int notify_panic(struct notifier_block *self, unsigned long unused1,
+                        void *ptr)
+{
+        char *message = ptr;
+
+        if(notify_socket == NULL) return(0);
+
+        mconsole_notify(notify_socket, MCONSOLE_PANIC, message, 
+                        strlen(message) + 1);
+        return(0);
+}
+
+static struct notifier_block panic_exit_notifier = {
+        .notifier_call          = notify_panic,
+        .next                   = NULL,
+        .priority               = 1
+};
+
+static int add_notifier(void)
+{
+        notifier_chain_register(&panic_notifier_list, &panic_exit_notifier);
+        return(0);
+}
+
+__initcall(add_notifier);
+
+char *mconsole_notify_socket(void)
+{
+        return(notify_socket);
+}
+
+EXPORT_SYMBOL(mconsole_notify_socket);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
new file mode 100644
index 000000000000..fe5afb13252c
--- /dev/null
+++ b/arch/um/drivers/mconsole_user.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include "user.h"
+#include "mconsole.h"
+#include "umid.h"
+
+static struct mconsole_command commands[] = {
+        { "version", mconsole_version, MCONSOLE_INTR },
+        { "halt", mconsole_halt, MCONSOLE_PROC },
+        { "reboot", mconsole_reboot, MCONSOLE_PROC },
+        { "config", mconsole_config, MCONSOLE_PROC },
+        { "remove", mconsole_remove, MCONSOLE_PROC },
+        { "sysrq", mconsole_sysrq, MCONSOLE_INTR },
+        { "help", mconsole_help, MCONSOLE_INTR },
+        { "cad", mconsole_cad, MCONSOLE_INTR },
+        { "stop", mconsole_stop, MCONSOLE_PROC },
+        { "go", mconsole_go, MCONSOLE_INTR },
+        { "log", mconsole_log, MCONSOLE_INTR },
+        { "proc", mconsole_proc, MCONSOLE_PROC },
+};
+
+/* Initialized in mconsole_init, which is an initcall */
+char mconsole_socket_name[256];
+
+int mconsole_reply_v0(struct mc_request *req, char *reply)
+{
+        struct iovec iov;
+        struct msghdr msg;
+
+        iov.iov_base = reply;
+        iov.iov_len = strlen(reply);
+
+        msg.msg_name = &(req->origin);
+        msg.msg_namelen = req->originlen;
+        msg.msg_iov = &iov;
+        msg.msg_iovlen = 1;
+        msg.msg_control = NULL;
+        msg.msg_controllen = 0;
+        msg.msg_flags = 0;
+
+        return sendmsg(req->originating_fd, &msg, 0);
+}
+
+static struct mconsole_command *mconsole_parse(struct mc_request *req)
+{
+        struct mconsole_command *cmd;
+        int i;
+
+        for(i=0;i<sizeof(commands)/sizeof(commands[0]);i++){
+                cmd = &commands[i];
+                if(!strncmp(req->request.data, cmd->command, 
+                            strlen(cmd->command))){
+                        return(cmd);
+                }
+        }
+        return(NULL);
+}
+
+#define MIN(a,b) ((a)<(b) ? (a):(b))
+
+#define STRINGX(x) #x
+#define STRING(x) STRINGX(x)
+
+int mconsole_get_request(int fd, struct mc_request *req)
+{
+        int len;
+
+        req->originlen = sizeof(req->origin);
+        req->len = recvfrom(fd, &req->request, sizeof(req->request), 0,
+                            (struct sockaddr *) req->origin, &req->originlen);
+        if (req->len < 0)
+                return 0;
+
+        req->originating_fd = fd;
+
+        if(req->request.magic != MCONSOLE_MAGIC){
+                /* Unversioned request */
+                len = MIN(sizeof(req->request.data) - 1, 
+                          strlen((char *) &req->request));
+                memmove(req->request.data, &req->request, len);
+                req->request.data[len] = '\0';
+
+                req->request.magic = MCONSOLE_MAGIC;
+                req->request.version = 0;
+                req->request.len = len;
+
+                mconsole_reply_v0(req, "ERR Version 0 mconsole clients are "
+                                  "not supported by this driver");
+                return(0);
+        }
+
+        if(req->request.len >= MCONSOLE_MAX_DATA){
+                mconsole_reply(req, "Request too large", 1, 0);
+                return(0);
+        }
+        if(req->request.version != MCONSOLE_VERSION){
+                mconsole_reply(req, "This driver only supports version " 
+                               STRING(MCONSOLE_VERSION) " clients", 1, 0);
+        }
+        
+        req->request.data[req->request.len] = '\0';
+        req->cmd = mconsole_parse(req);
+        if(req->cmd == NULL){
+                mconsole_reply(req, "Unknown command", 1, 0);
+                return(0);
+        }
+
+        return(1);
+}
+
+int mconsole_reply(struct mc_request *req, char *str, int err, int more)
+{
+        struct mconsole_reply reply;
+        int total, len, n;
+
+        total = strlen(str);
+        do {
+                reply.err = err;
+
+                /* err can only be true on the first packet */
+                err = 0;
+
+                len = MIN(total, MCONSOLE_MAX_DATA - 1);
+
+                if(len == total) reply.more = more;
+                else reply.more = 1;
+
+                memcpy(reply.data, str, len);
+                reply.data[len] = '\0';
+                total -= len;
+                str += len;
+                reply.len = len + 1;
+
+                len = sizeof(reply) + reply.len - sizeof(reply.data);
+
+                n = sendto(req->originating_fd, &reply, len, 0,
+                           (struct sockaddr *) req->origin, req->originlen);
+
+                if(n < 0) return(-errno);
+        } while(total > 0);
+        return(0);
+}
+
+int mconsole_unlink_socket(void)
+{
+        unlink(mconsole_socket_name);
+        return 0;
+}
+
+static int notify_sock = -1;
+
+int mconsole_notify(char *sock_name, int type, const void *data, int len)
+{
+        struct sockaddr_un target;
+        struct mconsole_notify packet;
+        int n, err = 0;
+
+        lock_notify();
+        if(notify_sock < 0){
+                notify_sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+                if(notify_sock < 0){
+                        printk("mconsole_notify - socket failed, errno = %d\n",
+                               errno);
+                        err = -errno;
+                }
+        }
+        unlock_notify();
+        
+        if(err)
+                return(err);
+
+        target.sun_family = AF_UNIX;
+        strcpy(target.sun_path, sock_name);
+
+        packet.magic = MCONSOLE_MAGIC;
+        packet.version = MCONSOLE_VERSION;
+        packet.type = type;
+        len = (len > sizeof(packet.data)) ? sizeof(packet.data) : len;
+        packet.len = len;
+        memcpy(packet.data, data, len);
+
+        err = 0;
+        len = sizeof(packet) + packet.len - sizeof(packet.data);
+        n = sendto(notify_sock, &packet, len, 0, (struct sockaddr *) &target, 
+                   sizeof(target));
+        if(n < 0){
+                printk("mconsole_notify - sendto failed, errno = %d\n", errno);
+                err = -errno;
+        }
+        return(err);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
new file mode 100644
index 000000000000..a63231dffe05
--- /dev/null
+++ b/arch/um/drivers/mmapper_kern.c
@@ -0,0 +1,150 @@
+/*
+ * arch/um/drivers/mmapper_kern.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * Copyright (C) 2000 RidgeRun, Inc.
+ * Author: RidgeRun, Inc.
+ *         Greg Lonnon glonnon@ridgerun.com or info@ridgerun.com
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kdev_t.h>
+#include <linux/time.h>
+#include <linux/devfs_fs_kernel.h>
+#include <linux/module.h>
+#include <linux/mm.h> 
+#include <linux/slab.h>
+#include <linux/init.h> 
+#include <linux/smp_lock.h>
+#include <asm/uaccess.h>
+#include <asm/irq.h>
+#include <asm/pgtable.h>
+#include "mem_user.h"
+#include "user_util.h"
+ 
+/* These are set in mmapper_init, which is called at boot time */
+static unsigned long mmapper_size;
+static unsigned long p_buf = 0;
+static char *v_buf = NULL;
+
+static ssize_t
+mmapper_read(struct file *file, char *buf, size_t count, loff_t *ppos)
+{
+        if(*ppos > mmapper_size)
+                return -EINVAL;
+
+        if(count + *ppos > mmapper_size)
+                count = count + *ppos - mmapper_size;
+
+        if(count < 0)
+                return -EINVAL;
+ 
+        copy_to_user(buf,&v_buf[*ppos],count);
+        
+        return count;
+}
+
+static ssize_t
+mmapper_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
+{
+        if(*ppos > mmapper_size)
+                return -EINVAL;
+
+        if(count + *ppos > mmapper_size)
+                count = count + *ppos - mmapper_size;
+
+        if(count < 0)
+                return -EINVAL;
+
+        copy_from_user(&v_buf[*ppos],buf,count);
+        
+        return count;
+}
+
+static int 
+mmapper_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+         unsigned long arg)
+{
+        return(-ENOIOCTLCMD);
+}
+
+static int 
+mmapper_mmap(struct file *file, struct vm_area_struct * vma)
+{
+        int ret = -EINVAL;
+        int size;
+
+        lock_kernel();
+        if (vma->vm_pgoff != 0)
+                goto out;
+        
+        size = vma->vm_end - vma->vm_start;
+        if(size > mmapper_size) return(-EFAULT);
+
+        /* XXX A comment above remap_pfn_range says it should only be
+         * called when the mm semaphore is held
+         */
+        if (remap_pfn_range(vma, vma->vm_start, p_buf >> PAGE_SHIFT, size,
+                             vma->vm_page_prot))
+                goto out;
+        ret = 0;
+out:
+        unlock_kernel();
+        return ret;
+}
+
+static int
+mmapper_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static int 
+mmapper_release(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static struct file_operations mmapper_fops = {
+        .owner          = THIS_MODULE,
+        .read           = mmapper_read,
+        .write          = mmapper_write,
+        .ioctl          = mmapper_ioctl,
+        .mmap           = mmapper_mmap,
+        .open           = mmapper_open,
+        .release        = mmapper_release,
+};
+
+static int __init mmapper_init(void)
+{
+        printk(KERN_INFO "Mapper v0.1\n");
+
+        v_buf = (char *) find_iomem("mmapper", &mmapper_size);
+        if(mmapper_size == 0){
+                printk(KERN_ERR "mmapper_init - find_iomem failed\n");
+                return(0);
+        }
+
+        p_buf = __pa(v_buf);
+
+        devfs_mk_cdev(MKDEV(30, 0), S_IFCHR|S_IRUGO|S_IWUGO, "mmapper");
+        return(0);
+}
+
+static void mmapper_exit(void)
+{
+}
+
+module_init(mmapper_init);
+module_exit(mmapper_exit);
+
+MODULE_AUTHOR("Greg Lonnon <glonnon@ridgerun.com>");
+MODULE_DESCRIPTION("DSPLinux simulator mmapper driver");
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
new file mode 100644
index 000000000000..4eeaf88c1e97
--- /dev/null
+++ b/arch/um/drivers/net_kern.c
@@ -0,0 +1,896 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/netdevice.h"
+#include "linux/rtnetlink.h"
+#include "linux/skbuff.h"
+#include "linux/socket.h"
+#include "linux/spinlock.h"
+#include "linux/module.h"
+#include "linux/init.h"
+#include "linux/etherdevice.h"
+#include "linux/list.h"
+#include "linux/inetdevice.h"
+#include "linux/ctype.h"
+#include "linux/bootmem.h"
+#include "linux/ethtool.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+
+#define DRIVER_NAME "uml-netdev"
+
+static DEFINE_SPINLOCK(opened_lock);
+LIST_HEAD(opened);
+
+static int uml_net_rx(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        int pkt_len;
+        struct sk_buff *skb;
+
+        /* If we can't allocate memory, try again next round. */
+        skb = dev_alloc_skb(dev->mtu);
+        if (skb == NULL) {
+                lp->stats.rx_dropped++;
+                return 0;
+        }
+
+        skb->dev = dev;
+        skb_put(skb, dev->mtu);
+        skb->mac.raw = skb->data;
+        pkt_len = (*lp->read)(lp->fd, &skb, lp);
+
+        if (pkt_len > 0) {
+                skb_trim(skb, pkt_len);
+                skb->protocol = (*lp->protocol)(skb);
+                netif_rx(skb);
+
+                lp->stats.rx_bytes += skb->len;
+                lp->stats.rx_packets++;
+                return pkt_len;
+        }
+
+        kfree_skb(skb);
+        return pkt_len;
+}
+
+irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct uml_net_private *lp = dev->priv;
+        int err;
+
+        if(!netif_running(dev))
+                return(IRQ_NONE);
+
+        spin_lock(&lp->lock);
+        while((err = uml_net_rx(dev)) > 0) ;
+        if(err < 0) {
+                printk(KERN_ERR 
+                       "Device '%s' read returned %d, shutting it down\n", 
+                       dev->name, err);
+                dev_close(dev);
+                goto out;
+        }
+        reactivate_fd(lp->fd, UM_ETH_IRQ);
+
+ out:
+        spin_unlock(&lp->lock);
+        return(IRQ_HANDLED);
+}
+
+static int uml_net_open(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        char addr[sizeof("255.255.255.255\0")];
+        int err;
+
+        spin_lock(&lp->lock);
+
+        if(lp->fd >= 0){
+                err = -ENXIO;
+                goto out;
+        }
+
+        if(!lp->have_mac){
+                dev_ip_addr(dev, addr, &lp->mac[2]);
+                set_ether_mac(dev, lp->mac);
+        }
+
+        lp->fd = (*lp->open)(&lp->user);
+        if(lp->fd < 0){
+                err = lp->fd;
+                goto out;
+        }
+
+        err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
+                             SA_INTERRUPT | SA_SHIRQ, dev->name, dev);
+        if(err != 0){
+                printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
+                if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
+                lp->fd = -1;
+                err = -ENETUNREACH;
+        }
+
+        lp->tl.data = (unsigned long) &lp->user;
+        netif_start_queue(dev);
+
+        /* clear buffer - it can happen that the host side of the interface
+         * is full when we get here.  In this case, new data is never queued,
+         * SIGIOs never arrive, and the net never works.
+         */
+        while((err = uml_net_rx(dev)) > 0) ;
+
+ out:
+        spin_unlock(&lp->lock);
+        return(err);
+}
+
+static int uml_net_close(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        
+        netif_stop_queue(dev);
+        spin_lock(&lp->lock);
+
+        free_irq_by_irq_and_dev(dev->irq, dev);
+        free_irq(dev->irq, dev);
+        if(lp->close != NULL)
+                (*lp->close)(lp->fd, &lp->user);
+        lp->fd = -1;
+
+        spin_unlock(&lp->lock);
+        return 0;
+}
+
+static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        unsigned long flags;
+        int len;
+
+        netif_stop_queue(dev);
+
+        spin_lock_irqsave(&lp->lock, flags);
+
+        len = (*lp->write)(lp->fd, &skb, lp);
+
+        if(len == skb->len) {
+                lp->stats.tx_packets++;
+                lp->stats.tx_bytes += skb->len;
+                dev->trans_start = jiffies;
+                netif_start_queue(dev);
+
+                /* this is normally done in the interrupt when tx finishes */
+                netif_wake_queue(dev);
+        } 
+        else if(len == 0){
+                netif_start_queue(dev);
+                lp->stats.tx_dropped++;
+        }
+        else {
+                netif_start_queue(dev);
+                printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
+        }
+
+        spin_unlock_irqrestore(&lp->lock, flags);
+
+        dev_kfree_skb(skb);
+
+        return 0;
+}
+
+static struct net_device_stats *uml_net_get_stats(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        return &lp->stats;
+}
+
+static void uml_net_set_multicast_list(struct net_device *dev)
+{
+        if (dev->flags & IFF_PROMISC) return;
+        else if (dev->mc_count) dev->flags |= IFF_ALLMULTI;
+        else dev->flags &= ~IFF_ALLMULTI;
+}
+
+static void uml_net_tx_timeout(struct net_device *dev)
+{
+        dev->trans_start = jiffies;
+        netif_wake_queue(dev);
+}
+
+static int uml_net_set_mac(struct net_device *dev, void *addr)
+{
+        struct uml_net_private *lp = dev->priv;
+        struct sockaddr *hwaddr = addr;
+
+        spin_lock(&lp->lock);
+        memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN);
+        spin_unlock(&lp->lock);
+
+        return(0);
+}
+
+static int uml_net_change_mtu(struct net_device *dev, int new_mtu)
+{
+        struct uml_net_private *lp = dev->priv;
+        int err = 0;
+
+        spin_lock(&lp->lock);
+
+        new_mtu = (*lp->set_mtu)(new_mtu, &lp->user);
+        if(new_mtu < 0){
+                err = new_mtu;
+                goto out;
+        }
+
+        dev->mtu = new_mtu;
+
+ out:
+        spin_unlock(&lp->lock);
+        return err;
+}
+
+static int uml_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+{
+        static const struct ethtool_drvinfo info = {
+                .cmd     = ETHTOOL_GDRVINFO,
+                .driver  = DRIVER_NAME,
+                .version = "42",
+        };
+        void *useraddr;
+        u32 ethcmd;
+
+        switch (cmd) {
+        case SIOCETHTOOL:
+                useraddr = ifr->ifr_data;
+                if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
+                        return -EFAULT;
+                switch (ethcmd) {
+                case ETHTOOL_GDRVINFO:
+                        if (copy_to_user(useraddr, &info, sizeof(info)))
+                                return -EFAULT;
+                        return 0;
+                default:
+                        return -EOPNOTSUPP;
+                }
+        default:
+                return -EINVAL;
+        }
+}
+
+void uml_net_user_timer_expire(unsigned long _conn)
+{
+#ifdef undef
+        struct connection *conn = (struct connection *)_conn;
+
+        dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
+        do_connect(conn);
+#endif
+}
+
+static DEFINE_SPINLOCK(devices_lock);
+static struct list_head devices = LIST_HEAD_INIT(devices);
+
+static struct device_driver uml_net_driver = {
+        .name  = DRIVER_NAME,
+        .bus   = &platform_bus_type,
+};
+static int driver_registered;
+
+static int eth_configure(int n, void *init, char *mac,
+                         struct transport *transport)
+{
+        struct uml_net *device;
+        struct net_device *dev;
+        struct uml_net_private *lp;
+        int save, err, size;
+
+        size = transport->private_size + sizeof(struct uml_net_private) + 
+                sizeof(((struct uml_net_private *) 0)->user);
+
+        device = kmalloc(sizeof(*device), GFP_KERNEL);
+        if (device == NULL) {
+                printk(KERN_ERR "eth_configure failed to allocate uml_net\n");
+                return(1);
+        }
+
+        memset(device, 0, sizeof(*device));
+        INIT_LIST_HEAD(&device->list);
+        device->index = n;
+
+        spin_lock(&devices_lock);
+        list_add(&device->list, &devices);
+        spin_unlock(&devices_lock);
+
+        if (setup_etheraddr(mac, device->mac))
+                device->have_mac = 1;
+
+        printk(KERN_INFO "Netdevice %d ", n);
+        if (device->have_mac)
+                printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
+                       device->mac[0], device->mac[1],
+                       device->mac[2], device->mac[3],
+                       device->mac[4], device->mac[5]);
+        printk(": ");
+        dev = alloc_etherdev(size);
+        if (dev == NULL) {
+                printk(KERN_ERR "eth_configure: failed to allocate device\n");
+                return 1;
+        }
+
+        /* sysfs register */
+        if (!driver_registered) {
+                driver_register(&uml_net_driver);
+                driver_registered = 1;
+        }
+        device->pdev.id = n;
+        device->pdev.name = DRIVER_NAME;
+        platform_device_register(&device->pdev);
+        SET_NETDEV_DEV(dev,&device->pdev.dev);
+
+        /* If this name ends up conflicting with an existing registered
+         * netdevice, that is OK, register_netdev{,ice}() will notice this
+         * and fail.
+         */
+        snprintf(dev->name, sizeof(dev->name), "eth%d", n);
+        device->dev = dev;
+
+        (*transport->kern->init)(dev, init);
+
+        dev->mtu = transport->user->max_packet;
+        dev->open = uml_net_open;
+        dev->hard_start_xmit = uml_net_start_xmit;
+        dev->stop = uml_net_close;
+        dev->get_stats = uml_net_get_stats;
+        dev->set_multicast_list = uml_net_set_multicast_list;
+        dev->tx_timeout = uml_net_tx_timeout;
+        dev->set_mac_address = uml_net_set_mac;
+        dev->change_mtu = uml_net_change_mtu;
+        dev->do_ioctl = uml_net_ioctl;
+        dev->watchdog_timeo = (HZ >> 1);
+        dev->irq = UM_ETH_IRQ;
+
+        rtnl_lock();
+        err = register_netdevice(dev);
+        rtnl_unlock();
+        if (err) {
+                device->dev = NULL;
+                /* XXX: should we call ->remove() here? */
+                free_netdev(dev);
+                return 1;
+        }
+        lp = dev->priv;
+
+        /* lp.user is the first four bytes of the transport data, which
+         * has already been initialized.  This structure assignment will
+         * overwrite that, so we make sure that .user gets overwritten with
+         * what it already has.
+         */
+        save = lp->user[0];
+        *lp = ((struct uml_net_private)
+                { .list                 = LIST_HEAD_INIT(lp->list),
+                  .dev                  = dev,
+                  .fd                   = -1,
+                  .mac                  = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
+                  .have_mac             = device->have_mac,
+                  .protocol             = transport->kern->protocol,
+                  .open                 = transport->user->open,
+                  .close                = transport->user->close,
+                  .remove               = transport->user->remove,
+                  .read                 = transport->kern->read,
+                  .write                = transport->kern->write,
+                  .add_address          = transport->user->add_address,
+                  .delete_address       = transport->user->delete_address,
+                  .set_mtu              = transport->user->set_mtu,
+                  .user                 = { save } });
+
+        init_timer(&lp->tl);
+        spin_lock_init(&lp->lock);
+        lp->tl.function = uml_net_user_timer_expire;
+        if (lp->have_mac)
+                memcpy(lp->mac, device->mac, sizeof(lp->mac));
+
+        if (transport->user->init) 
+                (*transport->user->init)(&lp->user, dev);
+
+        if (device->have_mac)
+                set_ether_mac(dev, device->mac);
+
+        spin_lock(&opened_lock);
+        list_add(&lp->list, &opened);
+        spin_unlock(&opened_lock);
+
+        return(0);
+}
+
+static struct uml_net *find_device(int n)
+{
+        struct uml_net *device;
+        struct list_head *ele;
+
+        spin_lock(&devices_lock);
+        list_for_each(ele, &devices){
+                device = list_entry(ele, struct uml_net, list);
+                if(device->index == n)
+                        goto out;
+        }
+        device = NULL;
+ out:
+        spin_unlock(&devices_lock);
+        return(device);
+}
+
+static int eth_parse(char *str, int *index_out, char **str_out)
+{
+        char *end;
+        int n;
+
+        n = simple_strtoul(str, &end, 0);
+        if(end == str){
+                printk(KERN_ERR "eth_setup: Failed to parse '%s'\n", str);
+                return(1);
+        }
+        if(n < 0){
+                printk(KERN_ERR "eth_setup: device %d is negative\n", n);
+                return(1);
+        }
+        str = end;
+        if(*str != '='){
+                printk(KERN_ERR 
+                       "eth_setup: expected '=' after device number\n");
+                return(1);
+        }
+        str++;
+        if(find_device(n)){
+                printk(KERN_ERR "eth_setup: Device %d already configured\n",
+                       n);
+                return(1);
+        }
+        if(index_out) *index_out = n;
+        *str_out = str;
+        return(0);
+}
+
+struct eth_init {
+        struct list_head list;
+        char *init;
+        int index;
+};
+
+/* Filled in at boot time.  Will need locking if the transports become
+ * modular.
+ */
+struct list_head transports = LIST_HEAD_INIT(transports);
+
+/* Filled in during early boot */
+struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
+
+static int check_transport(struct transport *transport, char *eth, int n,
+                           void **init_out, char **mac_out)
+{
+        int len;
+
+        len = strlen(transport->name);
+        if(strncmp(eth, transport->name, len))
+                return(0);
+
+        eth += len;
+        if(*eth == ',')
+                eth++;
+        else if(*eth != '\0')
+                return(0);
+
+        *init_out = kmalloc(transport->setup_size, GFP_KERNEL);
+        if(*init_out == NULL)
+                return(1);
+
+        if(!transport->setup(eth, mac_out, *init_out)){
+                kfree(*init_out);
+                *init_out = NULL;
+        }
+        return(1);
+}
+
+void register_transport(struct transport *new)
+{
+        struct list_head *ele, *next;
+        struct eth_init *eth;
+        void *init;
+        char *mac = NULL;
+        int match;
+
+        list_add(&new->list, &transports);
+
+        list_for_each_safe(ele, next, &eth_cmd_line){
+                eth = list_entry(ele, struct eth_init, list);
+                match = check_transport(new, eth->init, eth->index, &init,
+                                        &mac);
+                if(!match)
+                        continue;
+                else if(init != NULL){
+                        eth_configure(eth->index, init, mac, new);
+                        kfree(init);
+                }
+                list_del(&eth->list);
+        }
+}
+
+static int eth_setup_common(char *str, int index)
+{
+        struct list_head *ele;
+        struct transport *transport;
+        void *init;
+        char *mac = NULL;
+
+        list_for_each(ele, &transports){
+                transport = list_entry(ele, struct transport, list);
+                if(!check_transport(transport, str, index, &init, &mac))
+                        continue;
+                if(init != NULL){
+                        eth_configure(index, init, mac, transport);
+                        kfree(init);
+                }
+                return(1);
+        }
+        return(0);
+}
+
+static int eth_setup(char *str)
+{
+        struct eth_init *new;
+        int n, err;
+
+        err = eth_parse(str, &n, &str);
+        if(err) return(1);
+
+        new = alloc_bootmem(sizeof(new));
+        if (new == NULL){
+                printk("eth_init : alloc_bootmem failed\n");
+                return(1);
+        }
+
+        INIT_LIST_HEAD(&new->list);
+        new->index = n;
+        new->init = str;
+
+        list_add_tail(&new->list, &eth_cmd_line);
+        return(1);
+}
+
+__setup("eth", eth_setup);
+__uml_help(eth_setup,
+"eth[0-9]+=<transport>,<options>\n"
+"    Configure a network device.\n\n"
+);
+
+#if 0
+static int eth_init(void)
+{
+        struct list_head *ele, *next;
+        struct eth_init *eth;
+
+        list_for_each_safe(ele, next, &eth_cmd_line){
+                eth = list_entry(ele, struct eth_init, list);
+
+                if(eth_setup_common(eth->init, eth->index))
+                        list_del(&eth->list);
+        }
+        
+        return(1);
+}
+__initcall(eth_init);
+#endif
+
+static int net_config(char *str)
+{
+        int n, err;
+
+        err = eth_parse(str, &n, &str);
+        if(err) return(err);
+
+        str = uml_strdup(str);
+        if(str == NULL){
+                printk(KERN_ERR "net_config failed to strdup string\n");
+                return(-1);
+        }
+        err = !eth_setup_common(str, n);
+        if(err) 
+                kfree(str);
+        return(err);
+}
+
+static int net_remove(char *str)
+{
+        struct uml_net *device;
+        struct net_device *dev;
+        struct uml_net_private *lp;
+        char *end;
+        int n;
+
+        n = simple_strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str))
+                return(-1);
+
+        device = find_device(n);
+        if(device == NULL)
+                return(0);
+
+        dev = device->dev;
+        lp = dev->priv;
+        if(lp->fd > 0) return(-1);
+        if(lp->remove != NULL) (*lp->remove)(&lp->user);
+        unregister_netdev(dev);
+        platform_device_unregister(&device->pdev);
+
+        list_del(&device->list);
+        kfree(device);
+        free_netdev(dev);
+        return(0);
+}
+
+static struct mc_device net_mc = {
+        .name           = "eth",
+        .config         = net_config,
+        .get_config     = NULL,
+        .remove         = net_remove,
+};
+
+static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
+                              void *ptr)
+{
+        struct in_ifaddr *ifa = ptr;
+        u32 addr = ifa->ifa_address;
+        u32 netmask = ifa->ifa_mask;
+        struct net_device *dev = ifa->ifa_dev->dev;
+        struct uml_net_private *lp;
+        void (*proc)(unsigned char *, unsigned char *, void *);
+        unsigned char addr_buf[4], netmask_buf[4];
+
+        if(dev->open != uml_net_open) return(NOTIFY_DONE);
+
+        lp = dev->priv;
+
+        proc = NULL;
+        switch (event){
+        case NETDEV_UP:
+                proc = lp->add_address;
+                break;
+        case NETDEV_DOWN:
+                proc = lp->delete_address;
+                break;
+        }
+        if(proc != NULL){
+                addr_buf[0] = addr & 0xff;
+                addr_buf[1] = (addr >> 8) & 0xff;
+                addr_buf[2] = (addr >> 16) & 0xff;
+                addr_buf[3] = addr >> 24;
+                netmask_buf[0] = netmask & 0xff;
+                netmask_buf[1] = (netmask >> 8) & 0xff;
+                netmask_buf[2] = (netmask >> 16) & 0xff;
+                netmask_buf[3] = netmask >> 24;
+                (*proc)(addr_buf, netmask_buf, &lp->user);
+        }
+        return(NOTIFY_DONE);
+}
+
+struct notifier_block uml_inetaddr_notifier = {
+        .notifier_call          = uml_inetaddr_event,
+};
+
+static int uml_net_init(void)
+{
+        struct list_head *ele;
+        struct uml_net_private *lp;     
+        struct in_device *ip;
+        struct in_ifaddr *in;
+
+        mconsole_register_dev(&net_mc);
+        register_inetaddr_notifier(&uml_inetaddr_notifier);
+
+        /* Devices may have been opened already, so the uml_inetaddr_notifier
+         * didn't get a chance to run for them.  This fakes it so that
+         * addresses which have already been set up get handled properly.
+         */
+        list_for_each(ele, &opened){
+                lp = list_entry(ele, struct uml_net_private, list);
+                ip = lp->dev->ip_ptr;
+                if(ip == NULL) continue;
+                in = ip->ifa_list;
+                while(in != NULL){
+                        uml_inetaddr_event(NULL, NETDEV_UP, in);
+                        in = in->ifa_next;
+                }
+        }       
+
+        return(0);
+}
+
+__initcall(uml_net_init);
+
+static void close_devices(void)
+{
+        struct list_head *ele;
+        struct uml_net_private *lp;
+
+        list_for_each(ele, &opened){
+                lp = list_entry(ele, struct uml_net_private, list);
+                if((lp->close != NULL) && (lp->fd >= 0))
+                        (*lp->close)(lp->fd, &lp->user);
+                if(lp->remove != NULL) (*lp->remove)(&lp->user);
+        }
+}
+
+__uml_exitcall(close_devices);
+
+int setup_etheraddr(char *str, unsigned char *addr)
+{
+        char *end;
+        int i;
+
+        if(str == NULL)
+                return(0);
+        for(i=0;i<6;i++){
+                addr[i] = simple_strtoul(str, &end, 16);
+                if((end == str) ||
+                   ((*end != ':') && (*end != ',') && (*end != '\0'))){
+                        printk(KERN_ERR 
+                               "setup_etheraddr: failed to parse '%s' "
+                               "as an ethernet address\n", str);
+                        return(0);
+                }
+                str = end + 1;
+        }
+        if(addr[0] & 1){
+                printk(KERN_ERR 
+                       "Attempt to assign a broadcast ethernet address to a "
+                       "device disallowed\n");
+                return(0);
+        }
+        return(1);
+}
+
+void dev_ip_addr(void *d, char *buf, char *bin_buf)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        u32 addr;
+
+        if((ip == NULL) || ((in = ip->ifa_list) == NULL)){
+                printk(KERN_WARNING "dev_ip_addr - device not assigned an "
+                       "IP address\n");
+                return;
+        }
+        addr = in->ifa_address;
+        sprintf(buf, "%d.%d.%d.%d", addr & 0xff, (addr >> 8) & 0xff, 
+                (addr >> 16) & 0xff, addr >> 24);
+        if(bin_buf){
+                bin_buf[0] = addr & 0xff;
+                bin_buf[1] = (addr >> 8) & 0xff;
+                bin_buf[2] = (addr >> 16) & 0xff;
+                bin_buf[3] = addr >> 24;
+        }
+}
+
+void set_ether_mac(void *d, unsigned char *addr)
+{
+        struct net_device *dev = d;
+
+        memcpy(dev->dev_addr, addr, ETH_ALEN);  
+}
+
+struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra)
+{
+        if((skb != NULL) && (skb_tailroom(skb) < extra)){
+                struct sk_buff *skb2;
+
+                skb2 = skb_copy_expand(skb, 0, extra, GFP_ATOMIC);
+                dev_kfree_skb(skb);
+                skb = skb2;
+        }
+        if(skb != NULL) skb_put(skb, extra);
+        return(skb);
+}
+
+void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *, 
+                                        void *), 
+                    void *arg)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        unsigned char address[4], netmask[4];
+
+        if(ip == NULL) return;
+        in = ip->ifa_list;
+        while(in != NULL){
+                address[0] = in->ifa_address & 0xff;
+                address[1] = (in->ifa_address >> 8) & 0xff;
+                address[2] = (in->ifa_address >> 16) & 0xff;
+                address[3] = in->ifa_address >> 24;
+                netmask[0] = in->ifa_mask & 0xff;
+                netmask[1] = (in->ifa_mask >> 8) & 0xff;
+                netmask[2] = (in->ifa_mask >> 16) & 0xff;
+                netmask[3] = in->ifa_mask >> 24;
+                (*cb)(address, netmask, arg);
+                in = in->ifa_next;
+        }
+}
+
+int dev_netmask(void *d, void *m)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        __u32 *mask_out = m;
+
+        if(ip == NULL) 
+                return(1);
+
+        in = ip->ifa_list;
+        if(in == NULL) 
+                return(1);
+
+        *mask_out = in->ifa_mask;
+        return(0);
+}
+
+void *get_output_buffer(int *len_out)
+{
+        void *ret;
+
+        ret = (void *) __get_free_pages(GFP_KERNEL, 0);
+        if(ret) *len_out = PAGE_SIZE;
+        else *len_out = 0;
+        return(ret);
+}
+
+void free_output_buffer(void *buffer)
+{
+        free_pages((unsigned long) buffer, 0);
+}
+
+int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out, 
+                     char **gate_addr)
+{
+        char *remain;
+
+        remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
+        if(remain != NULL){
+                printk("tap_setup_common - Extra garbage on specification : "
+                       "'%s'\n", remain);
+                return(1);
+        }
+
+        return(0);
+}
+
+unsigned short eth_protocol(struct sk_buff *skb)
+{
+        return(eth_type_trans(skb, skb->dev));
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
new file mode 100644
index 000000000000..47229fe4a813
--- /dev/null
+++ b/arch/um/drivers/net_user.c
@@ -0,0 +1,255 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include "user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "net_user.h"
+#include "helper.h"
+#include "os.h"
+
+int tap_open_common(void *dev, char *gate_addr)
+{
+        int tap_addr[4];
+
+        if(gate_addr == NULL) return(0);
+        if(sscanf(gate_addr, "%d.%d.%d.%d", &tap_addr[0], 
+                  &tap_addr[1], &tap_addr[2], &tap_addr[3]) != 4){
+                printk("Invalid tap IP address - '%s'\n", gate_addr);
+                return(-EINVAL);
+        }
+        return(0);
+}
+
+void tap_check_ips(char *gate_addr, char *eth_addr)
+{
+        int tap_addr[4];
+
+        if((gate_addr != NULL) && 
+           (sscanf(gate_addr, "%d.%d.%d.%d", &tap_addr[0], 
+                   &tap_addr[1], &tap_addr[2], &tap_addr[3]) == 4) &&
+           (eth_addr[0] == tap_addr[0]) && 
+           (eth_addr[1] == tap_addr[1]) && 
+           (eth_addr[2] == tap_addr[2]) && 
+           (eth_addr[3] == tap_addr[3])){
+                printk("The tap IP address and the UML eth IP address"
+                       " must be different\n");
+        }
+}
+
+void read_output(int fd, char *output, int len)
+{
+        int remain, n, actual;
+        char c;
+
+        if(output == NULL){
+                output = &c;
+                len = sizeof(c);
+        }
+                
+        *output = '\0';
+        n = os_read_file(fd, &remain, sizeof(remain));
+        if(n != sizeof(remain)){
+                printk("read_output - read of length failed, err = %d\n", -n);
+                return;
+        }
+
+        while(remain != 0){
+                n = (remain < len) ? remain : len;
+                actual = os_read_file(fd, output, n);
+                if(actual != n){
+                        printk("read_output - read of data failed, "
+                               "err = %d\n", -actual);
+                        return;
+                }
+                remain -= actual;
+        }
+        return;
+}
+
+int net_read(int fd, void *buf, int len)
+{
+        int n;
+
+        n = os_read_file(fd,  buf,  len);
+
+        if(n == -EAGAIN)
+                return(0);
+        else if(n == 0)
+                return(-ENOTCONN);
+        return(n);
+}
+
+int net_recvfrom(int fd, void *buf, int len)
+{
+        int n;
+
+        while(((n = recvfrom(fd,  buf,  len, 0, NULL, NULL)) < 0) && 
+              (errno == EINTR)) ;
+
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);
+}
+
+int net_write(int fd, void *buf, int len)
+{
+        int n;
+
+        n = os_write_file(fd, buf, len);
+
+        if(n == -EAGAIN)
+                return(0);
+        else if(n == 0)
+                return(-ENOTCONN);
+        return(n);
+}
+
+int net_send(int fd, void *buf, int len)
+{
+        int n;
+
+        while(((n = send(fd, buf, len, 0)) < 0) && (errno == EINTR)) ;
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);      
+}
+
+int net_sendto(int fd, void *buf, int len, void *to, int sock_len)
+{
+        int n;
+
+        while(((n = sendto(fd, buf, len, 0, (struct sockaddr *) to,
+                           sock_len)) < 0) && (errno == EINTR)) ;
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);      
+}
+
+struct change_pre_exec_data {
+        int close_me;
+        int stdout;
+};
+
+static void change_pre_exec(void *arg)
+{
+        struct change_pre_exec_data *data = arg;
+
+        os_close_file(data->close_me);
+        dup2(data->stdout, 1);
+}
+
+static int change_tramp(char **argv, char *output, int output_len)
+{
+        int pid, fds[2], err;
+        struct change_pre_exec_data pe_data;
+
+        err = os_pipe(fds, 1, 0);
+        if(err < 0){
+                printk("change_tramp - pipe failed, err = %d\n", -err);
+                return(err);
+        }
+        pe_data.close_me = fds[0];
+        pe_data.stdout = fds[1];
+        pid = run_helper(change_pre_exec, &pe_data, argv, NULL);
+
+        read_output(fds[0], output, output_len);
+        os_close_file(fds[0]);
+        os_close_file(fds[1]);
+
+        if (pid > 0)
+                CATCH_EINTR(err = waitpid(pid, NULL, 0));
+        return(pid);
+}
+
+static void change(char *dev, char *what, unsigned char *addr,
+                   unsigned char *netmask)
+{
+        char addr_buf[sizeof("255.255.255.255\0")];
+        char netmask_buf[sizeof("255.255.255.255\0")];
+        char version[sizeof("nnnnn\0")];
+        char *argv[] = { "uml_net", version, what, dev, addr_buf, 
+                         netmask_buf, NULL };
+        char *output;
+        int output_len, pid;
+
+        sprintf(version, "%d", UML_NET_VERSION);
+        sprintf(addr_buf, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
+        sprintf(netmask_buf, "%d.%d.%d.%d", netmask[0], netmask[1], 
+                netmask[2], netmask[3]);
+
+        output_len = page_size();
+        output = um_kmalloc(output_len);
+        if(output == NULL)
+                printk("change : failed to allocate output buffer\n");
+
+        pid = change_tramp(argv, output, output_len);
+        if(pid < 0) return;
+
+        if(output != NULL){
+                printk("%s", output);
+                kfree(output);
+        }
+}
+
+void open_addr(unsigned char *addr, unsigned char *netmask, void *arg)
+{
+        change(arg, "add", addr, netmask);
+}
+
+void close_addr(unsigned char *addr, unsigned char *netmask, void *arg)
+{
+        change(arg, "del", addr, netmask);
+}
+
+char *split_if_spec(char *str, ...)
+{
+        char **arg, *end;
+        va_list ap;
+
+        va_start(ap, str);
+        while((arg = va_arg(ap, char **)) != NULL){
+                if(*str == '\0')
+                        return(NULL);
+                end = strchr(str, ',');
+                if(end != str)
+                        *arg = str;
+                if(end == NULL)
+                        return(NULL);
+                *end++ = '\0';
+                str = end;
+        }
+        va_end(ap);
+        return(str);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/null.c b/arch/um/drivers/null.c
new file mode 100644
index 000000000000..14cc5f78398a
--- /dev/null
+++ b/arch/um/drivers/null.c
@@ -0,0 +1,56 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include "chan_user.h"
+#include "os.h"
+
+static int null_chan;
+
+static void *null_init(char *str, int device, struct chan_opts *opts)
+{
+        return(&null_chan);
+}
+
+static int null_open(int input, int output, int primary, void *d,
+                     char **dev_out)
+{
+        *dev_out = NULL;
+        return(os_open_file(DEV_NULL, of_rdwr(OPENFLAGS()), 0));
+}
+
+static int null_read(int fd, char *c_out, void *unused)
+{
+        return(-ENODEV);
+}
+
+static void null_free(void *data)
+{
+}
+
+struct chan_ops null_ops = {
+        .type           = "null",
+        .init           = null_init,
+        .open           = null_open,
+        .close          = generic_close,
+        .read           = null_read,
+        .write          = generic_write,
+        .console_write  = generic_console_write,
+        .window_size    = generic_window_size,
+        .free           = null_free,
+        .winch          = 0,
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/pcap_kern.c b/arch/um/drivers/pcap_kern.c
new file mode 100644
index 000000000000..07c80f2156ef
--- /dev/null
+++ b/arch/um/drivers/pcap_kern.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2002 Jeff Dike <jdike@karaya.com>
+ * Licensed under the GPL.
+ */
+
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "pcap_user.h"
+
+struct pcap_init {
+        char *host_if;
+        int promisc;
+        int optimize;
+        char *filter;
+};
+
+void pcap_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct pcap_data *ppri;
+        struct pcap_init *init = data;
+
+        pri = dev->priv;
+        ppri = (struct pcap_data *) pri->user;
+        ppri->host_if = init->host_if;
+        ppri->promisc = init->promisc;
+        ppri->optimize = init->optimize;
+        ppri->filter = init->filter;
+}
+
+static int pcap_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(pcap_user_read(fd, (*skb)->mac.raw, 
+                              (*skb)->dev->mtu + ETH_HEADER_OTHER,
+                              (struct pcap_data *) &lp->user));
+}
+
+static int pcap_write(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        return(-EPERM);
+}
+
+static struct net_kern_info pcap_kern_info = {
+        .init                   = pcap_init,
+        .protocol               = eth_protocol,
+        .read                   = pcap_read,
+        .write                  = pcap_write,
+};
+
+int pcap_setup(char *str, char **mac_out, void *data)
+{
+        struct pcap_init *init = data;
+        char *remain, *host_if = NULL, *options[2] = { NULL, NULL };
+        int i;
+
+        *init = ((struct pcap_init)
+                { .host_if      = "eth0",
+                  .promisc      = 1,
+                  .optimize     = 0,
+                  .filter       = NULL });
+
+        remain = split_if_spec(str, &host_if, &init->filter, 
+                               &options[0], &options[1], NULL);
+        if(remain != NULL){
+                printk(KERN_ERR "pcap_setup - Extra garbage on "
+                       "specification : '%s'\n", remain);
+                return(0);
+        }
+
+        if(host_if != NULL)
+                init->host_if = host_if;
+
+        for(i = 0; i < sizeof(options)/sizeof(options[0]); i++){
+                if(options[i] == NULL)
+                        continue;
+                if(!strcmp(options[i], "promisc"))
+                        init->promisc = 1;
+                else if(!strcmp(options[i], "nopromisc"))
+                        init->promisc = 0;
+                else if(!strcmp(options[i], "optimize"))
+                        init->optimize = 1;
+                else if(!strcmp(options[i], "nooptimize"))
+                        init->optimize = 0;
+                else printk("pcap_setup : bad option - '%s'\n", options[i]);
+        }
+
+        return(1);
+}
+
+static struct transport pcap_transport = {
+        .list           = LIST_HEAD_INIT(pcap_transport.list),
+        .name           = "pcap",
+        .setup          = pcap_setup,
+        .user           = &pcap_user_info,
+        .kern           = &pcap_kern_info,
+        .private_size   = sizeof(struct pcap_data),
+        .setup_size     = sizeof(struct pcap_init),
+};
+
+static int register_pcap(void)
+{
+        register_transport(&pcap_transport);
+        return(1);
+}
+
+__initcall(register_pcap);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/pcap_user.c b/arch/um/drivers/pcap_user.c
new file mode 100644
index 000000000000..edfcb29273e1
--- /dev/null
+++ b/arch/um/drivers/pcap_user.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2002 Jeff Dike <jdike@karaya.com>
+ * Licensed under the GPL.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <pcap.h>
+#include <asm/types.h>
+#include "net_user.h"
+#include "pcap_user.h"
+#include "user.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+#define PCAP_FD(p) (*(int *)(p))
+
+static void pcap_user_init(void *data, void *dev)
+{
+        struct pcap_data *pri = data;
+        pcap_t *p;
+        char errors[PCAP_ERRBUF_SIZE];
+
+        p = pcap_open_live(pri->host_if, MAX_PACKET, pri->promisc, 0, errors);
+        if(p == NULL){
+                printk("pcap_user_init : pcap_open_live failed - '%s'\n", 
+                       errors);
+                return;
+        }
+
+        pri->dev = dev;
+        pri->pcap = p;
+}
+
+static int pcap_open(void *data)
+{
+        struct pcap_data *pri = data;
+        __u32 netmask;
+        int err;
+
+        if(pri->pcap == NULL)
+                return(-ENODEV);
+
+        if(pri->filter != NULL){
+                err = dev_netmask(pri->dev, &netmask);
+                if(err < 0){
+                        printk("pcap_open : dev_netmask failed\n");
+                        return(-EIO);
+                }
+
+                pri->compiled = um_kmalloc(sizeof(struct bpf_program));
+                if(pri->compiled == NULL){
+                        printk("pcap_open : kmalloc failed\n");
+                        return(-ENOMEM);
+                }
+                
+                err = pcap_compile(pri->pcap, 
+                                   (struct bpf_program *) pri->compiled, 
+                                   pri->filter, pri->optimize, netmask);
+                if(err < 0){
+                        printk("pcap_open : pcap_compile failed - '%s'\n", 
+                               pcap_geterr(pri->pcap));
+                        return(-EIO);
+                }
+
+                err = pcap_setfilter(pri->pcap, pri->compiled);
+                if(err < 0){
+                        printk("pcap_open : pcap_setfilter failed - '%s'\n", 
+                               pcap_geterr(pri->pcap));
+                        return(-EIO);
+                }
+        }
+        
+        return(PCAP_FD(pri->pcap));
+}
+
+static void pcap_remove(void *data)
+{
+        struct pcap_data *pri = data;
+
+        if(pri->compiled != NULL)
+                pcap_freecode(pri->compiled);
+
+        pcap_close(pri->pcap);
+}
+
+struct pcap_handler_data {
+        char *buffer;
+        int len;
+};
+
+static void handler(u_char *data, const struct pcap_pkthdr *header, 
+                    const u_char *packet)
+{
+        int len;
+
+        struct pcap_handler_data *hdata = (struct pcap_handler_data *) data;
+
+        len = hdata->len < header->caplen ? hdata->len : header->caplen;
+        memcpy(hdata->buffer, packet, len);
+        hdata->len = len;
+}
+
+int pcap_user_read(int fd, void *buffer, int len, struct pcap_data *pri)
+{
+        struct pcap_handler_data hdata = ((struct pcap_handler_data)
+                                          { .buffer     = buffer,
+                                            .len        = len });
+        int n;
+
+        n = pcap_dispatch(pri->pcap, 1, handler, (u_char *) &hdata);
+        if(n < 0){
+                printk("pcap_dispatch failed - %s\n", pcap_geterr(pri->pcap));
+                return(-EIO);
+        }
+        else if(n == 0) 
+                return(0);
+        return(hdata.len);
+}
+
+struct net_user_info pcap_user_info = {
+        .init           = pcap_user_init,
+        .open           = pcap_open,
+        .close          = NULL,
+        .remove         = pcap_remove,
+        .set_mtu        = NULL,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/pcap_user.h b/arch/um/drivers/pcap_user.h
new file mode 100644
index 000000000000..58f9f6a1420f
--- /dev/null
+++ b/arch/um/drivers/pcap_user.h
@@ -0,0 +1,31 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+struct pcap_data {
+        char *host_if;
+        int promisc;
+        int optimize;
+        char *filter;
+        void *compiled;
+        void *pcap;
+        void *dev;
+};
+
+extern struct net_user_info pcap_user_info;
+
+extern int pcap_user_read(int fd, void *buf, int len, struct pcap_data *pri);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/port.h b/arch/um/drivers/port.h
new file mode 100644
index 000000000000..9117609a575d
--- /dev/null
+++ b/arch/um/drivers/port.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __PORT_H__
+#define __PORT_H__
+
+extern void *port_data(int port);
+extern int port_wait(void *data);
+extern void port_kern_close(void *d);
+extern int port_connection(int fd, int *socket_out, int *pid_out);
+extern int port_listen_fd(int port);
+extern void port_read(int fd, void *data);
+extern void port_kern_free(void *d);
+extern int port_rcv_fd(int fd);
+extern void port_remove_dev(void *d);
+
+#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:
+ */
diff --git a/arch/um/drivers/port_kern.c b/arch/um/drivers/port_kern.c
new file mode 100644
index 000000000000..b5ee07472f79
--- /dev/null
+++ b/arch/um/drivers/port_kern.c
@@ -0,0 +1,309 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/list.h"
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "linux/interrupt.h"
+#include "linux/irq.h"
+#include "linux/spinlock.h"
+#include "linux/errno.h"
+#include "asm/atomic.h"
+#include "asm/semaphore.h"
+#include "asm/errno.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "port.h"
+#include "init.h"
+#include "os.h"
+
+struct port_list {
+        struct list_head list;
+        atomic_t wait_count;
+        int has_connection;
+        struct completion done;
+        int port;
+        int fd;
+        spinlock_t lock;
+        struct list_head pending;
+        struct list_head connections;
+};
+
+struct port_dev {
+        struct port_list *port;
+        int helper_pid;
+        int telnetd_pid;
+};
+
+struct connection {
+        struct list_head list;
+        int fd;
+        int helper_pid;
+        int socket[2];
+        int telnetd_pid;
+        struct port_list *port;
+};
+
+static irqreturn_t pipe_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct connection *conn = data;
+        int fd;
+
+        fd = os_rcv_fd(conn->socket[0], &conn->helper_pid);
+        if(fd < 0){
+                if(fd == -EAGAIN)
+                        return(IRQ_NONE);
+
+                printk(KERN_ERR "pipe_interrupt : os_rcv_fd returned %d\n", 
+                       -fd);
+                os_close_file(conn->fd);
+        }
+
+        list_del(&conn->list);
+
+        conn->fd = fd;
+        list_add(&conn->list, &conn->port->connections);
+
+        complete(&conn->port->done);
+        return(IRQ_HANDLED);
+}
+
+#define NO_WAITER_MSG \
+    "****\n" \
+    "There are currently no UML consoles waiting for port connections.\n" \
+    "Either disconnect from one to make it available or activate some more\n" \
+    "by enabling more consoles in the UML /etc/inittab.\n" \
+    "****\n"
+
+static int port_accept(struct port_list *port)
+{
+        struct connection *conn;
+        int fd, socket[2], pid, ret = 0;
+
+        fd = port_connection(port->fd, socket, &pid);
+        if(fd < 0){
+                if(fd != -EAGAIN)
+                        printk(KERN_ERR "port_accept : port_connection "
+                               "returned %d\n", -fd);
+                goto out;
+        }
+
+        conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
+        if(conn == NULL){
+                printk(KERN_ERR "port_accept : failed to allocate "
+                       "connection\n");
+                goto out_close;
+        }
+        *conn = ((struct connection) 
+                { .list         = LIST_HEAD_INIT(conn->list),
+                  .fd           = fd,
+                  .socket       = { socket[0], socket[1] },
+                  .telnetd_pid  = pid,
+                  .port         = port });
+
+        if(um_request_irq(TELNETD_IRQ, socket[0], IRQ_READ, pipe_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                          "telnetd", conn)){
+                printk(KERN_ERR "port_accept : failed to get IRQ for "
+                       "telnetd\n");
+                goto out_free;
+        }
+
+        if(atomic_read(&port->wait_count) == 0){
+                os_write_file(fd, NO_WAITER_MSG, sizeof(NO_WAITER_MSG));
+                printk("No one waiting for port\n");
+        }
+        list_add(&conn->list, &port->pending);
+        return(1);
+
+ out_free:
+        kfree(conn);
+ out_close:
+        os_close_file(fd);
+        if(pid != -1) 
+                os_kill_process(pid, 1);
+ out:
+        return(ret);
+} 
+
+DECLARE_MUTEX(ports_sem);
+struct list_head ports = LIST_HEAD_INIT(ports);
+
+void port_work_proc(void *unused)
+{
+        struct port_list *port;
+        struct list_head *ele;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                if(!port->has_connection)
+                        continue;
+                reactivate_fd(port->fd, ACCEPT_IRQ);
+                while(port_accept(port)) ;
+                port->has_connection = 0;
+        }
+        local_irq_restore(flags);
+}
+
+DECLARE_WORK(port_work, port_work_proc, NULL);
+
+static irqreturn_t port_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct port_list *port = data;
+
+        port->has_connection = 1;
+        schedule_work(&port_work);
+        return(IRQ_HANDLED);
+} 
+
+void *port_data(int port_num)
+{
+        struct list_head *ele;
+        struct port_list *port;
+        struct port_dev *dev = NULL;
+        int fd;
+
+        down(&ports_sem);
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                if(port->port == port_num) goto found;
+        }
+        port = kmalloc(sizeof(struct port_list), GFP_KERNEL);
+        if(port == NULL){
+                printk(KERN_ERR "Allocation of port list failed\n");
+                goto out;
+        }
+
+        fd = port_listen_fd(port_num);
+        if(fd < 0){
+                printk(KERN_ERR "binding to port %d failed, errno = %d\n",
+                       port_num, -fd);
+                goto out_free;
+        }
+        if(um_request_irq(ACCEPT_IRQ, fd, IRQ_READ, port_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, "port",
+                          port)){
+                printk(KERN_ERR "Failed to get IRQ for port %d\n", port_num);
+                goto out_close;
+        }
+
+        *port = ((struct port_list) 
+                { .list                 = LIST_HEAD_INIT(port->list),
+                  .wait_count           = ATOMIC_INIT(0),
+                  .has_connection       = 0,
+                  .port                 = port_num,
+                  .fd                   = fd,
+                  .pending              = LIST_HEAD_INIT(port->pending),
+                  .connections          = LIST_HEAD_INIT(port->connections) });
+        spin_lock_init(&port->lock);
+        init_completion(&port->done);
+        list_add(&port->list, &ports);
+
+ found:
+        dev = kmalloc(sizeof(struct port_dev), GFP_KERNEL);
+        if(dev == NULL){
+                printk(KERN_ERR "Allocation of port device entry failed\n");
+                goto out;
+        }
+
+        *dev = ((struct port_dev) { .port               = port,
+                                    .helper_pid         = -1,
+                                    .telnetd_pid        = -1 });
+        goto out;
+
+ out_free:
+        kfree(port);
+ out_close:
+        os_close_file(fd);
+ out:
+        up(&ports_sem);
+        return(dev);
+}
+
+int port_wait(void *data)
+{
+        struct port_dev *dev = data;
+        struct connection *conn;
+        struct port_list *port = dev->port;
+        int fd;
+
+        atomic_inc(&port->wait_count);
+        while(1){
+                fd = -ERESTARTSYS;
+                if(wait_for_completion_interruptible(&port->done))
+                        goto out;
+
+                spin_lock(&port->lock);
+
+                conn = list_entry(port->connections.next, struct connection, 
+                                  list);
+                list_del(&conn->list);
+                spin_unlock(&port->lock);
+
+                os_shutdown_socket(conn->socket[0], 1, 1);
+                os_close_file(conn->socket[0]);
+                os_shutdown_socket(conn->socket[1], 1, 1);
+                os_close_file(conn->socket[1]); 
+
+                /* This is done here because freeing an IRQ can't be done
+                 * within the IRQ handler.  So, pipe_interrupt always ups
+                 * the semaphore regardless of whether it got a successful
+                 * connection.  Then we loop here throwing out failed 
+                 * connections until a good one is found.
+                 */
+                free_irq_by_irq_and_dev(TELNETD_IRQ, conn);
+                free_irq(TELNETD_IRQ, conn);
+
+                if(conn->fd >= 0) break;
+                os_close_file(conn->fd);
+                kfree(conn);
+        }
+
+        fd = conn->fd;
+        dev->helper_pid = conn->helper_pid;
+        dev->telnetd_pid = conn->telnetd_pid;
+        kfree(conn);
+ out:
+        atomic_dec(&port->wait_count);
+        return fd;
+}
+
+void port_remove_dev(void *d)
+{
+        struct port_dev *dev = d;
+
+        if(dev->helper_pid != -1)
+                os_kill_process(dev->helper_pid, 0);
+        if(dev->telnetd_pid != -1)
+                os_kill_process(dev->telnetd_pid, 1);
+        dev->helper_pid = -1;
+        dev->telnetd_pid = -1;
+}
+
+void port_kern_free(void *d)
+{
+        struct port_dev *dev = d;
+
+        port_remove_dev(dev);
+        kfree(dev);
+}
+
+static void free_port(void)
+{
+        struct list_head *ele;
+        struct port_list *port;
+
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                free_irq_by_fd(port->fd);
+                os_close_file(port->fd);
+        }
+}
+
+__uml_exitcall(free_port);
diff --git a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
new file mode 100644
index 000000000000..14dd2002d2da
--- /dev/null
+++ b/arch/um/drivers/port_user.c
@@ -0,0 +1,225 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <termios.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "chan_user.h"
+#include "port.h"
+#include "helper.h"
+#include "os.h"
+
+struct port_chan {
+        int raw;
+        struct termios tt;
+        void *kernel_data;
+        char dev[sizeof("32768\0")];
+};
+
+static void *port_init(char *str, int device, struct chan_opts *opts)
+{
+        struct port_chan *data;
+        void *kern_data;
+        char *end;
+        int port;
+
+        if(*str != ':'){
+                printk("port_init : channel type 'port' must specify a "
+                       "port number\n");
+                return(NULL);
+        }
+        str++;
+        port = strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str)){
+                printk("port_init : couldn't parse port '%s'\n", str);
+                return(NULL);
+        }
+
+        kern_data = port_data(port);
+        if(kern_data == NULL)
+                return(NULL);
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL)
+                goto err;
+
+        *data = ((struct port_chan) { .raw              = opts->raw,
+                                      .kernel_data      = kern_data });
+        sprintf(data->dev, "%d", port);
+
+        return(data);
+ err:
+        port_kern_free(kern_data);
+        return(NULL);
+}
+
+static void port_free(void *d)
+{
+        struct port_chan *data = d;
+
+        port_kern_free(data->kernel_data);
+        kfree(data);
+}
+
+static int port_open(int input, int output, int primary, void *d,
+                     char **dev_out)
+{
+        struct port_chan *data = d;
+        int fd, err;
+
+        fd = port_wait(data->kernel_data);
+        if((fd >= 0) && data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+        *dev_out = data->dev;
+        return(fd);
+}
+
+static void port_close(int fd, void *d)
+{
+        struct port_chan *data = d;
+
+        port_remove_dev(data->kernel_data);
+        os_close_file(fd);
+}
+
+static int port_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct port_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops port_ops = {
+        .type           = "port",
+        .init           = port_init,
+        .open           = port_open,
+        .close          = port_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = port_console_write,
+        .window_size    = generic_window_size,
+        .free           = port_free,
+        .winch          = 1,
+};
+
+int port_listen_fd(int port)
+{
+        struct sockaddr_in addr;
+        int fd, err, arg;
+
+        fd = socket(PF_INET, SOCK_STREAM, 0);
+        if(fd == -1) 
+                return(-errno);
+
+        arg = 1;
+        if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &arg, sizeof(arg)) < 0){
+                err = -errno;
+                goto out;
+        }
+
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(port);
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        if(bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0){
+                err = -errno;
+                goto out;
+        }
+  
+        if(listen(fd, 1) < 0){
+                err = -errno;
+                goto out;
+        }
+
+        err = os_set_fd_block(fd, 0);
+        if(err < 0)
+                goto out;
+
+        return(fd);
+ out:
+        os_close_file(fd);
+        return(err);
+}
+
+struct port_pre_exec_data {
+        int sock_fd;
+        int pipe_fd;
+};
+
+void port_pre_exec(void *arg)
+{
+        struct port_pre_exec_data *data = arg;
+
+        dup2(data->sock_fd, 0);
+        dup2(data->sock_fd, 1);
+        dup2(data->sock_fd, 2);
+        os_close_file(data->sock_fd);
+        dup2(data->pipe_fd, 3);
+        os_shutdown_socket(3, 1, 0);
+        os_close_file(data->pipe_fd);
+}
+
+int port_connection(int fd, int *socket, int *pid_out)
+{
+        int new, err;
+        char *argv[] = { "/usr/sbin/in.telnetd", "-L", 
+                         "/usr/lib/uml/port-helper", NULL };
+        struct port_pre_exec_data data;
+
+        new = os_accept_connection(fd);
+        if(new < 0)
+                return(new);
+
+        err = os_pipe(socket, 0, 0);
+        if(err < 0)
+                goto out_close;
+
+        data = ((struct port_pre_exec_data)
+                { .sock_fd              = new,
+                  .pipe_fd              = socket[1] });
+
+        err = run_helper(port_pre_exec, &data, argv, NULL);
+        if(err < 0) 
+                goto out_shutdown;
+
+        *pid_out = err;
+        return(new);
+
+ out_shutdown:
+        os_shutdown_socket(socket[0], 1, 1);
+        os_close_file(socket[0]);
+        os_shutdown_socket(socket[1], 1, 1);    
+        os_close_file(socket[1]);
+ out_close:
+        os_close_file(new);
+        return(err);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
new file mode 100644
index 000000000000..ed84d01df6cc
--- /dev/null
+++ b/arch/um/drivers/pty.c
@@ -0,0 +1,162 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include "chan_user.h"
+#include "user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "os.h"
+
+struct pty_chan {
+        void (*announce)(char *dev_name, int dev);
+        int dev;
+        int raw;
+        struct termios tt;
+        char dev_name[sizeof("/dev/pts/0123456\0")];
+};
+
+static void *pty_chan_init(char *str, int device, struct chan_opts *opts)
+{
+        struct pty_chan *data;
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct pty_chan) { .announce          = opts->announce, 
+                                     .dev               = device,
+                                     .raw               = opts->raw });
+        return(data);
+}
+
+static int pts_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct pty_chan *data = d;
+        char *dev;
+        int fd, err;
+
+        fd = get_pty();
+        if(fd < 0){
+                printk("open_pts : Failed to open pts\n");
+                return(-errno);
+        }
+        if(data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+
+        dev = ptsname(fd);
+        sprintf(data->dev_name, "%s", dev);
+        *dev_out = data->dev_name;
+        if (data->announce)
+                (*data->announce)(dev, data->dev);
+        return(fd);
+}
+
+static int getmaster(char *line)
+{
+        char *pty, *bank, *cp;
+        int master, err;
+
+        pty = &line[strlen("/dev/ptyp")];
+        for (bank = "pqrs"; *bank; bank++) {
+                line[strlen("/dev/pty")] = *bank;
+                *pty = '0';
+                if (os_stat_file(line, NULL) < 0)
+                        break;
+                for (cp = "0123456789abcdef"; *cp; cp++) {
+                        *pty = *cp;
+                        master = os_open_file(line, of_rdwr(OPENFLAGS()), 0);
+                        if (master >= 0) {
+                                char *tp = &line[strlen("/dev/")];
+
+                                /* verify slave side is usable */
+                                *tp = 't';
+                                err = os_access(line, OS_ACC_RW_OK);
+                                *tp = 'p';
+                                if(err == 0) return(master);
+                                (void) os_close_file(master);
+                        }
+                }
+        }
+        return(-1);
+}
+
+static int pty_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct pty_chan *data = d;
+        int fd, err;
+        char dev[sizeof("/dev/ptyxx\0")] = "/dev/ptyxx";
+
+        fd = getmaster(dev);
+        if(fd < 0)
+                return(-errno);
+
+        if(data->raw){
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+        
+        if(data->announce) (*data->announce)(dev, data->dev);
+
+        sprintf(data->dev_name, "%s", dev);
+        *dev_out = data->dev_name;
+        return(fd);
+}
+
+static int pty_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct pty_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops pty_ops = {
+        .type           = "pty",
+        .init           = pty_chan_init,
+        .open           = pty_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = pty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+struct chan_ops pts_ops = {
+        .type           = "pts",
+        .init           = pty_chan_init,
+        .open           = pts_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = pty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/random.c b/arch/um/drivers/random.c
new file mode 100644
index 000000000000..d43e9fab05a7
--- /dev/null
+++ b/arch/um/drivers/random.c
@@ -0,0 +1,122 @@
+/* Much of this ripped from hw_random.c */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/delay.h>
+#include <asm/uaccess.h>
+#include "os.h"
+
+/*
+ * core module and version information
+ */
+#define RNG_VERSION "1.0.0"
+#define RNG_MODULE_NAME "random"
+#define RNG_DRIVER_NAME   RNG_MODULE_NAME " virtual driver " RNG_VERSION
+#define PFX RNG_MODULE_NAME ": "
+
+#define RNG_MISCDEV_MINOR               183 /* official */
+
+static int random_fd = -1;
+
+static int rng_dev_open (struct inode *inode, struct file *filp)
+{
+        /* enforce read-only access to this chrdev */
+        if ((filp->f_mode & FMODE_READ) == 0)
+                return -EINVAL;
+        if (filp->f_mode & FMODE_WRITE)
+                return -EINVAL;
+
+        return 0;
+}
+
+static ssize_t rng_dev_read (struct file *filp, char __user *buf, size_t size,
+                             loff_t * offp)
+{
+        u32 data;
+        int n, ret = 0, have_data;
+
+        while(size){
+                n = os_read_file(random_fd, &data, sizeof(data));
+                if(n > 0){
+                        have_data = n;
+                        while (have_data && size) {
+                                if (put_user((u8)data, buf++)) {
+                                        ret = ret ? : -EFAULT;
+                                        break;
+                                }
+                                size--;
+                                ret++;
+                                have_data--;
+                                data>>=8;
+                        }
+                }
+                else if(n == -EAGAIN){
+                        if (filp->f_flags & O_NONBLOCK)
+                                return ret ? : -EAGAIN;
+
+                        if(need_resched()){
+                                current->state = TASK_INTERRUPTIBLE;
+                                schedule_timeout(1);
+                        }
+                }
+                else return n;
+                if (signal_pending (current))
+                        return ret ? : -ERESTARTSYS;
+        }
+        return ret;
+}
+
+static struct file_operations rng_chrdev_ops = {
+        .owner          = THIS_MODULE,
+        .open           = rng_dev_open,
+        .read           = rng_dev_read,
+};
+
+static struct miscdevice rng_miscdev = {
+        RNG_MISCDEV_MINOR,
+        RNG_MODULE_NAME,
+        &rng_chrdev_ops,
+};
+
+/*
+ * rng_init - initialize RNG module
+ */
+static int __init rng_init (void)
+{
+        int err;
+
+        err = os_open_file("/dev/random", of_read(OPENFLAGS()), 0);
+        if(err < 0)
+                goto out;
+
+        random_fd = err;
+
+        err = os_set_fd_block(random_fd, 0);
+        if(err)
+                goto err_out_cleanup_hw;
+
+        err = misc_register (&rng_miscdev);
+        if (err) {
+                printk (KERN_ERR PFX "misc device register failed\n");
+                goto err_out_cleanup_hw;
+        }
+
+ out:
+        return err;
+
+ err_out_cleanup_hw:
+        random_fd = -1;
+        goto out;
+}
+
+/*
+ * rng_cleanup - shutdown RNG module
+ */
+static void __exit rng_cleanup (void)
+{
+        misc_deregister (&rng_miscdev);
+}
+
+module_init (rng_init);
+module_exit (rng_cleanup);
diff --git a/arch/um/drivers/slip.h b/arch/um/drivers/slip.h
new file mode 100644
index 000000000000..495f2f1b1420
--- /dev/null
+++ b/arch/um/drivers/slip.h
@@ -0,0 +1,39 @@
+#ifndef __UM_SLIP_H
+#define __UM_SLIP_H
+
+#define BUF_SIZE 1500
+ /* two bytes each for a (pathological) max packet of escaped chars +  * 
+  * terminating END char + initial END char                            */
+#define ENC_BUF_SIZE (2 * BUF_SIZE + 2)
+
+struct slip_data {
+        void *dev;
+        char name[sizeof("slnnnnn\0")];
+        char *addr;
+        char *gate_addr;
+        int slave;
+        char ibuf[ENC_BUF_SIZE];
+        char obuf[ENC_BUF_SIZE];
+        int more; /* more data: do not read fd until ibuf has been drained */
+        int pos;
+        int esc;
+};
+
+extern struct net_user_info slip_user_info;
+
+extern int set_umn_addr(int fd, char *addr, char *ptp_addr);
+extern int slip_user_read(int fd, void *buf, int len, struct slip_data *pri);
+extern int slip_user_write(int fd, void *buf, int len, struct slip_data *pri);
+
+#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:
+ */
diff --git a/arch/um/drivers/slip_kern.c b/arch/um/drivers/slip_kern.c
new file mode 100644
index 000000000000..0886eedba213
--- /dev/null
+++ b/arch/um/drivers/slip_kern.c
@@ -0,0 +1,109 @@
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/stddef.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/if_arp.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "kern.h"
+#include "slip.h"
+
+struct slip_init {
+        char *gate_addr;
+};
+
+void slip_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *private;
+        struct slip_data *spri;
+        struct slip_init *init = data;
+
+        private = dev->priv;
+        spri = (struct slip_data *) private->user;
+        *spri = ((struct slip_data)
+                { .name         = { '\0' },
+                  .addr         = NULL,
+                  .gate_addr    = init->gate_addr,
+                  .slave        = -1,
+                  .ibuf         = { '\0' },
+                  .obuf         = { '\0' },
+                  .pos          = 0,
+                  .esc          = 0,
+                  .dev          = dev });
+
+        dev->init = NULL;
+        dev->hard_header_len = 0;
+        dev->addr_len = 4;
+        dev->type = ARPHRD_ETHER;
+        dev->tx_queue_len = 256;
+        dev->flags = IFF_NOARP;
+        printk("SLIP backend - SLIP IP = %s\n", spri->gate_addr);
+}
+
+static unsigned short slip_protocol(struct sk_buff *skbuff)
+{
+        return(htons(ETH_P_IP));
+}
+
+static int slip_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        return(slip_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 
+                              (struct slip_data *) &lp->user));
+}
+
+static int slip_write(int fd, struct sk_buff **skb,
+                      struct uml_net_private *lp)
+{
+        return(slip_user_write(fd, (*skb)->data, (*skb)->len, 
+                               (struct slip_data *) &lp->user));
+}
+
+struct net_kern_info slip_kern_info = {
+        .init                   = slip_init,
+        .protocol               = slip_protocol,
+        .read                   = slip_read,
+        .write                  = slip_write,
+};
+
+static int slip_setup(char *str, char **mac_out, void *data)
+{
+        struct slip_init *init = data;
+
+        *init = ((struct slip_init)
+                { .gate_addr            = NULL });
+
+        if(str[0] != '\0') 
+                init->gate_addr = str;
+        return(1);
+}
+
+static struct transport slip_transport = {
+        .list           = LIST_HEAD_INIT(slip_transport.list),
+        .name           = "slip",
+        .setup          = slip_setup,
+        .user           = &slip_user_info,
+        .kern           = &slip_kern_info,
+        .private_size   = sizeof(struct slip_data),
+        .setup_size     = sizeof(struct slip_init),
+};
+
+static int register_slip(void)
+{
+        register_transport(&slip_transport);
+        return(1);
+}
+
+__initcall(register_slip);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/slip_proto.h b/arch/um/drivers/slip_proto.h
new file mode 100644
index 000000000000..7206361ace45
--- /dev/null
+++ b/arch/um/drivers/slip_proto.h
@@ -0,0 +1,93 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_SLIP_PROTO_H__
+#define __UM_SLIP_PROTO_H__
+
+/* SLIP protocol characters. */
+#define SLIP_END             0300       /* indicates end of frame       */
+#define SLIP_ESC             0333       /* indicates byte stuffing      */
+#define SLIP_ESC_END         0334       /* ESC ESC_END means END 'data' */
+#define SLIP_ESC_ESC         0335       /* ESC ESC_ESC means ESC 'data' */
+
+static inline int slip_unesc(unsigned char c,char *buf,int *pos, int *esc)
+{
+        int ret;
+
+        switch(c){
+        case SLIP_END:
+                *esc = 0;
+                ret=*pos;
+                *pos=0;
+                return(ret);
+        case SLIP_ESC:
+                *esc = 1;
+                return(0);
+        case SLIP_ESC_ESC:
+                if(*esc){
+                        *esc = 0;
+                        c = SLIP_ESC;
+                }
+                break;
+        case SLIP_ESC_END:
+                if(*esc){
+                        *esc = 0;
+                        c = SLIP_END;
+                }
+                break;
+        }
+        buf[(*pos)++] = c;
+        return(0);
+}
+
+static inline int slip_esc(unsigned char *s, unsigned char *d, int len)
+{
+        unsigned char *ptr = d;
+        unsigned char c;
+
+        /*
+         * Send an initial END character to flush out any
+         * data that may have accumulated in the receiver
+         * due to line noise.
+         */
+
+        *ptr++ = SLIP_END;
+
+        /*
+         * For each byte in the packet, send the appropriate
+         * character sequence, according to the SLIP protocol.
+         */
+
+        while (len-- > 0) {
+                switch(c = *s++) {
+                case SLIP_END:
+                        *ptr++ = SLIP_ESC;
+                        *ptr++ = SLIP_ESC_END;
+                        break;
+                case SLIP_ESC:
+                        *ptr++ = SLIP_ESC;
+                        *ptr++ = SLIP_ESC_ESC;
+                        break;
+                default:
+                        *ptr++ = c;
+                        break;
+                }
+        }
+        *ptr++ = SLIP_END;
+        return (ptr - d);
+}
+
+#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:
+ */
diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
new file mode 100644
index 000000000000..d94846b1b4cf
--- /dev/null
+++ b/arch/um/drivers/slip_user.c
@@ -0,0 +1,280 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/termios.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "net_user.h"
+#include "slip.h"
+#include "slip_proto.h"
+#include "helper.h"
+#include "os.h"
+
+void slip_user_init(void *data, void *dev)
+{
+        struct slip_data *pri = data;
+
+        pri->dev = dev;
+}
+
+static int set_up_tty(int fd)
+{
+        int i;
+        struct termios tios;
+
+        if (tcgetattr(fd, &tios) < 0) {
+                printk("could not get initial terminal attributes\n");
+                return(-1);
+        }
+
+        tios.c_cflag = CS8 | CREAD | HUPCL | CLOCAL;
+        tios.c_iflag = IGNBRK | IGNPAR;
+        tios.c_oflag = 0;
+        tios.c_lflag = 0;
+        for (i = 0; i < NCCS; i++)
+                tios.c_cc[i] = 0;
+        tios.c_cc[VMIN] = 1;
+        tios.c_cc[VTIME] = 0;
+
+        cfsetospeed(&tios, B38400);
+        cfsetispeed(&tios, B38400);
+
+        if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
+                printk("failed to set terminal attributes\n");
+                return(-1);
+        }
+        return(0);
+}
+
+struct slip_pre_exec_data {
+        int stdin;
+        int stdout;
+        int close_me;
+};
+
+static void slip_pre_exec(void *arg)
+{
+        struct slip_pre_exec_data *data = arg;
+
+        if(data->stdin >= 0) dup2(data->stdin, 0);
+        dup2(data->stdout, 1);
+        if(data->close_me >= 0) os_close_file(data->close_me);
+}
+
+static int slip_tramp(char **argv, int fd)
+{
+        struct slip_pre_exec_data pe_data;
+        char *output;
+        int status, pid, fds[2], err, output_len;
+
+        err = os_pipe(fds, 1, 0);
+        if(err < 0){
+                printk("slip_tramp : pipe failed, err = %d\n", -err);
+                return(err);
+        }
+
+        err = 0;
+        pe_data.stdin = fd;
+        pe_data.stdout = fds[1];
+        pe_data.close_me = fds[0];
+        pid = run_helper(slip_pre_exec, &pe_data, argv, NULL);
+
+        if(pid < 0) err = pid;
+        else {
+                output_len = page_size();
+                output = um_kmalloc(output_len);
+                if(output == NULL)
+                        printk("slip_tramp : failed to allocate output "
+                               "buffer\n");
+
+                os_close_file(fds[1]);
+                read_output(fds[0], output, output_len);
+                if(output != NULL){
+                        printk("%s", output);
+                        kfree(output);
+                }
+                CATCH_EINTR(err = waitpid(pid, &status, 0));
+                if(err < 0)
+                        err = errno;
+                else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
+                        printk("'%s' didn't exit with status 0\n", argv[0]);
+                        err = -EINVAL;
+                }
+        }
+
+        os_close_file(fds[0]);
+
+        return(err);
+}
+
+static int slip_open(void *data)
+{
+        struct slip_data *pri = data;
+        char version_buf[sizeof("nnnnn\0")];
+        char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
+        char *argv[] = { "uml_net", version_buf, "slip", "up", gate_buf, 
+                         NULL };
+        int sfd, mfd, err;
+
+        mfd = get_pty();
+        if(mfd < 0){
+                printk("umn : Failed to open pty, err = %d\n", -mfd);
+                return(mfd);
+        }
+        sfd = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0);
+        if(sfd < 0){
+                printk("Couldn't open tty for slip line, err = %d\n", -sfd);
+                os_close_file(mfd);
+                return(sfd);
+        }
+        if(set_up_tty(sfd)) return(-1);
+        pri->slave = sfd;
+        pri->pos = 0;
+        pri->esc = 0;
+        if(pri->gate_addr != NULL){
+                sprintf(version_buf, "%d", UML_NET_VERSION);
+                strcpy(gate_buf, pri->gate_addr);
+
+                err = slip_tramp(argv, sfd);
+
+                if(err < 0){
+                        printk("slip_tramp failed - err = %d\n", -err);
+                        return(err);
+                }
+                err = os_get_ifname(pri->slave, pri->name);
+                if(err < 0){
+                        printk("get_ifname failed, err = %d\n", -err);
+                        return(err);
+                }
+                iter_addresses(pri->dev, open_addr, pri->name);
+        }
+        else {
+                err = os_set_slip(sfd);
+                if(err < 0){
+                        printk("Failed to set slip discipline encapsulation - "
+                               "err = %d\n", -err);
+                        return(err);
+                }
+        }
+        return(mfd);
+}
+
+static void slip_close(int fd, void *data)
+{
+        struct slip_data *pri = data;
+        char version_buf[sizeof("nnnnn\0")];
+        char *argv[] = { "uml_net", version_buf, "slip", "down", pri->name, 
+                         NULL };
+        int err;
+
+        if(pri->gate_addr != NULL)
+                iter_addresses(pri->dev, close_addr, pri->name);
+
+        sprintf(version_buf, "%d", UML_NET_VERSION);
+
+        err = slip_tramp(argv, pri->slave);
+
+        if(err != 0)
+                printk("slip_tramp failed - errno = %d\n", -err);
+        os_close_file(fd);
+        os_close_file(pri->slave);
+        pri->slave = -1;
+}
+
+int slip_user_read(int fd, void *buf, int len, struct slip_data *pri)
+{
+        int i, n, size, start;
+
+        if(pri->more>0) {
+                i = 0;
+                while(i < pri->more) {
+                        size = slip_unesc(pri->ibuf[i++],
+                                        pri->ibuf, &pri->pos, &pri->esc);
+                        if(size){
+                                memcpy(buf, pri->ibuf, size);
+                                memmove(pri->ibuf, &pri->ibuf[i], pri->more-i);
+                                pri->more=pri->more-i; 
+                                return(size);
+                        }
+                }
+                pri->more=0;
+        }
+
+        n = net_read(fd, &pri->ibuf[pri->pos], sizeof(pri->ibuf) - pri->pos);
+        if(n <= 0) return(n);
+
+        start = pri->pos;
+        for(i = 0; i < n; i++){
+                size = slip_unesc(pri->ibuf[start + i],
+                                pri->ibuf, &pri->pos, &pri->esc);
+                if(size){
+                        memcpy(buf, pri->ibuf, size);
+                        memmove(pri->ibuf, &pri->ibuf[start+i+1], n-(i+1));
+                        pri->more=n-(i+1); 
+                        return(size);
+                }
+        }
+        return(0);
+}
+
+int slip_user_write(int fd, void *buf, int len, struct slip_data *pri)
+{
+        int actual, n;
+
+        actual = slip_esc(buf, pri->obuf, len);
+        n = net_write(fd, pri->obuf, actual);
+        if(n < 0) return(n);
+        else return(len);
+}
+
+static int slip_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+static void slip_add_addr(unsigned char *addr, unsigned char *netmask,
+                          void *data)
+{
+        struct slip_data *pri = data;
+
+        if(pri->slave < 0) return;
+        open_addr(addr, netmask, pri->name);
+}
+
+static void slip_del_addr(unsigned char *addr, unsigned char *netmask,
+                            void *data)
+{
+        struct slip_data *pri = data;
+
+        if(pri->slave < 0) return;
+        close_addr(addr, netmask, pri->name);
+}
+
+struct net_user_info slip_user_info = {
+        .init           = slip_user_init,
+        .open           = slip_open,
+        .close          = slip_close,
+        .remove         = NULL,
+        .set_mtu        = slip_set_mtu,
+        .add_address    = slip_add_addr,
+        .delete_address = slip_del_addr,
+        .max_packet     = BUF_SIZE
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/slirp.h b/arch/um/drivers/slirp.h
new file mode 100644
index 000000000000..04e407d1e44a
--- /dev/null
+++ b/arch/um/drivers/slirp.h
@@ -0,0 +1,51 @@
+#ifndef __UM_SLIRP_H
+#define __UM_SLIRP_H
+
+#define BUF_SIZE 1500
+ /* two bytes each for a (pathological) max packet of escaped chars +  * 
+  * terminating END char + initial END char                            */
+#define ENC_BUF_SIZE (2 * BUF_SIZE + 2)
+
+#define SLIRP_MAX_ARGS 100
+/*
+ * XXX this next definition is here because I don't understand why this
+ * initializer doesn't work in slirp_kern.c:
+ *
+ *   argv :  { init->argv[ 0 ... SLIRP_MAX_ARGS-1 ] },
+ *
+ * or why I can't typecast like this:
+ *
+ *   argv :  (char* [SLIRP_MAX_ARGS])(init->argv), 
+ */
+struct arg_list_dummy_wrapper { char *argv[SLIRP_MAX_ARGS]; };
+
+struct slirp_data {
+        void *dev;
+        struct arg_list_dummy_wrapper argw;
+        int pid;
+        int slave;
+        char ibuf[ENC_BUF_SIZE];
+        char obuf[ENC_BUF_SIZE];
+        int more; /* more data: do not read fd until ibuf has been drained */
+        int pos;
+        int esc;
+};
+
+extern struct net_user_info slirp_user_info;
+
+extern int set_umn_addr(int fd, char *addr, char *ptp_addr);
+extern int slirp_user_read(int fd, void *buf, int len, struct slirp_data *pri);
+extern int slirp_user_write(int fd, void *buf, int len, struct slirp_data *pri);
+
+#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:
+ */
diff --git a/arch/um/drivers/slirp_kern.c b/arch/um/drivers/slirp_kern.c
new file mode 100644
index 000000000000..c9d6b52a831d
--- /dev/null
+++ b/arch/um/drivers/slirp_kern.c
@@ -0,0 +1,135 @@
+#include "linux/kernel.h"
+#include "linux/stddef.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/if_arp.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "kern.h"
+#include "slirp.h"
+
+struct slirp_init {
+        struct arg_list_dummy_wrapper argw;  /* XXX should be simpler... */
+};
+
+void slirp_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *private;
+        struct slirp_data *spri;
+        struct slirp_init *init = data;
+        int i;
+
+        private = dev->priv;
+        spri = (struct slirp_data *) private->user;
+        *spri = ((struct slirp_data)
+                { .argw         = init->argw,
+                  .pid          = -1,
+                  .slave        = -1,
+                  .ibuf         = { '\0' },
+                  .obuf         = { '\0' },
+                  .pos          = 0,
+                  .esc          = 0,
+                  .dev          = dev });
+
+        dev->init = NULL;
+        dev->hard_header_len = 0;
+        dev->header_cache_update = NULL;
+        dev->hard_header_cache = NULL;
+        dev->hard_header = NULL;
+        dev->addr_len = 0;
+        dev->type = ARPHRD_SLIP;
+        dev->tx_queue_len = 256;
+        dev->flags = IFF_NOARP;
+        printk("SLIRP backend - command line:");
+        for(i=0;spri->argw.argv[i]!=NULL;i++) {
+                printk(" '%s'",spri->argw.argv[i]);
+        }
+        printk("\n");
+}
+
+static unsigned short slirp_protocol(struct sk_buff *skbuff)
+{
+        return(htons(ETH_P_IP));
+}
+
+static int slirp_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        return(slirp_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 
+                              (struct slirp_data *) &lp->user));
+}
+
+static int slirp_write(int fd, struct sk_buff **skb,
+                      struct uml_net_private *lp)
+{
+        return(slirp_user_write(fd, (*skb)->data, (*skb)->len, 
+                               (struct slirp_data *) &lp->user));
+}
+
+struct net_kern_info slirp_kern_info = {
+        .init                   = slirp_init,
+        .protocol               = slirp_protocol,
+        .read                   = slirp_read,
+        .write                  = slirp_write,
+};
+
+static int slirp_setup(char *str, char **mac_out, void *data)
+{
+        struct slirp_init *init = data;
+        int i=0;
+
+        *init = ((struct slirp_init)
+                { argw :                { { "slirp", NULL  } } });
+
+        str = split_if_spec(str, mac_out, NULL);
+
+        if(str == NULL) { /* no command line given after MAC addr */
+                return(1);
+        }
+
+        do {
+                if(i>=SLIRP_MAX_ARGS-1) {
+                        printk("slirp_setup: truncating slirp arguments\n");
+                        break;
+                }
+                init->argw.argv[i++] = str;
+                while(*str && *str!=',') {
+                        if(*str=='_') *str=' ';
+                        str++;
+                }
+                if(*str!=',')
+                        break;
+                *str++='\0';
+        } while(1);
+        init->argw.argv[i]=NULL;
+        return(1);
+}
+
+static struct transport slirp_transport = {
+        .list           = LIST_HEAD_INIT(slirp_transport.list),
+        .name           = "slirp",
+        .setup          = slirp_setup,
+        .user           = &slirp_user_info,
+        .kern           = &slirp_kern_info,
+        .private_size   = sizeof(struct slirp_data),
+        .setup_size     = sizeof(struct slirp_init),
+};
+
+static int register_slirp(void)
+{
+        register_transport(&slirp_transport);
+        return(1);
+}
+
+__initcall(register_slirp);
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
new file mode 100644
index 000000000000..c322515c71cc
--- /dev/null
+++ b/arch/um/drivers/slirp_user.c
@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "net_user.h"
+#include "slirp.h"
+#include "slip_proto.h"
+#include "helper.h"
+#include "os.h"
+
+void slirp_user_init(void *data, void *dev)
+{
+        struct slirp_data *pri = data;
+
+        pri->dev = dev;
+}
+
+struct slirp_pre_exec_data {
+        int stdin;
+        int stdout;
+};
+
+static void slirp_pre_exec(void *arg)
+{
+        struct slirp_pre_exec_data *data = arg;
+
+        if(data->stdin != -1) dup2(data->stdin, 0);
+        if(data->stdout != -1) dup2(data->stdout, 1);
+}
+
+static int slirp_tramp(char **argv, int fd)
+{
+        struct slirp_pre_exec_data pe_data;
+        int pid;
+
+        pe_data.stdin = fd;
+        pe_data.stdout = fd;
+        pid = run_helper(slirp_pre_exec, &pe_data, argv, NULL);
+
+        return(pid);
+}
+
+/* XXX This is just a trivial wrapper around os_pipe */
+static int slirp_datachan(int *mfd, int *sfd)
+{
+        int fds[2], err;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("slirp_datachan: Failed to open pipe, err = %d\n", -err);
+                return(err);
+        }
+
+        *mfd = fds[0];
+        *sfd = fds[1];
+        return(0);
+}
+
+static int slirp_open(void *data)
+{
+        struct slirp_data *pri = data;
+        int sfd, mfd, pid, err;
+
+        err = slirp_datachan(&mfd, &sfd);
+        if(err)
+                return(err);
+
+        pid = slirp_tramp(pri->argw.argv, sfd);
+
+        if(pid < 0){
+                printk("slirp_tramp failed - errno = %d\n", -pid);
+                os_close_file(sfd);     
+                os_close_file(mfd);     
+                return(pid);
+        }
+
+        pri->slave = sfd;
+        pri->pos = 0;
+        pri->esc = 0;
+
+        pri->pid = pid;
+
+        return(mfd);
+}
+
+static void slirp_close(int fd, void *data)
+{
+        struct slirp_data *pri = data;
+        int status,err;
+
+        os_close_file(fd);
+        os_close_file(pri->slave);
+
+        pri->slave = -1;
+
+        if(pri->pid<1) {
+                printk("slirp_close: no child process to shut down\n");
+                return;
+        }
+
+#if 0
+        if(kill(pri->pid, SIGHUP)<0) {
+                printk("slirp_close: sending hangup to %d failed (%d)\n",
+                        pri->pid, errno);
+        }
+#endif
+
+        CATCH_EINTR(err = waitpid(pri->pid, &status, WNOHANG));
+        if(err < 0) {
+                printk("slirp_close: waitpid returned %d\n", errno);
+                return;
+        }
+
+        if(err == 0) {
+                printk("slirp_close: process %d has not exited\n");
+                return;
+        }
+
+        pri->pid = -1;
+}
+
+int slirp_user_read(int fd, void *buf, int len, struct slirp_data *pri)
+{
+        int i, n, size, start;
+
+        if(pri->more>0) {
+                i = 0;
+                while(i < pri->more) {
+                        size = slip_unesc(pri->ibuf[i++],
+                                        pri->ibuf,&pri->pos,&pri->esc);
+                        if(size){
+                                memcpy(buf, pri->ibuf, size);
+                                memmove(pri->ibuf, &pri->ibuf[i], pri->more-i);
+                                pri->more=pri->more-i; 
+                                return(size);
+                        }
+                }
+                pri->more=0;
+        }
+
+        n = net_read(fd, &pri->ibuf[pri->pos], sizeof(pri->ibuf) - pri->pos);
+        if(n <= 0) return(n);
+
+        start = pri->pos;
+        for(i = 0; i < n; i++){
+                size = slip_unesc(pri->ibuf[start + i],
+                                pri->ibuf,&pri->pos,&pri->esc);
+                if(size){
+                        memcpy(buf, pri->ibuf, size);
+                        memmove(pri->ibuf, &pri->ibuf[start+i+1], n-(i+1));
+                        pri->more=n-(i+1); 
+                        return(size);
+                }
+        }
+        return(0);
+}
+
+int slirp_user_write(int fd, void *buf, int len, struct slirp_data *pri)
+{
+        int actual, n;
+
+        actual = slip_esc(buf, pri->obuf, len);
+        n = net_write(fd, pri->obuf, actual);
+        if(n < 0) return(n);
+        else return(len);
+}
+
+static int slirp_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info slirp_user_info = {
+        .init           = slirp_user_init,
+        .open           = slirp_open,
+        .close          = slirp_close,
+        .remove         = NULL,
+        .set_mtu        = slirp_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = BUF_SIZE
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
new file mode 100644
index 000000000000..c5839c3141f8
--- /dev/null
+++ b/arch/um/drivers/ssl.c
@@ -0,0 +1,251 @@
+/* 
+ * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/fs.h"
+#include "linux/tty.h"
+#include "linux/tty_driver.h"
+#include "linux/major.h"
+#include "linux/mm.h"
+#include "linux/init.h"
+#include "linux/console.h"
+#include "asm/termbits.h"
+#include "asm/irq.h"
+#include "line.h"
+#include "ssl.h"
+#include "chan_kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "mconsole_kern.h"
+#include "2_5compat.h"
+
+static int ssl_version = 1;
+
+/* Referenced only by tty_driver below - presumably it's locked correctly
+ * by the tty driver.
+ */
+
+static struct tty_driver *ssl_driver;
+
+#define NR_PORTS 64
+
+void ssl_announce(char *dev_name, int dev)
+{
+        printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
+               dev_name);
+}
+
+static struct chan_opts opts = {
+        .announce       = ssl_announce,
+        .xterm_title    = "Serial Line #%d",
+        .raw            = 1,
+        .tramp_stack    = 0,
+        .in_kernel      = 1,
+};
+
+static int ssl_config(char *str);
+static int ssl_get_config(char *dev, char *str, int size, char **error_out);
+static int ssl_remove(char *str);
+
+static struct line_driver driver = {
+        .name                   = "UML serial line",
+        .device_name            = "ttyS",
+        .devfs_name             = "tts/",
+        .major                  = TTY_MAJOR,
+        .minor_start            = 64,
+        .type                   = TTY_DRIVER_TYPE_SERIAL,
+        .subtype                = 0,
+        .read_irq               = SSL_IRQ,
+        .read_irq_name          = "ssl",
+        .write_irq              = SSL_WRITE_IRQ,
+        .write_irq_name         = "ssl-write",
+        .symlink_from           = "serial",
+        .symlink_to             = "tts",
+        .mc  = {
+                .name           = "ssl",
+                .config         = ssl_config,
+                .get_config     = ssl_get_config,
+                .remove         = ssl_remove,
+        },
+};
+
+/* The array is initialized by line_init, which is an initcall.  The 
+ * individual elements are protected by individual semaphores.
+ */
+static struct line serial_lines[NR_PORTS] =
+        { [0 ... NR_PORTS - 1] = LINE_INIT(CONFIG_SSL_CHAN, &driver) };
+
+static struct lines lines = LINES_INIT(NR_PORTS);
+
+static int ssl_config(char *str)
+{
+        return(line_config(serial_lines, 
+                           sizeof(serial_lines)/sizeof(serial_lines[0]), str));
+}
+
+static int ssl_get_config(char *dev, char *str, int size, char **error_out)
+{
+        return(line_get_config(dev, serial_lines, 
+                               sizeof(serial_lines)/sizeof(serial_lines[0]), 
+                               str, size, error_out));
+}
+
+static int ssl_remove(char *str)
+{
+        return(line_remove(serial_lines, 
+                           sizeof(serial_lines)/sizeof(serial_lines[0]), str));
+}
+
+int ssl_open(struct tty_struct *tty, struct file *filp)
+{
+        return line_open(serial_lines, tty, &opts);
+}
+
+#if 0
+static int ssl_chars_in_buffer(struct tty_struct *tty)
+{
+        return(0);
+}
+
+static void ssl_flush_buffer(struct tty_struct *tty)
+{
+        return;
+}
+
+static void ssl_throttle(struct tty_struct * tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_throttle\n");
+}
+
+static void ssl_unthrottle(struct tty_struct * tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_unthrottle\n");
+}
+
+static void ssl_stop(struct tty_struct *tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_stop\n");
+}
+
+static void ssl_start(struct tty_struct *tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_start\n");
+}
+
+void ssl_hangup(struct tty_struct *tty)
+{
+}
+#endif
+
+static struct tty_operations ssl_ops = {
+        .open                   = ssl_open,
+        .close                  = line_close,
+        .write                  = line_write,
+        .put_char               = line_put_char,
+        .write_room             = line_write_room,
+        .chars_in_buffer        = line_chars_in_buffer,
+        .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
+#if 0
+        .flush_chars            = ssl_flush_chars,
+        .flush_buffer           = ssl_flush_buffer,
+        .throttle               = ssl_throttle,
+        .unthrottle             = ssl_unthrottle,
+        .stop                   = ssl_stop,
+        .start                  = ssl_start,
+        .hangup                 = ssl_hangup,
+#endif
+};
+
+/* Changed by ssl_init and referenced by ssl_exit, which are both serialized
+ * by being an initcall and exitcall, respectively.
+ */
+static int ssl_init_done = 0;
+
+static void ssl_console_write(struct console *c, const char *string,
+                              unsigned len)
+{
+        struct line *line = &serial_lines[c->index];
+
+        down(&line->sem);
+        console_write_chan(&line->chan_list, string, len);
+        up(&line->sem);
+}
+
+static struct tty_driver *ssl_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return ssl_driver;
+}
+
+static int ssl_console_setup(struct console *co, char *options)
+{
+        struct line *line = &serial_lines[co->index];
+
+        return console_open_chan(line,co,&opts);
+}
+
+static struct console ssl_cons = {
+        .name           = "ttyS",
+        .write          = ssl_console_write,
+        .device         = ssl_console_device,
+        .setup          = ssl_console_setup,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+};
+
+int ssl_init(void)
+{
+        char *new_title;
+
+        printk(KERN_INFO "Initializing software serial port version %d\n", 
+               ssl_version);
+        ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops,
+                                         serial_lines, ARRAY_SIZE(serial_lines));
+
+        lines_init(serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0]));
+
+        new_title = add_xterm_umid(opts.xterm_title);
+        if (new_title != NULL)
+                opts.xterm_title = new_title;
+
+        ssl_init_done = 1;
+        register_console(&ssl_cons);
+        return(0);
+}
+late_initcall(ssl_init);
+
+static void ssl_exit(void)
+{
+        if (!ssl_init_done)
+                return;
+        close_lines(serial_lines,
+                    sizeof(serial_lines)/sizeof(serial_lines[0]));
+}
+__uml_exitcall(ssl_exit);
+
+static int ssl_chan_setup(char *str)
+{
+        return(line_setup(serial_lines,
+                          sizeof(serial_lines)/sizeof(serial_lines[0]),
+                          str, 1));
+}
+
+__setup("ssl", ssl_chan_setup);
+__channel_help(ssl_chan_setup, "ssl");
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/ssl.h b/arch/um/drivers/ssl.h
new file mode 100644
index 000000000000..98412aa66607
--- /dev/null
+++ b/arch/um/drivers/ssl.h
@@ -0,0 +1,23 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SSL_H__
+#define __SSL_H__
+
+extern int ssl_read(int fd, int line);
+extern void ssl_receive_char(int line, char ch);
+
+#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:
+ */
diff --git a/arch/um/drivers/stderr_console.c b/arch/um/drivers/stderr_console.c
new file mode 100644
index 000000000000..98565b53d170
--- /dev/null
+++ b/arch/um/drivers/stderr_console.c
@@ -0,0 +1,45 @@
+#include <linux/init.h>
+#include <linux/console.h>
+
+#include "chan_user.h"
+
+/* ----------------------------------------------------------------------------- */
+/* trivial console driver -- simply dump everything to stderr                    */
+
+/*
+ * Don't register by default -- as this registeres very early in the
+ * boot process it becomes the default console.  And as this isn't a
+ * real tty driver init isn't able to open /dev/console then.
+ *
+ * In most cases this isn't what you want ...
+ */
+static int use_stderr_console = 0;
+
+static void stderr_console_write(struct console *console, const char *string,
+                                 unsigned len)
+{
+        generic_write(2 /* stderr */, string, len, NULL);
+}
+
+static struct console stderr_console = {
+        .name           "stderr",
+        .write          stderr_console_write,
+        .flags          CON_PRINTBUFFER,
+};
+
+static int __init stderr_console_init(void)
+{
+        if (use_stderr_console)
+                register_console(&stderr_console);
+        return 0;
+}
+console_initcall(stderr_console_init);
+
+static int stderr_setup(char *str)
+{
+        if (!str)
+                return 0;
+        use_stderr_console = simple_strtoul(str,&str,0);
+        return 1;
+}
+__setup("stderr=", stderr_setup);
diff --git a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
new file mode 100644
index 000000000000..e604d7c87695
--- /dev/null
+++ b/arch/um/drivers/stdio_console.c
@@ -0,0 +1,205 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/posix_types.h"
+#include "linux/tty.h"
+#include "linux/tty_flip.h"
+#include "linux/types.h"
+#include "linux/major.h"
+#include "linux/kdev_t.h"
+#include "linux/console.h"
+#include "linux/string.h"
+#include "linux/sched.h"
+#include "linux/list.h"
+#include "linux/init.h"
+#include "linux/interrupt.h"
+#include "linux/slab.h"
+#include "linux/hardirq.h"
+#include "asm/current.h"
+#include "asm/irq.h"
+#include "stdio_console.h"
+#include "line.h"
+#include "chan_kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "irq_user.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "2_5compat.h"
+
+#define MAX_TTYS (16)
+
+/* ----------------------------------------------------------------------------- */
+
+/* Referenced only by tty_driver below - presumably it's locked correctly
+ * by the tty driver.
+ */
+
+static struct tty_driver *console_driver;
+
+void stdio_announce(char *dev_name, int dev)
+{
+        printk(KERN_INFO "Virtual console %d assigned device '%s'\n", dev,
+               dev_name);
+}
+
+static struct chan_opts opts = {
+        .announce       = stdio_announce,
+        .xterm_title    = "Virtual Console #%d",
+        .raw            = 1,
+        .tramp_stack    = 0,
+        .in_kernel      = 1,
+};
+
+static int con_config(char *str);
+static int con_get_config(char *dev, char *str, int size, char **error_out);
+static int con_remove(char *str);
+
+static struct line_driver driver = {
+        .name                   = "UML console",
+        .device_name            = "tty",
+        .devfs_name             = "vc/",
+        .major                  = TTY_MAJOR,
+        .minor_start            = 0,
+        .type                   = TTY_DRIVER_TYPE_CONSOLE,
+        .subtype                = SYSTEM_TYPE_CONSOLE,
+        .read_irq               = CONSOLE_IRQ,
+        .read_irq_name          = "console",
+        .write_irq              = CONSOLE_WRITE_IRQ,
+        .write_irq_name         = "console-write",
+        .symlink_from           = "ttys",
+        .symlink_to             = "vc",
+        .mc  = {
+                .name           = "con",
+                .config         = con_config,
+                .get_config     = con_get_config,
+                .remove         = con_remove,
+        },
+};
+
+static struct lines console_lines = LINES_INIT(MAX_TTYS);
+
+/* The array is initialized by line_init, which is an initcall.  The 
+ * individual elements are protected by individual semaphores.
+ */
+struct line vts[MAX_TTYS] = { LINE_INIT(CONFIG_CON_ZERO_CHAN, &driver),
+                              [ 1 ... MAX_TTYS - 1 ] = 
+                              LINE_INIT(CONFIG_CON_CHAN, &driver) };
+
+static int con_config(char *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)
+{
+        return(line_get_config(dev, vts, sizeof(vts)/sizeof(vts[0]), str, 
+                               size, error_out));
+}
+
+static int con_remove(char *str)
+{
+        return(line_remove(vts, sizeof(vts)/sizeof(vts[0]), str));
+}
+
+static int con_open(struct tty_struct *tty, struct file *filp)
+{
+        return line_open(vts, tty, &opts);
+}
+
+static int con_init_done = 0;
+
+static struct tty_operations console_ops = {
+        .open                   = con_open,
+        .close                  = line_close,
+        .write                  = line_write,
+        .write_room             = line_write_room,
+        .chars_in_buffer        = line_chars_in_buffer,
+        .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
+};
+
+static void uml_console_write(struct console *console, const char *string,
+                          unsigned len)
+{
+        struct line *line = &vts[console->index];
+
+        down(&line->sem);
+        console_write_chan(&line->chan_list, string, len);
+        up(&line->sem);
+}
+
+static struct tty_driver *uml_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return console_driver;
+}
+
+static int uml_console_setup(struct console *co, char *options)
+{
+        struct line *line = &vts[co->index];
+
+        return console_open_chan(line,co,&opts);
+}
+
+static struct console stdiocons = {
+        .name           = "tty",
+        .write          = uml_console_write,
+        .device         = uml_console_device,
+        .setup          = uml_console_setup,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+        .data           = &vts,
+};
+
+int stdio_init(void)
+{
+        char *new_title;
+
+        console_driver = line_register_devfs(&console_lines, &driver,
+                                             &console_ops, vts,
+                                             ARRAY_SIZE(vts));
+        if (NULL == console_driver)
+                return -1;
+        printk(KERN_INFO "Initialized stdio console driver\n");
+
+        lines_init(vts, sizeof(vts)/sizeof(vts[0]));
+
+        new_title = add_xterm_umid(opts.xterm_title);
+        if(new_title != NULL)
+                opts.xterm_title = new_title;
+
+        con_init_done = 1;
+        register_console(&stdiocons);
+        return(0);
+}
+late_initcall(stdio_init);
+
+static void console_exit(void)
+{
+        if (!con_init_done)
+                return;
+        close_lines(vts, sizeof(vts)/sizeof(vts[0]));
+}
+__uml_exitcall(console_exit);
+
+static int console_chan_setup(char *str)
+{
+        return(line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1));
+}
+__setup("con", console_chan_setup);
+__channel_help(console_chan_setup, "con");
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/stdio_console.h b/arch/um/drivers/stdio_console.h
new file mode 100644
index 000000000000..505a3d5bea5e
--- /dev/null
+++ b/arch/um/drivers/stdio_console.h
@@ -0,0 +1,21 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __STDIO_CONSOLE_H
+#define __STDIO_CONSOLE_H
+
+extern void save_console_flags(void);
+#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:
+ */
diff --git a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
new file mode 100644
index 000000000000..6fbb670ee274
--- /dev/null
+++ b/arch/um/drivers/tty.c
@@ -0,0 +1,92 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <termios.h>
+#include <errno.h>
+#include <unistd.h>
+#include "chan_user.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+struct tty_chan {
+        char *dev;
+        int raw;
+        struct termios tt;
+};
+
+static void *tty_chan_init(char *str, int device, struct chan_opts *opts)
+{
+        struct tty_chan *data;
+
+        if(*str != ':'){
+                printk("tty_init : channel type 'tty' must specify "
+                       "a device\n");
+                return(NULL);
+        }
+        str++;
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL)
+                return(NULL);
+        *data = ((struct tty_chan) { .dev       = str,
+                                     .raw       = opts->raw });
+                                     
+        return(data);
+}
+
+static int tty_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct tty_chan *data = d;
+        int fd, err;
+
+        fd = os_open_file(data->dev, of_set_rw(OPENFLAGS(), input, output), 0);
+        if(fd < 0) return(fd);
+        if(data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+
+        *dev_out = data->dev;
+        return(fd);
+}
+
+static int tty_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct tty_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops tty_ops = {
+        .type           = "tty",
+        .init           = tty_chan_init,
+        .open           = tty_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = tty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
new file mode 100644
index 000000000000..4d8b165bfa48
--- /dev/null
+++ b/arch/um/drivers/ubd_kern.c
@@ -0,0 +1,1669 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+/* 2001-09-28...2002-04-17
+ * Partition stuff by James_McMechan@hotmail.com
+ * old style ubd by setting UBD_SHIFT to 0
+ * 2002-09-27...2002-10-18 massive tinkering for 2.5
+ * partitions have changed in 2.5
+ * 2003-01-29 more tinkering for 2.5.59-1
+ * This should now address the sysfs problems and has
+ * the symlink for devfs to allow for booting with
+ * the common /dev/ubd/discX/... names rather than
+ * only /dev/ubdN/discN this version also has lots of
+ * clean ups preparing for ubd-many.
+ * James McMechan
+ */
+
+#define MAJOR_NR UBD_MAJOR
+#define UBD_SHIFT 4
+
+#include "linux/config.h"
+#include "linux/module.h"
+#include "linux/blkdev.h"
+#include "linux/hdreg.h"
+#include "linux/init.h"
+#include "linux/devfs_fs_kernel.h"
+#include "linux/cdrom.h"
+#include "linux/proc_fs.h"
+#include "linux/ctype.h"
+#include "linux/capability.h"
+#include "linux/mm.h"
+#include "linux/vmalloc.h"
+#include "linux/blkpg.h"
+#include "linux/genhd.h"
+#include "linux/spinlock.h"
+#include "asm/segment.h"
+#include "asm/uaccess.h"
+#include "asm/irq.h"
+#include "asm/types.h"
+#include "asm/tlbflush.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "ubd_user.h"
+#include "2_5compat.h"
+#include "os.h"
+#include "mem.h"
+#include "mem_kern.h"
+#include "cow.h"
+
+enum ubd_req { UBD_READ, UBD_WRITE, UBD_MMAP };
+
+struct io_thread_req {
+        enum ubd_req op;
+        int fds[2];
+        unsigned long offsets[2];
+        unsigned long long offset;
+        unsigned long length;
+        char *buffer;
+        int sectorsize;
+        unsigned long sector_mask;
+        unsigned long long cow_offset;
+        unsigned long bitmap_words[2];
+        int map_fd;
+        unsigned long long map_offset;
+        int error;
+};
+
+extern int open_ubd_file(char *file, struct openflags *openflags,
+                         char **backing_file_out, int *bitmap_offset_out,
+                         unsigned long *bitmap_len_out, int *data_offset_out,
+                         int *create_cow_out);
+extern int create_cow_file(char *cow_file, char *backing_file,
+                           struct openflags flags, int sectorsize,
+                           int alignment, int *bitmap_offset_out,
+                           unsigned long *bitmap_len_out,
+                           int *data_offset_out);
+extern int read_cow_bitmap(int fd, void *buf, int offset, int len);
+extern void do_io(struct io_thread_req *req);
+
+static inline int ubd_test_bit(__u64 bit, unsigned char *data)
+{
+        __u64 n;
+        int bits, off;
+
+        bits = sizeof(data[0]) * 8;
+        n = bit / bits;
+        off = bit % bits;
+        return((data[n] & (1 << off)) != 0);
+}
+
+static inline void ubd_set_bit(__u64 bit, unsigned char *data)
+{
+        __u64 n;
+        int bits, off;
+
+        bits = sizeof(data[0]) * 8;
+        n = bit / bits;
+        off = bit % bits;
+        data[n] |= (1 << off);
+}
+/*End stuff from ubd_user.h*/
+
+#define DRIVER_NAME "uml-blkdev"
+
+static DEFINE_SPINLOCK(ubd_io_lock);
+static DEFINE_SPINLOCK(ubd_lock);
+
+static void (*do_ubd)(void);
+
+static int ubd_open(struct inode * inode, struct file * filp);
+static int ubd_release(struct inode * inode, struct file * file);
+static int ubd_ioctl(struct inode * inode, struct file * file,
+                     unsigned int cmd, unsigned long arg);
+
+#define MAX_DEV (8)
+
+/* Changed in early boot */
+static int ubd_do_mmap = 0;
+#define UBD_MMAP_BLOCK_SIZE PAGE_SIZE
+
+static struct block_device_operations ubd_blops = {
+        .owner          = THIS_MODULE,
+        .open           = ubd_open,
+        .release        = ubd_release,
+        .ioctl          = ubd_ioctl,
+};
+
+/* Protected by the queue_lock */
+static request_queue_t *ubd_queue;
+
+/* Protected by ubd_lock */
+static int fake_major = MAJOR_NR;
+
+static struct gendisk *ubd_gendisk[MAX_DEV];
+static struct gendisk *fake_gendisk[MAX_DEV];
+ 
+#ifdef CONFIG_BLK_DEV_UBD_SYNC
+#define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 1, .c = 0, \
+                                         .cl = 1 })
+#else
+#define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 0, .c = 0, \
+                                         .cl = 1 })
+#endif
+
+/* Not protected - changed only in ubd_setup_common and then only to
+ * to enable O_SYNC.
+ */
+static struct openflags global_openflags = OPEN_FLAGS;
+
+struct cow {
+        char *file;
+        int fd;
+        unsigned long *bitmap;
+        unsigned long bitmap_len;
+        int bitmap_offset;
+        int data_offset;
+};
+
+struct ubd {
+        char *file;
+        int count;
+        int fd;
+        __u64 size;
+        struct openflags boot_openflags;
+        struct openflags openflags;
+        int no_cow;
+        struct cow cow;
+        struct platform_device pdev;
+
+        int map_writes;
+        int map_reads;
+        int nomap_writes;
+        int nomap_reads;
+        int write_maps;
+};
+
+#define DEFAULT_COW { \
+        .file =                 NULL, \
+        .fd =                   -1, \
+        .bitmap =               NULL, \
+        .bitmap_offset =        0, \
+        .data_offset =          0, \
+}
+
+#define DEFAULT_UBD { \
+        .file =                 NULL, \
+        .count =                0, \
+        .fd =                   -1, \
+        .size =                 -1, \
+        .boot_openflags =       OPEN_FLAGS, \
+        .openflags =            OPEN_FLAGS, \
+        .no_cow =               0, \
+        .cow =                  DEFAULT_COW, \
+        .map_writes             = 0, \
+        .map_reads              = 0, \
+        .nomap_writes           = 0, \
+        .nomap_reads            = 0, \
+        .write_maps             = 0, \
+}
+
+struct ubd ubd_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_UBD };
+
+static int ubd0_init(void)
+{
+        struct ubd *dev = &ubd_dev[0];
+
+        if(dev->file == NULL)
+                dev->file = "root_fs";
+        return(0);
+}
+
+__initcall(ubd0_init);
+
+/* Only changed by fake_ide_setup which is a setup */
+static int fake_ide = 0;
+static struct proc_dir_entry *proc_ide_root = NULL;
+static struct proc_dir_entry *proc_ide = NULL;
+
+static void make_proc_ide(void)
+{
+        proc_ide_root = proc_mkdir("ide", NULL);
+        proc_ide = proc_mkdir("ide0", proc_ide_root);
+}
+
+static int proc_ide_read_media(char *page, char **start, off_t off, int count,
+                               int *eof, void *data)
+{
+        int len;
+
+        strcpy(page, "disk\n");
+        len = strlen("disk\n");
+        len -= off;
+        if (len < count){
+                *eof = 1;
+                if (len <= 0) return 0;
+        }
+        else len = count;
+        *start = page + off;
+        return len;
+}
+
+static void make_ide_entries(char *dev_name)
+{
+        struct proc_dir_entry *dir, *ent;
+        char name[64];
+
+        if(proc_ide_root == NULL) make_proc_ide();
+
+        dir = proc_mkdir(dev_name, proc_ide);
+        if(!dir) return;
+
+        ent = create_proc_entry("media", S_IFREG|S_IRUGO, dir);
+        if(!ent) return;
+        ent->nlink = 1;
+        ent->data = NULL;
+        ent->read_proc = proc_ide_read_media;
+        ent->write_proc = NULL;
+        sprintf(name,"ide0/%s", dev_name);
+        proc_symlink(dev_name, proc_ide_root, name);
+}
+
+static int fake_ide_setup(char *str)
+{
+        fake_ide = 1;
+        return(1);
+}
+
+__setup("fake_ide", fake_ide_setup);
+
+__uml_help(fake_ide_setup,
+"fake_ide\n"
+"    Create ide0 entries that map onto ubd devices.\n\n"
+);
+
+static int parse_unit(char **ptr)
+{
+        char *str = *ptr, *end;
+        int n = -1;
+
+        if(isdigit(*str)) {
+                n = simple_strtoul(str, &end, 0);
+                if(end == str)
+                        return(-1);
+                *ptr = end;
+        }
+        else if (('a' <= *str) && (*str <= 'h')) {
+                n = *str - 'a';
+                str++;
+                *ptr = str;
+        }
+        return(n);
+}
+
+static int ubd_setup_common(char *str, int *index_out)
+{
+        struct ubd *dev;
+        struct openflags flags = global_openflags;
+        char *backing_file;
+        int n, err, i;
+
+        if(index_out) *index_out = -1;
+        n = *str;
+        if(n == '='){
+                char *end;
+                int major;
+
+                str++;
+                if(!strcmp(str, "mmap")){
+                        CHOOSE_MODE(printk("mmap not supported by the ubd "
+                                           "driver in tt mode\n"),
+                                    ubd_do_mmap = 1);
+                        return(0);
+                }
+
+                if(!strcmp(str, "sync")){
+                        global_openflags = of_sync(global_openflags);
+                        return(0);
+                }
+                major = simple_strtoul(str, &end, 0);
+                if((*end != '\0') || (end == str)){
+                        printk(KERN_ERR 
+                               "ubd_setup : didn't parse major number\n");
+                        return(1);
+                }
+
+                err = 1;
+                spin_lock(&ubd_lock);
+                if(fake_major != MAJOR_NR){
+                        printk(KERN_ERR "Can't assign a fake major twice\n");
+                        goto out1;
+                }
+ 
+                fake_major = major;
+
+                printk(KERN_INFO "Setting extra ubd major number to %d\n",
+                       major);
+                err = 0;
+        out1:
+                spin_unlock(&ubd_lock);
+                return(err);
+        }
+
+        n = parse_unit(&str);
+        if(n < 0){
+                printk(KERN_ERR "ubd_setup : couldn't parse unit number "
+                       "'%s'\n", str);
+                return(1);
+        }
+        if(n >= MAX_DEV){
+                printk(KERN_ERR "ubd_setup : index %d out of range "
+                       "(%d devices, from 0 to %d)\n", n, MAX_DEV, MAX_DEV - 1);
+                return(1);
+        }
+
+        err = 1;
+        spin_lock(&ubd_lock);
+
+        dev = &ubd_dev[n];
+        if(dev->file != NULL){
+                printk(KERN_ERR "ubd_setup : device already configured\n");
+                goto out;
+        }
+
+        if (index_out)
+                *index_out = n;
+
+        for (i = 0; i < 4; i++) {
+                switch (*str) {
+                case 'r':
+                        flags.w = 0;
+                        break;
+                case 's':
+                        flags.s = 1;
+                        break;
+                case 'd':
+                        dev->no_cow = 1;
+                        break;
+                case '=':
+                        str++;
+                        goto break_loop;
+                default:
+                        printk(KERN_ERR "ubd_setup : Expected '=' or flag letter (r,s or d)\n");
+                        goto out;
+                }
+                str++;
+        }
+
+        if (*str == '=')
+                printk(KERN_ERR "ubd_setup : Too many flags specified\n");
+        else
+                printk(KERN_ERR "ubd_setup : Expected '='\n");
+        goto out;
+
+break_loop:
+        err = 0;
+        backing_file = strchr(str, ',');
+
+        if (!backing_file) {
+                backing_file = strchr(str, ':');
+        }
+
+        if(backing_file){
+                if(dev->no_cow)
+                        printk(KERN_ERR "Can't specify both 'd' and a "
+                               "cow file\n");
+                else {
+                        *backing_file = '\0';
+                        backing_file++;
+                }
+        }
+        dev->file = str;
+        dev->cow.file = backing_file;
+        dev->boot_openflags = flags;
+out:
+        spin_unlock(&ubd_lock);
+        return(err);
+}
+
+static int ubd_setup(char *str)
+{
+        ubd_setup_common(str, NULL);
+        return(1);
+}
+
+__setup("ubd", ubd_setup);
+__uml_help(ubd_setup,
+"ubd<n><flags>=<filename>[(:|,)<filename2>]\n"
+"    This is used to associate a device with a file in the underlying\n"
+"    filesystem. When specifying two filenames, the first one is the\n"
+"    COW name and the second is the backing file name. As separator you can\n"
+"    use either a ':' or a ',': the first one allows writing things like;\n"
+"       ubd0=~/Uml/root_cow:~/Uml/root_backing_file\n"
+"    while with a ',' the shell would not expand the 2nd '~'.\n"
+"    When using only one filename, UML will detect whether to thread it like\n"
+"    a COW file or a backing file. To override this detection, add the 'd'\n"
+"    flag:\n"
+"       ubd0d=BackingFile\n"
+"    Usually, there is a filesystem in the file, but \n"
+"    that's not required. Swap devices containing swap files can be\n"
+"    specified like this. Also, a file which doesn't contain a\n"
+"    filesystem can have its contents read in the virtual \n"
+"    machine by running 'dd' on the device. <n> must be in the range\n"
+"    0 to 7. Appending an 'r' to the number will cause that device\n"
+"    to be mounted read-only. For example ubd1r=./ext_fs. Appending\n"
+"    an 's' will cause data to be written to disk on the host immediately.\n\n"
+);
+
+static int udb_setup(char *str)
+{
+        printk("udb%s specified on command line is almost certainly a ubd -> "
+               "udb TYPO\n", str);
+        return(1);
+}
+
+__setup("udb", udb_setup);
+__uml_help(udb_setup,
+"udb\n"
+"    This option is here solely to catch ubd -> udb typos, which can be\n\n"
+"    to impossible to catch visually unless you specifically look for\n\n"
+"    them.  The only result of any option starting with 'udb' is an error\n\n"
+"    in the boot output.\n\n"
+);
+
+static int fakehd_set = 0;
+static int fakehd(char *str)
+{
+        printk(KERN_INFO "fakehd : Changing ubd name to \"hd\".\n");
+        fakehd_set = 1;
+        return 1;
+}
+
+__setup("fakehd", fakehd);
+__uml_help(fakehd,
+"fakehd\n"
+"    Change the ubd device name to \"hd\".\n\n"
+);
+
+static void do_ubd_request(request_queue_t * q);
+
+/* Only changed by ubd_init, which is an initcall. */
+int thread_fd = -1;
+
+/* Changed by ubd_handler, which is serialized because interrupts only
+ * happen on CPU 0.
+ */
+int intr_count = 0;
+
+/* call ubd_finish if you need to serialize */
+static void __ubd_finish(struct request *req, int error)
+{
+        int nsect;
+
+        if(error){
+                end_request(req, 0);
+                return;
+        }
+        nsect = req->current_nr_sectors;
+        req->sector += nsect;
+        req->buffer += nsect << 9;
+        req->errors = 0;
+        req->nr_sectors -= nsect;
+        req->current_nr_sectors = 0;
+        end_request(req, 1);
+}
+
+static inline void ubd_finish(struct request *req, int error)
+{
+        spin_lock(&ubd_io_lock);
+        __ubd_finish(req, error);
+        spin_unlock(&ubd_io_lock);
+}
+
+/* Called without ubd_io_lock held */
+static void ubd_handler(void)
+{
+        struct io_thread_req req;
+        struct request *rq = elv_next_request(ubd_queue);
+        int n, err;
+
+        do_ubd = NULL;
+        intr_count++;
+        n = os_read_file(thread_fd, &req, sizeof(req));
+        if(n != sizeof(req)){
+                printk(KERN_ERR "Pid %d - spurious interrupt in ubd_handler, "
+                       "err = %d\n", os_getpid(), -n);
+                spin_lock(&ubd_io_lock);
+                end_request(rq, 0);
+                spin_unlock(&ubd_io_lock);
+                return;
+        }
+        
+        if((req.op != UBD_MMAP) &&
+           ((req.offset != ((__u64) (rq->sector)) << 9) ||
+            (req.length != (rq->current_nr_sectors) << 9)))
+                panic("I/O op mismatch");
+        
+        if(req.map_fd != -1){
+                err = physmem_subst_mapping(req.buffer, req.map_fd,
+                                            req.map_offset, 1);
+                if(err)
+                        printk("ubd_handler - physmem_subst_mapping failed, "
+                               "err = %d\n", -err);
+        }
+
+        ubd_finish(rq, req.error);
+        reactivate_fd(thread_fd, UBD_IRQ);      
+        do_ubd_request(ubd_queue);
+}
+
+static irqreturn_t ubd_intr(int irq, void *dev, struct pt_regs *unused)
+{
+        ubd_handler();
+        return(IRQ_HANDLED);
+}
+
+/* Only changed by ubd_init, which is an initcall. */
+static int io_pid = -1;
+
+void kill_io_thread(void)
+{
+        if(io_pid != -1) 
+                os_kill_process(io_pid, 1);
+}
+
+__uml_exitcall(kill_io_thread);
+
+static int ubd_file_size(struct ubd *dev, __u64 *size_out)
+{
+        char *file;
+
+        file = dev->cow.file ? dev->cow.file : dev->file;
+        return(os_file_size(file, size_out));
+}
+
+static void ubd_close(struct ubd *dev)
+{
+        if(ubd_do_mmap)
+                physmem_forget_descriptor(dev->fd);
+        os_close_file(dev->fd);
+        if(dev->cow.file == NULL)
+                return;
+
+        if(ubd_do_mmap)
+                physmem_forget_descriptor(dev->cow.fd);
+        os_close_file(dev->cow.fd);
+        vfree(dev->cow.bitmap);
+        dev->cow.bitmap = NULL;
+}
+
+static int ubd_open_dev(struct ubd *dev)
+{
+        struct openflags flags;
+        char **back_ptr;
+        int err, create_cow, *create_ptr;
+
+        dev->openflags = dev->boot_openflags;
+        create_cow = 0;
+        create_ptr = (dev->cow.file != NULL) ? &create_cow : NULL;
+        back_ptr = dev->no_cow ? NULL : &dev->cow.file;
+        dev->fd = open_ubd_file(dev->file, &dev->openflags, back_ptr,
+                                &dev->cow.bitmap_offset, &dev->cow.bitmap_len, 
+                                &dev->cow.data_offset, create_ptr);
+
+        if((dev->fd == -ENOENT) && create_cow){
+                dev->fd = create_cow_file(dev->file, dev->cow.file, 
+                                          dev->openflags, 1 << 9, PAGE_SIZE,
+                                          &dev->cow.bitmap_offset, 
+                                          &dev->cow.bitmap_len,
+                                          &dev->cow.data_offset);
+                if(dev->fd >= 0){
+                        printk(KERN_INFO "Creating \"%s\" as COW file for "
+                               "\"%s\"\n", dev->file, dev->cow.file);
+                }
+        }
+
+        if(dev->fd < 0){
+                printk("Failed to open '%s', errno = %d\n", dev->file,
+                       -dev->fd);
+                return(dev->fd);
+        }
+
+        if(dev->cow.file != NULL){
+                err = -ENOMEM;
+                dev->cow.bitmap = (void *) vmalloc(dev->cow.bitmap_len);
+                if(dev->cow.bitmap == NULL){
+                        printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
+                        goto error;
+                }
+                flush_tlb_kernel_vm();
+
+                err = read_cow_bitmap(dev->fd, dev->cow.bitmap, 
+                                      dev->cow.bitmap_offset, 
+                                      dev->cow.bitmap_len);
+                if(err < 0)
+                        goto error;
+
+                flags = dev->openflags;
+                flags.w = 0;
+                err = open_ubd_file(dev->cow.file, &flags, NULL, NULL, NULL, 
+                                    NULL, NULL);
+                if(err < 0) goto error;
+                dev->cow.fd = err;
+        }
+        return(0);
+ error:
+        os_close_file(dev->fd);
+        return(err);
+}
+
+static int ubd_new_disk(int major, u64 size, int unit,
+                        struct gendisk **disk_out)
+                        
+{
+        struct gendisk *disk;
+        char from[sizeof("ubd/nnnnn\0")], to[sizeof("discnnnnn/disc\0")];
+        int err;
+
+        disk = alloc_disk(1 << UBD_SHIFT);
+        if(disk == NULL)
+                return(-ENOMEM);
+
+        disk->major = major;
+        disk->first_minor = unit << UBD_SHIFT;
+        disk->fops = &ubd_blops;
+        set_capacity(disk, size / 512);
+        if(major == MAJOR_NR){
+                sprintf(disk->disk_name, "ubd%c", 'a' + unit);
+                sprintf(disk->devfs_name, "ubd/disc%d", unit);
+                sprintf(from, "ubd/%d", unit);
+                sprintf(to, "disc%d/disc", unit);
+                err = devfs_mk_symlink(from, to);
+                if(err)
+                        printk("ubd_new_disk failed to make link from %s to "
+                               "%s, error = %d\n", from, to, err);
+        }
+        else {
+                sprintf(disk->disk_name, "ubd_fake%d", unit);
+                sprintf(disk->devfs_name, "ubd_fake/disc%d", unit);
+        }
+
+        /* sysfs register (not for ide fake devices) */
+        if (major == MAJOR_NR) {
+                ubd_dev[unit].pdev.id   = unit;
+                ubd_dev[unit].pdev.name = DRIVER_NAME;
+                platform_device_register(&ubd_dev[unit].pdev);
+                disk->driverfs_dev = &ubd_dev[unit].pdev.dev;
+        }
+
+        disk->private_data = &ubd_dev[unit];
+        disk->queue = ubd_queue;
+        add_disk(disk);
+
+        *disk_out = disk;
+        return 0;
+}
+
+#define ROUND_BLOCK(n) ((n + ((1 << 9) - 1)) & (-1 << 9))
+
+static int ubd_add(int n)
+{
+        struct ubd *dev = &ubd_dev[n];
+        int err;
+
+        if(dev->file == NULL)
+                return(-ENODEV);
+
+        if (ubd_open_dev(dev))
+                return(-ENODEV);
+
+        err = ubd_file_size(dev, &dev->size);
+        if(err < 0)
+                return(err);
+
+        dev->size = ROUND_BLOCK(dev->size);
+
+        err = ubd_new_disk(MAJOR_NR, dev->size, n, &ubd_gendisk[n]);
+        if(err) 
+                return(err);
+ 
+        if(fake_major != MAJOR_NR)
+                ubd_new_disk(fake_major, dev->size, n, 
+                             &fake_gendisk[n]);
+
+        /* perhaps this should also be under the "if (fake_major)" above */
+        /* using the fake_disk->disk_name and also the fakehd_set name */
+        if (fake_ide)
+                make_ide_entries(ubd_gendisk[n]->disk_name);
+
+        ubd_close(dev);
+        return 0;
+}
+
+static int ubd_config(char *str)
+{
+        int n, err;
+
+        str = uml_strdup(str);
+        if(str == NULL){
+                printk(KERN_ERR "ubd_config failed to strdup string\n");
+                return(1);
+        }
+        err = ubd_setup_common(str, &n);
+        if(err){
+                kfree(str);
+                return(-1);
+        }
+        if(n == -1) return(0);
+
+        spin_lock(&ubd_lock);
+        err = ubd_add(n);
+        if(err)
+                ubd_dev[n].file = NULL;
+        spin_unlock(&ubd_lock);
+
+        return(err);
+}
+
+static int ubd_get_config(char *name, char *str, int size, char **error_out)
+{
+        struct ubd *dev;
+        int n, len = 0;
+
+        n = parse_unit(&name);
+        if((n >= MAX_DEV) || (n < 0)){
+                *error_out = "ubd_get_config : device number out of range";
+                return(-1);
+        }
+
+        dev = &ubd_dev[n];
+        spin_lock(&ubd_lock);
+
+        if(dev->file == NULL){
+                CONFIG_CHUNK(str, size, len, "", 1);
+                goto out;
+        }
+
+        CONFIG_CHUNK(str, size, len, dev->file, 0);
+
+        if(dev->cow.file != NULL){
+                CONFIG_CHUNK(str, size, len, ",", 0);
+                CONFIG_CHUNK(str, size, len, dev->cow.file, 1);
+        }
+        else CONFIG_CHUNK(str, size, len, "", 1);
+
+ out:
+        spin_unlock(&ubd_lock);
+        return(len);
+}
+
+static int ubd_remove(char *str)
+{
+        struct ubd *dev;
+        int n, err = -ENODEV;
+
+        n = parse_unit(&str);
+
+        if((n < 0) || (n >= MAX_DEV))
+                return(err);
+
+        dev = &ubd_dev[n];
+        if(dev->count > 0)
+                return(-EBUSY); /* you cannot remove a open disk */
+
+        err = 0;
+        spin_lock(&ubd_lock);
+
+        if(ubd_gendisk[n] == NULL)
+                goto out;
+
+        del_gendisk(ubd_gendisk[n]);
+        put_disk(ubd_gendisk[n]);
+        ubd_gendisk[n] = NULL;
+
+        if(fake_gendisk[n] != NULL){
+                del_gendisk(fake_gendisk[n]);
+                put_disk(fake_gendisk[n]);
+                fake_gendisk[n] = NULL;
+        }
+
+        platform_device_unregister(&dev->pdev);
+        *dev = ((struct ubd) DEFAULT_UBD);
+        err = 0;
+ out:
+        spin_unlock(&ubd_lock);
+        return(err);
+}
+
+static struct mc_device ubd_mc = {
+        .name           = "ubd",
+        .config         = ubd_config,
+        .get_config     = ubd_get_config,
+        .remove         = ubd_remove,
+};
+
+static int ubd_mc_init(void)
+{
+        mconsole_register_dev(&ubd_mc);
+        return 0;
+}
+
+__initcall(ubd_mc_init);
+
+static struct device_driver ubd_driver = {
+        .name  = DRIVER_NAME,
+        .bus   = &platform_bus_type,
+};
+
+int ubd_init(void)
+{
+        int i;
+
+        devfs_mk_dir("ubd");
+        if (register_blkdev(MAJOR_NR, "ubd"))
+                return -1;
+
+        ubd_queue = blk_init_queue(do_ubd_request, &ubd_io_lock);
+        if (!ubd_queue) {
+                unregister_blkdev(MAJOR_NR, "ubd");
+                return -1;
+        }
+                
+        if (fake_major != MAJOR_NR) {
+                char name[sizeof("ubd_nnn\0")];
+
+                snprintf(name, sizeof(name), "ubd_%d", fake_major);
+                devfs_mk_dir(name);
+                if (register_blkdev(fake_major, "ubd"))
+                        return -1;
+        }
+        driver_register(&ubd_driver);
+        for (i = 0; i < MAX_DEV; i++) 
+                ubd_add(i);
+        return 0;
+}
+
+late_initcall(ubd_init);
+
+int ubd_driver_init(void){
+        unsigned long stack;
+        int err;
+
+        /* Set by CONFIG_BLK_DEV_UBD_SYNC or ubd=sync.*/
+        if(global_openflags.s){
+                printk(KERN_INFO "ubd: Synchronous mode\n");
+                /* Letting ubd=sync be like using ubd#s= instead of ubd#= is
+                 * enough. So use anyway the io thread. */
+        }
+        stack = alloc_stack(0, 0);
+        io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), 
+                                 &thread_fd);
+        if(io_pid < 0){
+                printk(KERN_ERR 
+                       "ubd : Failed to start I/O thread (errno = %d) - "
+                       "falling back to synchronous I/O\n", -io_pid);
+                io_pid = -1;
+                return(0);
+        }
+        err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr, 
+                             SA_INTERRUPT, "ubd", ubd_dev);
+        if(err != 0)
+                printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
+        return(err);
+}
+
+device_initcall(ubd_driver_init);
+
+static int ubd_open(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ubd *dev = disk->private_data;
+        int err = 0;
+
+        if(dev->count == 0){
+                err = ubd_open_dev(dev);
+                if(err){
+                        printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",
+                               disk->disk_name, dev->file, -err);
+                        goto out;
+                }
+        }
+        dev->count++;
+        if((filp->f_mode & FMODE_WRITE) && !dev->openflags.w){
+                if(--dev->count == 0) ubd_close(dev);
+                err = -EROFS;
+        }
+ out:
+        return(err);
+}
+
+static int ubd_release(struct inode * inode, struct file * file)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ubd *dev = disk->private_data;
+
+        if(--dev->count == 0)
+                ubd_close(dev);
+        return(0);
+}
+
+static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask,
+                          __u64 *cow_offset, unsigned long *bitmap,
+                          __u64 bitmap_offset, unsigned long *bitmap_words,
+                          __u64 bitmap_len)
+{
+        __u64 sector = io_offset >> 9;
+        int i, update_bitmap = 0;
+
+        for(i = 0; i < length >> 9; i++){
+                if(cow_mask != NULL)
+                        ubd_set_bit(i, (unsigned char *) cow_mask);
+                if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
+                        continue;
+
+                update_bitmap = 1;
+                ubd_set_bit(sector + i, (unsigned char *) bitmap);
+        }
+
+        if(!update_bitmap)
+                return;
+
+        *cow_offset = sector / (sizeof(unsigned long) * 8);
+
+        /* This takes care of the case where we're exactly at the end of the
+         * device, and *cow_offset + 1 is off the end.  So, just back it up
+         * by one word.  Thanks to Lynn Kerby for the fix and James McMechan
+         * for the original diagnosis.
+         */
+        if(*cow_offset == ((bitmap_len + sizeof(unsigned long) - 1) /
+                           sizeof(unsigned long) - 1))
+                (*cow_offset)--;
+
+        bitmap_words[0] = bitmap[*cow_offset];
+        bitmap_words[1] = bitmap[*cow_offset + 1];
+
+        *cow_offset *= sizeof(unsigned long);
+        *cow_offset += bitmap_offset;
+}
+
+static void cowify_req(struct io_thread_req *req, unsigned long *bitmap,
+                       __u64 bitmap_offset, __u64 bitmap_len)
+{
+        __u64 sector = req->offset >> 9;
+        int i;
+
+        if(req->length > (sizeof(req->sector_mask) * 8) << 9)
+                panic("Operation too long");
+
+        if(req->op == UBD_READ) {
+                for(i = 0; i < req->length >> 9; i++){
+                        if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
+                                ubd_set_bit(i, (unsigned char *) 
+                                            &req->sector_mask);
+                }
+        }
+        else cowify_bitmap(req->offset, req->length, &req->sector_mask,
+                           &req->cow_offset, bitmap, bitmap_offset,
+                           req->bitmap_words, bitmap_len);
+}
+
+static int mmap_fd(struct request *req, struct ubd *dev, __u64 offset)
+{
+        __u64 sector;
+        unsigned char *bitmap;
+        int bit, i;
+
+        /* mmap must have been requested on the command line */
+        if(!ubd_do_mmap)
+                return(-1);
+
+        /* The buffer must be page aligned */
+        if(((unsigned long) req->buffer % UBD_MMAP_BLOCK_SIZE) != 0)
+                return(-1);
+
+        /* The request must be a page long */
+        if((req->current_nr_sectors << 9) != PAGE_SIZE)
+                return(-1);
+
+        if(dev->cow.file == NULL)
+                return(dev->fd);
+
+        sector = offset >> 9;
+        bitmap = (unsigned char *) dev->cow.bitmap;
+        bit = ubd_test_bit(sector, bitmap);
+
+        for(i = 1; i < req->current_nr_sectors; i++){
+                if(ubd_test_bit(sector + i, bitmap) != bit)
+                        return(-1);
+        }
+
+        if(bit || (rq_data_dir(req) == WRITE))
+                offset += dev->cow.data_offset;
+
+        /* The data on disk must be page aligned */
+        if((offset % UBD_MMAP_BLOCK_SIZE) != 0)
+                return(-1);
+
+        return(bit ? dev->fd : dev->cow.fd);
+}
+
+static int prepare_mmap_request(struct ubd *dev, int fd, __u64 offset,
+                                struct request *req,
+                                struct io_thread_req *io_req)
+{
+        int err;
+
+        if(rq_data_dir(req) == WRITE){
+                /* Writes are almost no-ops since the new data is already in the
+                 * host page cache
+                 */
+                dev->map_writes++;
+                if(dev->cow.file != NULL)
+                        cowify_bitmap(io_req->offset, io_req->length,
+                                      &io_req->sector_mask, &io_req->cow_offset,
+                                      dev->cow.bitmap, dev->cow.bitmap_offset,
+                                      io_req->bitmap_words,
+                                      dev->cow.bitmap_len);
+        }
+        else {
+                int w;
+
+                if((dev->cow.file != NULL) && (fd == dev->cow.fd))
+                        w = 0;
+                else w = dev->openflags.w;
+
+                if((dev->cow.file != NULL) && (fd == dev->fd))
+                        offset += dev->cow.data_offset;
+
+                err = physmem_subst_mapping(req->buffer, fd, offset, w);
+                if(err){
+                        printk("physmem_subst_mapping failed, err = %d\n",
+                               -err);
+                        return(1);
+                }
+                dev->map_reads++;
+        }
+        io_req->op = UBD_MMAP;
+        io_req->buffer = req->buffer;
+        return(0);
+}
+
+/* Called with ubd_io_lock held */
+static int prepare_request(struct request *req, struct io_thread_req *io_req)
+{
+        struct gendisk *disk = req->rq_disk;
+        struct ubd *dev = disk->private_data;
+        __u64 offset;
+        int len, fd;
+
+        if(req->rq_status == RQ_INACTIVE) return(1);
+
+        if((rq_data_dir(req) == WRITE) && !dev->openflags.w){
+                printk("Write attempted on readonly ubd device %s\n", 
+                       disk->disk_name);
+                end_request(req, 0);
+                return(1);
+        }
+
+        offset = ((__u64) req->sector) << 9;
+        len = req->current_nr_sectors << 9;
+
+        io_req->fds[0] = (dev->cow.file != NULL) ? dev->cow.fd : dev->fd;
+        io_req->fds[1] = dev->fd;
+        io_req->map_fd = -1;
+        io_req->cow_offset = -1;
+        io_req->offset = offset;
+        io_req->length = len;
+        io_req->error = 0;
+        io_req->sector_mask = 0;
+
+        fd = mmap_fd(req, dev, io_req->offset);
+        if(fd > 0){
+                /* If mmapping is otherwise OK, but the first access to the
+                 * page is a write, then it's not mapped in yet.  So we have
+                 * to write the data to disk first, then we can map the disk
+                 * page in and continue normally from there.
+                 */
+                if((rq_data_dir(req) == WRITE) && !is_remapped(req->buffer)){
+                        io_req->map_fd = dev->fd;
+                        io_req->map_offset = io_req->offset +
+                                dev->cow.data_offset;
+                        dev->write_maps++;
+                }
+                else return(prepare_mmap_request(dev, fd, io_req->offset, req,
+                                                 io_req));
+        }
+
+        if(rq_data_dir(req) == READ)
+                dev->nomap_reads++;
+        else dev->nomap_writes++;
+
+        io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;
+        io_req->offsets[0] = 0;
+        io_req->offsets[1] = dev->cow.data_offset;
+        io_req->buffer = req->buffer;
+        io_req->sectorsize = 1 << 9;
+
+        if(dev->cow.file != NULL)
+                cowify_req(io_req, dev->cow.bitmap, dev->cow.bitmap_offset,
+                           dev->cow.bitmap_len);
+
+        return(0);
+}
+
+/* Called with ubd_io_lock held */
+static void do_ubd_request(request_queue_t *q)
+{
+        struct io_thread_req io_req;
+        struct request *req;
+        int err, n;
+
+        if(thread_fd == -1){
+                while((req = elv_next_request(q)) != NULL){
+                        err = prepare_request(req, &io_req);
+                        if(!err){
+                                do_io(&io_req);
+                                __ubd_finish(req, io_req.error);
+                        }
+                }
+        }
+        else {
+                if(do_ubd || (req = elv_next_request(q)) == NULL)
+                        return;
+                err = prepare_request(req, &io_req);
+                if(!err){
+                        do_ubd = ubd_handler;
+                        n = os_write_file(thread_fd, (char *) &io_req,
+                                         sizeof(io_req));
+                        if(n != sizeof(io_req))
+                                printk("write to io thread failed, "
+                                       "errno = %d\n", -n);
+                }
+        }
+}
+
+static int ubd_ioctl(struct inode * inode, struct file * file,
+                     unsigned int cmd, unsigned long arg)
+{
+        struct hd_geometry __user *loc = (struct hd_geometry __user *) arg;
+        struct ubd *dev = inode->i_bdev->bd_disk->private_data;
+        struct hd_driveid ubd_id = {
+                .cyls           = 0,
+                .heads          = 128,
+                .sectors        = 32,
+        };
+
+        switch (cmd) {
+                struct hd_geometry g;
+                struct cdrom_volctrl volume;
+        case HDIO_GETGEO:
+                if(!loc) return(-EINVAL);
+                g.heads = 128;
+                g.sectors = 32;
+                g.cylinders = dev->size / (128 * 32 * 512);
+                g.start = get_start_sect(inode->i_bdev);
+                return(copy_to_user(loc, &g, sizeof(g)) ? -EFAULT : 0);
+
+        case HDIO_GET_IDENTITY:
+                ubd_id.cyls = dev->size / (128 * 32 * 512);
+                if(copy_to_user((char __user *) arg, (char *) &ubd_id,
+                                 sizeof(ubd_id)))
+                        return(-EFAULT);
+                return(0);
+                
+        case CDROMVOLREAD:
+                if(copy_from_user(&volume, (char __user *) arg, sizeof(volume)))
+                        return(-EFAULT);
+                volume.channel0 = 255;
+                volume.channel1 = 255;
+                volume.channel2 = 255;
+                volume.channel3 = 255;
+                if(copy_to_user((char __user *) arg, &volume, sizeof(volume)))
+                        return(-EFAULT);
+                return(0);
+        }
+        return(-EINVAL);
+}
+
+static int ubd_check_remapped(int fd, unsigned long address, int is_write,
+                              __u64 offset)
+{
+        __u64 bitmap_offset;
+        unsigned long new_bitmap[2];
+        int i, err, n;
+
+        /* If it's not a write access, we can't do anything about it */
+        if(!is_write)
+                return(0);
+
+        /* We have a write */
+        for(i = 0; i < sizeof(ubd_dev) / sizeof(ubd_dev[0]); i++){
+                struct ubd *dev = &ubd_dev[i];
+
+                if((dev->fd != fd) && (dev->cow.fd != fd))
+                        continue;
+
+                /* It's a write to a ubd device */
+
+                if(!dev->openflags.w){
+                        /* It's a write access on a read-only device - probably
+                         * shouldn't happen.  If the kernel is trying to change
+                         * something with no intention of writing it back out,
+                         * then this message will clue us in that this needs
+                         * fixing
+                         */
+                        printk("Write access to mapped page from readonly ubd "
+                               "device %d\n", i);
+                        return(0);
+                }
+
+                /* It's a write to a writeable ubd device - it must be COWed
+                 * because, otherwise, the page would have been mapped in
+                 * writeable
+                 */
+
+                if(!dev->cow.file)
+                        panic("Write fault on writeable non-COW ubd device %d",
+                              i);
+
+                /* It should also be an access to the backing file since the
+                 * COW pages should be mapped in read-write
+                 */
+
+                if(fd == dev->fd)
+                        panic("Write fault on a backing page of ubd "
+                              "device %d\n", i);
+
+                /* So, we do the write, copying the backing data to the COW
+                 * file...
+                 */
+
+                err = os_seek_file(dev->fd, offset + dev->cow.data_offset);
+                if(err < 0)
+                        panic("Couldn't seek to %lld in COW file of ubd "
+                              "device %d, err = %d",
+                              offset + dev->cow.data_offset, i, -err);
+
+                n = os_write_file(dev->fd, (void *) address, PAGE_SIZE);
+                if(n != PAGE_SIZE)
+                        panic("Couldn't copy data to COW file of ubd "
+                              "device %d, err = %d", i, -n);
+
+                /* ... updating the COW bitmap... */
+
+                cowify_bitmap(offset, PAGE_SIZE, NULL, &bitmap_offset,
+                              dev->cow.bitmap, dev->cow.bitmap_offset,
+                              new_bitmap, dev->cow.bitmap_len);
+
+                err = os_seek_file(dev->fd, bitmap_offset);
+                if(err < 0)
+                        panic("Couldn't seek to %lld in COW file of ubd "
+                              "device %d, err = %d", bitmap_offset, i, -err);
+
+                n = os_write_file(dev->fd, new_bitmap, sizeof(new_bitmap));
+                if(n != sizeof(new_bitmap))
+                        panic("Couldn't update bitmap  of ubd device %d, "
+                              "err = %d", i, -n);
+
+                /* Maybe we can map the COW page in, and maybe we can't.  If
+                 * it is a pre-V3 COW file, we can't, since the alignment will
+                 * be wrong.  If it is a V3 or later COW file which has been
+                 * moved to a system with a larger page size, then maybe we
+                 * can't, depending on the exact location of the page.
+                 */
+
+                offset += dev->cow.data_offset;
+
+                /* Remove the remapping, putting the original anonymous page
+                 * back.  If the COW file can be mapped in, that is done.
+                 * Otherwise, the COW page is read in.
+                 */
+
+                if(!physmem_remove_mapping((void *) address))
+                        panic("Address 0x%lx not remapped by ubd device %d",
+                              address, i);
+                if((offset % UBD_MMAP_BLOCK_SIZE) == 0)
+                        physmem_subst_mapping((void *) address, dev->fd,
+                                              offset, 1);
+                else {
+                        err = os_seek_file(dev->fd, offset);
+                        if(err < 0)
+                                panic("Couldn't seek to %lld in COW file of "
+                                      "ubd device %d, err = %d", offset, i,
+                                      -err);
+
+                        n = os_read_file(dev->fd, (void *) address, PAGE_SIZE);
+                        if(n != PAGE_SIZE)
+                                panic("Failed to read page from offset %llx of "
+                                      "COW file of ubd device %d, err = %d",
+                                      offset, i, -n);
+                }
+
+                return(1);
+        }
+
+        /* It's not a write on a ubd device */
+        return(0);
+}
+
+static struct remapper ubd_remapper = {
+        .list   = LIST_HEAD_INIT(ubd_remapper.list),
+        .proc   = ubd_check_remapped,
+};
+
+static int ubd_remapper_setup(void)
+{
+        if(ubd_do_mmap)
+                register_remapper(&ubd_remapper);
+
+        return(0);
+}
+
+__initcall(ubd_remapper_setup);
+
+static int same_backing_files(char *from_cmdline, char *from_cow, char *cow)
+{
+        struct uml_stat buf1, buf2;
+        int err;
+
+        if(from_cmdline == NULL) return(1);
+        if(!strcmp(from_cmdline, from_cow)) return(1);
+
+        err = os_stat_file(from_cmdline, &buf1);
+        if(err < 0){
+                printk("Couldn't stat '%s', err = %d\n", from_cmdline, -err);
+                return(1);
+        }
+        err = os_stat_file(from_cow, &buf2);
+        if(err < 0){
+                printk("Couldn't stat '%s', err = %d\n", from_cow, -err);
+                return(1);
+        }
+        if((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino))
+                return(1);
+
+        printk("Backing file mismatch - \"%s\" requested,\n"
+               "\"%s\" specified in COW header of \"%s\"\n",
+               from_cmdline, from_cow, cow);
+        return(0);
+}
+
+static int backing_file_mismatch(char *file, __u64 size, time_t mtime)
+{
+        unsigned long modtime;
+        long long actual;
+        int err;
+
+        err = os_file_modtime(file, &modtime);
+        if(err < 0){
+                printk("Failed to get modification time of backing file "
+                       "\"%s\", err = %d\n", file, -err);
+                return(err);
+        }
+
+        err = os_file_size(file, &actual);
+        if(err < 0){
+                printk("Failed to get size of backing file \"%s\", "
+                       "err = %d\n", file, -err);
+                return(err);
+        }
+
+        if(actual != size){
+                /*__u64 can be a long on AMD64 and with %lu GCC complains; so
+                 * the typecast.*/
+                printk("Size mismatch (%llu vs %llu) of COW header vs backing "
+                       "file\n", (unsigned long long) size, actual);
+                return(-EINVAL);
+        }
+        if(modtime != mtime){
+                printk("mtime mismatch (%ld vs %ld) of COW header vs backing "
+                       "file\n", mtime, modtime);
+                return(-EINVAL);
+        }
+        return(0);
+}
+
+int read_cow_bitmap(int fd, void *buf, int offset, int len)
+{
+        int err;
+
+        err = os_seek_file(fd, offset);
+        if(err < 0)
+                return(err);
+
+        err = os_read_file(fd, buf, len);
+        if(err < 0)
+                return(err);
+
+        return(0);
+}
+
+int open_ubd_file(char *file, struct openflags *openflags,
+                  char **backing_file_out, int *bitmap_offset_out,
+                  unsigned long *bitmap_len_out, int *data_offset_out,
+                  int *create_cow_out)
+{
+        time_t mtime;
+        unsigned long long size;
+        __u32 version, align;
+        char *backing_file;
+        int fd, err, sectorsize, same, mode = 0644;
+
+        fd = os_open_file(file, *openflags, mode);
+        if(fd < 0){
+                if((fd == -ENOENT) && (create_cow_out != NULL))
+                        *create_cow_out = 1;
+                if(!openflags->w ||
+                   ((fd != -EROFS) && (fd != -EACCES))) return(fd);
+                openflags->w = 0;
+                fd = os_open_file(file, *openflags, mode);
+                if(fd < 0)
+                        return(fd);
+        }
+
+        err = os_lock_file(fd, openflags->w);
+        if(err < 0){
+                printk("Failed to lock '%s', err = %d\n", file, -err);
+                goto out_close;
+        }
+
+        if(backing_file_out == NULL) return(fd);
+
+        err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
+                              &size, &sectorsize, &align, bitmap_offset_out);
+        if(err && (*backing_file_out != NULL)){
+                printk("Failed to read COW header from COW file \"%s\", "
+                       "errno = %d\n", file, -err);
+                goto out_close;
+        }
+        if(err) return(fd);
+
+        if(backing_file_out == NULL) return(fd);
+
+        same = same_backing_files(*backing_file_out, backing_file, file);
+
+        if(!same && !backing_file_mismatch(*backing_file_out, size, mtime)){
+                printk("Switching backing file to '%s'\n", *backing_file_out);
+                err = write_cow_header(file, fd, *backing_file_out,
+                                       sectorsize, align, &size);
+                if(err){
+                        printk("Switch failed, errno = %d\n", -err);
+                        return(err);
+                }
+        }
+        else {
+                *backing_file_out = backing_file;
+                err = backing_file_mismatch(*backing_file_out, size, mtime);
+                if(err) goto out_close;
+        }
+
+        cow_sizes(version, size, sectorsize, align, *bitmap_offset_out,
+                  bitmap_len_out, data_offset_out);
+
+        return(fd);
+ out_close:
+        os_close_file(fd);
+        return(err);
+}
+
+int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
+                    int sectorsize, int alignment, int *bitmap_offset_out,
+                    unsigned long *bitmap_len_out, int *data_offset_out)
+{
+        int err, fd;
+
+        flags.c = 1;
+        fd = open_ubd_file(cow_file, &flags, NULL, NULL, NULL, NULL, NULL);
+        if(fd < 0){
+                err = fd;
+                printk("Open of COW file '%s' failed, errno = %d\n", cow_file,
+                       -err);
+                goto out;
+        }
+
+        err = init_cow_file(fd, cow_file, backing_file, sectorsize, alignment,
+                            bitmap_offset_out, bitmap_len_out,
+                            data_offset_out);
+        if(!err)
+                return(fd);
+        os_close_file(fd);
+ out:
+        return(err);
+}
+
+static int update_bitmap(struct io_thread_req *req)
+{
+        int n;
+
+        if(req->cow_offset == -1)
+                return(0);
+
+        n = os_seek_file(req->fds[1], req->cow_offset);
+        if(n < 0){
+                printk("do_io - bitmap lseek failed : err = %d\n", -n);
+                return(1);
+        }
+
+        n = os_write_file(req->fds[1], &req->bitmap_words,
+                          sizeof(req->bitmap_words));
+        if(n != sizeof(req->bitmap_words)){
+                printk("do_io - bitmap update failed, err = %d fd = %d\n", -n,
+                       req->fds[1]);
+                return(1);
+        }
+
+        return(0);
+}
+
+void do_io(struct io_thread_req *req)
+{
+        char *buf;
+        unsigned long len;
+        int n, nsectors, start, end, bit;
+        int err;
+        __u64 off;
+
+        if(req->op == UBD_MMAP){
+                /* Touch the page to force the host to do any necessary IO to
+                 * get it into memory
+                 */
+                n = *((volatile int *) req->buffer);
+                req->error = update_bitmap(req);
+                return;
+        }
+
+        nsectors = req->length / req->sectorsize;
+        start = 0;
+        do {
+                bit = ubd_test_bit(start, (unsigned char *) &req->sector_mask);
+                end = start;
+                while((end < nsectors) &&
+                      (ubd_test_bit(end, (unsigned char *)
+                                    &req->sector_mask) == bit))
+                        end++;
+
+                off = req->offset + req->offsets[bit] +
+                        start * req->sectorsize;
+                len = (end - start) * req->sectorsize;
+                buf = &req->buffer[start * req->sectorsize];
+
+                err = os_seek_file(req->fds[bit], off);
+                if(err < 0){
+                        printk("do_io - lseek failed : err = %d\n", -err);
+                        req->error = 1;
+                        return;
+                }
+                if(req->op == UBD_READ){
+                        n = 0;
+                        do {
+                                buf = &buf[n];
+                                len -= n;
+                                n = os_read_file(req->fds[bit], buf, len);
+                                if (n < 0) {
+                                        printk("do_io - read failed, err = %d "
+                                               "fd = %d\n", -n, req->fds[bit]);
+                                        req->error = 1;
+                                        return;
+                                }
+                        } while((n < len) && (n != 0));
+                        if (n < len) memset(&buf[n], 0, len - n);
+                }
+                else {
+                        n = os_write_file(req->fds[bit], buf, len);
+                        if(n != len){
+                                printk("do_io - write failed err = %d "
+                                       "fd = %d\n", -n, req->fds[bit]);
+                                req->error = 1;
+                                return;
+                        }
+                }
+
+                start = end;
+        } while(start < nsectors);
+
+        req->error = update_bitmap(req);
+}
+
+/* Changed in start_io_thread, which is serialized by being called only
+ * from ubd_init, which is an initcall.
+ */
+int kernel_fd = -1;
+
+/* Only changed by the io thread */
+int io_count = 0;
+
+int io_thread(void *arg)
+{
+        struct io_thread_req req;
+        int n;
+
+        ignore_sigwinch_sig();
+        while(1){
+                n = os_read_file(kernel_fd, &req, sizeof(req));
+                if(n != sizeof(req)){
+                        if(n < 0)
+                                printk("io_thread - read failed, fd = %d, "
+                                       "err = %d\n", kernel_fd, -n);
+                        else {
+                                printk("io_thread - short read, fd = %d, "
+                                       "length = %d\n", kernel_fd, n);
+                        }
+                        continue;
+                }
+                io_count++;
+                do_io(&req);
+                n = os_write_file(kernel_fd, &req, sizeof(req));
+                if(n != sizeof(req))
+                        printk("io_thread - write failed, fd = %d, err = %d\n",
+                               kernel_fd, -n);
+        }
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
new file mode 100644
index 000000000000..b94d2bc4fe06
--- /dev/null
+++ b/arch/um/drivers/ubd_user.c
@@ -0,0 +1,75 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001 Ridgerun,Inc (glonnon@ridgerun.com)
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+#include <signal.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include "asm/types.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "ubd_user.h"
+#include "os.h"
+#include "cow.h"
+
+#include <endian.h>
+#include <byteswap.h>
+
+void ignore_sigwinch_sig(void)
+{
+        signal(SIGWINCH, SIG_IGN);
+}
+
+int start_io_thread(unsigned long sp, int *fd_out)
+{
+        int pid, fds[2], err;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("start_io_thread - os_pipe failed, err = %d\n", -err);
+                goto out;
+        }
+
+        kernel_fd = fds[0];
+        *fd_out = fds[1];
+
+        pid = clone(io_thread, (void *) sp, CLONE_FILES | CLONE_VM | SIGCHLD,
+                    NULL);
+        if(pid < 0){
+                printk("start_io_thread - clone failed : errno = %d\n", errno);
+                err = -errno;
+                goto out_close;
+        }
+
+        return(pid);
+
+ out_close:
+        os_close_file(fds[0]);
+        os_close_file(fds[1]);
+        kernel_fd = -1;
+        *fd_out = -1;
+ out:
+        return(err);
+}
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/xterm.c b/arch/um/drivers/xterm.c
new file mode 100644
index 000000000000..93dc1911363f
--- /dev/null
+++ b/arch/um/drivers/xterm.c
@@ -0,0 +1,225 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <signal.h>
+#include <sched.h>
+#include <sys/socket.h>
+#include "kern_util.h"
+#include "chan_user.h"
+#include "helper.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+#include "xterm.h"
+
+struct xterm_chan {
+        int pid;
+        int helper_pid;
+        char *title;
+        int device;
+        int raw;
+        struct termios tt;
+        unsigned long stack;
+        int direct_rcv;
+};
+
+/* Not static because it's called directly by the tt mode gdb code */
+void *xterm_init(char *str, int device, struct chan_opts *opts)
+{
+        struct xterm_chan *data;
+
+        data = malloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct xterm_chan) { .pid             = -1, 
+                                       .helper_pid      = -1,
+                                       .device          = device, 
+                                       .title           = opts->xterm_title,
+                                       .raw             = opts->raw,
+                                       .stack           = opts->tramp_stack,
+                                       .direct_rcv      = !opts->in_kernel } );
+        return(data);
+}
+
+/* Only changed by xterm_setup, which is a setup */
+static char *terminal_emulator = "xterm";
+static char *title_switch = "-T";
+static char *exec_switch = "-e";
+
+static int __init xterm_setup(char *line, int *add)
+{
+        *add = 0;
+        terminal_emulator = line;
+
+        line = strchr(line, ',');
+        if(line == NULL) return(0);
+        *line++ = '\0';
+        if(*line) title_switch = line;
+
+        line = strchr(line, ',');
+        if(line == NULL) return(0);
+        *line++ = '\0';
+        if(*line) exec_switch = line;
+
+        return(0);
+}
+
+__uml_setup("xterm=", xterm_setup,
+"xterm=<terminal emulator>,<title switch>,<exec switch>\n"
+"    Specifies an alternate terminal emulator to use for the debugger,\n"
+"    consoles, and serial lines when they are attached to the xterm channel.\n"
+"    The values are the terminal emulator binary, the switch it uses to set\n"
+"    its title, and the switch it uses to execute a subprocess,\n"
+"    respectively.  The title switch must have the form '<switch> title',\n"
+"    not '<switch>=title'.  Similarly, the exec switch must have the form\n"
+"    '<switch> command arg1 arg2 ...'.\n"
+"    The default values are 'xterm=xterm,-T,-e'.  Values for gnome-terminal\n"
+"    are 'xterm=gnome-terminal,-t,-x'.\n\n"
+);
+
+/* XXX This badly needs some cleaning up in the error paths
+ * Not static because it's called directly by the tt mode gdb code
+ */
+int xterm_open(int input, int output, int primary, void *d,
+                      char **dev_out)
+{
+        struct xterm_chan *data = d;
+        unsigned long stack;
+        int pid, fd, new, err;
+        char title[256], file[] = "/tmp/xterm-pipeXXXXXX";
+        char *argv[] = { terminal_emulator, title_switch, title, exec_switch, 
+                         "/usr/lib/uml/port-helper", "-uml-socket",
+                         file, NULL };
+
+        if(os_access(argv[4], OS_ACC_X_OK) < 0)
+                argv[4] = "port-helper";
+
+        /* Check that DISPLAY is set, this doesn't guarantee the xterm
+         * will work but w/o it we can be pretty sure it won't. */
+        if (!getenv("DISPLAY")) {
+                printk("xterm_open: $DISPLAY not set.\n");
+                return -ENODEV;
+        }
+
+        fd = mkstemp(file);
+        if(fd < 0){
+                printk("xterm_open : mkstemp failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        if(unlink(file)){
+                printk("xterm_open : unlink failed, errno = %d\n", errno);
+                return(-errno);
+        }
+        os_close_file(fd);
+
+        fd = os_create_unix_socket(file, sizeof(file), 1);
+        if(fd < 0){
+                printk("xterm_open : create_unix_socket failed, errno = %d\n", 
+                       -fd);
+                return(fd);
+        }
+
+        sprintf(title, data->title, data->device);
+        stack = data->stack;
+        pid = run_helper(NULL, NULL, argv, &stack);
+        if(pid < 0){
+                printk("xterm_open : run_helper failed, errno = %d\n", -pid);
+                return(pid);
+        }
+
+        if(data->stack == 0) free_stack(stack, 0);
+
+        if (data->direct_rcv) {
+                new = os_rcv_fd(fd, &data->helper_pid);
+        } else {
+                err = os_set_fd_block(fd, 0);
+                if(err < 0){
+                        printk("xterm_open : failed to set descriptor "
+                               "non-blocking, err = %d\n", -err);
+                        return(err);
+                }
+                new = xterm_fd(fd, &data->helper_pid);
+        }
+        if(new < 0){
+                printk("xterm_open : os_rcv_fd failed, err = %d\n", -new);
+                goto out;
+        }
+
+        CATCH_EINTR(err = tcgetattr(new, &data->tt));
+        if(err){
+                new = err;
+                goto out;
+        }
+
+        if(data->raw){
+                err = raw(new);
+                if(err){
+                        new = err;
+                        goto out;
+                }
+        }
+
+        data->pid = pid;
+        *dev_out = NULL;
+ out:
+        unlink(file);
+        return(new);
+}
+
+/* Not static because it's called directly by the tt mode gdb code */
+void xterm_close(int fd, void *d)
+{
+        struct xterm_chan *data = d;
+        
+        if(data->pid != -1) 
+                os_kill_process(data->pid, 1);
+        data->pid = -1;
+        if(data->helper_pid != -1) 
+                os_kill_process(data->helper_pid, 0);
+        data->helper_pid = -1;
+        os_close_file(fd);
+}
+
+static void xterm_free(void *d)
+{
+        free(d);
+}
+
+static int xterm_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct xterm_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops xterm_ops = {
+        .type           = "xterm",
+        .init           = xterm_init,
+        .open           = xterm_open,
+        .close          = xterm_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = xterm_console_write,
+        .window_size    = generic_window_size,
+        .free           = xterm_free,
+        .winch          = 1,
+};
+
+/*
+ * 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:
+ */
diff --git a/arch/um/drivers/xterm.h b/arch/um/drivers/xterm.h
new file mode 100644
index 000000000000..f33a6e77b186
--- /dev/null
+++ b/arch/um/drivers/xterm.h
@@ -0,0 +1,22 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __XTERM_H__
+#define __XTERM_H__
+
+extern int xterm_fd(int socket, int *pid_out);
+
+#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:
+ */
diff --git a/arch/um/drivers/xterm_kern.c b/arch/um/drivers/xterm_kern.c
new file mode 100644
index 000000000000..7917b9d1cec8
--- /dev/null
+++ b/arch/um/drivers/xterm_kern.c
@@ -0,0 +1,93 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/errno.h"
+#include "linux/slab.h"
+#include "linux/signal.h"
+#include "linux/interrupt.h"
+#include "asm/semaphore.h"
+#include "asm/irq.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "kern_util.h"
+#include "os.h"
+#include "xterm.h"
+
+struct xterm_wait {
+        struct completion ready;
+        int fd;
+        int pid;
+        int new_fd;
+};
+
+static irqreturn_t xterm_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct xterm_wait *xterm = data;
+        int fd;
+
+        fd = os_rcv_fd(xterm->fd, &xterm->pid);
+        if(fd == -EAGAIN)
+                return(IRQ_NONE);
+
+        xterm->new_fd = fd;
+        complete(&xterm->ready);
+        return(IRQ_HANDLED);
+}
+
+int xterm_fd(int socket, int *pid_out)
+{
+        struct xterm_wait *data;
+        int err, ret;
+
+        data = kmalloc(sizeof(*data), GFP_KERNEL);
+        if(data == NULL){
+                printk(KERN_ERR "xterm_fd : failed to allocate xterm_wait\n");
+                return(-ENOMEM);
+        }
+
+        /* This is a locked semaphore... */
+        *data = ((struct xterm_wait) 
+                { .fd           = socket,
+                  .pid          = -1,
+                  .new_fd       = -1 });
+        init_completion(&data->ready);
+
+        err = um_request_irq(XTERM_IRQ, socket, IRQ_READ, xterm_interrupt, 
+                             SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                             "xterm", data);
+        if (err){
+                printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, "
+                       "err = %d\n",  err);
+                ret = err;
+                goto out;
+        }
+
+        /* ... so here we wait for an xterm interrupt.
+         *
+         * XXX Note, if the xterm doesn't work for some reason (eg. DISPLAY
+         * isn't set) this will hang... */
+        wait_for_completion(&data->ready);
+
+        free_irq_by_irq_and_dev(XTERM_IRQ, data);
+        free_irq(XTERM_IRQ, data);
+
+        ret = data->new_fd;
+        *pid_out = data->pid;
+ out:
+        kfree(data);
+
+        return(ret);
+}
+
+/*
+ * 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:
+ */