Patched in Tegra support.

48 files changed, 872 insertions, 921 deletions

diff --git a/arch/um/drivers/chan.h b/arch/um/drivers/chan.h
deleted file mode 100644
index 02b5a76e98d..00000000000
--- a/arch/um/drivers/chan.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/* 
- * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __CHAN_KERN_H__
-#define __CHAN_KERN_H__
-
-#include <linux/tty.h>
-#include <linux/list.h>
-#include <linux/console.h>
-#include "chan_user.h"
-#include "line.h"
-
-struct chan {
-        struct list_head list;
-        struct list_head free_list;
-        struct line *line;
-        char *dev;
-        unsigned int primary:1;
-        unsigned int input:1;
-        unsigned int output:1;
-        unsigned int opened:1;
-        unsigned int enabled:1;
-        int fd;
-        const struct chan_ops *ops;
-        void *data;
-};
-
-extern void chan_interrupt(struct line *line,
-                           struct tty_struct *tty, int irq);
-extern int parse_chan_pair(char *str, struct line *line, int device,
-                           const struct chan_opts *opts, char **error_out);
-extern int write_chan(struct chan *chan, const char *buf, int len,
-                             int write_irq);
-extern int console_write_chan(struct chan *chan, const char *buf, 
-                              int len);
-extern int console_open_chan(struct line *line, struct console *co);
-extern void deactivate_chan(struct chan *chan, int irq);
-extern void reactivate_chan(struct chan *chan, int irq);
-extern void chan_enable_winch(struct chan *chan, struct tty_struct *tty);
-extern int enable_chan(struct line *line);
-extern void close_chan(struct line *line);
-extern int chan_window_size(struct line *line, 
-                             unsigned short *rows_out, 
-                             unsigned short *cols_out);
-extern int chan_config_string(struct line *line, char *str, int size,
-                              char **error_out);
-
-#endif
diff --git a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
index e9a0abc6a32..d4191fe1ced 100644
--- a/arch/um/drivers/chan_kern.c
+++ b/arch/um/drivers/chan_kern.c
@@ -6,9 +6,8 @@
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
-#include "chan.h"
-#include <os.h>
-#include <irq_kern.h>
+#include "chan_kern.h"
+#include "os.h"
 
 #ifdef CONFIG_NOCONFIG_CHAN
 static void *not_configged_init(char *str, int device,
@@ -83,8 +82,21 @@ static const struct chan_ops not_configged_ops = {
 
 static void tty_receive_char(struct tty_struct *tty, char ch)
 {
-        if (tty)
-                tty_insert_flip_char(tty, ch, TTY_NORMAL);
+        if (tty == NULL)
+                return;
+
+        if (I_IXON(tty) && !I_IXOFF(tty) && !tty->raw) {
+                if (ch == STOP_CHAR(tty)) {
+                        stop_tty(tty);
+                        return;
+                }
+                else if (ch == START_CHAR(tty)) {
+                        start_tty(tty);
+                        return;
+                }
+        }
+
+        tty_insert_flip_char(tty, ch, TTY_NORMAL);
 }
 
 static int open_one_chan(struct chan *chan)
@@ -128,20 +140,18 @@ static int open_chan(struct list_head *chans)
         return err;
 }
 
-void chan_enable_winch(struct chan *chan, struct tty_struct *tty)
+void chan_enable_winch(struct list_head *chans, struct tty_struct *tty)
 {
-        if (chan && chan->primary && chan->ops->winch)
-                register_winch(chan->fd, tty);
-}
-
-static void line_timer_cb(struct work_struct *work)
-{
-        struct line *line = container_of(work, struct line, task.work);
-        struct tty_struct *tty = tty_port_tty_get(&line->port);
+        struct list_head *ele;
+        struct chan *chan;
 
-        if (!line->throttled)
-                chan_interrupt(line, tty, line->driver->read_irq);
-        tty_kref_put(tty);
+        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;
+                }
+        }
 }
 
 int enable_chan(struct line *line)
@@ -150,8 +160,6 @@ int enable_chan(struct line *line)
         struct chan *chan;
         int err;
 
-        INIT_DELAYED_WORK(&line->task, line_timer_cb);
-
         list_for_each(ele, &line->chan_list) {
                 chan = list_entry(ele, struct chan, list);
                 err = open_one_chan(chan);
@@ -175,7 +183,7 @@ int enable_chan(struct line *line)
         return 0;
 
  out_close:
-        close_chan(line);
+        close_chan(&line->chan_list, 0);
         return err;
 }
 
@@ -203,9 +211,9 @@ void free_irqs(void)
                 chan = list_entry(ele, struct chan, free_list);
 
                 if (chan->input && chan->enabled)
-                        um_free_irq(chan->line->driver->read_irq, chan);
+                        free_irq(chan->line->driver->read_irq, chan);
                 if (chan->output && chan->enabled)
-                        um_free_irq(chan->line->driver->write_irq, chan);
+                        free_irq(chan->line->driver->write_irq, chan);
                 chan->enabled = 0;
         }
 }
@@ -224,9 +232,9 @@ static void close_one_chan(struct chan *chan, int delay_free_irq)
         }
         else {
                 if (chan->input && chan->enabled)
-                        um_free_irq(chan->line->driver->read_irq, chan);
+                        free_irq(chan->line->driver->read_irq, chan);
                 if (chan->output && chan->enabled)
-                        um_free_irq(chan->line->driver->write_irq, chan);
+                        free_irq(chan->line->driver->write_irq, chan);
                 chan->enabled = 0;
         }
         if (chan->ops->close != NULL)
@@ -236,7 +244,7 @@ static void close_one_chan(struct chan *chan, int delay_free_irq)
         chan->fd = -1;
 }
 
-void close_chan(struct line *line)
+void close_chan(struct list_head *chans, int delay_free_irq)
 {
         struct chan *chan;
 
@@ -245,50 +253,77 @@ void close_chan(struct line *line)
          * state.  Then, the first one opened will have the original state,
          * so it must be the last closed.
          */
-        list_for_each_entry_reverse(chan, &line->chan_list, list) {
-                close_one_chan(chan, 0);
+        list_for_each_entry_reverse(chan, chans, list) {
+                close_one_chan(chan, delay_free_irq);
         }
 }
 
-void deactivate_chan(struct chan *chan, int irq)
+void deactivate_chan(struct list_head *chans, int irq)
 {
-        if (chan && chan->enabled)
-                deactivate_fd(chan->fd, irq);
+        struct list_head *ele;
+
+        struct chan *chan;
+        list_for_each(ele, chans) {
+                chan = list_entry(ele, struct chan, list);
+
+                if (chan->enabled && chan->input)
+                        deactivate_fd(chan->fd, irq);
+        }
 }
 
-void reactivate_chan(struct chan *chan, int irq)
+void reactivate_chan(struct list_head *chans, int irq)
 {
-        if (chan && chan->enabled)
-                reactivate_fd(chan->fd, irq);
+        struct list_head *ele;
+        struct chan *chan;
+
+        list_for_each(ele, chans) {
+                chan = list_entry(ele, struct chan, list);
+
+                if (chan->enabled && chan->input)
+                        reactivate_fd(chan->fd, irq);
+        }
 }
 
-int write_chan(struct chan *chan, const char *buf, int len,
+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;
 
-        if (len == 0 || !chan || !chan->ops->write)
+        if (len == 0)
                 return 0;
 
-        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);
+        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 chan *chan, const char *buf, int len)
+int console_write_chan(struct list_head *chans, const char *buf, int len)
 {
+        struct list_head *ele;
+        struct chan *chan;
         int n, ret = 0;
 
-        if (!chan || !chan->ops->console_write)
-                return 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);
-        if (chan->primary)
-                ret = n;
+                n = chan->ops->console_write(chan->fd, buf, len);
+                if (chan->primary)
+                        ret = n;
+        }
         return ret;
 }
 
@@ -305,33 +340,29 @@ int console_open_chan(struct line *line, struct console *co)
         return 0;
 }
 
-int chan_window_size(struct line *line, unsigned short *rows_out,
+int chan_window_size(struct list_head *chans, unsigned short *rows_out,
                       unsigned short *cols_out)
 {
+        struct list_head *ele;
         struct chan *chan;
 
-        chan = line->chan_in;
-        if (chan && chan->primary) {
-                if (chan->ops->window_size == NULL)
-                        return 0;
-                return chan->ops->window_size(chan->fd, chan->data,
-                                              rows_out, cols_out);
-        }
-        chan = line->chan_out;
-        if (chan && chan->primary) {
-                if (chan->ops->window_size == NULL)
-                        return 0;
-                return chan->ops->window_size(chan->fd, chan->data,
-                                              rows_out, cols_out);
+        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;
 }
 
-static void free_one_chan(struct chan *chan)
+static void free_one_chan(struct chan *chan, int delay_free_irq)
 {
         list_del(&chan->list);
 
-        close_one_chan(chan, 0);
+        close_one_chan(chan, delay_free_irq);
 
         if (chan->ops->free != NULL)
                 (*chan->ops->free)(chan->data);
@@ -341,14 +372,14 @@ static void free_one_chan(struct chan *chan)
         kfree(chan);
 }
 
-static void free_chan(struct list_head *chans)
+static void free_chan(struct list_head *chans, int delay_free_irq)
 {
         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);
+                free_one_chan(chan, delay_free_irq);
         }
 }
 
@@ -398,15 +429,21 @@ static int chan_pair_config_string(struct chan *in, struct chan *out,
         return n;
 }
 
-int chan_config_string(struct line *line, char *str, int size,
+int chan_config_string(struct list_head *chans, char *str, int size,
                        char **error_out)
 {
-        struct chan *in = line->chan_in, *out = line->chan_out;
+        struct list_head *ele;
+        struct chan *chan, *in = NULL, *out = NULL;
 
-        if (in && !in->primary)
-                in = NULL;
-        if (out && !out->primary)
-                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);
 }
@@ -510,14 +547,10 @@ int parse_chan_pair(char *str, struct line *line, int device,
         char *in, *out;
 
         if (!list_empty(chans)) {
-                line->chan_in = line->chan_out = NULL;
-                free_chan(chans);
+                free_chan(chans, 0);
                 INIT_LIST_HEAD(chans);
         }
 
-        if (!str)
-                return 0;
-
         out = strchr(str, ',');
         if (out != NULL) {
                 in = str;
@@ -529,7 +562,6 @@ int parse_chan_pair(char *str, struct line *line, int device,
 
                 new->input = 1;
                 list_add(&new->list, chans);
-                line->chan_in = new;
 
                 new = parse_chan(line, out, device, opts, error_out);
                 if (new == NULL)
@@ -537,7 +569,6 @@ int parse_chan_pair(char *str, struct line *line, int device,
 
                 list_add(&new->list, chans);
                 new->output = 1;
-                line->chan_out = new;
         }
         else {
                 new = parse_chan(line, str, device, opts, error_out);
@@ -547,42 +578,43 @@ int parse_chan_pair(char *str, struct line *line, int device,
                 list_add(&new->list, chans);
                 new->input = 1;
                 new->output = 1;
-                line->chan_in = line->chan_out = new;
         }
         return 0;
 }
 
-void chan_interrupt(struct line *line, struct tty_struct *tty, int irq)
+void chan_interrupt(struct list_head *chans, struct delayed_work *task,
+                    struct tty_struct *tty, int irq)
 {
-        struct chan *chan = line->chan_in;
+        struct list_head *ele, *next;
+        struct chan *chan;
         int err;
         char c;
 
-        if (!chan || !chan->ops->read)
-                goto out;
-
-        do {
-                if (tty && !tty_buffer_request_room(tty, 1)) {
-                        schedule_delayed_work(&line->task, 1);
-                        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);
-                        if (line->chan_out != chan)
-                                close_one_chan(line->chan_out, 1);
+        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 && !tty_buffer_request_room(tty, 1)) {
+                                schedule_delayed_work(task, 1);
+                                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);
+                                close_chan(chans, 1);
+                                return;
+                        }
+                        else close_one_chan(chan, 1);
                 }
-                close_one_chan(chan, 1);
-                if (chan->primary)
-                        return;
         }
  out:
         if (tty)
diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
index 9be670ad23b..cfeb3f4a44a 100644
--- a/arch/um/drivers/chan_user.c
+++ b/arch/um/drivers/chan_user.c
@@ -11,8 +11,10 @@
 #include <termios.h>
 #include <sys/ioctl.h>
 #include "chan_user.h"
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 void generic_close(int fd, void *unused)
 {
@@ -281,12 +283,7 @@ void register_winch(int fd, struct tty_struct *tty)
                 return;
 
         pid = tcgetpgrp(fd);
-        if (is_skas_winch(pid, fd, tty)) {
-                register_winch_irq(-1, fd, -1, tty, 0);
-                return;
-        }
-
-        if (pid == -1) {
+        if (!is_skas_winch(pid, fd, tty) && (pid == -1)) {
                 thread = winch_tramp(fd, tty, &thread_fd, &stack);
                 if (thread < 0)
                         return;
diff --git a/arch/um/drivers/chan_user.h b/arch/um/drivers/chan_user.h
deleted file mode 100644
index dc693298eb8..00000000000
--- a/arch/um/drivers/chan_user.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __CHAN_USER_H__
-#define __CHAN_USER_H__
-
-#include <init.h>
-
-struct chan_opts {
-        void (*const announce)(char *dev_name, int dev);
-        char *xterm_title;
-        const int raw;
-};
-
-struct chan_ops {
-        char *type;
-        void *(*init)(char *, int, const struct chan_opts *);
-        int (*open)(int, int, int, void *, char **);
-        void (*close)(int, void *);
-        int (*read)(int, char *, void *);
-        int (*write)(int, const char *, int, void *);
-        int (*console_write)(int, const char *, int);
-        int (*window_size)(int, void *, unsigned short *, unsigned short *);
-        void (*free)(void *);
-        int winch;
-};
-
-extern const struct chan_ops fd_ops, null_ops, port_ops, pts_ops, pty_ops,
-        tty_ops, xterm_ops;
-
-extern void generic_close(int fd, void *unused);
-extern int generic_read(int fd, char *c_out, void *unused);
-extern int generic_write(int fd, const char *buf, int n, void *unused);
-extern int generic_console_write(int fd, const char *buf, int n);
-extern int generic_window_size(int fd, void *unused, unsigned short *rows_out,
-                               unsigned short *cols_out);
-extern void generic_free(void *data);
-
-struct tty_struct;
-extern void register_winch(int fd,  struct tty_struct *tty);
-extern void register_winch_irq(int fd, int tty_fd, int pid,
-                               struct tty_struct *tty, unsigned long stack);
-
-#define __channel_help(fn, prefix) \
-__uml_help(fn, prefix "[0-9]*=<channel description>\n" \
-"    Attach a console or serial line to a host channel.  See\n" \
-"    http://user-mode-linux.sourceforge.net/old/input.html for a complete\n" \
-"    description of this switch.\n\n" \
-);
-
-#endif
diff --git a/arch/um/drivers/cow.h b/arch/um/drivers/cow.h
index 6673508f342..dc36b222100 100644
--- a/arch/um/drivers/cow.h
+++ b/arch/um/drivers/cow.h
@@ -3,6 +3,41 @@
 
 #include <asm/types.h>
 
+#if defined(__KERNEL__)
+
+# include <asm/byteorder.h>
+
+# if defined(__BIG_ENDIAN)
+#       define ntohll(x) (x)
+#       define htonll(x) (x)
+# elif defined(__LITTLE_ENDIAN)
+#       define ntohll(x)  be64_to_cpu(x)
+#       define htonll(x)  cpu_to_be64(x)
+# else
+#       error "Could not determine byte order"
+# endif
+
+#else
+/* For the definition of ntohl, htonl and __BYTE_ORDER */
+#include <endian.h>
+#include <netinet/in.h>
+#if defined(__BYTE_ORDER)
+
+#  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 "Could not determine byte order: __BYTE_ORDER uncorrectly defined"
+#  endif
+
+#else  /* ! defined(__BYTE_ORDER) */
+#       error "Could not determine byte order: __BYTE_ORDER not defined"
+#endif
+#endif /* ! defined(__KERNEL__) */
+
 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);
diff --git a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
index 67cbee63e70..f5701fd2ef9 100644
--- a/arch/um/drivers/cow_sys.h
+++ b/arch/um/drivers/cow_sys.h
@@ -1,9 +1,10 @@
 #ifndef __COW_SYS_H__
 #define __COW_SYS_H__
 
-#include <kern_util.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_util.h"
+#include "os.h"
+#include "user.h"
+#include "um_malloc.h"
 
 static inline void *cow_malloc(int size)
 {
diff --git a/arch/um/drivers/cow_user.c b/arch/um/drivers/cow_user.c
index 0ee9cc6cc4c..9cbb426c0b9 100644
--- a/arch/um/drivers/cow_user.c
+++ b/arch/um/drivers/cow_user.c
@@ -8,10 +8,11 @@
  * that.
  */
 #include <unistd.h>
+#include <byteswap.h>
 #include <errno.h>
 #include <string.h>
 #include <arpa/inet.h>
-#include <endian.h>
+#include <asm/types.h>
 #include "cow.h"
 #include "cow_sys.h"
 
@@ -213,8 +214,8 @@ int write_cow_header(char *cow_file, int fd, char *backing_file,
                            "header\n");
                 goto out;
         }
-        header->magic = htobe32(COW_MAGIC);
-        header->version = htobe32(COW_VERSION);
+        header->magic = htonl(COW_MAGIC);
+        header->version = htonl(COW_VERSION);
 
         err = -EINVAL;
         if (strlen(backing_file) > sizeof(header->backing_file) - 1) {
@@ -245,10 +246,10 @@ int write_cow_header(char *cow_file, int fd, char *backing_file,
                 goto out_free;
         }
 
-        header->mtime = htobe32(modtime);
-        header->size = htobe64(*size);
-        header->sectorsize = htobe32(sectorsize);
-        header->alignment = htobe32(alignment);
+        header->mtime = htonl(modtime);
+        header->size = htonll(*size);
+        header->sectorsize = htonl(sectorsize);
+        header->alignment = htonl(alignment);
         header->cow_format = COW_BITMAP;
 
         err = cow_write_file(fd, header, sizeof(*header));
@@ -300,8 +301,8 @@ int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
         magic = header->v1.magic;
         if (magic == COW_MAGIC)
                 version = header->v1.version;
-        else if (magic == be32toh(COW_MAGIC))
-                version = be32toh(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;
 
@@ -326,9 +327,9 @@ int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
                                    "header\n");
                         goto out;
                 }
-                *mtime_out = be32toh(header->v2.mtime);
-                *size_out = be64toh(header->v2.size);
-                *sectorsize_out = be32toh(header->v2.sectorsize);
+                *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;
@@ -340,10 +341,10 @@ int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
                                    "header\n");
                         goto out;
                 }
-                *mtime_out = be32toh(header->v3.mtime);
-                *size_out = be64toh(header->v3.size);
-                *sectorsize_out = be32toh(header->v3.sectorsize);
-                *align_out = be32toh(header->v3.alignment);
+                *mtime_out = ntohl(header->v3.mtime);
+                *size_out = ntohll(header->v3.size);
+                *sectorsize_out = ntohl(header->v3.sectorsize);
+                *align_out = ntohl(header->v3.alignment);
                 if (*align_out == 0) {
                         cow_printf("read_cow_header - invalid COW header, "
                                    "align == 0\n");
@@ -365,16 +366,16 @@ int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
                  * this was used until Dec2005 - 64bits are needed to represent
                  * 2038+. I.e. we can safely do this truncating cast.
                  *
-                 * Additionally, we must use be32toh() instead of be64toh(), since
+                 * Additionally, we must use ntohl() instead of ntohll(), since
                  * the program used to use the former (tested - I got mtime
                  * mismatch "0 vs whatever").
                  *
                  * Ever heard about bug-to-bug-compatibility ? ;-) */
-                *mtime_out = (time32_t) be32toh(header->v3_b.mtime);
+                *mtime_out = (time32_t) ntohl(header->v3_b.mtime);
 
-                *size_out = be64toh(header->v3_b.size);
-                *sectorsize_out = be32toh(header->v3_b.sectorsize);
-                *align_out = be32toh(header->v3_b.alignment);
+                *size_out = ntohll(header->v3_b.size);
+                *sectorsize_out = ntohl(header->v3_b.sectorsize);
+                *align_out = ntohl(header->v3_b.alignment);
                 if (*align_out == 0) {
                         cow_printf("read_cow_header - invalid COW header, "
                                    "align == 0\n");
diff --git a/arch/um/drivers/daemon.h b/arch/um/drivers/daemon.h
index c2dd1951559..6e0e891f8a0 100644
--- a/arch/um/drivers/daemon.h
+++ b/arch/um/drivers/daemon.h
@@ -6,7 +6,7 @@
 #ifndef __DAEMON_H__
 #define __DAEMON_H__
 
-#include <net_user.h>
+#include "net_user.h"
 
 #define SWITCH_VERSION 3
 
diff --git a/arch/um/drivers/daemon_kern.c b/arch/um/drivers/daemon_kern.c
index 7568cc2f3cd..b4a1522f215 100644
--- a/arch/um/drivers/daemon_kern.c
+++ b/arch/um/drivers/daemon_kern.c
@@ -6,9 +6,9 @@
  * Licensed under the GPL.
  */
 
-#include <linux/init.h>
+#include "linux/init.h"
 #include <linux/netdevice.h>
-#include <net_kern.h>
+#include "net_kern.h"
 #include "daemon.h"
 
 struct daemon_init {
diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
index 8813c10d017..f8e85e0bdac 100644
--- a/arch/um/drivers/daemon_user.c
+++ b/arch/um/drivers/daemon_user.c
@@ -14,9 +14,10 @@
 #include <sys/time.h>
 #include <sys/un.h>
 #include "daemon.h"
-#include <net_user.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "net_user.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 enum request_type { REQ_NEW_CONTROL };
 
diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
index a13a427b996..f5a981a1624 100644
--- a/arch/um/drivers/fd.c
+++ b/arch/um/drivers/fd.c
@@ -9,8 +9,10 @@
 #include <errno.h>
 #include <termios.h>
 #include "chan_user.h"
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 struct fd_chan {
         int fd;
diff --git a/arch/um/drivers/harddog_user.c b/arch/um/drivers/harddog_user.c
index f99b32a4dbf..84dce3fc590 100644
--- a/arch/um/drivers/harddog_user.c
+++ b/arch/um/drivers/harddog_user.c
@@ -6,7 +6,8 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
-#include <os.h>
+#include "os.h"
+#include "user.h"
 
 struct dog_data {
         int stdin;
diff --git a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c
index 9b90fdc4b15..f9f6a4e2059 100644
--- a/arch/um/drivers/hostaudio_kern.c
+++ b/arch/um/drivers/hostaudio_kern.c
@@ -3,15 +3,15 @@
  * Licensed under the GPL
  */
 
-#include <linux/fs.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/sound.h>
-#include <linux/soundcard.h>
-#include <linux/mutex.h>
-#include <asm/uaccess.h>
-#include <init.h>
-#include <os.h>
+#include "linux/fs.h"
+#include "linux/module.h"
+#include "linux/slab.h"
+#include "linux/sound.h"
+#include "linux/soundcard.h"
+#include "linux/mutex.h"
+#include "asm/uaccess.h"
+#include "init.h"
+#include "os.h"
 
 struct hostaudio_state {
         int fd;
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
index 9ffc28bd4b7..364c8a15c4c 100644
--- a/arch/um/drivers/line.c
+++ b/arch/um/drivers/line.c
@@ -3,15 +3,15 @@
  * Licensed under the GPL
  */
 
-#include <linux/irqreturn.h>
-#include <linux/kd.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include "chan.h"
-#include <irq_kern.h>
-#include <irq_user.h>
-#include <kern_util.h>
-#include <os.h>
+#include "linux/irqreturn.h"
+#include "linux/kd.h"
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "chan_kern.h"
+#include "irq_kern.h"
+#include "irq_user.h"
+#include "kern_util.h"
+#include "os.h"
 
 #define LINE_BUFSIZE 4096
 
@@ -19,14 +19,21 @@ static irqreturn_t line_interrupt(int irq, void *data)
 {
         struct chan *chan = data;
         struct line *line = chan->line;
-        struct tty_struct *tty = tty_port_tty_get(&line->port);
 
         if (line)
-                chan_interrupt(line, tty, irq);
-        tty_kref_put(tty);
+                chan_interrupt(&line->chan_list, &line->task, line->tty, irq);
         return IRQ_HANDLED;
 }
 
+static void line_timer_cb(struct work_struct *work)
+{
+        struct line *line = container_of(work, struct line, task.work);
+
+        if (!line->throttled)
+                chan_interrupt(&line->chan_list, &line->task, line->tty,
+                               line->driver->read_irq);
+}
+
 /*
  * Returns the free space inside the ring buffer of this line.
  *
@@ -138,7 +145,7 @@ static int flush_buffer(struct line *line)
                 /* line->buffer + LINE_BUFSIZE is the end of the buffer! */
                 count = line->buffer + LINE_BUFSIZE - line->head;
 
-                n = write_chan(line->chan_out, line->head, count,
+                n = write_chan(&line->chan_list, line->head, count,
                                line->driver->write_irq);
                 if (n < 0)
                         return n;
@@ -155,7 +162,7 @@ static int flush_buffer(struct line *line)
         }
 
         count = line->tail - line->head;
-        n = write_chan(line->chan_out, line->head, count,
+        n = write_chan(&line->chan_list, line->head, count,
                        line->driver->write_irq);
 
         if (n < 0)
@@ -199,7 +206,7 @@ int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
         if (line->head != line->tail)
                 ret = buffer_data(line, buf, len);
         else {
-                n = write_chan(line->chan_out, buf, len,
+                n = write_chan(&line->chan_list, buf, len,
                                line->driver->write_irq);
                 if (n < 0) {
                         ret = n;
@@ -221,11 +228,97 @@ void line_set_termios(struct tty_struct *tty, struct ktermios * old)
         /* nothing */
 }
 
+static const 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, 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
+        /* Note: these are out of date as we now have TCGETS2 etc but this
+           whole lot should probably go away */
+        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)) {
+                        printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n",
+                               __func__, tty->name, cmd);
+                }
+                ret = -ENOIOCTLCMD;
+                break;
+        }
+        return ret;
+}
+
 void line_throttle(struct tty_struct *tty)
 {
         struct line *line = tty->driver_data;
 
-        deactivate_chan(line->chan_in, line->driver->read_irq);
+        deactivate_chan(&line->chan_list, line->driver->read_irq);
         line->throttled = 1;
 }
 
@@ -234,7 +327,8 @@ void line_unthrottle(struct tty_struct *tty)
         struct line *line = tty->driver_data;
 
         line->throttled = 0;
-        chan_interrupt(line, tty, line->driver->read_irq);
+        chan_interrupt(&line->chan_list, &line->task, tty,
+                       line->driver->read_irq);
 
         /*
          * Maybe there is enough stuff pending that calling the interrupt
@@ -242,25 +336,24 @@ void line_unthrottle(struct tty_struct *tty)
          * again and we shouldn't turn the interrupt back on.
          */
         if (!line->throttled)
-                reactivate_chan(line->chan_in, line->driver->read_irq);
+                reactivate_chan(&line->chan_list, line->driver->read_irq);
 }
 
 static irqreturn_t line_write_interrupt(int irq, void *data)
 {
         struct chan *chan = data;
         struct line *line = chan->line;
-        struct tty_struct *tty;
+        struct tty_struct *tty = line->tty;
         int err;
 
         /*
-         * Interrupts are disabled here because genirq keep irqs disabled when
-         * calling the action handler.
+         * Interrupts are disabled here because we registered the interrupt with
+         * IRQF_DISABLED (see line_setup_irq).
          */
 
         spin_lock(&line->lock);
         err = flush_buffer(line);
         if (err == 0) {
-                spin_unlock(&line->lock);
                 return IRQ_NONE;
         } else if (err < 0) {
                 line->head = line->buffer;
@@ -268,103 +361,124 @@ static irqreturn_t line_write_interrupt(int irq, void *data)
         }
         spin_unlock(&line->lock);
 
-        tty = tty_port_tty_get(&line->port);
         if (tty == NULL)
                 return IRQ_NONE;
 
         tty_wakeup(tty);
-        tty_kref_put(tty);
-
         return IRQ_HANDLED;
 }
 
 int line_setup_irq(int fd, int input, int output, struct line *line, void *data)
 {
         const struct line_driver *driver = line->driver;
-        int err = 0;
+        int err = 0, flags = IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM;
 
         if (input)
                 err = um_request_irq(driver->read_irq, fd, IRQ_READ,
-                                     line_interrupt, IRQF_SHARED,
-                                     driver->read_irq_name, data);
+                                       line_interrupt, flags,
+                                       driver->read_irq_name, data);
         if (err)
                 return err;
         if (output)
                 err = um_request_irq(driver->write_irq, fd, IRQ_WRITE,
-                                     line_write_interrupt, IRQF_SHARED,
-                                     driver->write_irq_name, data);
+                                        line_write_interrupt, flags,
+                                        driver->write_irq_name, data);
+        line->have_irq = 1;
         return err;
 }
 
-static int line_activate(struct tty_port *port, struct tty_struct *tty)
+/*
+ * Normally, a driver like this can rely mostly on the tty layer
+ * locking, particularly when it comes to the driver structure.
+ * However, in this case, mconsole requests can come in "from the
+ * side", and race with opens and closes.
+ *
+ * mconsole config requests will want to be sure the device isn't in
+ * use, and get_config, open, and close will want a stable
+ * configuration.  The checking and modification of the configuration
+ * is done under a spinlock.  Checking whether the device is in use is
+ * line->tty->count > 1, also under the spinlock.
+ *
+ * line->count serves to decide whether the device should be enabled or
+ * disabled on the host.  If it's equal to 0, then we are doing the
+ * first open or last close.  Otherwise, open and close just return.
+ */
+
+int line_open(struct line *lines, struct tty_struct *tty)
 {
-        int ret;
-        struct line *line = tty->driver_data;
+        struct line *line = &lines[tty->index];
+        int err = -ENODEV;
+
+        spin_lock(&line->count_lock);
+        if (!line->valid)
+                goto out_unlock;
+
+        err = 0;
+        if (line->count++)
+                goto out_unlock;
+
+        BUG_ON(tty->driver_data);
+        tty->driver_data = line;
+        line->tty = tty;
+
+        spin_unlock(&line->count_lock);
+        err = enable_chan(line);
+        if (err) /* line_close() will be called by our caller */
+                return err;
 
-        ret = enable_chan(line);
-        if (ret)
-                return ret;
+        INIT_DELAYED_WORK(&line->task, line_timer_cb);
 
         if (!line->sigio) {
-                chan_enable_winch(line->chan_out, tty);
+                chan_enable_winch(&line->chan_list, tty);
                 line->sigio = 1;
         }
 
-        chan_window_size(line, &tty->winsize.ws_row,
-                &tty->winsize.ws_col);
+        chan_window_size(&line->chan_list, &tty->winsize.ws_row,
+                         &tty->winsize.ws_col);
 
         return 0;
+
+out_unlock:
+        spin_unlock(&line->count_lock);
+        return err;
 }
 
-static const struct tty_port_operations line_port_ops = {
-        .activate = line_activate,
-};
+static void unregister_winch(struct tty_struct *tty);
 
-int line_open(struct tty_struct *tty, struct file *filp)
+void line_close(struct tty_struct *tty, struct file * filp)
 {
         struct line *line = tty->driver_data;
 
-        return tty_port_open(&line->port, tty, filp);
-}
+        /*
+         * If line_open fails (and tty->driver_data is never set),
+         * tty_open will call line_close.  So just return in this case.
+         */
+        if (line == NULL)
+                return;
 
-int line_install(struct tty_driver *driver, struct tty_struct *tty,
-                 struct line *line)
-{
-        int ret;
+        /* We ignore the error anyway! */
+        flush_buffer(line);
 
-        ret = tty_standard_install(driver, tty);
-        if (ret)
-                return ret;
+        spin_lock(&line->count_lock);
+        BUG_ON(!line->valid);
 
-        tty->driver_data = line;
+        if (--line->count)
+                goto out_unlock;
 
-        return 0;
-}
+        line->tty = NULL;
+        tty->driver_data = NULL;
 
-static void unregister_winch(struct tty_struct *tty);
-
-void line_cleanup(struct tty_struct *tty)
-{
-        struct line *line = tty->driver_data;
+        spin_unlock(&line->count_lock);
 
         if (line->sigio) {
                 unregister_winch(tty);
                 line->sigio = 0;
         }
-}
-
-void line_close(struct tty_struct *tty, struct file * filp)
-{
-        struct line *line = tty->driver_data;
 
-        tty_port_close(&line->port, tty, filp);
-}
-
-void line_hangup(struct tty_struct *tty)
-{
-        struct line *line = tty->driver_data;
+        return;
 
-        tty_port_hangup(&line->port);
+out_unlock:
+        spin_unlock(&line->count_lock);
 }
 
 void close_lines(struct line *lines, int nlines)
@@ -372,58 +486,34 @@ void close_lines(struct line *lines, int nlines)
         int i;
 
         for(i = 0; i < nlines; i++)
-                close_chan(&lines[i]);
+                close_chan(&lines[i].chan_list, 0);
 }
 
-int setup_one_line(struct line *lines, int n, char *init,
-                   const struct chan_opts *opts, char **error_out)
+static int setup_one_line(struct line *lines, int n, char *init, int init_prio,
+                          char **error_out)
 {
         struct line *line = &lines[n];
-        struct tty_driver *driver = line->driver->driver;
         int err = -EINVAL;
 
-        if (line->port.count) {
+        spin_lock(&line->count_lock);
+
+        if (line->count) {
                 *error_out = "Device is already open";
                 goto out;
         }
 
-        if (!strcmp(init, "none")) {
-                if (line->valid) {
+        if (line->init_pri <= init_prio) {
+                line->init_pri = init_prio;
+                if (!strcmp(init, "none"))
                         line->valid = 0;
-                        kfree(line->init_str);
-                        tty_unregister_device(driver, n);
-                        parse_chan_pair(NULL, line, n, opts, error_out);
-                        err = 0;
-                }
-        } else {
-                char *new = kstrdup(init, GFP_KERNEL);
-                if (!new) {
-                        *error_out = "Failed to allocate memory";
-                        return -ENOMEM;
-                }
-                if (line->valid) {
-                        tty_unregister_device(driver, n);
-                        kfree(line->init_str);
-                }
-                line->init_str = new;
-                line->valid = 1;
-                err = parse_chan_pair(new, line, n, opts, error_out);
-                if (!err) {
-                        struct device *d = tty_port_register_device(&line->port,
-                                        driver, n, NULL);
-                        if (IS_ERR(d)) {
-                                *error_out = "Failed to register device";
-                                err = PTR_ERR(d);
-                                parse_chan_pair(NULL, line, n, opts, error_out);
-                        }
-                }
-                if (err) {
-                        line->init_str = NULL;
-                        line->valid = 0;
-                        kfree(new);
+                else {
+                        line->init_str = init;
+                        line->valid = 1;
                 }
         }
+        err = 0;
 out:
+        spin_unlock(&line->count_lock);
         return err;
 }
 
@@ -434,43 +524,54 @@ out:
  * @error_out is an error string in the case of failure;
  */
 
-int line_setup(char **conf, unsigned int num, char **def,
-               char *init, char *name)
+int line_setup(struct line *lines, unsigned int num, char *init,
+               char **error_out)
 {
-        char *error;
+        int i, n, err;
+        char *end;
 
         if (*init == '=') {
                 /*
                  * We said con=/ssl= instead of con#=, so we are configuring all
                  * consoles at once.
                  */
-                *def = init + 1;
-        } else {
-                char *end;
-                unsigned n = simple_strtoul(init, &end, 0);
-
+                n = -1;
+        }
+        else {
+                n = simple_strtoul(init, &end, 0);
                 if (*end != '=') {
-                        error = "Couldn't parse device number";
-                        goto out;
-                }
-                if (n >= num) {
-                        error = "Device number out of range";
-                        goto out;
+                        *error_out = "Couldn't parse device number";
+                        return -EINVAL;
                 }
-                conf[n] = end + 1;
+                init = end;
         }
-        return 0;
+        init++;
 
-out:
-        printk(KERN_ERR "Failed to set up %s with "
-               "configuration string \"%s\" : %s\n", name, init, error);
-        return -EINVAL;
+        if (n >= (signed int) num) {
+                *error_out = "Device number out of range";
+                return -EINVAL;
+        }
+        else if (n >= 0) {
+                err = setup_one_line(lines, n, init, INIT_ONE, error_out);
+                if (err)
+                        return err;
+        }
+        else {
+                for(i = 0; i < num; i++) {
+                        err = setup_one_line(lines, i, init, INIT_ALL,
+                                             error_out);
+                        if (err)
+                                return err;
+                }
+        }
+        return n == -1 ? num : n;
 }
 
 int line_config(struct line *lines, unsigned int num, char *str,
                 const struct chan_opts *opts, char **error_out)
 {
-        char *end;
+        struct line *line;
+        char *new;
         int n;
 
         if (*str == '=') {
@@ -478,17 +579,17 @@ int line_config(struct line *lines, unsigned int num, char *str,
                 return -EINVAL;
         }
 
-        n = simple_strtoul(str, &end, 0);
-        if (*end++ != '=') {
-                *error_out = "Couldn't parse device number";
-                return -EINVAL;
-        }
-        if (n >= num) {
-                *error_out = "Device number out of range";
-                return -EINVAL;
+        new = kstrdup(str, GFP_KERNEL);
+        if (new == NULL) {
+                *error_out = "Failed to allocate memory";
+                return -ENOMEM;
         }
+        n = line_setup(lines, num, new, error_out);
+        if (n < 0)
+                return n;
 
-        return setup_one_line(lines, n, end, opts, error_out);
+        line = &lines[n];
+        return parse_chan_pair(line->init_str, line, n, opts, error_out);
 }
 
 int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
@@ -511,17 +612,13 @@ int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
 
         line = &lines[dev];
 
+        spin_lock(&line->count_lock);
         if (!line->valid)
                 CONFIG_CHUNK(str, size, n, "none", 1);
-        else {
-                struct tty_struct *tty = tty_port_tty_get(&line->port);
-                if (tty == NULL) {
-                        CONFIG_CHUNK(str, size, n, line->init_str, 1);
-                } else {
-                        n = chan_config_string(line, str, size, error_out);
-                        tty_kref_put(tty);
-                }
-        }
+        else if (line->tty == NULL)
+                CONFIG_CHUNK(str, size, n, line->init_str, 1);
+        else n = chan_config_string(&line->chan_list, str, size, error_out);
+        spin_unlock(&line->count_lock);
 
         return n;
 }
@@ -543,23 +640,25 @@ int line_id(char **str, int *start_out, int *end_out)
 
 int line_remove(struct line *lines, unsigned int num, int n, char **error_out)
 {
-        if (n >= num) {
-                *error_out = "Device number out of range";
-                return -EINVAL;
-        }
-        return setup_one_line(lines, n, "none", NULL, error_out);
+        int err;
+        char config[sizeof("conxxxx=none\0")];
+
+        sprintf(config, "%d=none", n);
+        err = line_setup(lines, num, config, error_out);
+        if (err >= 0)
+                err = 0;
+        return err;
 }
 
-int register_lines(struct line_driver *line_driver,
-                   const struct tty_operations *ops,
-                   struct line *lines, int nlines)
+struct tty_driver *register_lines(struct line_driver *line_driver,
+                                  const struct tty_operations *ops,
+                                  struct line *lines, int nlines)
 {
-        struct tty_driver *driver = alloc_tty_driver(nlines);
-        int err;
         int i;
+        struct tty_driver *driver = alloc_tty_driver(nlines);
 
         if (!driver)
-                return -ENOMEM;
+                return NULL;
 
         driver->driver_name = line_driver->name;
         driver->name = line_driver->device_name;
@@ -567,36 +666,54 @@ int register_lines(struct line_driver *line_driver,
         driver->minor_start = line_driver->minor_start;
         driver->type = line_driver->type;
         driver->subtype = line_driver->subtype;
-        driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        driver->flags = TTY_DRIVER_REAL_RAW;
         driver->init_termios = tty_std_termios;
-        
-        for (i = 0; i < nlines; i++) {
-                tty_port_init(&lines[i].port);
-                lines[i].port.ops = &line_port_ops;
-                spin_lock_init(&lines[i].lock);
-                lines[i].driver = line_driver;
-                INIT_LIST_HEAD(&lines[i].chan_list);
-        }
         tty_set_operations(driver, ops);
 
-        err = tty_register_driver(driver);
-        if (err) {
+        if (tty_register_driver(driver)) {
                 printk(KERN_ERR "register_lines : can't register %s driver\n",
                        line_driver->name);
                 put_tty_driver(driver);
-                for (i = 0; i < nlines; i++)
-                        tty_port_destroy(&lines[i].port);
-                return err;
+                return NULL;
+        }
+
+        for(i = 0; i < nlines; i++) {
+                if (!lines[i].valid)
+                        tty_unregister_device(driver, i);
         }
 
-        line_driver->driver = driver;
         mconsole_register_dev(&line_driver->mc);
-        return 0;
+        return driver;
 }
 
 static DEFINE_SPINLOCK(winch_handler_lock);
 static LIST_HEAD(winch_handlers);
 
+void lines_init(struct line *lines, int nlines, struct chan_opts *opts)
+{
+        struct line *line;
+        char *error;
+        int i;
+
+        for(i = 0; i < nlines; i++) {
+                line = &lines[i];
+                INIT_LIST_HEAD(&line->chan_list);
+
+                if (line->init_str == NULL)
+                        continue;
+
+                line->init_str = kstrdup(line->init_str, GFP_KERNEL);
+                if (line->init_str == NULL)
+                        printk(KERN_ERR "lines_init - kstrdup returned NULL\n");
+
+                if (parse_chan_pair(line->init_str, line, i, opts, &error)) {
+                        printk(KERN_ERR "parse_chan_pair failed for "
+                               "device %d : %s\n", i, error);
+                        line->valid = 0;
+                }
+        }
+}
+
 struct winch {
         struct list_head list;
         int fd;
@@ -610,7 +727,7 @@ struct winch {
 static void __free_winch(struct work_struct *work)
 {
         struct winch *winch = container_of(work, struct winch, work);
-        um_free_irq(WINCH_IRQ, winch);
+        free_irq(WINCH_IRQ, winch);
 
         if (winch->pid != -1)
                 os_kill_process(winch->pid, 1);
@@ -660,7 +777,7 @@ static irqreturn_t winch_interrupt(int irq, void *data)
         if (tty != NULL) {
                 line = tty->driver_data;
                 if (line != NULL) {
-                        chan_window_size(line, &tty->winsize.ws_row,
+                        chan_window_size(&line->chan_list, &tty->winsize.ws_row,
                                          &tty->winsize.ws_col);
                         kill_pgrp(tty->pgrp, SIGWINCH, 1);
                 }
@@ -690,7 +807,8 @@ void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty,
                                    .stack       = stack });
 
         if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
-                           IRQF_SHARED, "winch", winch) < 0) {
+                           IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                           "winch", winch) < 0) {
                 printk(KERN_ERR "register_winch_irq - failed to register "
                        "IRQ\n");
                 goto out_free;
diff --git a/arch/um/drivers/line.h b/arch/um/drivers/line.h
deleted file mode 100644
index 138a14526d9..00000000000
--- a/arch/um/drivers/line.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/* 
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __LINE_H__
-#define __LINE_H__
-
-#include <linux/list.h>
-#include <linux/workqueue.h>
-#include <linux/tty.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <linux/mutex.h>
-#include "chan_user.h"
-#include "mconsole_kern.h"
-
-/* There's only two modifiable fields in this - .mc.list and .driver */
-struct line_driver {
-        const char *name;
-        const char *device_name;
-        const short major;
-        const short minor_start;
-        const short type;
-        const short subtype;
-        const int read_irq;
-        const char *read_irq_name;
-        const int write_irq;
-        const char *write_irq_name;
-        struct mc_device mc;
-        struct tty_driver *driver;
-};
-
-struct line {
-        struct tty_port port;
-        int valid;
-
-        char *init_str;
-        struct list_head chan_list;
-        struct chan *chan_in, *chan_out;
-
-        /*This lock is actually, mostly, local to*/
-        spinlock_t lock;
-        int throttled;
-        /* Yes, this is a real circular buffer.
-         * XXX: And this should become a struct kfifo!
-         *
-         * buffer points to a buffer allocated on demand, of length
-         * LINE_BUFSIZE, head to the start of the ring, tail to the end.*/
-        char *buffer;
-        char *head;
-        char *tail;
-
-        int sigio;
-        struct delayed_work task;
-        const struct line_driver *driver;
-};
-
-extern void line_close(struct tty_struct *tty, struct file * filp);
-extern int line_open(struct tty_struct *tty, struct file *filp);
-extern int line_install(struct tty_driver *driver, struct tty_struct *tty,
-        struct line *line);
-extern void line_cleanup(struct tty_struct *tty);
-extern void line_hangup(struct tty_struct *tty);
-extern int line_setup(char **conf, unsigned nlines, char **def,
-                      char *init, char *name);
-extern int line_write(struct tty_struct *tty, const unsigned char *buf,
-                      int len);
-extern int line_put_char(struct tty_struct *tty, unsigned char ch);
-extern void line_set_termios(struct tty_struct *tty, struct ktermios * old);
-extern int line_chars_in_buffer(struct tty_struct *tty);
-extern void line_flush_buffer(struct tty_struct *tty);
-extern void line_flush_chars(struct tty_struct *tty);
-extern int line_write_room(struct tty_struct *tty);
-extern void line_throttle(struct tty_struct *tty);
-extern void line_unthrottle(struct tty_struct *tty);
-
-extern char *add_xterm_umid(char *base);
-extern int line_setup_irq(int fd, int input, int output, struct line *line,
-                          void *data);
-extern void line_close_chan(struct line *line);
-extern int register_lines(struct line_driver *line_driver,
-                          const struct tty_operations *driver,
-                          struct line *lines, int nlines);
-extern int setup_one_line(struct line *lines, int n, char *init,
-                          const struct chan_opts *opts, char **error_out);
-extern void close_lines(struct line *lines, int nlines);
-
-extern int line_config(struct line *lines, unsigned int sizeof_lines,
-                       char *str, const struct chan_opts *opts,
-                       char **error_out);
-extern int line_id(char **str, int *start_out, int *end_out);
-extern int line_remove(struct line *lines, unsigned int sizeof_lines, int n,
-                       char **error_out);
-extern int line_get_config(char *dev, struct line *lines,
-                           unsigned int sizeof_lines, char *str,
-                           int size, char **error_out);
-
-#endif
diff --git a/arch/um/drivers/mconsole.h b/arch/um/drivers/mconsole.h
deleted file mode 100644
index 8b22535c62c..00000000000
--- a/arch/um/drivers/mconsole.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
- * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
- * Licensed under the GPL
- */
-
-#ifndef __MCONSOLE_H__
-#define __MCONSOLE_H__
-
-#ifndef __KERNEL__
-#include <stdint.h>
-#define u32 uint32_t
-#endif
-
-#include <sysdep/ptrace.h>
-
-#define MCONSOLE_MAGIC (0xcafebabe)
-#define MCONSOLE_MAX_DATA (512)
-#define MCONSOLE_VERSION 2
-
-struct mconsole_request {
-        u32 magic;
-        u32 version;
-        u32 len;
-        char data[MCONSOLE_MAX_DATA];
-};
-
-struct mconsole_reply {
-        u32 err;
-        u32 more;
-        u32 len;
-        char data[MCONSOLE_MAX_DATA];
-};
-
-struct mconsole_notify {
-        u32 magic;
-        u32 version;
-        enum { MCONSOLE_SOCKET, MCONSOLE_PANIC, MCONSOLE_HANG,
-               MCONSOLE_USER_NOTIFY } type;
-        u32 len;
-        char data[MCONSOLE_MAX_DATA];
-};
-
-struct mc_request;
-
-enum mc_context { MCONSOLE_INTR, MCONSOLE_PROC };
-
-struct mconsole_command
-{
-        char *command;
-        void (*handler)(struct mc_request *req);
-        enum mc_context context;
-};
-
-struct mc_request
-{
-        int len;
-        int as_interrupt;
-
-        int originating_fd;
-        unsigned int originlen;
-        unsigned char origin[128];                      /* sockaddr_un */
-
-        struct mconsole_request request;
-        struct mconsole_command *cmd;
-        struct uml_pt_regs regs;
-};
-
-extern char mconsole_socket_name[];
-
-extern int mconsole_unlink_socket(void);
-extern int mconsole_reply_len(struct mc_request *req, const char *reply,
-                              int len, int err, int more);
-extern int mconsole_reply(struct mc_request *req, const char *str, int err,
-                          int more);
-
-extern void mconsole_version(struct mc_request *req);
-extern void mconsole_help(struct mc_request *req);
-extern void mconsole_halt(struct mc_request *req);
-extern void mconsole_reboot(struct mc_request *req);
-extern void mconsole_config(struct mc_request *req);
-extern void mconsole_remove(struct mc_request *req);
-extern void mconsole_sysrq(struct mc_request *req);
-extern void mconsole_cad(struct mc_request *req);
-extern void mconsole_stop(struct mc_request *req);
-extern void mconsole_go(struct mc_request *req);
-extern void mconsole_log(struct mc_request *req);
-extern void mconsole_proc(struct mc_request *req);
-extern void mconsole_stack(struct mc_request *req);
-
-extern int mconsole_get_request(int fd, struct mc_request *req);
-extern int mconsole_notify(char *sock_name, int type, const void *data,
-                           int len);
-extern char *mconsole_notify_socket(void);
-extern void lock_notify(void);
-extern void unlock_notify(void);
-
-#endif
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 4bd82ac0210..c70e047eed7 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -21,19 +21,15 @@
 #include <linux/un.h>
 #include <linux/workqueue.h>
 #include <linux/mutex.h>
-#include <linux/fs.h>
-#include <linux/mount.h>
-#include <linux/file.h>
 #include <asm/uaccess.h>
-#include <asm/switch_to.h>
 
-#include <init.h>
-#include <irq_kern.h>
-#include <irq_user.h>
-#include <kern_util.h>
+#include "init.h"
+#include "irq_kern.h"
+#include "irq_user.h"
+#include "kern_util.h"
 #include "mconsole.h"
 #include "mconsole_kern.h"
-#include <os.h>
+#include "os.h"
 
 static int do_unlink_socket(struct notifier_block *notifier,
                             unsigned long what, void *data)
@@ -121,14 +117,18 @@ void mconsole_log(struct mc_request *req)
         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 vfsmount *mnt = task_active_pid_ns(current)->proc_mnt;
-        char *buf;
-        int len;
+        struct vfsmount *mnt = current->nsproxy->pid_ns->proc_mnt;
         struct file *file;
-        int first_chunk = 1;
-        char *ptr = req->request.data;
+        int n;
+        char *ptr = req->request.data, *buf;
+        mm_segment_t old_fs = get_fs();
 
         ptr += strlen("proc");
         ptr = skip_spaces(ptr);
@@ -136,7 +136,6 @@ void mconsole_proc(struct mc_request *req)
         file = file_open_root(mnt->mnt_root, mnt, ptr, O_RDONLY);
         if (IS_ERR(file)) {
                 mconsole_reply(req, "Failed to open file", 1, 0);
-                printk(KERN_ERR "open /proc/%s: %ld\n", ptr, PTR_ERR(file));
                 goto out;
         }
 
@@ -146,13 +145,62 @@ void mconsole_proc(struct mc_request *req)
                 goto out_fput;
         }
 
-        do {
-                loff_t pos;
-                mm_segment_t old_fs = get_fs();
-                set_fs(KERNEL_DS);
-                len = vfs_read(file, buf, PAGE_SIZE - 1, &pos);
-                set_fs(old_fs);
-                file->f_pos = pos;
+        if (file->f_op->read) {
+                do {
+                        loff_t pos;
+                        set_fs(KERNEL_DS);
+                        n = vfs_read(file, buf, PAGE_SIZE - 1, &pos);
+                        file_pos_write(file, pos);
+                        set_fs(old_fs);
+                        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: ;
+}
+#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");
+        ptr = skip_spaces(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(KERN_ERR "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;
@@ -162,14 +210,22 @@ void mconsole_proc(struct mc_request *req)
                         mconsole_reply(req, "\n", 0, 1);
                         first_chunk = 0;
                 }
-                buf[len] = '\0';
-                mconsole_reply(req, buf, 0, (len > 0));
-        } while (len > 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_fput:
-        fput(file);
- out: ;
+ out_close:
+        sys_close(fd);
+ out:
+        /* nothing */;
 }
 
 #define UML_MCONSOLE_HELPTEXT \
@@ -648,7 +704,6 @@ static void stack_proc(void *arg)
         struct task_struct *from = current, *to = arg;
 
         to->thread.saved_task = from;
-        rcu_user_hooks_switch(from, to);
         switch_to(from, to, from);
 }
 
@@ -718,7 +773,8 @@ static int __init mconsole_init(void)
         register_reboot_notifier(&reboot_notifier);
 
         err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
-                             IRQF_SHARED, "mconsole", (void *)sock);
+                             IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                             "mconsole", (void *)sock);
         if (err) {
                 printk(KERN_ERR "Failed to get IRQ for management console\n");
                 goto out;
diff --git a/arch/um/drivers/mconsole_kern.h b/arch/um/drivers/mconsole_kern.h
deleted file mode 100644
index 7a0c6a1ad1d..00000000000
--- a/arch/um/drivers/mconsole_kern.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __MCONSOLE_KERN_H__
-#define __MCONSOLE_KERN_H__
-
-#include <linux/list.h>
-#include "mconsole.h"
-
-struct mconsole_entry {
-        struct list_head list;
-        struct mc_request request;
-};
-
-/* All these methods are called in process context. */
-struct mc_device {
-        struct list_head list;
-        char *name;
-        int (*config)(char *, char **);
-        int (*get_config)(char *, char *, int, char **);
-        int (*id)(char **, int *, int *);
-        int (*remove)(int, char **);
-};
-
-#define CONFIG_CHUNK(str, size, current, chunk, end) \
-do { \
-        current += strlen(chunk); \
-        if(current >= size) \
-                str = NULL; \
-        if(str != NULL){ \
-                strcpy(str, chunk); \
-                str += strlen(chunk); \
-        } \
-        if(end) \
-                current++; \
-} while(0)
-
-#ifdef CONFIG_MCONSOLE
-
-extern void mconsole_register_dev(struct mc_device *new);
-
-#else
-
-static inline void mconsole_register_dev(struct mc_device *new)
-{
-}
-
-#endif
-
-#endif
diff --git a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
index 99209826adb..f8cf4c8bede 100644
--- a/arch/um/drivers/mconsole_user.c
+++ b/arch/um/drivers/mconsole_user.c
@@ -10,7 +10,9 @@
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <sys/un.h>
+#include "kern_constants.h"
 #include "mconsole.h"
+#include "user.h"
 
 static struct mconsole_command commands[] = {
         /*
diff --git a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
index 62145c27616..c0ef803c7c7 100644
--- a/arch/um/drivers/mmapper_kern.c
+++ b/arch/um/drivers/mmapper_kern.c
@@ -18,7 +18,7 @@
 #include <linux/mm.h>
 
 #include <asm/uaccess.h>
-#include <mem_user.h>
+#include "mem_user.h"
 
 /* These are set in mmapper_init, which is called at boot time */
 static unsigned long mmapper_size;
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index b1314ebf1f7..22745b47c82 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -18,12 +18,12 @@
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
-#include <init.h>
-#include <irq_kern.h>
-#include <irq_user.h>
+#include "init.h"
+#include "irq_kern.h"
+#include "irq_user.h"
 #include "mconsole_kern.h"
-#include <net_kern.h>
-#include <net_user.h>
+#include "net_kern.h"
+#include "net_user.h"
 
 #define DRIVER_NAME "uml-netdev"
 
@@ -161,7 +161,7 @@ static int uml_net_open(struct net_device *dev)
         }
 
         err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
-                             IRQF_SHARED, dev->name, dev);
+                             IRQF_DISABLED | IRQF_SHARED, dev->name, dev);
         if (err != 0) {
                 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
                 err = -ENETUNREACH;
@@ -195,7 +195,7 @@ static int uml_net_close(struct net_device *dev)
 
         netif_stop_queue(dev);
 
-        um_free_irq(dev->irq, dev);
+        free_irq(dev->irq, dev);
         if (lp->close != NULL)
                 (*lp->close)(lp->fd, &lp->user);
         lp->fd = -1;
@@ -293,7 +293,7 @@ static void uml_net_user_timer_expire(unsigned long _conn)
 #endif
 }
 
-static int setup_etheraddr(char *str, unsigned char *addr, char *name)
+static void setup_etheraddr(char *str, unsigned char *addr, char *name)
 {
         char *end;
         int i;
@@ -334,13 +334,12 @@ static int setup_etheraddr(char *str, unsigned char *addr, char *name)
                        addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
                        addr[5]);
         }
-        return 0;
+        return;
 
 random:
         printk(KERN_INFO
                "Choosing a random ethernet address for device %s\n", name);
-        eth_random_addr(addr);
-        return 1;
+        random_ether_addr(addr);
 }
 
 static DEFINE_SPINLOCK(devices_lock);
@@ -369,7 +368,7 @@ static const struct net_device_ops uml_netdev_ops = {
         .ndo_open               = uml_net_open,
         .ndo_stop               = uml_net_close,
         .ndo_start_xmit         = uml_net_start_xmit,
-        .ndo_set_rx_mode        = uml_net_set_multicast_list,
+        .ndo_set_multicast_list = uml_net_set_multicast_list,
         .ndo_tx_timeout         = uml_net_tx_timeout,
         .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = uml_net_change_mtu,
@@ -392,7 +391,6 @@ static void eth_configure(int n, void *init, char *mac,
         struct net_device *dev;
         struct uml_net_private *lp;
         int err, size;
-        int random_mac;
 
         size = transport->private_size + sizeof(struct uml_net_private);
 
@@ -419,7 +417,7 @@ static void eth_configure(int n, void *init, char *mac,
          */
         snprintf(dev->name, sizeof(dev->name), "eth%d", n);
 
-        random_mac = setup_etheraddr(mac, device->mac, dev->name);
+        setup_etheraddr(mac, device->mac, dev->name);
 
         printk(KERN_INFO "Netdevice %d (%pM) : ", n, device->mac);
 
@@ -476,9 +474,6 @@ static void eth_configure(int n, void *init, char *mac,
 
         /* don't use eth_mac_addr, it will not work here */
         memcpy(dev->dev_addr, device->mac, ETH_ALEN);
-        if (random_mac)
-                dev->addr_assign_type |= NET_ADDR_RANDOM;
-
         dev->mtu = transport->user->mtu;
         dev->netdev_ops = &uml_netdev_ops;
         dev->ethtool_ops = &uml_net_ethtool_ops;
@@ -835,7 +830,7 @@ static void close_devices(void)
         spin_lock(&opened_lock);
         list_for_each(ele, &opened) {
                 lp = list_entry(ele, struct uml_net_private, list);
-                um_free_irq(lp->dev->irq, lp->dev);
+                free_irq(lp->dev->irq, lp->dev);
                 if ((lp->close != NULL) && (lp->fd >= 0))
                         (*lp->close)(lp->fd, &lp->user);
                 if (lp->remove != NULL)
diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
index cd14157b556..520118888f1 100644
--- a/arch/um/drivers/net_user.c
+++ b/arch/um/drivers/net_user.c
@@ -11,9 +11,11 @@
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/wait.h>
-#include <net_user.h>
-#include <os.h>
-#include <um_malloc.h>
+#include "net_user.h"
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 int tap_open_common(void *dev, char *gate_addr)
 {
diff --git a/arch/um/drivers/null.c b/arch/um/drivers/null.c
index 10495747ce8..2b45a1446c8 100644
--- a/arch/um/drivers/null.c
+++ b/arch/um/drivers/null.c
@@ -7,7 +7,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include "chan_user.h"
-#include <os.h>
+#include "os.h"
 
 /* This address is used only as a unique identifier */
 static int null_chan;
diff --git a/arch/um/drivers/pcap_kern.c b/arch/um/drivers/pcap_kern.c
index be0fb57bd1d..2860525f8ff 100644
--- a/arch/um/drivers/pcap_kern.c
+++ b/arch/um/drivers/pcap_kern.c
@@ -3,9 +3,9 @@
  * Licensed under the GPL.
  */
 
-#include <linux/init.h>
+#include "linux/init.h"
 #include <linux/netdevice.h>
-#include <net_kern.h>
+#include "net_kern.h"
 #include "pcap_user.h"
 
 struct pcap_init {
diff --git a/arch/um/drivers/pcap_user.c b/arch/um/drivers/pcap_user.c
index c07b9c752c8..5f903587d69 100644
--- a/arch/um/drivers/pcap_user.c
+++ b/arch/um/drivers/pcap_user.c
@@ -7,9 +7,11 @@
 #include <pcap.h>
 #include <string.h>
 #include <asm/types.h>
-#include <net_user.h>
+#include "net_user.h"
 #include "pcap_user.h"
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "um_malloc.h"
+#include "user.h"
 
 #define PCAP_FD(p) (*(int *)(p))
 
diff --git a/arch/um/drivers/pcap_user.h b/arch/um/drivers/pcap_user.h
index 1ca7c764cc6..d8ba6153f91 100644
--- a/arch/um/drivers/pcap_user.h
+++ b/arch/um/drivers/pcap_user.h
@@ -3,7 +3,7 @@
  * Licensed under the GPL
  */
 
-#include <net_user.h>
+#include "net_user.h"
 
 struct pcap_data {
         char *host_if;
diff --git a/arch/um/drivers/port_kern.c b/arch/um/drivers/port_kern.c
index 40ca5cc275e..a11573be096 100644
--- a/arch/um/drivers/port_kern.c
+++ b/arch/um/drivers/port_kern.c
@@ -3,16 +3,16 @@
  * Licensed under the GPL
  */
 
-#include <linux/completion.h>
-#include <linux/interrupt.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <asm/atomic.h>
-#include <init.h>
-#include <irq_kern.h>
-#include <os.h>
+#include "linux/completion.h"
+#include "linux/interrupt.h"
+#include "linux/list.h"
+#include "linux/mutex.h"
+#include "linux/slab.h"
+#include "linux/workqueue.h"
+#include "asm/atomic.h"
+#include "init.h"
+#include "irq_kern.h"
+#include "os.h"
 #include "port.h"
 
 struct port_list {
@@ -100,7 +100,8 @@ static int port_accept(struct port_list *port)
                   .port         = port });
 
         if (um_request_irq(TELNETD_IRQ, socket[0], IRQ_READ, pipe_interrupt,
-                          IRQF_SHARED, "telnetd", conn)) {
+                          IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                          "telnetd", conn)) {
                 printk(KERN_ERR "port_accept : failed to get IRQ for "
                        "telnetd\n");
                 goto out_free;
@@ -183,7 +184,8 @@ void *port_data(int port_num)
         }
 
         if (um_request_irq(ACCEPT_IRQ, fd, IRQ_READ, port_interrupt,
-                          IRQF_SHARED, "port", port)) {
+                          IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                          "port", port)) {
                 printk(KERN_ERR "Failed to get IRQ for port %d\n", port_num);
                 goto out_close;
         }
@@ -252,7 +254,7 @@ int port_wait(void *data)
                  * connection.  Then we loop here throwing out failed
                  * connections until a good one is found.
                  */
-                um_free_irq(TELNETD_IRQ, conn);
+                free_irq(TELNETD_IRQ, conn);
 
                 if (conn->fd >= 0)
                         break;
diff --git a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
index 9a8e1b64c22..b49bf56a56a 100644
--- a/arch/um/drivers/port_user.c
+++ b/arch/um/drivers/port_user.c
@@ -10,9 +10,11 @@
 #include <unistd.h>
 #include <netinet/in.h>
 #include "chan_user.h"
-#include <os.h>
+#include "kern_constants.h"
+#include "os.h"
 #include "port.h"
-#include <um_malloc.h>
+#include "um_malloc.h"
+#include "user.h"
 
 struct port_chan {
         int raw;
diff --git a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
index f1fcc2cedb5..1113911dcb2 100644
--- a/arch/um/drivers/pty.c
+++ b/arch/um/drivers/pty.c
@@ -12,8 +12,10 @@
 #include <termios.h>
 #include <sys/stat.h>
 #include "chan_user.h"
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 struct pty_chan {
         void (*announce)(char *dev_name, int dev);
diff --git a/arch/um/drivers/random.c b/arch/um/drivers/random.c
index 9e3a7220582..981085a93f3 100644
--- a/arch/um/drivers/random.c
+++ b/arch/um/drivers/random.c
@@ -13,8 +13,8 @@
 #include <linux/miscdevice.h>
 #include <linux/delay.h>
 #include <asm/uaccess.h>
-#include <irq_kern.h>
-#include <os.h>
+#include "irq_kern.h"
+#include "os.h"
 
 /*
  * core module and version information
@@ -131,7 +131,8 @@ static int __init rng_init (void)
         random_fd = err;
 
         err = um_request_irq(RANDOM_IRQ, random_fd, IRQ_READ, random_interrupt,
-                             0, "random", NULL);
+                             IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "random",
+                             NULL);
         if (err)
                 goto err_out_cleanup_hw;
 
diff --git a/arch/um/drivers/slip_common.c b/arch/um/drivers/slip_common.c
index f597fa7c91d..e89cfc68fc3 100644
--- a/arch/um/drivers/slip_common.c
+++ b/arch/um/drivers/slip_common.c
@@ -1,6 +1,6 @@
 #include <string.h>
 #include "slip_common.h"
-#include <net_user.h>
+#include "net_user.h"
 
 int slip_proto_read(int fd, void *buf, int len, struct slip_proto *slip)
 {
diff --git a/arch/um/drivers/slip_kern.c b/arch/um/drivers/slip_kern.c
index ed5249fc057..dd2aadc14af 100644
--- a/arch/um/drivers/slip_kern.c
+++ b/arch/um/drivers/slip_kern.c
@@ -6,7 +6,7 @@
 #include <linux/if_arp.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
-#include <net_kern.h>
+#include "net_kern.h"
 #include "slip.h"
 
 struct slip_init {
diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
index 55c290d925f..cbacfc4e63e 100644
--- a/arch/um/drivers/slip_user.c
+++ b/arch/um/drivers/slip_user.c
@@ -11,10 +11,12 @@
 #include <string.h>
 #include <sys/termios.h>
 #include <sys/wait.h>
-#include <net_user.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "net_user.h"
+#include "os.h"
 #include "slip.h"
-#include <um_malloc.h>
+#include "um_malloc.h"
+#include "user.h"
 
 static int slip_user_init(void *data, void *dev)
 {
diff --git a/arch/um/drivers/slirp_kern.c b/arch/um/drivers/slirp_kern.c
index 4ef11ca7cac..e376284f0fb 100644
--- a/arch/um/drivers/slirp_kern.c
+++ b/arch/um/drivers/slirp_kern.c
@@ -4,11 +4,11 @@
  */
 
 #include <linux/if_arp.h>
-#include <linux/init.h>
+#include "linux/init.h"
 #include <linux/netdevice.h>
 #include <linux/string.h>
-#include <net_kern.h>
-#include <net_user.h>
+#include "net_kern.h"
+#include "net_user.h"
 #include "slirp.h"
 
 struct slirp_init {
diff --git a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
index c999d187abb..a0ada8fec72 100644
--- a/arch/um/drivers/slirp_user.c
+++ b/arch/um/drivers/slirp_user.c
@@ -7,9 +7,11 @@
 #include <errno.h>
 #include <string.h>
 #include <sys/wait.h>
-#include <net_user.h>
-#include <os.h>
+#include "kern_constants.h"
+#include "net_user.h"
+#include "os.h"
 #include "slirp.h"
+#include "user.h"
 
 static int slirp_user_init(void *data, void *dev)
 {
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
index 16fdd0a0f9d..f1786e64607 100644
--- a/arch/um/drivers/ssl.c
+++ b/arch/um/drivers/ssl.c
@@ -3,23 +3,31 @@
  * Licensed under the GPL
  */
 
-#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 "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.h"
-#include <init.h>
-#include <irq_user.h>
+#include "chan_kern.h"
+#include "kern.h"
+#include "init.h"
+#include "irq_user.h"
 #include "mconsole_kern.h"
 
 static const 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
 
 static void ssl_announce(char *dev_name, int dev)
@@ -65,9 +73,8 @@ static struct line_driver driver = {
 /* The array is initialized by line_init, at initcall time.  The
  * elements are locked individually as needed.
  */
-static char *conf[NR_PORTS];
-static char *def_conf = CONFIG_SSL_CHAN;
-static struct line serial_lines[NR_PORTS];
+static struct line serial_lines[NR_PORTS] =
+        { [0 ... NR_PORTS - 1] = LINE_INIT(CONFIG_SSL_CHAN, &driver) };
 
 static int ssl_config(char *str, char **error_out)
 {
@@ -87,13 +94,40 @@ static int ssl_remove(int n, char **error_out)
                            error_out);
 }
 
-static int ssl_install(struct tty_driver *driver, struct tty_struct *tty)
+static int ssl_open(struct tty_struct *tty, struct file *filp)
+{
+        int err = line_open(serial_lines, tty);
+
+        if (err)
+                printk(KERN_ERR "Failed to open serial line %d, err = %d\n",
+                       tty->index, err);
+
+        return err;
+}
+
+#if 0
+static void ssl_flush_buffer(struct tty_struct *tty)
+{
+        return;
+}
+
+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)
 {
-        return line_install(driver, tty, &serial_lines[tty->index]);
+        printk(KERN_ERR "Someone should implement ssl_start\n");
 }
 
+void ssl_hangup(struct tty_struct *tty)
+{
+}
+#endif
+
 static const struct tty_operations ssl_ops = {
-        .open                   = line_open,
+        .open                   = ssl_open,
         .close                  = line_close,
         .write                  = line_write,
         .put_char               = line_put_char,
@@ -102,11 +136,14 @@ static const struct tty_operations ssl_ops = {
         .flush_buffer           = line_flush_buffer,
         .flush_chars            = line_flush_chars,
         .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
         .throttle               = line_throttle,
         .unthrottle             = line_unthrottle,
-        .install                = ssl_install,
-        .cleanup                = line_cleanup,
-        .hangup                 = line_hangup,
+#if 0
+        .stop                   = ssl_stop,
+        .start                  = ssl_start,
+        .hangup                 = ssl_hangup,
+#endif
 };
 
 /* Changed by ssl_init and referenced by ssl_exit, which are both serialized
@@ -121,14 +158,14 @@ static void ssl_console_write(struct console *c, const char *string,
         unsigned long flags;
 
         spin_lock_irqsave(&line->lock, flags);
-        console_write_chan(line->chan_out, string, len);
+        console_write_chan(&line->chan_list, string, len);
         spin_unlock_irqrestore(&line->lock, flags);
 }
 
 static struct tty_driver *ssl_console_device(struct console *c, int *index)
 {
         *index = c->index;
-        return driver.driver;
+        return ssl_driver;
 }
 
 static int ssl_console_setup(struct console *co, char *options)
@@ -151,30 +188,17 @@ static struct console ssl_cons = {
 static int ssl_init(void)
 {
         char *new_title;
-        int err;
-        int i;
 
         printk(KERN_INFO "Initializing software serial port version %d\n",
                ssl_version);
-
-        err = register_lines(&driver, &ssl_ops, serial_lines,
+        ssl_driver = register_lines(&driver, &ssl_ops, serial_lines,
                                     ARRAY_SIZE(serial_lines));
-        if (err)
-                return err;
 
         new_title = add_xterm_umid(opts.xterm_title);
         if (new_title != NULL)
                 opts.xterm_title = new_title;
 
-        for (i = 0; i < NR_PORTS; i++) {
-                char *error;
-                char *s = conf[i];
-                if (!s)
-                        s = def_conf;
-                if (setup_one_line(serial_lines, i, s, &opts, &error))
-                        printk(KERN_ERR "setup_one_line failed for "
-                               "device %d : %s\n", i, error);
-        }
+        lines_init(serial_lines, ARRAY_SIZE(serial_lines), &opts);
 
         ssl_init_done = 1;
         register_console(&ssl_cons);
@@ -192,7 +216,14 @@ __uml_exitcall(ssl_exit);
 
 static int ssl_chan_setup(char *str)
 {
-        line_setup(conf, NR_PORTS, &def_conf, str, "serial line");
+        char *error;
+        int ret;
+
+        ret = line_setup(serial_lines, ARRAY_SIZE(serial_lines), str, &error);
+        if(ret < 0)
+                printk(KERN_ERR "Failed to set up serial line with "
+                       "configuration string \"%s\" : %s\n", str, error);
+
         return 1;
 }
 
diff --git a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
index 827777af3f6..49266f6108c 100644
--- a/arch/um/drivers/stdio_console.c
+++ b/arch/um/drivers/stdio_console.c
@@ -3,30 +3,37 @@
  * Licensed under the GPL
  */
 
-#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 "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 "chan.h"
-#include <irq_user.h>
+#include "line.h"
+#include "chan_kern.h"
+#include "irq_user.h"
 #include "mconsole_kern.h"
-#include <init.h>
+#include "init.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;
+
 static void stdio_announce(char *dev_name, int dev)
 {
         printk(KERN_INFO "Virtual console %d assigned device '%s'\n", dev,
@@ -70,9 +77,9 @@ static struct line_driver driver = {
 /* The array is initialized by line_init, at initcall time.  The
  * elements are locked individually as needed.
  */
-static char *vt_conf[MAX_TTYS];
-static char *def_conf;
-static struct line vts[MAX_TTYS];
+static 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, char **error_out)
 {
@@ -89,17 +96,21 @@ static int con_remove(int n, char **error_out)
         return line_remove(vts, ARRAY_SIZE(vts), n, error_out);
 }
 
-/* Set in an initcall, checked in an exitcall */
-static int con_init_done = 0;
-
-static int con_install(struct tty_driver *driver, struct tty_struct *tty)
+static int con_open(struct tty_struct *tty, struct file *filp)
 {
-        return line_install(driver, tty, &vts[tty->index]);
+        int err = line_open(vts, tty);
+        if (err)
+                printk(KERN_ERR "Failed to open console %d, err = %d\n",
+                       tty->index, err);
+
+        return err;
 }
 
+/* Set in an initcall, checked in an exitcall */
+static int con_init_done = 0;
+
 static const struct tty_operations console_ops = {
-        .open                   = line_open,
-        .install                = con_install,
+        .open                   = con_open,
         .close                  = line_close,
         .write                  = line_write,
         .put_char               = line_put_char,
@@ -108,10 +119,9 @@ static const struct tty_operations console_ops = {
         .flush_buffer           = line_flush_buffer,
         .flush_chars            = line_flush_chars,
         .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
         .throttle               = line_throttle,
         .unthrottle             = line_unthrottle,
-        .cleanup                = line_cleanup,
-        .hangup                 = line_hangup,
 };
 
 static void uml_console_write(struct console *console, const char *string,
@@ -121,14 +131,14 @@ static void uml_console_write(struct console *console, const char *string,
         unsigned long flags;
 
         spin_lock_irqsave(&line->lock, flags);
-        console_write_chan(line->chan_out, string, len);
+        console_write_chan(&line->chan_list, string, len);
         spin_unlock_irqrestore(&line->lock, flags);
 }
 
 static struct tty_driver *uml_console_device(struct console *c, int *index)
 {
         *index = c->index;
-        return driver.driver;
+        return console_driver;
 }
 
 static int uml_console_setup(struct console *co, char *options)
@@ -151,31 +161,18 @@ static struct console stdiocons = {
 static int stdio_init(void)
 {
         char *new_title;
-        int err;
-        int i;
 
-        err = register_lines(&driver, &console_ops, vts,
+        console_driver = register_lines(&driver, &console_ops, vts,
                                         ARRAY_SIZE(vts));
-        if (err)
-                return err;
-
+        if (console_driver == NULL)
+                return -1;
         printk(KERN_INFO "Initialized stdio console driver\n");
 
         new_title = add_xterm_umid(opts.xterm_title);
         if(new_title != NULL)
                 opts.xterm_title = new_title;
 
-        for (i = 0; i < MAX_TTYS; i++) {
-                char *error;
-                char *s = vt_conf[i];
-                if (!s)
-                        s = def_conf;
-                if (!s)
-                        s = i ? CONFIG_CON_CHAN : CONFIG_CON_ZERO_CHAN;
-                if (setup_one_line(vts, i, s, &opts, &error))
-                        printk(KERN_ERR "setup_one_line failed for "
-                               "device %d : %s\n", i, error);
-        }
+        lines_init(vts, ARRAY_SIZE(vts), &opts);
 
         con_init_done = 1;
         register_console(&stdiocons);
@@ -193,7 +190,14 @@ __uml_exitcall(console_exit);
 
 static int console_chan_setup(char *str)
 {
-        line_setup(vt_conf, MAX_TTYS, &def_conf, str, "console");
+        char *error;
+        int ret;
+
+        ret = line_setup(vts, ARRAY_SIZE(vts), str, &error);
+        if(ret < 0)
+                printk(KERN_ERR "Failed to set up console with "
+                       "configuration string \"%s\" : %s\n", str, error);
+
         return 1;
 }
 __setup("con", console_chan_setup);
diff --git a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
index eaa201bca5e..495858a090e 100644
--- a/arch/um/drivers/tty.c
+++ b/arch/um/drivers/tty.c
@@ -7,8 +7,10 @@
 #include <fcntl.h>
 #include <termios.h>
 #include "chan_user.h"
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 
 struct tty_chan {
         char *dev;
diff --git a/arch/um/drivers/ubd.h b/arch/um/drivers/ubd.h
deleted file mode 100644
index 3845051f1b1..00000000000
--- a/arch/um/drivers/ubd.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/* 
- * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
- * Copyright (C) 2001 RidgeRun, Inc (glonnon@ridgerun.com)
- * Licensed under the GPL
- */
-
-#ifndef __UM_UBD_USER_H
-#define __UM_UBD_USER_H
-
-extern void ignore_sigwinch_sig(void);
-extern int start_io_thread(unsigned long sp, int *fds_out);
-extern int io_thread(void *arg);
-extern int kernel_fd;
-
-#endif
-
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index 41bf72073cc..0491e40d696 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -19,26 +19,42 @@
 
 #define UBD_SHIFT 4
 
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/blkdev.h>
-#include <linux/ata.h>
-#include <linux/hdreg.h>
-#include <linux/cdrom.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/ctype.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/platform_device.h>
-#include <linux/scatterlist.h>
-#include <asm/tlbflush.h>
-#include <kern_util.h>
+#include "linux/kernel.h"
+#include "linux/module.h"
+#include "linux/blkdev.h"
+#include "linux/ata.h"
+#include "linux/hdreg.h"
+#include "linux/init.h"
+#include "linux/cdrom.h"
+#include "linux/proc_fs.h"
+#include "linux/seq_file.h"
+#include "linux/ctype.h"
+#include "linux/capability.h"
+#include "linux/mm.h"
+#include "linux/slab.h"
+#include "linux/vmalloc.h"
+#include "linux/mutex.h"
+#include "linux/blkpg.h"
+#include "linux/genhd.h"
+#include "linux/spinlock.h"
+#include "linux/platform_device.h"
+#include "linux/scatterlist.h"
+#include "asm/segment.h"
+#include "asm/uaccess.h"
+#include "asm/irq.h"
+#include "asm/types.h"
+#include "asm/tlbflush.h"
+#include "mem_user.h"
+#include "kern_util.h"
+#include "kern.h"
 #include "mconsole_kern.h"
-#include <init.h>
-#include <irq_kern.h>
-#include "ubd.h"
-#include <os.h>
+#include "init.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "ubd_user.h"
+#include "os.h"
+#include "mem.h"
+#include "mem_kern.h"
 #include "cow.h"
 
 enum ubd_req { UBD_READ, UBD_WRITE };
@@ -514,7 +530,7 @@ static inline int ubd_file_size(struct ubd *ubd_dev, __u64 *size_out)
                 goto out;
         }
 
-        fd = os_open_file(ubd_dev->file, of_read(OPENFLAGS()), 0);
+        fd = os_open_file(ubd_dev->file, global_openflags, 0);
         if (fd < 0)
                 return fd;
 
@@ -1101,7 +1117,7 @@ static int __init ubd_driver_init(void){
                 return 0;
         }
         err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,
-                             0, "ubd", ubd_devs);
+                             IRQF_DISABLED, "ubd", ubd_devs);
         if(err != 0)
                 printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
         return 0;
diff --git a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
index a703e45d8aa..b591bb9c41d 100644
--- a/arch/um/drivers/ubd_user.c
+++ b/arch/um/drivers/ubd_user.c
@@ -15,12 +15,15 @@
 #include <sys/socket.h>
 #include <sys/mman.h>
 #include <sys/param.h>
+#include "asm/types.h"
+#include "user.h"
+#include "ubd_user.h"
+#include "os.h"
+#include "cow.h"
+
 #include <endian.h>
 #include <byteswap.h>
 
-#include "ubd.h"
-#include <os.h>
-
 void ignore_sigwinch_sig(void)
 {
         signal(SIGWINCH, SIG_IGN);
diff --git a/arch/um/drivers/umcast.h b/arch/um/drivers/umcast.h
index c190c644091..6f8c0fe890f 100644
--- a/arch/um/drivers/umcast.h
+++ b/arch/um/drivers/umcast.h
@@ -6,7 +6,7 @@
 #ifndef __DRIVERS_UMCAST_H
 #define __DRIVERS_UMCAST_H
 
-#include <net_user.h>
+#include "net_user.h"
 
 struct umcast_data {
         char *addr;
diff --git a/arch/um/drivers/umcast_kern.c b/arch/um/drivers/umcast_kern.c
index f5ba6e37791..42dab11d2ec 100644
--- a/arch/um/drivers/umcast_kern.c
+++ b/arch/um/drivers/umcast_kern.c
@@ -11,10 +11,10 @@
  * Licensed under the GPL.
  */
 
-#include <linux/init.h>
+#include "linux/init.h"
 #include <linux/netdevice.h>
 #include "umcast.h"
-#include <net_kern.h>
+#include "net_kern.h"
 
 struct umcast_init {
         char *addr;
diff --git a/arch/um/drivers/umcast_user.c b/arch/um/drivers/umcast_user.c
index 6074184bb51..59c56fd6f52 100644
--- a/arch/um/drivers/umcast_user.c
+++ b/arch/um/drivers/umcast_user.c
@@ -15,9 +15,11 @@
 #include <unistd.h>
 #include <errno.h>
 #include <netinet/in.h>
+#include "kern_constants.h"
 #include "umcast.h"
-#include <net_user.h>
-#include <um_malloc.h>
+#include "net_user.h"
+#include "um_malloc.h"
+#include "user.h"
 
 static struct sockaddr_in *new_addr(char *addr, unsigned short port)
 {
diff --git a/arch/um/drivers/vde_kern.c b/arch/um/drivers/vde_kern.c
index 6a365fadc7c..1b852bffdeb 100644
--- a/arch/um/drivers/vde_kern.c
+++ b/arch/um/drivers/vde_kern.c
@@ -7,10 +7,10 @@
  *
  */
 
-#include <linux/init.h>
+#include "linux/init.h"
 #include <linux/netdevice.h>
-#include <net_kern.h>
-#include <net_user.h>
+#include "net_kern.h"
+#include "net_user.h"
 #include "vde.h"
 
 static void vde_init(struct net_device *dev, void *data)
diff --git a/arch/um/drivers/vde_user.c b/arch/um/drivers/vde_user.c
index 64cb630d115..c5c43253e6c 100644
--- a/arch/um/drivers/vde_user.c
+++ b/arch/um/drivers/vde_user.c
@@ -6,8 +6,10 @@
 #include <stddef.h>
 #include <errno.h>
 #include <libvdeplug.h>
-#include <net_user.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "net_user.h"
+#include "um_malloc.h"
+#include "user.h"
 #include "vde.h"
 
 static int vde_user_init(void *data, void *dev)
diff --git a/arch/um/drivers/xterm.c b/arch/um/drivers/xterm.c
index 20e30be4479..2e1de572860 100644
--- a/arch/um/drivers/xterm.c
+++ b/arch/um/drivers/xterm.c
@@ -11,8 +11,10 @@
 #include <string.h>
 #include <termios.h>
 #include "chan_user.h"
-#include <os.h>
-#include <um_malloc.h>
+#include "kern_constants.h"
+#include "os.h"
+#include "um_malloc.h"
+#include "user.h"
 #include "xterm.h"
 
 struct xterm_chan {
diff --git a/arch/um/drivers/xterm_kern.c b/arch/um/drivers/xterm_kern.c
index e8f9957bfbf..b646bccef37 100644
--- a/arch/um/drivers/xterm_kern.c
+++ b/arch/um/drivers/xterm_kern.c
@@ -7,8 +7,8 @@
 #include <linux/completion.h>
 #include <linux/irqreturn.h>
 #include <asm/irq.h>
-#include <irq_kern.h>
-#include <os.h>
+#include "irq_kern.h"
+#include "os.h"
 
 struct xterm_wait {
         struct completion ready;
@@ -50,7 +50,8 @@ int xterm_fd(int socket, int *pid_out)
         init_completion(&data->ready);
 
         err = um_request_irq(XTERM_IRQ, socket, IRQ_READ, xterm_interrupt,
-                             IRQF_SHARED, "xterm", data);
+                             IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                             "xterm", data);
         if (err) {
                 printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, "
                        "err = %d\n",  err);
@@ -64,7 +65,7 @@ int xterm_fd(int socket, int *pid_out)
          * isn't set) this will hang... */
         wait_for_completion(&data->ready);
 
-        um_free_irq(XTERM_IRQ, data);
+        free_irq(XTERM_IRQ, data);
 
         ret = data->new_fd;
         *pid_out = data->pid;