106 files changed, 1498 insertions, 1819 deletions

diff --git a/arch/um/defconfig b/arch/um/defconfig
index 780cc0a4a128..f938fa822146 100644
--- a/arch/um/defconfig
+++ b/arch/um/defconfig
@@ -41,6 +41,7 @@ CONFIG_M686=y
 # CONFIG_MGEODE_LX is not set
 # CONFIG_MCYRIXIII is not set
 # CONFIG_MVIAC3_2 is not set
+# CONFIG_MVIAC7 is not set
 # CONFIG_X86_GENERIC is not set
 CONFIG_X86_CMPXCHG=y
 CONFIG_X86_XADD=y
diff --git a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
index 9fdfad649536..3aa351611763 100644
--- a/arch/um/drivers/chan_kern.c
+++ b/arch/um/drivers/chan_kern.c
@@ -12,7 +12,6 @@
 #include <linux/tty_flip.h>
 #include <asm/irq.h>
 #include "chan_kern.h"
-#include "user_util.h"
 #include "kern.h"
 #include "irq_user.h"
 #include "sigio.h"
diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
index 0cad3546cb89..13f0bf852b2a 100644
--- a/arch/um/drivers/chan_user.c
+++ b/arch/um/drivers/chan_user.c
@@ -14,7 +14,6 @@
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include "kern_util.h"
-#include "user_util.h"
 #include "chan_user.h"
 #include "user.h"
 #include "os.h"
@@ -158,7 +157,7 @@ static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out)
          */
         err = run_helper_thread(winch_thread, &data, CLONE_FILES, &stack, 0);
         if(err < 0){
-                printk("fork of winch_thread failed - errno = %d\n", errno);
+                printk("fork of winch_thread failed - errno = %d\n", -err);
                 goto out_close;
         }
 
@@ -204,14 +203,3 @@ void register_winch(int fd, struct tty_struct *tty)
                 }
         }
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
index c6a308464acb..15453845d2ba 100644
--- a/arch/um/drivers/cow_sys.h
+++ b/arch/um/drivers/cow_sys.h
@@ -2,14 +2,13 @@
 #define __COW_SYS_H__
 
 #include "kern_util.h"
-#include "user_util.h"
 #include "os.h"
 #include "user.h"
 #include "um_malloc.h"
 
 static inline void *cow_malloc(int size)
 {
-        return(um_kmalloc(size));
+        return um_kmalloc(size);
 }
 
 static inline void cow_free(void *ptr)
@@ -21,29 +20,22 @@ static inline void cow_free(void *ptr)
 
 static inline char *cow_strdup(char *str)
 {
-        return(uml_strdup(str));
+        return uml_strdup(str);
 }
 
 static inline int cow_seek_file(int fd, __u64 offset)
 {
-        return(os_seek_file(fd, offset));
+        return os_seek_file(fd, offset);
 }
 
 static inline int cow_file_size(char *file, unsigned long long *size_out)
 {
-        return(os_file_size(file, size_out));
+        return os_file_size(file, size_out);
 }
 
 static inline int cow_write_file(int fd, void *buf, int size)
 {
-        return(os_write_file(fd, buf, size));
+        return os_write_file(fd, buf, size);
 }
 
 #endif
-
-/*
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
index 021b82c7a759..b869e3899683 100644
--- a/arch/um/drivers/daemon_user.c
+++ b/arch/um/drivers/daemon_user.c
@@ -14,7 +14,6 @@
 #include "net_user.h"
 #include "daemon.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 #include "um_malloc.h"
@@ -39,11 +38,11 @@ static struct sockaddr_un *new_addr(void *name, int len)
         sun = um_kmalloc(sizeof(struct sockaddr_un));
         if(sun == NULL){
                 printk("new_addr: allocation of sockaddr_un failed\n");
-                return(NULL);
+                return NULL;
         }
         sun->sun_family = AF_UNIX;
         memcpy(sun->sun_path, name, len);
-        return(sun);
+        return sun;
 }
 
 static int connect_to_switch(struct daemon_data *pri)
@@ -112,7 +111,7 @@ static int connect_to_switch(struct daemon_data *pri)
         }
 
         pri->data_addr = sun;
-        return(fd);
+        return fd;
 
  out_free:
         kfree(sun);
@@ -120,10 +119,10 @@ static int connect_to_switch(struct daemon_data *pri)
         os_close_file(fd);
  out:
         os_close_file(pri->control);
-        return(err);
+        return err;
 }
 
-static void daemon_user_init(void *data, void *dev)
+static int daemon_user_init(void *data, void *dev)
 {
         struct daemon_data *pri = data;
         struct timeval tv;
@@ -146,13 +145,16 @@ static void daemon_user_init(void *data, void *dev)
         if(pri->fd < 0){
                 kfree(pri->local_addr);
                 pri->local_addr = NULL;
+                return pri->fd;
         }
+
+        return 0;
 }
 
 static int daemon_open(void *data)
 {
         struct daemon_data *pri = data;
-        return(pri->fd);
+        return pri->fd;
 }
 
 static void daemon_remove(void *data)
@@ -176,12 +178,12 @@ int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
 {
         struct sockaddr_un *data_addr = pri->data_addr;
 
-        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+        return net_sendto(fd, buf, len, data_addr, sizeof(*data_addr));
 }
 
 static int daemon_set_mtu(int mtu, void *data)
 {
-        return(mtu);
+        return mtu;
 }
 
 const struct net_user_info daemon_user_info = {
@@ -194,14 +196,3 @@ const struct net_user_info daemon_user_info = {
         .delete_address = NULL,
         .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
 };
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
index 218aa0e9b792..7f083ec47a4f 100644
--- a/arch/um/drivers/fd.c
+++ b/arch/um/drivers/fd.c
@@ -9,7 +9,6 @@
 #include <termios.h>
 #include <errno.h>
 #include "user.h"
-#include "user_util.h"
 #include "chan_user.h"
 #include "os.h"
 #include "um_malloc.h"
diff --git a/arch/um/drivers/harddog_user.c b/arch/um/drivers/harddog_user.c
index c495ecf263b1..5eeecf8917c3 100644
--- a/arch/um/drivers/harddog_user.c
+++ b/arch/um/drivers/harddog_user.c
@@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <errno.h>
-#include "user_util.h"
 #include "user.h"
 #include "mconsole.h"
 #include "os.h"
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
index f75d7b05c481..ced99106f798 100644
--- a/arch/um/drivers/line.c
+++ b/arch/um/drivers/line.c
@@ -13,7 +13,6 @@
 #include "irq_user.h"
 #include "line.h"
 #include "kern.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "os.h"
 #include "irq_kern.h"
diff --git a/arch/um/drivers/mcast_user.c b/arch/um/drivers/mcast_user.c
index b827e82884c9..d319db16d4ec 100644
--- a/arch/um/drivers/mcast_user.c
+++ b/arch/um/drivers/mcast_user.c
@@ -20,7 +20,6 @@
 #include "net_user.h"
 #include "mcast.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 #include "um_malloc.h"
@@ -34,20 +33,21 @@ static struct sockaddr_in *new_addr(char *addr, unsigned short port)
         sin = um_kmalloc(sizeof(struct sockaddr_in));
         if(sin == NULL){
                 printk("new_addr: allocation of sockaddr_in failed\n");
-                return(NULL);
+                return NULL;
         }
         sin->sin_family = AF_INET;
         sin->sin_addr.s_addr = in_aton(addr);
         sin->sin_port = htons(port);
-        return(sin);
+        return sin;
 }
 
-static void mcast_user_init(void *data, void *dev)
+static int mcast_user_init(void *data, void *dev)
 {
         struct mcast_data *pri = data;
 
         pri->mcast_addr = new_addr(pri->addr, pri->port);
         pri->dev = dev;
+        return 0;
 }
 
 static void mcast_remove(void *data)
@@ -107,8 +107,8 @@ static int mcast_open(void *data)
                 err = -errno;
                 printk("mcast_open : data bind failed, errno = %d\n", errno);
                 goto out_close;
-        }               
-        
+        }
+
         /* subscribe to the multicast group */
         mreq.imr_multiaddr.s_addr = sin->sin_addr.s_addr;
         mreq.imr_interface.s_addr = 0;
@@ -153,12 +153,12 @@ int mcast_user_write(int fd, void *buf, int len, struct mcast_data *pri)
 {
         struct sockaddr_in *data_addr = pri->mcast_addr;
 
-        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+        return net_sendto(fd, buf, len, data_addr, sizeof(*data_addr));
 }
 
 static int mcast_set_mtu(int mtu, void *data)
 {
-        return(mtu);
+        return mtu;
 }
 
 const struct net_user_info mcast_user_info = {
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 65ad2932672c..542c9ef858f8 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -25,7 +25,6 @@
 #include "linux/console.h"
 #include "asm/irq.h"
 #include "asm/uaccess.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
 #include "mconsole.h"
diff --git a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
index f02634fbf32a..62e5ad63181a 100644
--- a/arch/um/drivers/mconsole_user.c
+++ b/arch/um/drivers/mconsole_user.c
@@ -17,7 +17,6 @@
 #include "sysdep/ptrace.h"
 #include "mconsole.h"
 #include "os.h"
-#include "user_util.h"
 
 static struct mconsole_command commands[] = {
         /* With uts namespaces, uts information becomes process-specific, so
diff --git a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
index df3516e47d4d..e41a08f04694 100644
--- a/arch/um/drivers/mmapper_kern.c
+++ b/arch/um/drivers/mmapper_kern.c
@@ -15,7 +15,6 @@
 #include <linux/miscdevice.h>
 #include <asm/uaccess.h>
 #include "mem_user.h"
-#include "user_util.h"
  
 /* These are set in mmapper_init, which is called at boot time */
 static unsigned long mmapper_size;
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index 859303730b2f..baac4ad5e68e 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -21,7 +21,6 @@
 #include "linux/ethtool.h"
 #include "linux/platform_device.h"
 #include "asm/uaccess.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "net_kern.h"
 #include "net_user.h"
@@ -284,7 +283,7 @@ void uml_net_user_timer_expire(unsigned long _conn)
 #endif
 }
 
-static void setup_etheraddr(char *str, unsigned char *addr)
+static void setup_etheraddr(char *str, unsigned char *addr, char *name)
 {
         char *end;
         int i;
@@ -303,15 +302,32 @@ static void setup_etheraddr(char *str, unsigned char *addr)
                 }
                 str = end + 1;
         }
-        if(addr[0] & 1){
+        if (is_multicast_ether_addr(addr)) {
                 printk(KERN_ERR
-                       "Attempt to assign a broadcast ethernet address to a "
+                       "Attempt to assign a multicast ethernet address to a "
                        "device disallowed\n");
                 goto random;
         }
+        if (!is_valid_ether_addr(addr)) {
+                printk(KERN_ERR
+                       "Attempt to assign an invalid ethernet address to a "
+                       "device disallowed\n");
+                goto random;
+        }
+        if (!is_local_ether_addr(addr)) {
+                printk(KERN_WARNING
+                       "Warning: attempt to assign a globally valid ethernet address to a "
+                       "device\n");
+                printk(KERN_WARNING "You should better enable the 2nd rightmost bit "
+                      "in the first byte of the MAC, i.e. "
+                      "%02x:%02x:%02x:%02x:%02x:%02x\n",
+                      addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4], addr[5]);
+        }
         return;
 
 random:
+        printk(KERN_INFO
+               "Choosing a random ethernet address for device %s\n", name);
         random_ether_addr(addr);
 }
 
@@ -325,31 +341,53 @@ static struct platform_driver uml_net_driver = {
 };
 static int driver_registered;
 
-static int eth_configure(int n, void *init, char *mac,
-                         struct transport *transport)
+static void net_device_release(struct device *dev)
+{
+        struct uml_net *device = dev->driver_data;
+        struct net_device *netdev = device->dev;
+        struct uml_net_private *lp = netdev->priv;
+
+        if(lp->remove != NULL)
+                (*lp->remove)(&lp->user);
+        list_del(&device->list);
+        kfree(device);
+        free_netdev(netdev);
+}
+
+static void eth_configure(int n, void *init, char *mac,
+                          struct transport *transport)
 {
         struct uml_net *device;
         struct net_device *dev;
         struct uml_net_private *lp;
-        int save, err, size;
+        int err, size;
 
-        size = transport->private_size + sizeof(struct uml_net_private) +
-                sizeof(((struct uml_net_private *) 0)->user);
+        size = transport->private_size + sizeof(struct uml_net_private);
 
         device = kzalloc(sizeof(*device), GFP_KERNEL);
         if (device == NULL) {
-                printk(KERN_ERR "eth_configure failed to allocate uml_net\n");
-                return(1);
+                printk(KERN_ERR "eth_configure failed to allocate struct "
+                       "uml_net\n");
+                return;
+        }
+
+        dev = alloc_etherdev(size);
+        if (dev == NULL) {
+                printk(KERN_ERR "eth_configure: failed to allocate struct "
+                       "net_device for eth%d\n", n);
+                goto out_free_device;
         }
 
         INIT_LIST_HEAD(&device->list);
         device->index = n;
 
-        spin_lock(&devices_lock);
-        list_add(&device->list, &devices);
-        spin_unlock(&devices_lock);
+        /* If this name ends up conflicting with an existing registered
+         * netdevice, that is OK, register_netdev{,ice}() will notice this
+         * and fail.
+         */
+        snprintf(dev->name, sizeof(dev->name), "eth%d", n);
 
-        setup_etheraddr(mac, device->mac);
+        setup_etheraddr(mac, device->mac, dev->name);
 
         printk(KERN_INFO "Netdevice %d ", n);
         printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
@@ -357,11 +395,6 @@ static int eth_configure(int n, void *init, char *mac,
                device->mac[2], device->mac[3],
                device->mac[4], device->mac[5]);
         printk(": ");
-        dev = alloc_etherdev(size);
-        if (dev == NULL) {
-                printk(KERN_ERR "eth_configure: failed to allocate device\n");
-                return 1;
-        }
 
         lp = dev->priv;
         /* This points to the transport private data. It's still clear, but we
@@ -376,47 +409,20 @@ static int eth_configure(int n, void *init, char *mac,
         }
         device->pdev.id = n;
         device->pdev.name = DRIVER_NAME;
-        platform_device_register(&device->pdev);
+        device->pdev.dev.release = net_device_release;
+        device->pdev.dev.driver_data = device;
+        if(platform_device_register(&device->pdev))
+                goto out_free_netdev;
         SET_NETDEV_DEV(dev,&device->pdev.dev);
 
-        /* If this name ends up conflicting with an existing registered
-         * netdevice, that is OK, register_netdev{,ice}() will notice this
-         * and fail.
-         */
-        snprintf(dev->name, sizeof(dev->name), "eth%d", n);
         device->dev = dev;
 
+        /*
+         * These just fill in a data structure, so there's no failure
+         * to be worried about.
+         */
         (*transport->kern->init)(dev, init);
 
-        dev->mtu = transport->user->max_packet;
-        dev->open = uml_net_open;
-        dev->hard_start_xmit = uml_net_start_xmit;
-        dev->stop = uml_net_close;
-        dev->get_stats = uml_net_get_stats;
-        dev->set_multicast_list = uml_net_set_multicast_list;
-        dev->tx_timeout = uml_net_tx_timeout;
-        dev->set_mac_address = uml_net_set_mac;
-        dev->change_mtu = uml_net_change_mtu;
-        dev->ethtool_ops = &uml_net_ethtool_ops;
-        dev->watchdog_timeo = (HZ >> 1);
-        dev->irq = UM_ETH_IRQ;
-
-        rtnl_lock();
-        err = register_netdevice(dev);
-        rtnl_unlock();
-        if (err) {
-                device->dev = NULL;
-                /* XXX: should we call ->remove() here? */
-                free_netdev(dev);
-                return 1;
-        }
-
-        /* lp.user is the first four bytes of the transport data, which
-         * has already been initialized.  This structure assignment will
-         * overwrite that, so we make sure that .user gets overwritten with
-         * what it already has.
-         */
-        save = lp->user[0];
         *lp = ((struct uml_net_private)
                 { .list                 = LIST_HEAD_INIT(lp->list),
                   .dev                  = dev,
@@ -430,20 +436,52 @@ static int eth_configure(int n, void *init, char *mac,
                   .write                = transport->kern->write,
                   .add_address          = transport->user->add_address,
                   .delete_address       = transport->user->delete_address,
-                  .set_mtu              = transport->user->set_mtu,
-                  .user                 = { save } });
+                  .set_mtu              = transport->user->set_mtu });
 
         init_timer(&lp->tl);
         spin_lock_init(&lp->lock);
         lp->tl.function = uml_net_user_timer_expire;
         memcpy(lp->mac, device->mac, sizeof(lp->mac));
 
-        if (transport->user->init)
-                (*transport->user->init)(&lp->user, dev);
+        if ((transport->user->init != NULL) &&
+            ((*transport->user->init)(&lp->user, dev) != 0))
+                goto out_unregister;
 
         set_ether_mac(dev, device->mac);
+        dev->mtu = transport->user->max_packet;
+        dev->open = uml_net_open;
+        dev->hard_start_xmit = uml_net_start_xmit;
+        dev->stop = uml_net_close;
+        dev->get_stats = uml_net_get_stats;
+        dev->set_multicast_list = uml_net_set_multicast_list;
+        dev->tx_timeout = uml_net_tx_timeout;
+        dev->set_mac_address = uml_net_set_mac;
+        dev->change_mtu = uml_net_change_mtu;
+        dev->ethtool_ops = &uml_net_ethtool_ops;
+        dev->watchdog_timeo = (HZ >> 1);
+        dev->irq = UM_ETH_IRQ;
 
-        return 0;
+        rtnl_lock();
+        err = register_netdevice(dev);
+        rtnl_unlock();
+        if (err)
+                goto out_undo_user_init;
+
+        spin_lock(&devices_lock);
+        list_add(&device->list, &devices);
+        spin_unlock(&devices_lock);
+
+        return;
+
+out_undo_user_init:
+        if (transport->user->remove != NULL)
+                (*transport->user->remove)(&lp->user);
+out_unregister:
+        platform_device_unregister(&device->pdev);
+out_free_netdev:
+        free_netdev(dev);
+out_free_device:
+        kfree(device);
 }
 
 static struct uml_net *find_device(int n)
@@ -666,13 +704,9 @@ static int net_remove(int n, char **error_out)
         lp = dev->priv;
         if(lp->fd > 0)
                 return -EBUSY;
-        if(lp->remove != NULL) (*lp->remove)(&lp->user);
         unregister_netdev(dev);
         platform_device_unregister(&device->pdev);
 
-        list_del(&device->list);
-        kfree(device);
-        free_netdev(dev);
         return 0;
 }
 
diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
index 0ffd7ac295d4..3503cff867c3 100644
--- a/arch/um/drivers/net_user.c
+++ b/arch/um/drivers/net_user.c
@@ -14,11 +14,11 @@
 #include <sys/wait.h>
 #include <sys/time.h>
 #include "user.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "net_user.h"
 #include "os.h"
 #include "um_malloc.h"
+#include "kern_constants.h"
 
 int tap_open_common(void *dev, char *gate_addr)
 {
@@ -216,7 +216,7 @@ static void change(char *dev, char *what, unsigned char *addr,
         sprintf(netmask_buf, "%d.%d.%d.%d", netmask[0], netmask[1], 
                 netmask[2], netmask[3]);
 
-        output_len = page_size();
+        output_len = UM_KERN_PAGE_SIZE;
         output = um_kmalloc(output_len);
         if(output == NULL)
                 printk("change : failed to allocate output buffer\n");
diff --git a/arch/um/drivers/pcap_user.c b/arch/um/drivers/pcap_user.c
index 11921a7baa7b..dc0a903ef9a6 100644
--- a/arch/um/drivers/pcap_user.c
+++ b/arch/um/drivers/pcap_user.c
@@ -18,7 +18,7 @@
 
 #define PCAP_FD(p) (*(int *)(p))
 
-static void pcap_user_init(void *data, void *dev)
+static int pcap_user_init(void *data, void *dev)
 {
         struct pcap_data *pri = data;
         pcap_t *p;
@@ -28,11 +28,12 @@ static void pcap_user_init(void *data, void *dev)
         if(p == NULL){
                 printk("pcap_user_init : pcap_open_live failed - '%s'\n", 
                        errors);
-                return;
+                return -EINVAL;
         }
 
         pri->dev = dev;
         pri->pcap = p;
+        return 0;
 }
 
 static int pcap_open(void *data)
@@ -42,39 +43,39 @@ static int pcap_open(void *data)
         int err;
 
         if(pri->pcap == NULL)
-                return(-ENODEV);
+                return -ENODEV;
 
         if(pri->filter != NULL){
                 err = dev_netmask(pri->dev, &netmask);
                 if(err < 0){
                         printk("pcap_open : dev_netmask failed\n");
-                        return(-EIO);
+                        return -EIO;
                 }
 
                 pri->compiled = um_kmalloc(sizeof(struct bpf_program));
                 if(pri->compiled == NULL){
                         printk("pcap_open : kmalloc failed\n");
-                        return(-ENOMEM);
+                        return -ENOMEM;
                 }
-                
+
                 err = pcap_compile(pri->pcap, 
                                    (struct bpf_program *) pri->compiled, 
                                    pri->filter, pri->optimize, netmask);
                 if(err < 0){
                         printk("pcap_open : pcap_compile failed - '%s'\n", 
                                pcap_geterr(pri->pcap));
-                        return(-EIO);
+                        return -EIO;
                 }
 
                 err = pcap_setfilter(pri->pcap, pri->compiled);
                 if(err < 0){
                         printk("pcap_open : pcap_setfilter failed - '%s'\n", 
                                pcap_geterr(pri->pcap));
-                        return(-EIO);
+                        return -EIO;
                 }
         }
-        
-        return(PCAP_FD(pri->pcap));
+
+        return PCAP_FD(pri->pcap);
 }
 
 static void pcap_remove(void *data)
@@ -114,11 +115,11 @@ int pcap_user_read(int fd, void *buffer, int len, struct pcap_data *pri)
         n = pcap_dispatch(pri->pcap, 1, handler, (u_char *) &hdata);
         if(n < 0){
                 printk("pcap_dispatch failed - %s\n", pcap_geterr(pri->pcap));
-                return(-EIO);
+                return -EIO;
         }
         else if(n == 0) 
-                return(0);
-        return(hdata.len);
+                return 0;
+        return hdata.len;
 }
 
 const struct net_user_info pcap_user_info = {
@@ -131,14 +132,3 @@ const struct net_user_info pcap_user_info = {
         .delete_address = NULL,
         .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
 };
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
index 80508023054f..3f6357d24bee 100644
--- a/arch/um/drivers/port_user.c
+++ b/arch/um/drivers/port_user.c
@@ -13,7 +13,6 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <netinet/in.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "chan_user.h"
diff --git a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
index 829a5eca8c07..df4976c9eef2 100644
--- a/arch/um/drivers/pty.c
+++ b/arch/um/drivers/pty.c
@@ -4,13 +4,13 @@
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 #include <errno.h>
 #include <termios.h>
 #include "chan_user.h"
 #include "user.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "os.h"
 #include "um_malloc.h"
diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
index 7eddacc53b6e..78f0e515da8f 100644
--- a/arch/um/drivers/slip_user.c
+++ b/arch/um/drivers/slip_user.c
@@ -8,7 +8,6 @@
 #include <sys/termios.h>
 #include <sys/wait.h>
 #include <sys/signal.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "net_user.h"
@@ -16,12 +15,14 @@
 #include "slip_common.h"
 #include "os.h"
 #include "um_malloc.h"
+#include "kern_constants.h"
 
-void slip_user_init(void *data, void *dev)
+static int slip_user_init(void *data, void *dev)
 {
         struct slip_data *pri = data;
 
         pri->dev = dev;
+        return 0;
 }
 
 static int set_up_tty(int fd)
@@ -89,7 +90,7 @@ static int slip_tramp(char **argv, int fd)
                 goto out_close;
         pid = err;
 
-        output_len = page_size();
+        output_len = UM_KERN_PAGE_SIZE;
         output = um_kmalloc(output_len);
         if(output == NULL){
                 printk("slip_tramp : failed to allocate output buffer\n");
diff --git a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
index ce5e85d1de3d..39f889fe9949 100644
--- a/arch/um/drivers/slirp_user.c
+++ b/arch/um/drivers/slirp_user.c
@@ -7,7 +7,6 @@
 #include <errno.h>
 #include <sys/wait.h>
 #include <sys/signal.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "net_user.h"
@@ -15,11 +14,12 @@
 #include "slip_common.h"
 #include "os.h"
 
-void slirp_user_init(void *data, void *dev)
+static int slirp_user_init(void *data, void *dev)
 {
         struct slirp_data *pri = data;
 
         pri->dev = dev;
+        return 0;
 }
 
 struct slirp_pre_exec_data {
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
index 4b382a6e710f..fd09ad9e9c0a 100644
--- a/arch/um/drivers/ssl.c
+++ b/arch/um/drivers/ssl.c
@@ -15,7 +15,6 @@
 #include "line.h"
 #include "ssl.h"
 #include "chan_kern.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
 #include "init.h"
@@ -192,12 +191,12 @@ static int ssl_init(void)
         ssl_driver = register_lines(&driver, &ssl_ops, serial_lines,
                                     ARRAY_SIZE(serial_lines));
 
-        lines_init(serial_lines, ARRAY_SIZE(serial_lines), &opts);
-
         new_title = add_xterm_umid(opts.xterm_title);
         if (new_title != NULL)
                 opts.xterm_title = new_title;
 
+        lines_init(serial_lines, ARRAY_SIZE(serial_lines), &opts);
+
         ssl_init_done = 1;
         register_console(&ssl_cons);
         return 0;
diff --git a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
index 76d1f1c980ef..2bb4193ac1aa 100644
--- a/arch/um/drivers/stdio_console.c
+++ b/arch/um/drivers/stdio_console.c
@@ -22,7 +22,6 @@
 #include "stdio_console.h"
 #include "line.h"
 #include "chan_kern.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "irq_user.h"
 #include "mconsole_kern.h"
@@ -167,12 +166,12 @@ int stdio_init(void)
                 return -1;
         printk(KERN_INFO "Initialized stdio console driver\n");
 
-        lines_init(vts, ARRAY_SIZE(vts), &opts);
-
         new_title = add_xterm_umid(opts.xterm_title);
         if(new_title != NULL)
                 opts.xterm_title = new_title;
 
+        lines_init(vts, ARRAY_SIZE(vts), &opts);
+
         con_init_done = 1;
         register_console(&stdiocons);
         return 0;
diff --git a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
index d95d64309eaf..c07d0d562780 100644
--- a/arch/um/drivers/tty.c
+++ b/arch/um/drivers/tty.c
@@ -8,7 +8,6 @@
 #include <errno.h>
 #include <unistd.h>
 #include "chan_user.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 #include "um_malloc.h"
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index 8bd9204ac1ab..70509ddaac03 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -39,7 +39,6 @@
 #include "asm/irq.h"
 #include "asm/types.h"
 #include "asm/tlbflush.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "kern_util.h"
 #include "kern.h"
@@ -90,7 +89,7 @@ static inline int ubd_test_bit(__u64 bit, unsigned char *data)
         bits = sizeof(data[0]) * 8;
         n = bit / bits;
         off = bit % bits;
-        return((data[n] & (1 << off)) != 0);
+        return (data[n] & (1 << off)) != 0;
 }
 
 static inline void ubd_set_bit(__u64 bit, unsigned char *data)
@@ -147,10 +146,13 @@ struct cow {
         unsigned long *bitmap;
         unsigned long bitmap_len;
         int bitmap_offset;
-        int data_offset;
+        int data_offset;
 };
 
+#define MAX_SG 64
+
 struct ubd {
+        struct list_head restart;
         /* name (and fd, below) of the file opened for writing, either the
          * backing or the cow file. */
         char *file;
@@ -165,15 +167,17 @@ struct ubd {
         struct platform_device pdev;
         struct request_queue *queue;
         spinlock_t lock;
-        int active;
+        struct scatterlist sg[MAX_SG];
+        struct request *request;
+        int start_sg, end_sg;
 };
 
 #define DEFAULT_COW { \
         .file =                 NULL, \
-        .fd =                   -1, \
-        .bitmap =               NULL, \
+        .fd =                   -1,     \
+        .bitmap =               NULL, \
         .bitmap_offset =        0, \
-        .data_offset =          0, \
+        .data_offset =          0, \
 }
 
 #define DEFAULT_UBD { \
@@ -183,11 +187,13 @@ struct ubd {
         .size =                 -1, \
         .boot_openflags =       OPEN_FLAGS, \
         .openflags =            OPEN_FLAGS, \
-        .no_cow =               0, \
+        .no_cow =               0, \
         .shared =               0, \
-        .cow =                  DEFAULT_COW, \
+        .cow =                  DEFAULT_COW, \
         .lock =                 SPIN_LOCK_UNLOCKED,     \
-        .active =               0, \
+        .request =              NULL, \
+        .start_sg =             0, \
+        .end_sg =               0, \
 }
 
 /* Protected by ubd_lock */
@@ -243,7 +249,7 @@ static void make_ide_entries(char *dev_name)
 static int fake_ide_setup(char *str)
 {
         fake_ide = 1;
-        return(1);
+        return 1;
 }
 
 __setup("fake_ide", fake_ide_setup);
@@ -261,7 +267,7 @@ static int parse_unit(char **ptr)
         if(isdigit(*str)) {
                 n = simple_strtoul(str, &end, 0);
                 if(end == str)
-                        return(-1);
+                        return -1;
                 *ptr = end;
         }
         else if (('a' <= *str) && (*str <= 'z')) {
@@ -269,7 +275,7 @@ static int parse_unit(char **ptr)
                 str++;
                 *ptr = str;
         }
-        return(n);
+        return n;
 }
 
 /* If *index_out == -1 at exit, the passed option was a general one;
@@ -436,7 +442,7 @@ static int udb_setup(char *str)
 {
         printk("udb%s specified on command line is almost certainly a ubd -> "
                "udb TYPO\n", str);
-        return(1);
+        return 1;
 }
 
 __setup("udb", udb_setup);
@@ -467,66 +473,75 @@ static void do_ubd_request(request_queue_t * q);
 /* Only changed by ubd_init, which is an initcall. */
 int thread_fd = -1;
 
-/* call ubd_finish if you need to serialize */
-static void __ubd_finish(struct request *req, int error)
+static void ubd_end_request(struct request *req, int bytes, int uptodate)
 {
-        int nsect;
-
-        if(error){
-                end_request(req, 0);
-                return;
+        if (!end_that_request_first(req, uptodate, bytes >> 9)) {
+                struct ubd *dev = req->rq_disk->private_data;
+                unsigned long flags;
+
+                add_disk_randomness(req->rq_disk);
+                spin_lock_irqsave(&dev->lock, flags);
+                end_that_request_last(req, uptodate);
+                spin_unlock_irqrestore(&dev->lock, flags);
         }
-        nsect = req->current_nr_sectors;
-        req->sector += nsect;
-        req->buffer += nsect << 9;
-        req->errors = 0;
-        req->nr_sectors -= nsect;
-        req->current_nr_sectors = 0;
-        end_request(req, 1);
 }
 
 /* Callable only from interrupt context - otherwise you need to do
  * spin_lock_irq()/spin_lock_irqsave() */
-static inline void ubd_finish(struct request *req, int error)
+static inline void ubd_finish(struct request *req, int bytes)
 {
-        struct ubd *dev = req->rq_disk->private_data;
-
-        spin_lock(&dev->lock);
-        __ubd_finish(req, error);
-        spin_unlock(&dev->lock);
+        if(bytes < 0){
+                ubd_end_request(req, 0, 0);
+                return;
+        }
+        ubd_end_request(req, bytes, 1);
 }
 
+static LIST_HEAD(restart);
+
 /* XXX - move this inside ubd_intr. */
 /* Called without dev->lock held, and only in interrupt context. */
 static void ubd_handler(void)
 {
-        struct io_thread_req req;
+        struct io_thread_req *req;
         struct request *rq;
-        struct ubd *dev;
+        struct ubd *ubd;
+        struct list_head *list, *next_ele;
+        unsigned long flags;
         int n;
 
-        n = os_read_file(thread_fd, &req, sizeof(req));
-        if(n != sizeof(req)){
-                printk(KERN_ERR "Pid %d - spurious interrupt in ubd_handler, "
-                       "err = %d\n", os_getpid(), -n);
-                return;
-        }
-
-        rq = req.req;
-        dev = rq->rq_disk->private_data;
-        dev->active = 0;
+        while(1){
+                n = os_read_file(thread_fd, &req,
+                                 sizeof(struct io_thread_req *));
+                if(n != sizeof(req)){
+                        if(n == -EAGAIN)
+                                break;
+                        printk(KERN_ERR "spurious interrupt in ubd_handler, "
+                               "err = %d\n", -n);
+                        return;
+                }
 
-        ubd_finish(rq, req.error);
+                rq = req->req;
+                rq->nr_sectors -= req->length >> 9;
+                if(rq->nr_sectors == 0)
+                        ubd_finish(rq, rq->hard_nr_sectors << 9);
+                kfree(req);
+        }
         reactivate_fd(thread_fd, UBD_IRQ);
-        spin_lock(&dev->lock);
-        do_ubd_request(dev->queue);
-        spin_unlock(&dev->lock);
+
+        list_for_each_safe(list, next_ele, &restart){
+                ubd = container_of(list, struct ubd, restart);
+                list_del_init(&ubd->restart);
+                spin_lock_irqsave(&ubd->lock, flags);
+                do_ubd_request(ubd->queue);
+                spin_unlock_irqrestore(&ubd->lock, flags);
+        }
 }
 
 static irqreturn_t ubd_intr(int irq, void *dev)
 {
         ubd_handler();
-        return(IRQ_HANDLED);
+        return IRQ_HANDLED;
 }
 
 /* Only changed by ubd_init, which is an initcall. */
@@ -545,7 +560,7 @@ static inline int ubd_file_size(struct ubd *ubd_dev, __u64 *size_out)
         char *file;
 
         file = ubd_dev->cow.file ? ubd_dev->cow.file : ubd_dev->file;
-        return(os_file_size(file, size_out));
+        return os_file_size(file, size_out);
 }
 
 static void ubd_close_dev(struct ubd *ubd_dev)
@@ -617,10 +632,18 @@ static int ubd_open_dev(struct ubd *ubd_dev)
                 if(err < 0) goto error;
                 ubd_dev->cow.fd = err;
         }
-        return(0);
+        return 0;
  error:
         os_close_file(ubd_dev->fd);
-        return(err);
+        return err;
+}
+
+static void ubd_device_release(struct device *dev)
+{
+        struct ubd *ubd_dev = dev->driver_data;
+
+        blk_cleanup_queue(ubd_dev->queue);
+        *ubd_dev = ((struct ubd) DEFAULT_UBD);
 }
 
 static int ubd_disk_register(int major, u64 size, int unit,
@@ -630,7 +653,7 @@ static int ubd_disk_register(int major, u64 size, int unit,
 
         disk = alloc_disk(1 << UBD_SHIFT);
         if(disk == NULL)
-                return(-ENOMEM);
+                return -ENOMEM;
 
         disk->major = major;
         disk->first_minor = unit << UBD_SHIFT;
@@ -645,6 +668,8 @@ static int ubd_disk_register(int major, u64 size, int unit,
         if (major == MAJOR_NR) {
                 ubd_devs[unit].pdev.id   = unit;
                 ubd_devs[unit].pdev.name = DRIVER_NAME;
+                ubd_devs[unit].pdev.dev.release = ubd_device_release;
+                ubd_devs[unit].pdev.dev.driver_data = &ubd_devs[unit];
                 platform_device_register(&ubd_devs[unit].pdev);
                 disk->driverfs_dev = &ubd_devs[unit].pdev.dev;
         }
@@ -675,6 +700,8 @@ static int ubd_add(int n, char **error_out)
 
         ubd_dev->size = ROUND_BLOCK(ubd_dev->size);
 
+        INIT_LIST_HEAD(&ubd_dev->restart);
+
         err = -ENOMEM;
         ubd_dev->queue = blk_init_queue(do_ubd_request, &ubd_dev->lock);
         if (ubd_dev->queue == NULL) {
@@ -683,6 +710,7 @@ static int ubd_add(int n, char **error_out)
         }
         ubd_dev->queue->queuedata = ubd_dev;
 
+        blk_queue_max_hw_segments(ubd_dev->queue, MAX_SG);
         err = ubd_disk_register(MAJOR_NR, ubd_dev->size, n, &ubd_gendisk[n]);
         if(err){
                 *error_out = "Failed to register device";
@@ -730,14 +758,14 @@ static int ubd_config(char *str, char **error_out)
                 goto err_free;
         }
 
-        mutex_lock(&ubd_lock);
+        mutex_lock(&ubd_lock);
         ret = ubd_add(n, error_out);
         if (ret)
                 ubd_devs[n].file = NULL;
-        mutex_unlock(&ubd_lock);
+        mutex_unlock(&ubd_lock);
 
 out:
-        return ret;
+        return ret;
 
 err_free:
         kfree(str);
@@ -752,7 +780,7 @@ static int ubd_get_config(char *name, char *str, int size, char **error_out)
         n = parse_unit(&name);
         if((n >= MAX_DEV) || (n < 0)){
                 *error_out = "ubd_get_config : device number out of range";
-                return(-1);
+                return -1;
         }
 
         ubd_dev = &ubd_devs[n];
@@ -773,29 +801,27 @@ static int ubd_get_config(char *name, char *str, int size, char **error_out)
 
  out:
         mutex_unlock(&ubd_lock);
-        return(len);
+        return len;
 }
 
 static int ubd_id(char **str, int *start_out, int *end_out)
 {
-        int n;
+        int n;
 
         n = parse_unit(str);
-        *start_out = 0;
-        *end_out = MAX_DEV - 1;
-        return n;
+        *start_out = 0;
+        *end_out = MAX_DEV - 1;
+        return n;
 }
 
 static int ubd_remove(int n, char **error_out)
 {
+        struct gendisk *disk = ubd_gendisk[n];
         struct ubd *ubd_dev;
         int err = -ENODEV;
 
         mutex_lock(&ubd_lock);
 
-        if(ubd_gendisk[n] == NULL)
-                goto out;
-
         ubd_dev = &ubd_devs[n];
 
         if(ubd_dev->file == NULL)
@@ -806,9 +832,11 @@ static int ubd_remove(int n, char **error_out)
         if(ubd_dev->count > 0)
                 goto out;
 
-        del_gendisk(ubd_gendisk[n]);
-        put_disk(ubd_gendisk[n]);
         ubd_gendisk[n] = NULL;
+        if(disk != NULL){
+                del_gendisk(disk);
+                put_disk(disk);
+        }
 
         if(fake_gendisk[n] != NULL){
                 del_gendisk(fake_gendisk[n]);
@@ -816,10 +844,8 @@ static int ubd_remove(int n, char **error_out)
                 fake_gendisk[n] = NULL;
         }
 
-        blk_cleanup_queue(ubd_dev->queue);
-        platform_device_unregister(&ubd_dev->pdev);
-        *ubd_dev = ((struct ubd) DEFAULT_UBD);
         err = 0;
+        platform_device_unregister(&ubd_dev->pdev);
 out:
         mutex_unlock(&ubd_lock);
         return err;
@@ -832,7 +858,7 @@ static struct mc_device ubd_mc = {
         .list           = LIST_HEAD_INIT(ubd_mc.list),
         .name           = "ubd",
         .config         = ubd_config,
-        .get_config     = ubd_get_config,
+        .get_config     = ubd_get_config,
         .id             = ubd_id,
         .remove         = ubd_remove,
 };
@@ -854,7 +880,7 @@ static int __init ubd0_init(void)
                 ubd_dev->file = "root_fs";
         mutex_unlock(&ubd_lock);
 
-        return(0);
+        return 0;
 }
 
 __initcall(ubd0_init);
@@ -882,14 +908,14 @@ static int __init ubd_init(void)
                         return -1;
         }
         platform_driver_register(&ubd_driver);
-        mutex_lock(&ubd_lock);
+        mutex_lock(&ubd_lock);
         for (i = 0; i < MAX_DEV; i++){
                 err = ubd_add(i, &error);
                 if(err)
                         printk(KERN_ERR "Failed to initialize ubd device %d :"
                                "%s\n", i, error);
         }
-        mutex_unlock(&ubd_lock);
+        mutex_unlock(&ubd_lock);
         return 0;
 }
 
@@ -913,7 +939,7 @@ static int __init ubd_driver_init(void){
                        "ubd : Failed to start I/O thread (errno = %d) - "
                        "falling back to synchronous I/O\n", -io_pid);
                 io_pid = -1;
-                return(0);
+                return 0;
         }
         err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr,
                              IRQF_DISABLED, "ubd", ubd_devs);
@@ -948,7 +974,7 @@ static int ubd_open(struct inode *inode, struct file *filp)
                 err = -EROFS;
         }*/
  out:
-        return(err);
+        return err;
 }
 
 static int ubd_release(struct inode * inode, struct file * file)
@@ -958,7 +984,7 @@ static int ubd_release(struct inode * inode, struct file * file)
 
         if(--ubd_dev->count == 0)
                 ubd_close_dev(ubd_dev);
-        return(0);
+        return 0;
 }
 
 static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask,
@@ -1014,7 +1040,7 @@ static void cowify_req(struct io_thread_req *req, unsigned long *bitmap,
                         if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
                                 ubd_set_bit(i, (unsigned char *)
                                             &req->sector_mask);
-                }
+                }
         }
         else cowify_bitmap(req->offset, req->length, &req->sector_mask,
                            &req->cow_offset, bitmap, bitmap_offset,
@@ -1022,26 +1048,16 @@ static void cowify_req(struct io_thread_req *req, unsigned long *bitmap,
 }
 
 /* Called with dev->lock held */
-static int prepare_request(struct request *req, struct io_thread_req *io_req)
+static void prepare_request(struct request *req, struct io_thread_req *io_req,
+                            unsigned long long offset, int page_offset,
+                            int len, struct page *page)
 {
         struct gendisk *disk = req->rq_disk;
         struct ubd *ubd_dev = disk->private_data;
-        __u64 offset;
-        int len;
-
-        /* This should be impossible now */
-        if((rq_data_dir(req) == WRITE) && !ubd_dev->openflags.w){
-                printk("Write attempted on readonly ubd device %s\n",
-                       disk->disk_name);
-                end_request(req, 0);
-                return(1);
-        }
-
-        offset = ((__u64) req->sector) << 9;
-        len = req->current_nr_sectors << 9;
 
         io_req->req = req;
-        io_req->fds[0] = (ubd_dev->cow.file != NULL) ? ubd_dev->cow.fd : ubd_dev->fd;
+        io_req->fds[0] = (ubd_dev->cow.file != NULL) ? ubd_dev->cow.fd :
+                ubd_dev->fd;
         io_req->fds[1] = ubd_dev->fd;
         io_req->cow_offset = -1;
         io_req->offset = offset;
@@ -1052,45 +1068,66 @@ static int prepare_request(struct request *req, struct io_thread_req *io_req)
         io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;
         io_req->offsets[0] = 0;
         io_req->offsets[1] = ubd_dev->cow.data_offset;
-        io_req->buffer = req->buffer;
+        io_req->buffer = page_address(page) + page_offset;
         io_req->sectorsize = 1 << 9;
 
         if(ubd_dev->cow.file != NULL)
-                cowify_req(io_req, ubd_dev->cow.bitmap, ubd_dev->cow.bitmap_offset,
-                           ubd_dev->cow.bitmap_len);
+                cowify_req(io_req, ubd_dev->cow.bitmap,
+                           ubd_dev->cow.bitmap_offset, ubd_dev->cow.bitmap_len);
 
-        return(0);
 }
 
 /* Called with dev->lock held */
 static void do_ubd_request(request_queue_t *q)
 {
-        struct io_thread_req io_req;
+        struct io_thread_req *io_req;
         struct request *req;
-        int err, n;
-
-        if(thread_fd == -1){
-                while((req = elv_next_request(q)) != NULL){
-                        err = prepare_request(req, &io_req);
-                        if(!err){
-                                do_io(&io_req);
-                                __ubd_finish(req, io_req.error);
-                        }
-                }
-        }
-        else {
+        int n;
+
+        while(1){
                 struct ubd *dev = q->queuedata;
-                if(dev->active || (req = elv_next_request(q)) == NULL)
-                        return;
-                err = prepare_request(req, &io_req);
-                if(!err){
-                        dev->active = 1;
-                        n = os_write_file(thread_fd, (char *) &io_req,
-                                         sizeof(io_req));
-                        if(n != sizeof(io_req))
-                                printk("write to io thread failed, "
-                                       "errno = %d\n", -n);
+                if(dev->end_sg == 0){
+                        struct request *req = elv_next_request(q);
+                        if(req == NULL)
+                                return;
+
+                        dev->request = req;
+                        blkdev_dequeue_request(req);
+                        dev->start_sg = 0;
+                        dev->end_sg = blk_rq_map_sg(q, req, dev->sg);
                 }
+
+                req = dev->request;
+                while(dev->start_sg < dev->end_sg){
+                        struct scatterlist *sg = &dev->sg[dev->start_sg];
+
+                        io_req = kmalloc(sizeof(struct io_thread_req),
+                                         GFP_ATOMIC);
+                        if(io_req == NULL){
+                                if(list_empty(&dev->restart))
+                                        list_add(&dev->restart, &restart);
+                                return;
+                        }
+                        prepare_request(req, io_req,
+                                        (unsigned long long) req->sector << 9,
+                                        sg->offset, sg->length, sg->page);
+
+                        n = os_write_file(thread_fd, &io_req,
+                                          sizeof(struct io_thread_req *));
+                        if(n != sizeof(struct io_thread_req *)){
+                                if(n != -EAGAIN)
+                                        printk("write to io thread failed, "
+                                               "errno = %d\n", -n);
+                                else if(list_empty(&dev->restart))
+                                        list_add(&dev->restart, &restart);
+                                return;
+                        }
+
+                        req->sector += sg->length >> 9;
+                        dev->start_sg++;
+                }
+                dev->end_sg = 0;
+                dev->request = NULL;
         }
 }
 
@@ -1120,21 +1157,21 @@ static int ubd_ioctl(struct inode * inode, struct file * file,
                 ubd_id.cyls = ubd_dev->size / (128 * 32 * 512);
                 if(copy_to_user((char __user *) arg, (char *) &ubd_id,
                                  sizeof(ubd_id)))
-                        return(-EFAULT);
-                return(0);
+                        return -EFAULT;
+                return 0;
 
         case CDROMVOLREAD:
                 if(copy_from_user(&volume, (char __user *) arg, sizeof(volume)))
-                        return(-EFAULT);
+                        return -EFAULT;
                 volume.channel0 = 255;
                 volume.channel1 = 255;
                 volume.channel2 = 255;
                 volume.channel3 = 255;
                 if(copy_to_user((char __user *) arg, &volume, sizeof(volume)))
-                        return(-EFAULT);
-                return(0);
+                        return -EFAULT;
+                return 0;
         }
-        return(-EINVAL);
+        return -EINVAL;
 }
 
 static int path_requires_switch(char *from_cmdline, char *from_cow, char *cow)
@@ -1176,29 +1213,29 @@ static int backing_file_mismatch(char *file, __u64 size, time_t mtime)
         if(err < 0){
                 printk("Failed to get modification time of backing file "
                        "\"%s\", err = %d\n", file, -err);
-                return(err);
+                return err;
         }
 
         err = os_file_size(file, &actual);
         if(err < 0){
                 printk("Failed to get size of backing file \"%s\", "
                        "err = %d\n", file, -err);
-                return(err);
+                return err;
         }
 
-        if(actual != size){
+        if(actual != size){
                 /*__u64 can be a long on AMD64 and with %lu GCC complains; so
                  * the typecast.*/
                 printk("Size mismatch (%llu vs %llu) of COW header vs backing "
                        "file\n", (unsigned long long) size, actual);
-                return(-EINVAL);
+                return -EINVAL;
         }
         if(modtime != mtime){
                 printk("mtime mismatch (%ld vs %ld) of COW header vs backing "
                        "file\n", mtime, modtime);
-                return(-EINVAL);
+                return -EINVAL;
         }
-        return(0);
+        return 0;
 }
 
 int read_cow_bitmap(int fd, void *buf, int offset, int len)
@@ -1207,13 +1244,13 @@ int read_cow_bitmap(int fd, void *buf, int offset, int len)
 
         err = os_seek_file(fd, offset);
         if(err < 0)
-                return(err);
+                return err;
 
         err = os_read_file(fd, buf, len);
         if(err < 0)
-                return(err);
+                return err;
 
-        return(0);
+        return 0;
 }
 
 int open_ubd_file(char *file, struct openflags *openflags, int shared,
@@ -1231,14 +1268,14 @@ int open_ubd_file(char *file, struct openflags *openflags, int shared,
         if (fd < 0) {
                 if ((fd == -ENOENT) && (create_cow_out != NULL))
                         *create_cow_out = 1;
-                if (!openflags->w ||
-                   ((fd != -EROFS) && (fd != -EACCES)))
+                if (!openflags->w ||
+                    ((fd != -EROFS) && (fd != -EACCES)))
                         return fd;
                 openflags->w = 0;
                 fd = os_open_file(file, *openflags, mode);
                 if (fd < 0)
                         return fd;
-        }
+        }
 
         if(shared)
                 printk("Not locking \"%s\" on the host\n", file);
@@ -1252,7 +1289,7 @@ int open_ubd_file(char *file, struct openflags *openflags, int shared,
 
         /* Successful return case! */
         if(backing_file_out == NULL)
-                return(fd);
+                return fd;
 
         err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
                               &size, &sectorsize, &align, bitmap_offset_out);
@@ -1262,7 +1299,7 @@ int open_ubd_file(char *file, struct openflags *openflags, int shared,
                 goto out_close;
         }
         if(err)
-                return(fd);
+                return fd;
 
         asked_switch = path_requires_switch(*backing_file_out, backing_file, file);
 
@@ -1285,7 +1322,7 @@ int open_ubd_file(char *file, struct openflags *openflags, int shared,
         cow_sizes(version, size, sectorsize, align, *bitmap_offset_out,
                   bitmap_len_out, data_offset_out);
 
-        return fd;
+        return fd;
  out_close:
         os_close_file(fd);
         return err;
@@ -1310,10 +1347,10 @@ int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
                             bitmap_offset_out, bitmap_len_out,
                             data_offset_out);
         if(!err)
-                return(fd);
+                return fd;
         os_close_file(fd);
  out:
-        return(err);
+        return err;
 }
 
 static int update_bitmap(struct io_thread_req *req)
@@ -1321,23 +1358,23 @@ static int update_bitmap(struct io_thread_req *req)
         int n;
 
         if(req->cow_offset == -1)
-                return(0);
+                return 0;
 
         n = os_seek_file(req->fds[1], req->cow_offset);
         if(n < 0){
                 printk("do_io - bitmap lseek failed : err = %d\n", -n);
-                return(1);
+                return 1;
         }
 
         n = os_write_file(req->fds[1], &req->bitmap_words,
-                          sizeof(req->bitmap_words));
+                          sizeof(req->bitmap_words));
         if(n != sizeof(req->bitmap_words)){
                 printk("do_io - bitmap update failed, err = %d fd = %d\n", -n,
                        req->fds[1]);
-                return(1);
+                return 1;
         }
 
-        return(0);
+        return 0;
 }
 
 void do_io(struct io_thread_req *req)
@@ -1409,13 +1446,14 @@ static int io_count = 0;
 
 int io_thread(void *arg)
 {
-        struct io_thread_req req;
+        struct io_thread_req *req;
         int n;
 
         ignore_sigwinch_sig();
         while(1){
-                n = os_read_file(kernel_fd, &req, sizeof(req));
-                if(n != sizeof(req)){
+                n = os_read_file(kernel_fd, &req,
+                                 sizeof(struct io_thread_req *));
+                if(n != sizeof(struct io_thread_req *)){
                         if(n < 0)
                                 printk("io_thread - read failed, fd = %d, "
                                        "err = %d\n", kernel_fd, -n);
@@ -1426,9 +1464,10 @@ int io_thread(void *arg)
                         continue;
                 }
                 io_count++;
-                do_io(&req);
-                n = os_write_file(kernel_fd, &req, sizeof(req));
-                if(n != sizeof(req))
+                do_io(req);
+                n = os_write_file(kernel_fd, &req,
+                                  sizeof(struct io_thread_req *));
+                if(n != sizeof(struct io_thread_req *))
                         printk("io_thread - write failed, fd = %d, err = %d\n",
                                kernel_fd, -n);
         }
diff --git a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
index b94d2bc4fe06..4707b3f14c2f 100644
--- a/arch/um/drivers/ubd_user.c
+++ b/arch/um/drivers/ubd_user.c
@@ -16,7 +16,6 @@
 #include <sys/mman.h>
 #include <sys/param.h>
 #include "asm/types.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "ubd_user.h"
@@ -47,8 +46,8 @@ int start_io_thread(unsigned long sp, int *fd_out)
         pid = clone(io_thread, (void *) sp, CLONE_FILES | CLONE_VM | SIGCHLD,
                     NULL);
         if(pid < 0){
-                printk("start_io_thread - clone failed : errno = %d\n", errno);
                 err = -errno;
+                printk("start_io_thread - clone failed : errno = %d\n", errno);
                 goto out_close;
         }
 
@@ -60,16 +59,5 @@ int start_io_thread(unsigned long sp, int *fd_out)
         kernel_fd = -1;
         *fd_out = -1;
  out:
-        return(err);
+        return err;
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/drivers/xterm.c b/arch/um/drivers/xterm.c
index 850221d9b4c9..571c2b3325d5 100644
--- a/arch/um/drivers/xterm.c
+++ b/arch/um/drivers/xterm.c
@@ -14,7 +14,6 @@
 #include <sys/socket.h>
 #include "kern_util.h"
 #include "chan_user.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 #include "xterm.h"
diff --git a/arch/um/include/arch.h b/arch/um/include/arch.h
new file mode 100644
index 000000000000..10ad52daa8c5
--- /dev/null
+++ b/arch/um/include/arch.h
@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __ARCH_H__
+#define __ARCH_H__
+
+#include "sysdep/ptrace.h"
+
+extern void arch_check_bugs(void);
+extern int arch_fixup(unsigned long address, union uml_pt_regs *regs);
+extern int arch_handle_signal(int sig, union uml_pt_regs *regs);
+
+#endif
diff --git a/arch/um/include/as-layout.h b/arch/um/include/as-layout.h
new file mode 100644
index 000000000000..fccf187bf4e1
--- /dev/null
+++ b/arch/um/include/as-layout.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __START_H__
+#define __START_H__
+
+#include "sysdep/ptrace.h"
+
+struct cpu_task {
+        int pid;
+        void *task;
+};
+
+extern struct cpu_task cpu_tasks[];
+
+extern unsigned long low_physmem;
+extern unsigned long high_physmem;
+extern unsigned long uml_physmem;
+extern unsigned long uml_reserved;
+extern unsigned long end_vm;
+extern unsigned long start_vm;
+extern unsigned long long highmem;
+
+extern unsigned long _stext, _etext, _sdata, _edata, __bss_start, _end;
+extern unsigned long _unprotected_end;
+extern unsigned long brk_start;
+
+extern int linux_main(int argc, char **argv);
+extern void set_cmdline(char *cmd);
+
+extern void (*sig_info[])(int, union uml_pt_regs *);
+
+#endif
diff --git a/arch/um/include/common-offsets.h b/arch/um/include/common-offsets.h
index 461175f8b1d9..5593a8027083 100644
--- a/arch/um/include/common-offsets.h
+++ b/arch/um/include/common-offsets.h
@@ -24,5 +24,7 @@ DEFINE(UM_ELF_CLASS, ELF_CLASS);
 DEFINE(UM_ELFCLASS32, ELFCLASS32);
 DEFINE(UM_ELFCLASS64, ELFCLASS64);
 
+DEFINE(UM_NR_CPUS, NR_CPUS);
+
 /* For crypto assembler code. */
 DEFINE(crypto_tfm_ctx_offset, offsetof(struct crypto_tfm, __crt_ctx));
diff --git a/arch/um/include/kern_util.h b/arch/um/include/kern_util.h
index 173af029d12b..50a49691e0e6 100644
--- a/arch/um/include/kern_util.h
+++ b/arch/um/include/kern_util.h
@@ -8,6 +8,7 @@
 
 #include "sysdep/ptrace.h"
 #include "sysdep/faultinfo.h"
+#include "uml-config.h"
 
 typedef void (*kern_hndl)(int, union uml_pt_regs *);
 
@@ -23,7 +24,6 @@ struct kern_handlers {
 extern const struct kern_handlers handlinfo_kern;
 
 extern int ncpus;
-extern char *linux_prog;
 extern char *gdb_init;
 extern int kmalloc_ok;
 extern int jail;
@@ -34,7 +34,9 @@ extern int nsyscalls;
         UML_ROUND_DOWN(((unsigned long) addr) + PAGE_SIZE - 1)
 
 extern int kernel_fork(unsigned long flags, int (*fn)(void *), void * arg);
+#ifdef UML_CONFIG_MODE_TT
 extern unsigned long stack_sp(unsigned long page);
+#endif
 extern int kernel_thread_proc(void *data);
 extern void syscall_segv(int sig);
 extern int current_pid(void);
@@ -42,7 +44,7 @@ extern unsigned long alloc_stack(int order, int atomic);
 extern int do_signal(void);
 extern int is_stack_fault(unsigned long sp);
 extern unsigned long segv(struct faultinfo fi, unsigned long ip,
-                          int is_user, void *sc);
+                          int is_user, union uml_pt_regs *regs);
 extern int handle_page_fault(unsigned long address, unsigned long ip,
                              int is_write, int is_user, int *code_out);
 extern void syscall_ready(void);
@@ -50,7 +52,6 @@ extern void set_tracing(void *t, int tracing);
 extern int is_tracing(void *task);
 extern int segv_syscall(void);
 extern void kern_finish_exec(void *task, int new_pid, unsigned long stack);
-extern int page_size(void);
 extern unsigned long page_mask(void);
 extern int need_finish_fork(void);
 extern void free_stack(unsigned long stack, int order);
@@ -58,7 +59,6 @@ extern void add_input_request(int op, void (*proc)(int), void *arg);
 extern char *current_cmd(void);
 extern void timer_handler(int sig, union uml_pt_regs *regs);
 extern int set_signals(int enable);
-extern void force_sigbus(void);
 extern int pid_to_processor_id(int pid);
 extern void deliver_signals(void *t);
 extern int next_trap_index(int max);
@@ -70,7 +70,6 @@ extern void *syscall_sp(void *t);
 extern void syscall_trace(union uml_pt_regs *regs, int entryexit);
 extern int hz(void);
 extern unsigned int do_IRQ(int irq, union uml_pt_regs *regs);
-extern int external_pid(void *t);
 extern void interrupt_end(void);
 extern void initial_thread_cb(void (*proc)(void *), void *arg);
 extern int debugger_signal(int status, int pid);
@@ -81,7 +80,6 @@ extern int init_parent_proxy(int pid);
 extern int singlestepping(void *t);
 extern void check_stack_overflow(void *ptr);
 extern void relay_signal(int sig, union uml_pt_regs *regs);
-extern void not_implemented(void);
 extern int user_context(unsigned long sp);
 extern void timer_irq(union uml_pt_regs *regs);
 extern void unprotect_stack(unsigned long stack);
@@ -93,7 +91,6 @@ extern char *uml_strdup(char *string);
 extern void unprotect_kernel_mem(void);
 extern void protect_kernel_mem(void);
 extern void uml_cleanup(void);
-extern void set_current(void *t);
 extern void lock_signalled_task(void *t);
 extern void IPI_handler(int cpu);
 extern int jail_setup(char *line, int *add);
@@ -118,4 +115,6 @@ extern void time_init_kern(void);
 extern int __cant_sleep(void);
 extern void sigio_handler(int sig, union uml_pt_regs *regs);
 
+extern void copy_sc(union uml_pt_regs *regs, void *from);
+
 #endif
diff --git a/arch/um/include/net_kern.h b/arch/um/include/net_kern.h
index 125ab42df18a..9237056b9103 100644
--- a/arch/um/include/net_kern.h
+++ b/arch/um/include/net_kern.h
@@ -40,7 +40,7 @@ struct uml_net_private {
         void (*add_address)(unsigned char *, unsigned char *, void *);
         void (*delete_address)(unsigned char *, unsigned char *, void *);
         int (*set_mtu)(int mtu, void *);
-        int user[1];
+        char user[0];
 };
 
 struct net_kern_info {
diff --git a/arch/um/include/net_user.h b/arch/um/include/net_user.h
index 19f207cd70fe..cfe7c50634b9 100644
--- a/arch/um/include/net_user.h
+++ b/arch/um/include/net_user.h
@@ -14,7 +14,7 @@
 #define UML_NET_VERSION (4)
 
 struct net_user_info {
-        void (*init)(void *, void *);
+        int (*init)(void *, void *);
         int (*open)(void *);
         void (*close)(int, void *);
         void (*remove)(void *);
diff --git a/arch/um/include/os.h b/arch/um/include/os.h
index 5c74da410451..688d181b5f8a 100644
--- a/arch/um/include/os.h
+++ b/arch/um/include/os.h
@@ -16,6 +16,8 @@
 #include "sysdep/tls.h"
 #include "sysdep/archsetjmp.h"
 
+#define CATCH_EINTR(expr) while ((errno = 0, ((expr) < 0)) && (errno == EINTR))
+
 #define OS_TYPE_FILE 1
 #define OS_TYPE_DIR 2
 #define OS_TYPE_SYMLINK 3
@@ -273,8 +275,9 @@ extern void stack_protections(unsigned long address);
 extern void task_protections(unsigned long address);
 extern int raw(int fd);
 extern void setup_machinename(char *machine_out);
-extern void setup_hostinfo(void);
+extern void setup_hostinfo(char *buf, int len);
 extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
+extern void os_dump_core(void);
 
 /* time.c */
 #define BILLION (1000 * 1000 * 1000)
@@ -297,13 +300,12 @@ extern long syscall_stub_data(struct mm_id * mm_idp,
                               unsigned long *data, int data_count,
                               void **addr, void **stub_addr);
 extern int map(struct mm_id * mm_idp, unsigned long virt,
-               unsigned long len, int r, int w, int x, int phys_fd,
+               unsigned long len, int prot, int phys_fd,
                unsigned long long offset, int done, void **data);
-extern int unmap(struct mm_id * mm_idp, void *addr, unsigned long len,
+extern int unmap(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
                  int done, void **data);
 extern int protect(struct mm_id * mm_idp, unsigned long addr,
-                   unsigned long len, int r, int w, int x, int done,
-                   void **data);
+                   unsigned long len, unsigned int prot, int done, void **data);
 
 /* skas/process.c */
 extern int is_skas_winch(int pid, int fd, void *data);
@@ -339,8 +341,11 @@ extern void maybe_sigio_broken(int fd, int read);
 
 /* skas/trap */
 extern void sig_handler_common_skas(int sig, void *sc_ptr);
-extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
 
+/* sys-x86_64/prctl.c */
 extern int os_arch_prctl(int pid, int code, unsigned long *addr);
 
+/* tty.c */
+int get_pty(void);
+
 #endif
diff --git a/arch/um/include/skas/mode_kern_skas.h b/arch/um/include/skas/mode_kern_skas.h
index 9cd9c6ec9a63..8ee6285dfacc 100644
--- a/arch/um/include/skas/mode_kern_skas.h
+++ b/arch/um/include/skas/mode_kern_skas.h
@@ -33,6 +33,8 @@ extern unsigned long set_task_sizes_skas(unsigned long *task_size_out);
 extern int start_uml_skas(void);
 extern int external_pid_skas(struct task_struct *task);
 extern int thread_pid_skas(struct task_struct *task);
+extern void flush_tlb_page_skas(struct vm_area_struct *vma,
+                                unsigned long address);
 
 #define kmem_end_skas (host_task_size - 1024 * 1024)
 
diff --git a/arch/um/include/tlb.h b/arch/um/include/tlb.h
index 8efc1e0f1b84..bcd1a4afb842 100644
--- a/arch/um/include/tlb.h
+++ b/arch/um/include/tlb.h
@@ -14,9 +14,7 @@ struct host_vm_op {
                 struct {
                         unsigned long addr;
                         unsigned long len;
-                        unsigned int r:1;
-                        unsigned int w:1;
-                        unsigned int x:1;
+                        unsigned int prot;
                         int fd;
                         __u64 offset;
                 } mmap;
@@ -27,9 +25,7 @@ struct host_vm_op {
                 struct {
                         unsigned long addr;
                         unsigned long len;
-                        unsigned int r:1;
-                        unsigned int w:1;
-                        unsigned int x:1;
+                        unsigned int prot;
                 } mprotect;
         } u;
 };
diff --git a/arch/um/include/tt/uaccess-tt.h b/arch/um/include/tt/uaccess-tt.h
index b19645f32f24..13a64f61fcf4 100644
--- a/arch/um/include/tt/uaccess-tt.h
+++ b/arch/um/include/tt/uaccess-tt.h
@@ -27,8 +27,6 @@ extern unsigned long uml_physmem;
 #define access_ok_tt(type, addr, size) \
         (is_stack(addr, size))
 
-extern unsigned long get_fault_addr(void);
-
 extern int __do_copy_from_user(void *to, const void *from, int n,
                                void **fault_addr, void **fault_catcher);
 extern int __do_strncpy_from_user(char *dst, const char *src, size_t n,
diff --git a/arch/um/include/um_malloc.h b/arch/um/include/um_malloc.h
index 0363a9b53f8d..e6d7c5aa3f4e 100644
--- a/arch/um/include/um_malloc.h
+++ b/arch/um/include/um_malloc.h
@@ -11,7 +11,6 @@ extern void *um_kmalloc_atomic(int size);
 extern void kfree(const void *ptr);
 
 extern void *um_vmalloc(int size);
-extern void *um_vmalloc_atomic(int size);
 extern void vfree(void *ptr);
 
 #endif /* __UM_MALLOC_H__ */
diff --git a/arch/um/include/user.h b/arch/um/include/user.h
index acadce3f271f..d380e6d91a90 100644
--- a/arch/um/include/user.h
+++ b/arch/um/include/user.h
@@ -6,6 +6,19 @@
 #ifndef __USER_H__
 #define __USER_H__
 
+/*
+ * The usual definition - copied here because the kernel provides its own,
+ * fancier, type-safe, definition.  Using that one would require
+ * copying too much infrastructure for my taste, so userspace files
+ * get less checking than kernel files.
+ */
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+/*
+ * This will provide the size_t definition in both kernel and userspace builds
+ */
+#include <linux/types.h>
+
 extern void panic(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
 extern int printk(const char *fmt, ...)
@@ -13,19 +26,7 @@ extern int printk(const char *fmt, ...)
 extern void schedule(void);
 extern int in_aton(char *str);
 extern int open_gdb_chan(void);
-/* These use size_t, however unsigned long is correct on both i386 and x86_64. */
-extern unsigned long strlcpy(char *, const char *, unsigned long);
-extern unsigned long strlcat(char *, const char *, unsigned long);
+extern size_t strlcpy(char *, const char *, size_t);
+extern size_t strlcat(char *, const char *, size_t);
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/include/user_util.h b/arch/um/include/user_util.h
deleted file mode 100644
index 023575f67343..000000000000
--- a/arch/um/include/user_util.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __USER_UTIL_H__
-#define __USER_UTIL_H__
-
-#include "sysdep/ptrace.h"
-
-/* Copied from kernel.h */
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-
-#define CATCH_EINTR(expr) while ((errno = 0, ((expr) < 0)) && (errno == EINTR))
-
-extern int mode_tt;
-
-extern int grantpt(int __fd);
-extern int unlockpt(int __fd);
-extern char *ptsname(int __fd);
-
-struct cpu_task {
-        int pid;
-        void *task;
-};
-
-extern struct cpu_task cpu_tasks[];
-
-extern void (*sig_info[])(int, union uml_pt_regs *);
-
-extern unsigned long low_physmem;
-extern unsigned long high_physmem;
-extern unsigned long uml_physmem;
-extern unsigned long uml_reserved;
-extern unsigned long end_vm;
-extern unsigned long start_vm;
-extern unsigned long long highmem;
-
-extern char host_info[];
-
-extern unsigned long _stext, _etext, _sdata, _edata, __bss_start, _end;
-extern unsigned long _unprotected_end;
-extern unsigned long brk_start;
-
-extern int pty_output_sigio;
-extern int pty_close_sigio;
-
-extern void *add_signal_handler(int sig, void (*handler)(int));
-extern int linux_main(int argc, char **argv);
-extern void set_cmdline(char *cmd);
-extern void input_cb(void (*proc)(void *), void *arg, int arg_len);
-extern int get_pty(void);
-extern int switcheroo(int fd, int prot, void *from, void *to, int size);
-extern void do_exec(int old_pid, int new_pid);
-extern void tracer_panic(char *msg, ...)
-        __attribute__ ((format (printf, 1, 2)));
-extern int detach(int pid, int sig);
-extern int attach(int pid);
-extern void kill_child_dead(int pid);
-extern int cont(int pid);
-extern void check_sigio(void);
-extern void arch_check_bugs(void);
-extern int cpu_feature(char *what, char *buf, int len);
-extern int arch_handle_signal(int sig, union uml_pt_regs *regs);
-extern int arch_fixup(unsigned long address, void *sc_ptr);
-extern void arch_init_thread(void);
-extern int raw(int fd);
-
-#endif
diff --git a/arch/um/kernel/exec.c b/arch/um/kernel/exec.c
index 121166400e25..356e50f5aaed 100644
--- a/arch/um/kernel/exec.c
+++ b/arch/um/kernel/exec.c
@@ -10,8 +10,8 @@
 #include "asm/pgtable.h"
 #include "asm/tlbflush.h"
 #include "asm/uaccess.h"
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "mem_user.h"
 #include "kern.h"
 #include "irq_user.h"
diff --git a/arch/um/kernel/init_task.c b/arch/um/kernel/init_task.c
index 8cde431348cc..cda91aa8e703 100644
--- a/arch/um/kernel/init_task.c
+++ b/arch/um/kernel/init_task.c
@@ -10,7 +10,6 @@
 #include "linux/mqueue.h"
 #include "asm/uaccess.h"
 #include "asm/pgtable.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "os.h"
 
diff --git a/arch/um/kernel/initrd.c b/arch/um/kernel/initrd.c
index 82ecf904b09c..16dc43e9d940 100644
--- a/arch/um/kernel/initrd.c
+++ b/arch/um/kernel/initrd.c
@@ -7,7 +7,6 @@
 #include "linux/bootmem.h"
 #include "linux/initrd.h"
 #include "asm/types.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "initrd.h"
 #include "init.h"
@@ -22,12 +21,20 @@ static int __init read_initrd(void)
         long long size;
         int err;
 
-        if(initrd == NULL) return 0;
+        if(initrd == NULL)
+                return 0;
+
         err = os_file_size(initrd, &size);
-        if(err) return 0;
+        if(err)
+                return 0;
+
         area = alloc_bootmem(size);
-        if(area == NULL) return 0;
-        if(load_initrd(initrd, area, size) == -1) return 0;
+        if(area == NULL)
+                return 0;
+
+        if(load_initrd(initrd, area, size) == -1)
+                return 0;
+
         initrd_start = (unsigned long) area;
         initrd_end = initrd_start + size;
         return 0;
@@ -54,25 +61,15 @@ int load_initrd(char *filename, void *buf, int size)
         fd = os_open_file(filename, of_read(OPENFLAGS()), 0);
         if(fd < 0){
                 printk("Opening '%s' failed - err = %d\n", filename, -fd);
-                return(-1);
+                return -1;
         }
         n = os_read_file(fd, buf, size);
         if(n != size){
                 printk("Read of %d bytes from '%s' failed, err = %d\n", size,
                        filename, -n);
-                return(-1);
+                return -1;
         }
 
         os_close_file(fd);
-        return(0);
+        return 0;
 }
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
index dbf2f5bc842f..8f2ed3690315 100644
--- a/arch/um/kernel/irq.c
+++ b/arch/um/kernel/irq.c
@@ -25,7 +25,6 @@
 #include "asm/system.h"
 #include "asm/errno.h"
 #include "asm/uaccess.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "irq_user.h"
 #include "irq_kern.h"
@@ -79,6 +78,14 @@ skip:
         return 0;
 }
 
+/*
+ * This list is accessed under irq_lock, except in sigio_handler,
+ * where it is safe from being modified.  IRQ handlers won't change it -
+ * if an IRQ source has vanished, it will be freed by free_irqs just
+ * before returning from sigio_handler.  That will process a separate
+ * list of irqs to free, with its own locking, coming back here to
+ * remove list elements, taking the irq_lock to do so.
+ */
 static struct irq_fd *active_fds = NULL;
 static struct irq_fd **last_irq_ptr = &active_fds;
 
@@ -244,6 +251,7 @@ void free_irq_by_fd(int fd)
         free_irq_by_cb(same_fd, &fd);
 }
 
+/* Must be called with irq_lock held */
 static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out)
 {
         struct irq_fd *irq;
@@ -309,6 +317,12 @@ void deactivate_fd(int fd, int irqnum)
         ignore_sigio_fd(fd);
 }
 
+/*
+ * Called just before shutdown in order to provide a clean exec
+ * environment in case the system is rebooting.  No locking because
+ * that would cause a pointless shutdown hang if something hadn't
+ * released the lock.
+ */
 int deactivate_all_fds(void)
 {
         struct irq_fd *irq;
diff --git a/arch/um/kernel/ksyms.c b/arch/um/kernel/ksyms.c
index 0e00cf93f900..7b3e53fb8070 100644
--- a/arch/um/kernel/ksyms.c
+++ b/arch/um/kernel/ksyms.c
@@ -16,7 +16,7 @@
 #include "asm/page.h"
 #include "asm/tlbflush.h"
 #include "kern_util.h"
-#include "user_util.h"
+#include "as-layout.h"
 #include "mem_user.h"
 #include "os.h"
 
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
index df7d662b98ce..72ff85693a39 100644
--- a/arch/um/kernel/mem.c
+++ b/arch/um/kernel/mem.c
@@ -13,8 +13,8 @@
 #include "asm/page.h"
 #include "asm/fixmap.h"
 #include "asm/pgalloc.h"
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "kern.h"
 #include "mem_user.h"
 #include "uml_uaccess.h"
@@ -216,7 +216,7 @@ static void __init fixaddr_user_init( void)
 #endif
 }
 
-void paging_init(void)
+void __init paging_init(void)
 {
         unsigned long zones_size[MAX_NR_ZONES], vaddr;
         int i;
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index 638f3b5f6094..3ba6e4c841da 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -13,7 +13,7 @@
 #include "asm/types.h"
 #include "asm/pgtable.h"
 #include "kern_util.h"
-#include "user_util.h"
+#include "as-layout.h"
 #include "mode_kern.h"
 #include "mem.h"
 #include "mem_user.h"
@@ -21,229 +21,8 @@
 #include "kern.h"
 #include "init.h"
 
-struct phys_desc {
-        struct rb_node rb;
-        int fd;
-        __u64 offset;
-        void *virt;
-        unsigned long phys;
-        struct list_head list;
-};
-
-static struct rb_root phys_mappings = RB_ROOT;
-
-static struct rb_node **find_rb(void *virt)
-{
-        struct rb_node **n = &phys_mappings.rb_node;
-        struct phys_desc *d;
-
-        while(*n != NULL){
-                d = rb_entry(*n, struct phys_desc, rb);
-                if(d->virt == virt)
-                        return n;
-
-                if(d->virt > virt)
-                        n = &(*n)->rb_left;
-                else
-                        n = &(*n)->rb_right;
-        }
-
-        return n;
-}
-
-static struct phys_desc *find_phys_mapping(void *virt)
-{
-        struct rb_node **n = find_rb(virt);
-
-        if(*n == NULL)
-                return NULL;
-
-        return rb_entry(*n, struct phys_desc, rb);
-}
-
-static void insert_phys_mapping(struct phys_desc *desc)
-{
-        struct rb_node **n = find_rb(desc->virt);
-
-        if(*n != NULL)
-                panic("Physical remapping for %p already present",
-                      desc->virt);
-
-        rb_link_node(&desc->rb, rb_parent(*n), n);
-        rb_insert_color(&desc->rb, &phys_mappings);
-}
-
-LIST_HEAD(descriptor_mappings);
-
-struct desc_mapping {
-        int fd;
-        struct list_head list;
-        struct list_head pages;
-};
-
-static struct desc_mapping *find_mapping(int fd)
-{
-        struct desc_mapping *desc;
-        struct list_head *ele;
-
-        list_for_each(ele, &descriptor_mappings){
-                desc = list_entry(ele, struct desc_mapping, list);
-                if(desc->fd == fd)
-                        return desc;
-        }
-
-        return NULL;
-}
-
-static struct desc_mapping *descriptor_mapping(int fd)
-{
-        struct desc_mapping *desc;
-
-        desc = find_mapping(fd);
-        if(desc != NULL)
-                return desc;
-
-        desc = kmalloc(sizeof(*desc), GFP_ATOMIC);
-        if(desc == NULL)
-                return NULL;
-
-        *desc = ((struct desc_mapping)
-                { .fd =         fd,
-                  .list =       LIST_HEAD_INIT(desc->list),
-                  .pages =      LIST_HEAD_INIT(desc->pages) });
-        list_add(&desc->list, &descriptor_mappings);
-
-        return desc;
-}
-
-int physmem_subst_mapping(void *virt, int fd, __u64 offset, int w)
-{
-        struct desc_mapping *fd_maps;
-        struct phys_desc *desc;
-        unsigned long phys;
-        int err;
-
-        fd_maps = descriptor_mapping(fd);
-        if(fd_maps == NULL)
-                return -ENOMEM;
-
-        phys = __pa(virt);
-        desc = find_phys_mapping(virt);
-        if(desc != NULL)
-                panic("Address 0x%p is already substituted\n", virt);
-
-        err = -ENOMEM;
-        desc = kmalloc(sizeof(*desc), GFP_ATOMIC);
-        if(desc == NULL)
-                goto out;
-
-        *desc = ((struct phys_desc)
-                { .fd =                 fd,
-                  .offset =             offset,
-                  .virt =               virt,
-                  .phys =               __pa(virt),
-                  .list =               LIST_HEAD_INIT(desc->list) });
-        insert_phys_mapping(desc);
-
-        list_add(&desc->list, &fd_maps->pages);
-
-        virt = (void *) ((unsigned long) virt & PAGE_MASK);
-        err = os_map_memory(virt, fd, offset, PAGE_SIZE, 1, w, 0);
-        if(!err)
-                goto out;
-
-        rb_erase(&desc->rb, &phys_mappings);
-        kfree(desc);
- out:
-        return err;
-}
-
 static int physmem_fd = -1;
 
-static void remove_mapping(struct phys_desc *desc)
-{
-        void *virt = desc->virt;
-        int err;
-
-        rb_erase(&desc->rb, &phys_mappings);
-        list_del(&desc->list);
-        kfree(desc);
-
-        err = os_map_memory(virt, physmem_fd, __pa(virt), PAGE_SIZE, 1, 1, 0);
-        if(err)
-                panic("Failed to unmap block device page from physical memory, "
-                      "errno = %d", -err);
-}
-
-int physmem_remove_mapping(void *virt)
-{
-        struct phys_desc *desc;
-
-        virt = (void *) ((unsigned long) virt & PAGE_MASK);
-        desc = find_phys_mapping(virt);
-        if(desc == NULL)
-                return 0;
-
-        remove_mapping(desc);
-        return 1;
-}
-
-void physmem_forget_descriptor(int fd)
-{
-        struct desc_mapping *desc;
-        struct phys_desc *page;
-        struct list_head *ele, *next;
-        __u64 offset;
-        void *addr;
-        int err;
-
-        desc = find_mapping(fd);
-        if(desc == NULL)
-                return;
-
-        list_for_each_safe(ele, next, &desc->pages){
-                page = list_entry(ele, struct phys_desc, list);
-                offset = page->offset;
-                addr = page->virt;
-                remove_mapping(page);
-                err = os_seek_file(fd, offset);
-                if(err)
-                        panic("physmem_forget_descriptor - failed to seek "
-                              "to %lld in fd %d, error = %d\n",
-                              offset, fd, -err);
-                err = os_read_file(fd, addr, PAGE_SIZE);
-                if(err < 0)
-                        panic("physmem_forget_descriptor - failed to read "
-                              "from fd %d to 0x%p, error = %d\n",
-                              fd, addr, -err);
-        }
-
-        list_del(&desc->list);
-        kfree(desc);
-}
-
-EXPORT_SYMBOL(physmem_forget_descriptor);
-EXPORT_SYMBOL(physmem_remove_mapping);
-EXPORT_SYMBOL(physmem_subst_mapping);
-
-void arch_free_page(struct page *page, int order)
-{
-        void *virt;
-        int i;
-
-        for(i = 0; i < (1 << order); i++){
-                virt = __va(page_to_phys(page + i));
-                physmem_remove_mapping(virt);
-        }
-}
-
-int is_remapped(void *virt)
-{
-        struct phys_desc *desc = find_phys_mapping(virt);
-
-        return desc != NULL;
-}
-
 /* Changed during early boot */
 unsigned long high_physmem;
 
@@ -350,14 +129,9 @@ void setup_physmem(unsigned long start, unsigned long reserve_end,
 
 int phys_mapping(unsigned long phys, __u64 *offset_out)
 {
-        struct phys_desc *desc = find_phys_mapping(__va(phys & PAGE_MASK));
         int fd = -1;
 
-        if(desc != NULL){
-                fd = desc->fd;
-                *offset_out = desc->offset;
-        }
-        else if(phys < physmem_size){
+        if(phys < physmem_size){
                 fd = physmem_fd;
                 *offset_out = phys;
         }
diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index 348b272bb766..8d2c5496532b 100644
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -32,8 +32,8 @@
 #include "asm/tlbflush.h"
 #include "asm/uaccess.h"
 #include "asm/user.h"
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "kern.h"
 #include "signal_kern.h"
 #include "init.h"
@@ -54,11 +54,9 @@
  */
 struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
 
-int external_pid(void *t)
+static inline int external_pid(struct task_struct *task)
 {
-        struct task_struct *task = t ? t : current;
-
-        return(CHOOSE_MODE_PROC(external_pid_tt, external_pid_skas, task));
+        return CHOOSE_MODE_PROC(external_pid_tt, external_pid_skas, task);
 }
 
 int pid_to_processor_id(int pid)
@@ -66,9 +64,10 @@ int pid_to_processor_id(int pid)
         int i;
 
         for(i = 0; i < ncpus; i++){
-                if(cpu_tasks[i].pid == pid) return(i);
+                if(cpu_tasks[i].pid == pid)
+                        return i;
         }
-        return(-1);
+        return -1;
 }
 
 void free_stack(unsigned long stack, int order)
@@ -85,9 +84,9 @@ unsigned long alloc_stack(int order, int atomic)
                 flags = GFP_ATOMIC;
         page = __get_free_pages(flags, order);
         if(page == 0)
-                return(0);
+                return 0;
         stack_protections(page);
-        return(page);
+        return page;
 }
 
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
@@ -98,15 +97,11 @@ int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
         current->thread.request.u.thread.arg = arg;
         pid = do_fork(CLONE_VM | CLONE_UNTRACED | flags, 0,
                       &current->thread.regs, 0, NULL, NULL);
-        if(pid < 0)
-                panic("do_fork failed in kernel_thread, errno = %d", pid);
-        return(pid);
+        return pid;
 }
 
-void set_current(void *t)
+static inline void set_current(struct task_struct *task)
 {
-        struct task_struct *task = t;
-
         cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
                 { external_pid(task), task });
 }
@@ -128,14 +123,16 @@ void *_switch_to(void *prev, void *next, void *last)
                 prev= current;
         } while(current->thread.saved_task);
 
-        return(current->thread.prev_sched);
+        return current->thread.prev_sched;
 
 }
 
 void interrupt_end(void)
 {
-        if(need_resched()) schedule();
-        if(test_tsk_thread_flag(current, TIF_SIGPENDING)) do_signal();
+        if(need_resched())
+                schedule();
+        if(test_tsk_thread_flag(current, TIF_SIGPENDING))
+                do_signal();
 }
 
 void release_thread(struct task_struct *task)
@@ -150,7 +147,7 @@ void exit_thread(void)
 
 void *get_current(void)
 {
-        return(current);
+        return current;
 }
 
 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
@@ -188,15 +185,12 @@ void initial_thread_cb(void (*proc)(void *), void *arg)
         kmalloc_ok = save_kmalloc_ok;
 }
 
+#ifdef CONFIG_MODE_TT
 unsigned long stack_sp(unsigned long page)
 {
-        return(page + PAGE_SIZE - sizeof(void *));
-}
-
-int current_pid(void)
-{
-        return(current->pid);
+        return page + PAGE_SIZE - sizeof(void *);
 }
+#endif
 
 void default_idle(void)
 {
@@ -221,11 +215,6 @@ void cpu_idle(void)
         CHOOSE_MODE(init_idle_tt(), init_idle_skas());
 }
 
-int page_size(void)
-{
-        return(PAGE_SIZE);
-}
-
 void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
                       pte_t *pte_out)
 {
@@ -236,68 +225,43 @@ void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
         pte_t ptent;
 
         if(task->mm == NULL)
-                return(ERR_PTR(-EINVAL));
+                return ERR_PTR(-EINVAL);
         pgd = pgd_offset(task->mm, addr);
         if(!pgd_present(*pgd))
-                return(ERR_PTR(-EINVAL));
+                return ERR_PTR(-EINVAL);
 
         pud = pud_offset(pgd, addr);
         if(!pud_present(*pud))
-                return(ERR_PTR(-EINVAL));
+                return ERR_PTR(-EINVAL);
 
         pmd = pmd_offset(pud, addr);
         if(!pmd_present(*pmd))
-                return(ERR_PTR(-EINVAL));
+                return ERR_PTR(-EINVAL);
 
         pte = pte_offset_kernel(pmd, addr);
         ptent = *pte;
         if(!pte_present(ptent))
-                return(ERR_PTR(-EINVAL));
+                return ERR_PTR(-EINVAL);
 
         if(pte_out != NULL)
                 *pte_out = ptent;
-        return((void *) (pte_val(ptent) & PAGE_MASK) + (addr & ~PAGE_MASK));
+        return (void *) (pte_val(ptent) & PAGE_MASK) + (addr & ~PAGE_MASK);
 }
 
 char *current_cmd(void)
 {
 #if defined(CONFIG_SMP) || defined(CONFIG_HIGHMEM)
-        return("(Unknown)");
+        return "(Unknown)";
 #else
         void *addr = um_virt_to_phys(current, current->mm->arg_start, NULL);
         return IS_ERR(addr) ? "(Unknown)": __va((unsigned long) addr);
 #endif
 }
 
-void force_sigbus(void)
-{
-        printk(KERN_ERR "Killing pid %d because of a lack of memory\n",
-               current->pid);
-        lock_kernel();
-        sigaddset(&current->pending.signal, SIGBUS);
-        recalc_sigpending();
-        current->flags |= PF_SIGNALED;
-        do_exit(SIGBUS | 0x80);
-}
-
 void dump_thread(struct pt_regs *regs, struct user *u)
 {
 }
 
-void enable_hlt(void)
-{
-        panic("enable_hlt");
-}
-
-EXPORT_SYMBOL(enable_hlt);
-
-void disable_hlt(void)
-{
-        panic("disable_hlt");
-}
-
-EXPORT_SYMBOL(disable_hlt);
-
 void *um_kmalloc(int size)
 {
         return kmalloc(size, GFP_KERNEL);
@@ -313,36 +277,17 @@ void *um_vmalloc(int size)
         return vmalloc(size);
 }
 
-void *um_vmalloc_atomic(int size)
-{
-        return __vmalloc(size, GFP_ATOMIC | __GFP_HIGHMEM, PAGE_KERNEL);
-}
-
 int __cant_sleep(void) {
         return in_atomic() || irqs_disabled() || in_interrupt();
         /* Is in_interrupt() really needed? */
 }
 
-unsigned long get_fault_addr(void)
-{
-        return((unsigned long) current->thread.fault_addr);
-}
-
-EXPORT_SYMBOL(get_fault_addr);
-
-void not_implemented(void)
-{
-        printk(KERN_DEBUG "Something isn't implemented in here\n");
-}
-
-EXPORT_SYMBOL(not_implemented);
-
 int user_context(unsigned long sp)
 {
         unsigned long stack;
 
         stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
-        return(stack != (unsigned long) current_thread);
+        return stack != (unsigned long) current_thread;
 }
 
 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
@@ -363,22 +308,22 @@ char *uml_strdup(char *string)
 
 int copy_to_user_proc(void __user *to, void *from, int size)
 {
-        return(copy_to_user(to, from, size));
+        return copy_to_user(to, from, size);
 }
 
 int copy_from_user_proc(void *to, void __user *from, int size)
 {
-        return(copy_from_user(to, from, size));
+        return copy_from_user(to, from, size);
 }
 
 int clear_user_proc(void __user *buf, int size)
 {
-        return(clear_user(buf, size));
+        return clear_user(buf, size);
 }
 
 int strlen_user_proc(char __user *str)
 {
-        return(strlen_user(str));
+        return strlen_user(str);
 }
 
 int smp_sigio_handler(void)
@@ -387,14 +332,14 @@ int smp_sigio_handler(void)
         int cpu = current_thread->cpu;
         IPI_handler(cpu);
         if(cpu != 0)
-                return(1);
+                return 1;
 #endif
-        return(0);
+        return 0;
 }
 
 int cpu(void)
 {
-        return(current_thread->cpu);
+        return current_thread->cpu;
 }
 
 static atomic_t using_sysemu = ATOMIC_INIT(0);
@@ -443,7 +388,7 @@ int __init make_proc_sysemu(void)
         if (ent == NULL)
         {
                 printk(KERN_WARNING "Failed to register /proc/sysemu\n");
-                return(0);
+                return 0;
         }
 
         ent->read_proc  = proc_read_sysemu;
diff --git a/arch/um/kernel/reboot.c b/arch/um/kernel/reboot.c
index f602623644aa..7e4305a1fd3c 100644
--- a/arch/um/kernel/reboot.c
+++ b/arch/um/kernel/reboot.c
@@ -6,7 +6,6 @@
 #include "linux/module.h"
 #include "linux/sched.h"
 #include "asm/smp.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
 #include "os.h"
diff --git a/arch/um/kernel/signal.c b/arch/um/kernel/signal.c
index 3c798cdde550..c4020c3d7857 100644
--- a/arch/um/kernel/signal.c
+++ b/arch/um/kernel/signal.c
@@ -17,7 +17,6 @@
 #include "asm/signal.h"
 #include "asm/uaccess.h"
 #include "asm/unistd.h"
-#include "user_util.h"
 #include "asm/ucontext.h"
 #include "kern_util.h"
 #include "signal_kern.h"
diff --git a/arch/um/kernel/skas/exec.c b/arch/um/kernel/skas/exec.c
index 54b795951372..580eb6468949 100644
--- a/arch/um/kernel/skas/exec.c
+++ b/arch/um/kernel/skas/exec.c
@@ -17,7 +17,17 @@
 
 void flush_thread_skas(void)
 {
-        force_flush_all();
+        void *data = NULL;
+        unsigned long end = proc_mm ? task_size : CONFIG_STUB_START;
+        int ret;
+
+        ret = unmap(&current->mm->context.skas.id, 0, end, 1, &data);
+        if(ret){
+                printk("flush_thread_skas - clearing address space failed, "
+                       "err = %d\n", ret);
+                force_sig(SIGKILL, current);
+        }
+
         switch_mm_skas(&current->mm->context.skas.id);
 }
 
diff --git a/arch/um/kernel/skas/process.c b/arch/um/kernel/skas/process.c
index ae4fa71d3b8b..ef36facd8fe9 100644
--- a/arch/um/kernel/skas/process.c
+++ b/arch/um/kernel/skas/process.c
@@ -13,9 +13,9 @@
 #include "asm/uaccess.h"
 #include "asm/atomic.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "skas.h"
 #include "os.h"
-#include "user_util.h"
 #include "tlb.h"
 #include "kern.h"
 #include "mode.h"
diff --git a/arch/um/kernel/skas/tlb.c b/arch/um/kernel/skas/tlb.c
index 27eb29ce666b..c0f0693743ba 100644
--- a/arch/um/kernel/skas/tlb.c
+++ b/arch/um/kernel/skas/tlb.c
@@ -10,7 +10,6 @@
 #include "asm/page.h"
 #include "asm/pgtable.h"
 #include "asm/mmu.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "mem.h"
 #include "skas.h"
@@ -28,19 +27,17 @@ static int do_ops(union mm_context *mmu, struct host_vm_op *ops, int last,
                 switch(op->type){
                 case MMAP:
                         ret = map(&mmu->skas.id, op->u.mmap.addr,
-                                  op->u.mmap.len, op->u.mmap.r, op->u.mmap.w,
-                                  op->u.mmap.x, op->u.mmap.fd,
-                                  op->u.mmap.offset, finished, flush);
+                                  op->u.mmap.len, op->u.mmap.prot,
+                                  op->u.mmap.fd, op->u.mmap.offset, finished,
+                                  flush);
                         break;
                 case MUNMAP:
-                        ret = unmap(&mmu->skas.id,
-                                    (void *) op->u.munmap.addr,
+                        ret = unmap(&mmu->skas.id, op->u.munmap.addr,
                                     op->u.munmap.len, finished, flush);
                         break;
                 case MPROTECT:
                         ret = protect(&mmu->skas.id, op->u.mprotect.addr,
-                                      op->u.mprotect.len, op->u.mprotect.r,
-                                      op->u.mprotect.w, op->u.mprotect.x,
+                                      op->u.mprotect.len, op->u.mprotect.prot,
                                       finished, flush);
                         break;
                 default:
@@ -92,6 +89,76 @@ void flush_tlb_mm_skas(struct mm_struct *mm)
 
 void force_flush_all_skas(void)
 {
-        unsigned long end = proc_mm ? task_size : CONFIG_STUB_START;
-        fix_range(current->mm, 0, end, 1);
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma = mm->mmap;
+
+        while(vma != NULL) {
+                fix_range(mm, vma->vm_start, vma->vm_end, 1);
+                vma = vma->vm_next;
+        }
+}
+
+void flush_tlb_page_skas(struct vm_area_struct *vma, unsigned long address)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        struct mm_struct *mm = vma->vm_mm;
+        void *flush = NULL;
+        int r, w, x, prot, err = 0;
+        struct mm_id *mm_id;
+
+        pgd = pgd_offset(mm, address);
+        if(!pgd_present(*pgd))
+                goto kill;
+
+        pud = pud_offset(pgd, address);
+        if(!pud_present(*pud))
+                goto kill;
+
+        pmd = pmd_offset(pud, address);
+        if(!pmd_present(*pmd))
+                goto kill;
+
+        pte = pte_offset_kernel(pmd, address);
+
+        r = pte_read(*pte);
+        w = pte_write(*pte);
+        x = pte_exec(*pte);
+        if (!pte_young(*pte)) {
+                r = 0;
+                w = 0;
+        } else if (!pte_dirty(*pte)) {
+                w = 0;
+        }
+
+        mm_id = &mm->context.skas.id;
+        prot = ((r ? UM_PROT_READ : 0) | (w ? UM_PROT_WRITE : 0) |
+                (x ? UM_PROT_EXEC : 0));
+        if(pte_newpage(*pte)){
+                if(pte_present(*pte)){
+                        unsigned long long offset;
+                        int fd;
+
+                        fd = phys_mapping(pte_val(*pte) & PAGE_MASK, &offset);
+                        err = map(mm_id, address, PAGE_SIZE, prot, fd, offset,
+                                  1, &flush);
+                }
+                else err = unmap(mm_id, address, PAGE_SIZE, 1, &flush);
+        }
+        else if(pte_newprot(*pte))
+                err = protect(mm_id, address, PAGE_SIZE, prot, 1, &flush);
+
+        if(err)
+                goto kill;
+
+        *pte = pte_mkuptodate(*pte);
+
+        return;
+
+kill:
+        printk("Failed to flush page for address 0x%lx\n", address);
+        force_sig(SIGKILL, current);
 }
+
diff --git a/arch/um/kernel/smp.c b/arch/um/kernel/smp.c
index 759b07053160..e6a7778006ad 100644
--- a/arch/um/kernel/smp.c
+++ b/arch/um/kernel/smp.c
@@ -21,7 +21,6 @@ DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 #include "asm/smp.h"
 #include "asm/processor.h"
 #include "asm/spinlock.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
 #include "irq_user.h"
@@ -90,7 +89,7 @@ static int idle_proc(void *cpup)
 
         cpu_set(cpu, cpu_online_map);
         default_idle();
-        return(0);
+        return 0;
 }
 
 static struct task_struct *idle_thread(int cpu)
@@ -98,8 +97,8 @@ static struct task_struct *idle_thread(int cpu)
         struct task_struct *new_task;
         unsigned char c;
 
-        current->thread.request.u.thread.proc = idle_proc;
-        current->thread.request.u.thread.arg = (void *) cpu;
+        current->thread.request.u.thread.proc = idle_proc;
+        current->thread.request.u.thread.arg = (void *) cpu;
         new_task = fork_idle(cpu);
         if(IS_ERR(new_task))
                 panic("copy_process failed in idle_thread, error = %ld",
@@ -110,9 +109,9 @@ static struct task_struct *idle_thread(int cpu)
                             .task =     new_task } );
         idle_threads[cpu] = new_task;
         CHOOSE_MODE(os_write_file(new_task->thread.mode.tt.switch_pipe[1], &c,
-                          sizeof(c)),
+                                  sizeof(c)),
                     ({ panic("skas mode doesn't support SMP"); }));
-        return(new_task);
+        return new_task;
 }
 
 void smp_prepare_cpus(unsigned int maxcpus)
@@ -163,13 +162,13 @@ int __cpu_up(unsigned int cpu)
         cpu_set(cpu, smp_commenced_mask);
         while (!cpu_isset(cpu, cpu_online_map))
                 mb();
-        return(0);
+        return 0;
 }
 
 int setup_profiling_timer(unsigned int multiplier)
 {
         printk(KERN_INFO "setup_profiling_timer\n");
-        return(0);
+        return 0;
 }
 
 void smp_call_function_slave(int cpu);
@@ -205,7 +204,7 @@ void IPI_handler(int cpu)
 
 int hard_smp_processor_id(void)
 {
-        return(pid_to_processor_id(os_getpid()));
+        return pid_to_processor_id(os_getpid());
 }
 
 static DEFINE_SPINLOCK(call_lock);
@@ -254,14 +253,3 @@ int smp_call_function(void (*_func)(void *info), void *_info, int nonatomic,
 }
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/syscall.c b/arch/um/kernel/syscall.c
index 2828c5283227..237c4eab7cfd 100644
--- a/arch/um/kernel/syscall.c
+++ b/arch/um/kernel/syscall.c
@@ -18,7 +18,6 @@
 #include "asm/mman.h"
 #include "asm/uaccess.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "sysdep/syscalls.h"
 #include "mode_kern.h"
 #include "choose-mode.h"
diff --git a/arch/um/kernel/sysrq.c b/arch/um/kernel/sysrq.c
index f9e02b31a97a..93263571d813 100644
--- a/arch/um/kernel/sysrq.c
+++ b/arch/um/kernel/sysrq.c
@@ -10,7 +10,6 @@
 #include "asm/page.h"
 #include "asm/processor.h"
 #include "sysrq.h"
-#include "user_util.h"
 
 /* Catch non-i386 SUBARCH's. */
 #if !defined(CONFIG_UML_X86) || defined(CONFIG_64BIT)
diff --git a/arch/um/kernel/time.c b/arch/um/kernel/time.c
index b1f8b0752419..cd7349de8ca6 100644
--- a/arch/um/kernel/time.c
+++ b/arch/um/kernel/time.c
@@ -18,7 +18,6 @@
 #include "asm/param.h"
 #include "asm/current.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "mode.h"
 #include "os.h"
 
@@ -35,8 +34,8 @@ unsigned long long sched_clock(void)
         return (unsigned long long)jiffies_64 * (1000000000 / HZ);
 }
 
-static unsigned long long prev_nsecs[NR_CPUS];
 #ifdef CONFIG_UML_REAL_TIME_CLOCK
+static unsigned long long prev_nsecs[NR_CPUS];
 static long long delta[NR_CPUS];                /* Deviation per interval */
 #endif
 
@@ -95,7 +94,12 @@ irqreturn_t um_timer(int irq, void *dev)
 
         do_timer(1);
 
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
         nsecs = get_time();
+#else
+        nsecs = (unsigned long long) xtime.tv_sec * BILLION + xtime.tv_nsec +
+                BILLION / HZ;
+#endif
         xtime.tv_sec = nsecs / NSEC_PER_SEC;
         xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
 
@@ -128,13 +132,18 @@ void time_init(void)
         nsecs = os_nsecs();
         set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
                                 -nsecs % BILLION);
+        set_normalized_timespec(&xtime, nsecs / BILLION, nsecs % BILLION);
         late_time_init = register_timer;
 }
 
 void do_gettimeofday(struct timeval *tv)
 {
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
         unsigned long long nsecs = get_time();
-
+#else
+        unsigned long long nsecs = (unsigned long long) xtime.tv_sec * BILLION +
+                xtime.tv_nsec;
+#endif
         tv->tv_sec = nsecs / NSEC_PER_SEC;
         /* Careful about calculations here - this was originally done as
          * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
diff --git a/arch/um/kernel/tlb.c b/arch/um/kernel/tlb.c
index 54a5ff25645a..8a8d52851443 100644
--- a/arch/um/kernel/tlb.c
+++ b/arch/um/kernel/tlb.c
@@ -6,17 +6,18 @@
 #include "linux/mm.h"
 #include "asm/page.h"
 #include "asm/pgalloc.h"
+#include "asm/pgtable.h"
 #include "asm/tlbflush.h"
 #include "choose-mode.h"
 #include "mode_kern.h"
-#include "user_util.h"
+#include "as-layout.h"
 #include "tlb.h"
 #include "mem.h"
 #include "mem_user.h"
 #include "os.h"
 
 static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
-                    int r, int w, int x, struct host_vm_op *ops, int *index,
+                    unsigned int prot, struct host_vm_op *ops, int *index,
                     int last_filled, union mm_context *mmu, void **flush,
                     int (*do_ops)(union mm_context *, struct host_vm_op *,
                                   int, int, void **))
@@ -30,8 +31,7 @@ static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
                 last = &ops[*index];
                 if((last->type == MMAP) &&
                    (last->u.mmap.addr + last->u.mmap.len == virt) &&
-                   (last->u.mmap.r == r) && (last->u.mmap.w == w) &&
-                   (last->u.mmap.x == x) && (last->u.mmap.fd == fd) &&
+                   (last->u.mmap.prot == prot) && (last->u.mmap.fd == fd) &&
                    (last->u.mmap.offset + last->u.mmap.len == offset)){
                         last->u.mmap.len += len;
                         return 0;
@@ -47,9 +47,7 @@ static int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
                                                 .u = { .mmap = {
                                                        .addr    = virt,
                                                        .len     = len,
-                                                       .r       = r,
-                                                       .w       = w,
-                                                       .x       = x,
+                                                       .prot    = prot,
                                                        .fd      = fd,
                                                        .offset  = offset }
                            } });
@@ -86,8 +84,8 @@ static int add_munmap(unsigned long addr, unsigned long len,
         return ret;
 }
 
-static int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
-                        int x, struct host_vm_op *ops, int *index,
+static int add_mprotect(unsigned long addr, unsigned long len,
+                        unsigned int prot, struct host_vm_op *ops, int *index,
                         int last_filled, union mm_context *mmu, void **flush,
                         int (*do_ops)(union mm_context *, struct host_vm_op *,
                                       int, int, void **))
@@ -99,8 +97,7 @@ static int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
                 last = &ops[*index];
                 if((last->type == MPROTECT) &&
                    (last->u.mprotect.addr + last->u.mprotect.len == addr) &&
-                   (last->u.mprotect.r == r) && (last->u.mprotect.w == w) &&
-                   (last->u.mprotect.x == x)){
+                   (last->u.mprotect.prot == prot)){
                         last->u.mprotect.len += len;
                         return 0;
                 }
@@ -115,114 +112,145 @@ static int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
                                                .u = { .mprotect = {
                                                        .addr    = addr,
                                                        .len     = len,
-                                                       .r       = r,
-                                                       .w       = w,
-                                                       .x       = x } } });
+                                                       .prot    = prot } } });
         return ret;
 }
 
 #define ADD_ROUND(n, inc) (((n) + (inc)) & ~((inc) - 1))
 
+static inline int update_pte_range(pmd_t *pmd, unsigned long addr,
+                                   unsigned long end, struct host_vm_op *ops,
+                                   int last_op, int *op_index, int force,
+                                   union mm_context *mmu, void **flush,
+                                   int (*do_ops)(union mm_context *,
+                                                 struct host_vm_op *, int, int,
+                                                 void **))
+{
+        pte_t *pte;
+        int r, w, x, prot, ret = 0;
+
+        pte = pte_offset_kernel(pmd, addr);
+        do {
+                r = pte_read(*pte);
+                w = pte_write(*pte);
+                x = pte_exec(*pte);
+                if (!pte_young(*pte)) {
+                        r = 0;
+                        w = 0;
+                } else if (!pte_dirty(*pte)) {
+                        w = 0;
+                }
+                prot = ((r ? UM_PROT_READ : 0) | (w ? UM_PROT_WRITE : 0) |
+                        (x ? UM_PROT_EXEC : 0));
+                if(force || pte_newpage(*pte)){
+                        if(pte_present(*pte))
+                                ret = add_mmap(addr, pte_val(*pte) & PAGE_MASK,
+                                               PAGE_SIZE, prot, ops, op_index,
+                                               last_op, mmu, flush, do_ops);
+                        else ret = add_munmap(addr, PAGE_SIZE, ops, op_index,
+                                              last_op, mmu, flush, do_ops);
+                }
+                else if(pte_newprot(*pte))
+                        ret = add_mprotect(addr, PAGE_SIZE, prot, ops, op_index,
+                                           last_op, mmu, flush, do_ops);
+                *pte = pte_mkuptodate(*pte);
+        } while (pte++, addr += PAGE_SIZE, ((addr != end) && !ret));
+        return ret;
+}
+
+static inline int update_pmd_range(pud_t *pud, unsigned long addr,
+                                   unsigned long end, struct host_vm_op *ops,
+                                   int last_op, int *op_index, int force,
+                                   union mm_context *mmu, void **flush,
+                                   int (*do_ops)(union mm_context *,
+                                                 struct host_vm_op *, int, int,
+                                                 void **))
+{
+        pmd_t *pmd;
+        unsigned long next;
+        int ret = 0;
+
+        pmd = pmd_offset(pud, addr);
+        do {
+                next = pmd_addr_end(addr, end);
+                if(!pmd_present(*pmd)){
+                        if(force || pmd_newpage(*pmd)){
+                                ret = add_munmap(addr, next - addr, ops,
+                                                 op_index, last_op, mmu,
+                                                 flush, do_ops);
+                                pmd_mkuptodate(*pmd);
+                        }
+                }
+                else ret = update_pte_range(pmd, addr, next, ops, last_op,
+                                            op_index, force, mmu, flush,
+                                            do_ops);
+        } while (pmd++, addr = next, ((addr != end) && !ret));
+        return ret;
+}
+
+static inline int update_pud_range(pgd_t *pgd, unsigned long addr,
+                                   unsigned long end, struct host_vm_op *ops,
+                                   int last_op, int *op_index, int force,
+                                   union mm_context *mmu, void **flush,
+                                   int (*do_ops)(union mm_context *,
+                                                 struct host_vm_op *, int, int,
+                                                 void **))
+{
+        pud_t *pud;
+        unsigned long next;
+        int ret = 0;
+
+        pud = pud_offset(pgd, addr);
+        do {
+                next = pud_addr_end(addr, end);
+                if(!pud_present(*pud)){
+                        if(force || pud_newpage(*pud)){
+                                ret = add_munmap(addr, next - addr, ops,
+                                                 op_index, last_op, mmu,
+                                                 flush, do_ops);
+                                pud_mkuptodate(*pud);
+                        }
+                }
+                else ret = update_pmd_range(pud, addr, next, ops, last_op,
+                                            op_index, force, mmu, flush,
+                                            do_ops);
+        } while (pud++, addr = next, ((addr != end) && !ret));
+        return ret;
+}
+
 void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
                       unsigned long end_addr, int force,
                       int (*do_ops)(union mm_context *, struct host_vm_op *,
                                     int, int, void **))
 {
-        pgd_t *npgd;
-        pud_t *npud;
-        pmd_t *npmd;
-        pte_t *npte;
+        pgd_t *pgd;
         union mm_context *mmu = &mm->context;
-        unsigned long addr, end;
-        int r, w, x;
         struct host_vm_op ops[1];
+        unsigned long addr = start_addr, next;
+        int ret = 0, last_op = ARRAY_SIZE(ops) - 1, op_index = -1;
         void *flush = NULL;
-        int op_index = -1, last_op = ARRAY_SIZE(ops) - 1;
-        int ret = 0;
-
-        if(mm == NULL)
-                return;
 
         ops[0].type = NONE;
-        for(addr = start_addr; addr < end_addr && !ret;){
-                npgd = pgd_offset(mm, addr);
-                if(!pgd_present(*npgd)){
-                        end = ADD_ROUND(addr, PGDIR_SIZE);
-                        if(end > end_addr)
-                                end = end_addr;
-                        if(force || pgd_newpage(*npgd)){
-                                ret = add_munmap(addr, end - addr, ops,
-                                                 &op_index, last_op, mmu,
-                                                 &flush, do_ops);
-                                pgd_mkuptodate(*npgd);
-                        }
-                        addr = end;
-                        continue;
-                }
-
-                npud = pud_offset(npgd, addr);
-                if(!pud_present(*npud)){
-                        end = ADD_ROUND(addr, PUD_SIZE);
-                        if(end > end_addr)
-                                end = end_addr;
-                        if(force || pud_newpage(*npud)){
-                                ret = add_munmap(addr, end - addr, ops,
-                                                 &op_index, last_op, mmu,
-                                                 &flush, do_ops);
-                                pud_mkuptodate(*npud);
-                        }
-                        addr = end;
-                        continue;
-                }
-
-                npmd = pmd_offset(npud, addr);
-                if(!pmd_present(*npmd)){
-                        end = ADD_ROUND(addr, PMD_SIZE);
-                        if(end > end_addr)
-                                end = end_addr;
-                        if(force || pmd_newpage(*npmd)){
-                                ret = add_munmap(addr, end - addr, ops,
+        pgd = pgd_offset(mm, addr);
+        do {
+                next = pgd_addr_end(addr, end_addr);
+                if(!pgd_present(*pgd)){
+                        if (force || pgd_newpage(*pgd)){
+                                ret = add_munmap(addr, next - addr, ops,
                                                  &op_index, last_op, mmu,
                                                  &flush, do_ops);
-                                pmd_mkuptodate(*npmd);
+                                pgd_mkuptodate(*pgd);
                         }
-                        addr = end;
-                        continue;
-                }
-
-                npte = pte_offset_kernel(npmd, addr);
-                r = pte_read(*npte);
-                w = pte_write(*npte);
-                x = pte_exec(*npte);
-                if (!pte_young(*npte)) {
-                        r = 0;
-                        w = 0;
-                } else if (!pte_dirty(*npte)) {
-                        w = 0;
-                }
-                if(force || pte_newpage(*npte)){
-                        if(pte_present(*npte))
-                                ret = add_mmap(addr,
-                                               pte_val(*npte) & PAGE_MASK,
-                                               PAGE_SIZE, r, w, x, ops,
-                                               &op_index, last_op, mmu,
-                                               &flush, do_ops);
-                        else ret = add_munmap(addr, PAGE_SIZE, ops,
-                                              &op_index, last_op, mmu,
-                                              &flush, do_ops);
                 }
-                else if(pte_newprot(*npte))
-                        ret = add_mprotect(addr, PAGE_SIZE, r, w, x, ops,
-                                           &op_index, last_op, mmu,
-                                           &flush, do_ops);
+                else ret = update_pud_range(pgd, addr, next, ops, last_op,
+                                            &op_index, force, mmu, &flush,
+                                            do_ops);
+        } while (pgd++, addr = next, ((addr != end_addr) && !ret));
 
-                *npte = pte_mkuptodate(*npte);
-                addr += PAGE_SIZE;
-        }
         if(!ret)
                 ret = (*do_ops)(mmu, ops, op_index, 1, &flush);
 
-/* This is not an else because ret is modified above */
+        /* This is not an else because ret is modified above */
         if(ret) {
                 printk("fix_range_common: failed, killing current process\n");
                 force_sig(SIGKILL, current);
@@ -343,12 +371,6 @@ pte_t *addr_pte(struct task_struct *task, unsigned long addr)
         return(pte_offset_map(pmd, addr));
 }
 
-void flush_tlb_page(struct vm_area_struct *vma, unsigned long address)
-{
-        address &= PAGE_MASK;
-        flush_tlb_range(vma, address, address + PAGE_SIZE);
-}
-
 void flush_tlb_all(void)
 {
         flush_tlb_mm(current->mm);
diff --git a/arch/um/kernel/trap.c b/arch/um/kernel/trap.c
index 26f15c458574..abab90c3803f 100644
--- a/arch/um/kernel/trap.c
+++ b/arch/um/kernel/trap.c
@@ -18,8 +18,9 @@
 #include "asm/current.h"
 #include "asm/irq.h"
 #include "sysdep/sigcontext.h"
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
+#include "arch.h"
 #include "kern.h"
 #include "chan_kern.h"
 #include "mconsole_kern.h"
@@ -71,8 +72,8 @@ good_area:
                 goto out;
 
         /* Don't require VM_READ|VM_EXEC for write faults! */
-        if(!is_write && !(vma->vm_flags & (VM_READ | VM_EXEC)))
-                goto out;
+        if(!is_write && !(vma->vm_flags & (VM_READ | VM_EXEC)))
+                goto out;
 
         do {
 survive:
@@ -156,20 +157,23 @@ static void segv_handler(int sig, union uml_pt_regs *regs)
  * the info in the regs. A pointer to the info then would
  * give us bad data!
  */
-unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, void *sc)
+unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user,
+                   union uml_pt_regs *regs)
 {
         struct siginfo si;
         void *catcher;
         int err;
-        int is_write = FAULT_WRITE(fi);
-        unsigned long address = FAULT_ADDRESS(fi);
+        int is_write = FAULT_WRITE(fi);
+        unsigned long address = FAULT_ADDRESS(fi);
 
-        if(!is_user && (address >= start_vm) && (address < end_vm)){
-                flush_tlb_kernel_vm();
-                return(0);
-        }
-        else if(current->mm == NULL)
-                panic("Segfault with no mm");
+        if(!is_user && (address >= start_vm) && (address < end_vm)){
+                flush_tlb_kernel_vm();
+                return 0;
+        }
+        else if(current->mm == NULL) {
+                show_regs(container_of(regs, struct pt_regs, regs));
+                panic("Segfault with no mm");
+        }
 
         if (SEGV_IS_FIXABLE(&fi) || SEGV_MAYBE_FIXABLE(&fi))
                 err = handle_page_fault(address, ip, is_write, is_user, &si.si_code);
@@ -182,26 +186,28 @@ unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, void *sc)
 
         catcher = current->thread.fault_catcher;
         if(!err)
-                return(0);
+                return 0;
         else if(catcher != NULL){
                 current->thread.fault_addr = (void *) address;
                 do_longjmp(catcher, 1);
         }
         else if(current->thread.fault_addr != NULL)
                 panic("fault_addr set but no fault catcher");
-        else if(!is_user && arch_fixup(ip, sc))
-                return(0);
+        else if(!is_user && arch_fixup(ip, regs))
+                return 0;
 
-        if(!is_user)
+        if(!is_user) {
+                show_regs(container_of(regs, struct pt_regs, regs));
                 panic("Kernel mode fault at addr 0x%lx, ip 0x%lx",
                       address, ip);
+        }
 
         if (err == -EACCES) {
                 si.si_signo = SIGBUS;
                 si.si_errno = 0;
                 si.si_code = BUS_ADRERR;
                 si.si_addr = (void __user *)address;
-                current->thread.arch.faultinfo = fi;
+                current->thread.arch.faultinfo = fi;
                 force_sig_info(SIGBUS, &si, current);
         } else if (err == -ENOMEM) {
                 printk("VM: killing process %s\n", current->comm);
@@ -210,10 +216,10 @@ unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user, void *sc)
                 BUG_ON(err != -EFAULT);
                 si.si_signo = SIGSEGV;
                 si.si_addr = (void __user *) address;
-                current->thread.arch.faultinfo = fi;
+                current->thread.arch.faultinfo = fi;
                 force_sig_info(SIGSEGV, &si, current);
         }
-        return(0);
+        return 0;
 }
 
 void relay_signal(int sig, union uml_pt_regs *regs)
@@ -223,12 +229,12 @@ void relay_signal(int sig, union uml_pt_regs *regs)
 
         if(!UPT_IS_USER(regs)){
                 if(sig == SIGBUS)
-                        printk("Bus error - the /dev/shm or /tmp mount likely "
-                               "just ran out of space\n");
+                        printk("Bus error - the host /dev/shm or /tmp mount "
+                               "likely just ran out of space\n");
                 panic("Kernel mode signal %d", sig);
         }
 
-        current->thread.arch.faultinfo = *UPT_FAULTINFO(regs);
+        current->thread.arch.faultinfo = *UPT_FAULTINFO(regs);
         force_sig(sig, current);
 }
 
diff --git a/arch/um/kernel/tt/exec_kern.c b/arch/um/kernel/tt/exec_kern.c
index ad66df17d9d7..98e21743e604 100644
--- a/arch/um/kernel/tt/exec_kern.c
+++ b/arch/um/kernel/tt/exec_kern.c
@@ -10,7 +10,6 @@
 #include "asm/uaccess.h"
 #include "asm/pgalloc.h"
 #include "asm/tlbflush.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "irq_user.h"
 #include "mem_user.h"
diff --git a/arch/um/kernel/tt/exec_user.c b/arch/um/kernel/tt/exec_user.c
index a92c02ff2ce3..7b5f2181cf51 100644
--- a/arch/um/kernel/tt/exec_user.c
+++ b/arch/um/kernel/tt/exec_user.c
@@ -10,7 +10,6 @@
 #include <errno.h>
 #include <sys/wait.h>
 #include <signal.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "ptrace_user.h"
diff --git a/arch/um/kernel/tt/gdb.c b/arch/um/kernel/tt/gdb.c
index 8eba8f7dca68..030e4658f36b 100644
--- a/arch/um/kernel/tt/gdb.c
+++ b/arch/um/kernel/tt/gdb.c
@@ -17,7 +17,6 @@
 #include "user.h"
 #include "debug.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "tt.h"
 #include "sysdep/thread.h"
 #include "os.h"
@@ -115,6 +114,8 @@ struct gdb_data {
         int err;
 };
 
+extern char *linux_prog;
+
 static void config_gdb_cb(void *arg)
 {
         struct gdb_data *data = arg;
diff --git a/arch/um/kernel/tt/include/mode_kern-tt.h b/arch/um/kernel/tt/include/mode_kern-tt.h
deleted file mode 100644
index 2a35b15c5fef..000000000000
--- a/arch/um/kernel/tt/include/mode_kern-tt.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __TT_MODE_KERN_H__
-#define __TT_MODE_KERN_H__
-
-#include "linux/sched.h"
-#include "asm/page.h"
-#include "asm/ptrace.h"
-#include "asm/uaccess.h"
-
-extern void switch_to_tt(void *prev, void *next);
-extern void flush_thread_tt(void);
-extern void start_thread_tt(struct pt_regs *regs, unsigned long eip,
-                           unsigned long esp);
-extern int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
-                          unsigned long stack_top, struct task_struct *p,
-                          struct pt_regs *regs);
-extern void release_thread_tt(struct task_struct *task);
-extern void initial_thread_cb_tt(void (*proc)(void *), void *arg);
-extern void init_idle_tt(void);
-extern void flush_tlb_kernel_range_tt(unsigned long start, unsigned long end);
-extern void flush_tlb_kernel_vm_tt(void);
-extern void __flush_tlb_one_tt(unsigned long addr);
-extern void flush_tlb_range_tt(struct vm_area_struct *vma,
-                               unsigned long start, unsigned long end);
-extern void flush_tlb_mm_tt(struct mm_struct *mm);
-extern void force_flush_all_tt(void);
-extern long execute_syscall_tt(void *r);
-extern void before_mem_tt(unsigned long brk_start);
-extern unsigned long set_task_sizes_tt(int arg, unsigned long *host_size_out,
-                                       unsigned long *task_size_out);
-extern int start_uml_tt(void);
-extern int external_pid_tt(struct task_struct *task);
-extern int thread_pid_tt(struct task_struct *task);
-
-#define kmem_end_tt (host_task_size - ABOVE_KMEM)
-
-#endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/tt/mem.c b/arch/um/kernel/tt/mem.c
index 4d1929dfa285..d0c3c4975f28 100644
--- a/arch/um/kernel/tt/mem.c
+++ b/arch/um/kernel/tt/mem.c
@@ -8,7 +8,6 @@
 #include "asm/uaccess.h"
 #include "mem_user.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "kern.h"
 #include "tt.h"
 
diff --git a/arch/um/kernel/tt/mem_user.c b/arch/um/kernel/tt/mem_user.c
index 03e589895388..9774f6360c32 100644
--- a/arch/um/kernel/tt/mem_user.c
+++ b/arch/um/kernel/tt/mem_user.c
@@ -11,7 +11,6 @@
 #include <sys/mman.h>
 #include "tt.h"
 #include "mem_user.h"
-#include "user_util.h"
 #include "os.h"
 
 void remap_data(void *segment_start, void *segment_end, int w)
diff --git a/arch/um/kernel/tt/process_kern.c b/arch/um/kernel/tt/process_kern.c
index 1e86f0bfef72..c631303cb800 100644
--- a/arch/um/kernel/tt/process_kern.c
+++ b/arch/um/kernel/tt/process_kern.c
@@ -14,7 +14,6 @@
 #include "asm/tlbflush.h"
 #include "irq_user.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "os.h"
 #include "kern.h"
 #include "sigcontext.h"
@@ -65,7 +64,8 @@ void switch_to_tt(void *prev, void *next)
         if(from->thread.mode.tt.switch_pipe[0] == -1)
                 os_kill_process(os_getpid(), 0);
 
-        err = os_read_file(from->thread.mode.tt.switch_pipe[0], &c, sizeof(c));
+        err = os_read_file(from->thread.mode.tt.switch_pipe[0], &c,
+                             sizeof(c));
         if(err != sizeof(c))
                 panic("read of switch_pipe failed, errno = %d", -err);
 
diff --git a/arch/um/kernel/tt/ptproxy/proxy.c b/arch/um/kernel/tt/ptproxy/proxy.c
index 58800c50b10e..420c23f311f3 100644
--- a/arch/um/kernel/tt/ptproxy/proxy.c
+++ b/arch/um/kernel/tt/ptproxy/proxy.c
@@ -26,7 +26,6 @@ Jeff Dike (jdike@karaya.com) : Modified for integration into uml
 #include "sysdep.h"
 #include "wait.h"
 
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 #include "tempfile.h"
@@ -339,11 +338,12 @@ int start_debugger(char *prog, int startup, int stop, int *fd_out)
                                "err = %d\n", -fd);
                         exit(1);
                 }
-                os_write_file(fd, gdb_init_string, sizeof(gdb_init_string) - 1);
+                os_write_file(fd, gdb_init_string,
+                              sizeof(gdb_init_string) - 1);
                 if(startup){
                         if(stop){
                                 os_write_file(fd, "b start_kernel\n",
-                                      strlen("b start_kernel\n"));
+                                                strlen("b start_kernel\n"));
                         }
                         os_write_file(fd, "c\n", strlen("c\n"));
                 }
diff --git a/arch/um/kernel/tt/ptproxy/ptrace.c b/arch/um/kernel/tt/ptproxy/ptrace.c
index 03774427d468..4b4f6179b212 100644
--- a/arch/um/kernel/tt/ptproxy/ptrace.c
+++ b/arch/um/kernel/tt/ptproxy/ptrace.c
@@ -16,7 +16,6 @@ Jeff Dike (jdike@karaya.com) : Modified for integration into uml
 
 #include "ptproxy.h"
 #include "debug.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "ptrace_user.h"
 #include "tt.h"
diff --git a/arch/um/kernel/tt/ptproxy/sysdep.c b/arch/um/kernel/tt/ptproxy/sysdep.c
index 99f178319d03..e0e1ab0588ad 100644
--- a/arch/um/kernel/tt/ptproxy/sysdep.c
+++ b/arch/um/kernel/tt/ptproxy/sysdep.c
@@ -13,7 +13,6 @@ terms and conditions.
 #include <sys/types.h>
 #include <linux/unistd.h>
 #include "ptrace_user.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 
diff --git a/arch/um/kernel/tt/ptproxy/wait.c b/arch/um/kernel/tt/ptproxy/wait.c
index 12f6319d8d76..bdd4af4b65fc 100644
--- a/arch/um/kernel/tt/ptproxy/wait.c
+++ b/arch/um/kernel/tt/ptproxy/wait.c
@@ -13,7 +13,6 @@ terms and conditions.
 #include "ptproxy.h"
 #include "sysdep.h"
 #include "wait.h"
-#include "user_util.h"
 #include "ptrace_user.h"
 #include "sysdep/ptrace.h"
 #include "sysdep/sigcontext.h"
diff --git a/arch/um/kernel/tt/syscall_user.c b/arch/um/kernel/tt/syscall_user.c
index 902987bf379b..f52b47aff1d2 100644
--- a/arch/um/kernel/tt/syscall_user.c
+++ b/arch/um/kernel/tt/syscall_user.c
@@ -11,7 +11,6 @@
 #include "sigcontext.h"
 #include "ptrace_user.h"
 #include "task.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "syscall.h"
 #include "tt.h"
diff --git a/arch/um/kernel/tt/tlb.c b/arch/um/kernel/tt/tlb.c
index ae6217c86135..7caa24fe05df 100644
--- a/arch/um/kernel/tt/tlb.c
+++ b/arch/um/kernel/tt/tlb.c
@@ -12,7 +12,6 @@
 #include "asm/pgtable.h"
 #include "asm/uaccess.h"
 #include "asm/tlbflush.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "os.h"
 #include "tlb.h"
diff --git a/arch/um/kernel/tt/tracer.c b/arch/um/kernel/tt/tracer.c
index b9195355075a..c23588393f6e 100644
--- a/arch/um/kernel/tt/tracer.c
+++ b/arch/um/kernel/tt/tracer.c
@@ -19,7 +19,6 @@
 #include "sigcontext.h"
 #include "sysdep/sigcontext.h"
 #include "os.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "process.h"
 #include "kern_util.h"
diff --git a/arch/um/kernel/tt/trap_user.c b/arch/um/kernel/tt/trap_user.c
index b5d9d64d91e4..3032eb5e2467 100644
--- a/arch/um/kernel/tt/trap_user.c
+++ b/arch/um/kernel/tt/trap_user.c
@@ -8,7 +8,6 @@
 #include <signal.h>
 #include "sysdep/ptrace.h"
 #include "sysdep/sigcontext.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "task.h"
 #include "tt.h"
diff --git a/arch/um/kernel/tt/uaccess_user.c b/arch/um/kernel/tt/uaccess_user.c
index ed1abcf4d057..0e5c82c5e5b7 100644
--- a/arch/um/kernel/tt/uaccess_user.c
+++ b/arch/um/kernel/tt/uaccess_user.c
@@ -5,7 +5,6 @@
  */
 
 #include <string.h>
-#include "user_util.h"
 #include "uml_uaccess.h"
 #include "task.h"
 #include "kern_util.h"
diff --git a/arch/um/kernel/um_arch.c b/arch/um/kernel/um_arch.c
index 89c6dba731f8..1cf954a47fd7 100644
--- a/arch/um/kernel/um_arch.c
+++ b/arch/um/kernel/um_arch.c
@@ -17,6 +17,7 @@
 #include "linux/seq_file.h"
 #include "linux/delay.h"
 #include "linux/module.h"
+#include "linux/utsname.h"
 #include "asm/page.h"
 #include "asm/pgtable.h"
 #include "asm/ptrace.h"
@@ -25,8 +26,9 @@
 #include "asm/setup.h"
 #include "ubd_user.h"
 #include "asm/current.h"
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
+#include "arch.h"
 #include "kern.h"
 #include "mem_user.h"
 #include "mem.h"
@@ -42,7 +44,7 @@
 
 #define DEFAULT_COMMAND_LINE "root=98:0"
 
-/* Changed in linux_main and setup_arch, which run before SMP is started */
+/* Changed in add_arg and setup_arch, which run before SMP is started */
 static char __initdata command_line[COMMAND_LINE_SIZE] = { 0 };
 
 static void __init add_arg(char *arg)
@@ -56,17 +58,25 @@ static void __init add_arg(char *arg)
         strcat(command_line, arg);
 }
 
-struct cpuinfo_um boot_cpu_data = { 
+/*
+ * These fields are initialized at boot time and not changed.
+ * XXX This structure is used only in the non-SMP case.  Maybe this
+ * should be moved to smp.c.
+ */
+struct cpuinfo_um boot_cpu_data = {
         .loops_per_jiffy        = 0,
         .ipi_pipe               = { -1, -1 }
 };
 
 unsigned long thread_saved_pc(struct task_struct *task)
 {
-        return(os_process_pc(CHOOSE_MODE_PROC(thread_pid_tt, thread_pid_skas,
-                                              task)));
+        return os_process_pc(CHOOSE_MODE_PROC(thread_pid_tt, thread_pid_skas,
+                                              task));
 }
 
+/* Changed in setup_arch, which is called in early boot */
+static char host_info[(__NEW_UTS_LEN + 1) * 5];
+
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
         int index = 0;
@@ -86,7 +96,7 @@ static int show_cpuinfo(struct seq_file *m, void *v)
                    loops_per_jiffy/(500000/HZ),
                    (loops_per_jiffy/(5000/HZ)) % 100);
 
-        return(0);
+        return 0;
 }
 
 static void *c_start(struct seq_file *m, loff_t *pos)
@@ -114,14 +124,12 @@ const struct seq_operations cpuinfo_op = {
 /* Set in linux_main */
 unsigned long host_task_size;
 unsigned long task_size;
-
-unsigned long uml_start;
-
-/* Set in early boot */
 unsigned long uml_physmem;
-unsigned long uml_reserved;
+unsigned long uml_reserved; /* Also modified in mem_init */
 unsigned long start_vm;
 unsigned long end_vm;
+
+/* Set in uml_ncpus_setup */
 int ncpus = 1;
 
 #ifdef CONFIG_CMDLINE_ON_HOST
@@ -135,6 +143,8 @@ static char *argv1_end = NULL;
 
 /* Set in early boot */
 static int have_root __initdata = 0;
+
+/* Set in uml_mem_setup and modified in linux_main */
 long long physmem_size = 32 * 1024 * 1024;
 
 void set_cmdline(char *cmd)
@@ -212,12 +222,12 @@ __uml_setup("debug", no_skas_debug_setup,
 #ifdef CONFIG_SMP
 static int __init uml_ncpus_setup(char *line, int *add)
 {
-       if (!sscanf(line, "%d", &ncpus)) {
-               printf("Couldn't parse [%s]\n", line);
-               return -1;
-       }
+        if (!sscanf(line, "%d", &ncpus)) {
+                printf("Couldn't parse [%s]\n", line);
+                return -1;
+        }
 
-       return 0;
+        return 0;
 }
 
 __uml_setup("ncpus=", uml_ncpus_setup,
@@ -234,7 +244,7 @@ static int force_tt = 0;
 static int __init mode_tt_setup(char *line, int *add)
 {
         force_tt = 1;
-        return(0);
+        return 0;
 }
 
 #else
@@ -245,7 +255,7 @@ static int __init mode_tt_setup(char *line, int *add)
 static int __init mode_tt_setup(char *line, int *add)
 {
         printf("CONFIG_MODE_TT disabled - 'mode=tt' ignored\n");
-        return(0);
+        return 0;
 }
 
 #else
@@ -256,7 +266,7 @@ static int __init mode_tt_setup(char *line, int *add)
 static int __init mode_tt_setup(char *line, int *add)
 {
         printf("CONFIG_MODE_SKAS disabled - 'mode=tt' redundant\n");
-        return(0);
+        return 0;
 }
 
 #endif
@@ -274,16 +284,15 @@ int mode_tt = DEFAULT_TT;
 
 static int __init Usage(char *line, int *add)
 {
-        const char **p;
+        const char **p;
 
         printf(usage_string, init_utsname()->release);
-        p = &__uml_help_start;
-        while (p < &__uml_help_end) {
-                printf("%s", *p);
-                p++;
-        }
+        p = &__uml_help_start;
+        while (p < &__uml_help_end) {
+                printf("%s", *p);
+                p++;
+        }
         exit(0);
-
         return 0;
 }
 
@@ -374,13 +383,12 @@ int __init linux_main(int argc, char **argv)
 
         printf("UML running in %s mode\n", mode);
 
-        uml_start = (unsigned long) &__binary_start;
         host_task_size = CHOOSE_MODE_PROC(set_task_sizes_tt,
                                           set_task_sizes_skas, &task_size);
 
         /*
-         * Setting up handlers to 'sig_info' struct
-         */
+         * Setting up handlers to 'sig_info' struct
+         */
         os_fill_handlinfo(handlinfo_kern);
 
         brk_start = (unsigned long) sbrk(0);
@@ -396,7 +404,7 @@ int __init linux_main(int argc, char **argv)
                 physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
         }
 
-        uml_physmem = uml_start & PAGE_MASK;
+        uml_physmem = (unsigned long) &__binary_start & PAGE_MASK;
 
         /* Reserve up to 4M after the current brk */
         uml_reserved = ROUND_4M(brk_start) + (1 << 22);
@@ -407,7 +415,7 @@ int __init linux_main(int argc, char **argv)
         argv1_begin = argv[1];
         argv1_end = &argv[1][strlen(argv[1])];
 #endif
-  
+
         highmem = 0;
         iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
         max_physmem = get_kmem_end() - uml_physmem - iomem_size - MIN_VMALLOC;
@@ -449,12 +457,12 @@ int __init linux_main(int argc, char **argv)
                 printf("Kernel virtual memory size shrunk to %lu bytes\n",
                        virtmem_size);
 
-        uml_postsetup();
+        uml_postsetup();
 
         task_protections((unsigned long) &init_thread_info);
         os_flush_stdout();
 
-        return(CHOOSE_MODE(start_uml_tt(), start_uml_skas()));
+        return CHOOSE_MODE(start_uml_tt(), start_uml_skas());
 }
 
 extern int uml_exitcode;
@@ -466,8 +474,8 @@ static int panic_exit(struct notifier_block *self, unsigned long unused1,
         show_regs(&(current->thread.regs));
         bust_spinlocks(0);
         uml_exitcode = 1;
-        machine_halt();
-        return(0);
+        os_dump_core();
+        return 0;
 }
 
 static struct notifier_block panic_exit_notifier = {
@@ -482,14 +490,14 @@ void __init setup_arch(char **cmdline_p)
                         &panic_exit_notifier);
         paging_init();
         strlcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
-        *cmdline_p = command_line;
-        setup_hostinfo();
+        *cmdline_p = command_line;
+        setup_hostinfo(host_info, sizeof host_info);
 }
 
 void __init check_bugs(void)
 {
         arch_check_bugs();
-        os_check_bugs();
+        os_check_bugs();
 }
 
 void apply_alternatives(struct alt_instr *start, struct alt_instr *end)
diff --git a/arch/um/os-Linux/aio.c b/arch/um/os-Linux/aio.c
index 6ff12743a0bd..9bf944f6a1db 100644
--- a/arch/um/os-Linux/aio.c
+++ b/arch/um/os-Linux/aio.c
@@ -132,10 +132,10 @@ static int aio_thread(void *arg)
                                 { .data = (void *) (long) event.data,
                                                 .err    = event.res });
                         reply_fd = ((struct aio_context *) reply.data)->reply_fd;
-                        err = os_write_file(reply_fd, &reply, sizeof(reply));
+                        err = write(reply_fd, &reply, sizeof(reply));
                         if(err != sizeof(reply))
                                 printk("aio_thread - write failed, fd = %d, "
-                                       "err = %d\n", reply_fd, -err);
+                                       "err = %d\n", reply_fd, errno);
                 }
         }
         return 0;
@@ -146,38 +146,31 @@ static int aio_thread(void *arg)
 static int do_not_aio(struct aio_thread_req *req)
 {
         char c;
-        int err;
+        unsigned long long actual;
+        int n;
+
+        actual = lseek64(req->io_fd, req->offset, SEEK_SET);
+        if(actual != req->offset)
+                return -errno;
 
         switch(req->type){
         case AIO_READ:
-                err = os_seek_file(req->io_fd, req->offset);
-                if(err)
-                        goto out;
-
-                err = os_read_file(req->io_fd, req->buf, req->len);
+                n = read(req->io_fd, req->buf, req->len);
                 break;
         case AIO_WRITE:
-                err = os_seek_file(req->io_fd, req->offset);
-                if(err)
-                        goto out;
-
-                err = os_write_file(req->io_fd, req->buf, req->len);
+                n = write(req->io_fd, req->buf, req->len);
                 break;
         case AIO_MMAP:
-                err = os_seek_file(req->io_fd, req->offset);
-                if(err)
-                        goto out;
-
-                err = os_read_file(req->io_fd, &c, sizeof(c));
+                n = read(req->io_fd, &c, sizeof(c));
                 break;
         default:
                 printk("do_not_aio - bad request type : %d\n", req->type);
-                err = -EINVAL;
-                break;
+                return -EINVAL;
         }
 
-out:
-        return err;
+        if(n < 0)
+                return -errno;
+        return 0;
 }
 
 /* These are initialized in initcalls and not changed */
@@ -193,12 +186,12 @@ static int not_aio_thread(void *arg)
 
         signal(SIGWINCH, SIG_IGN);
         while(1){
-                err = os_read_file(aio_req_fd_r, &req, sizeof(req));
+                err = read(aio_req_fd_r, &req, sizeof(req));
                 if(err != sizeof(req)){
                         if(err < 0)
                                 printk("not_aio_thread - read failed, "
                                        "fd = %d, err = %d\n", aio_req_fd_r,
-                                       -err);
+                                       errno);
                         else {
                                 printk("not_aio_thread - short read, fd = %d, "
                                        "length = %d\n", aio_req_fd_r, err);
@@ -207,11 +200,11 @@ static int not_aio_thread(void *arg)
                 }
                 err = do_not_aio(&req);
                 reply = ((struct aio_thread_reply) { .data      = req.aio,
-                                         .err   = err });
-                err = os_write_file(req.aio->reply_fd, &reply, sizeof(reply));
+                                                     .err       = err });
+                err = write(req.aio->reply_fd, &reply, sizeof(reply));
                 if(err != sizeof(reply))
                         printk("not_aio_thread - write failed, fd = %d, "
-                               "err = %d\n", req.aio->reply_fd, -err);
+                               "err = %d\n", req.aio->reply_fd, errno);
         }
 
         return 0;
@@ -228,6 +221,11 @@ static int init_aio_24(void)
 
         aio_req_fd_w = fds[0];
         aio_req_fd_r = fds[1];
+
+        err = os_set_fd_block(aio_req_fd_w, 0);
+        if(err)
+                goto out_close_pipe;
+
         err = run_helper_thread(not_aio_thread, NULL,
                                 CLONE_FILES | CLONE_VM | SIGCHLD, &stack, 0);
         if(err < 0)
@@ -285,10 +283,12 @@ static int submit_aio_26(enum aio_type type, int io_fd, char *buf, int len,
         if(err){
                 reply = ((struct aio_thread_reply) { .data = aio,
                                          .err  = err });
-                err = os_write_file(aio->reply_fd, &reply, sizeof(reply));
-                if(err != sizeof(reply))
+                err = write(aio->reply_fd, &reply, sizeof(reply));
+                if(err != sizeof(reply)){
+                        err = -errno;
                         printk("submit_aio_26 - write failed, "
                                "fd = %d, err = %d\n", aio->reply_fd, -err);
+                }
                 else err = 0;
         }
 
@@ -383,9 +383,10 @@ static int submit_aio_24(enum aio_type type, int io_fd, char *buf, int len,
         };
         int err;
 
-        err = os_write_file(aio_req_fd_w, &req, sizeof(req));
+        err = write(aio_req_fd_w, &req, sizeof(req));
         if(err == sizeof(req))
                 err = 0;
+        else err = -errno;
 
         return err;
 }
diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
index 863981ba1468..acba30161287 100644
--- a/arch/um/os-Linux/drivers/ethertap_user.c
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
  * James Leu (jleu@mindspring.net).
  * Copyright (C) 2001 by various other people who didn't put their name here.
  * Licensed under the GPL.
@@ -16,19 +16,20 @@
 #include <net/if.h>
 #include "user.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "net_user.h"
 #include "etap.h"
 #include "os.h"
 #include "um_malloc.h"
+#include "kern_constants.h"
 
 #define MAX_PACKET ETH_MAX_PACKET
 
-void etap_user_init(void *data, void *dev)
+static int etap_user_init(void *data, void *dev)
 {
         struct ethertap_data *pri = data;
 
         pri->dev = dev;
+        return 0;
 }
 
 struct addr_change {
@@ -47,13 +48,16 @@ static void etap_change(int op, unsigned char *addr, unsigned char *netmask,
         change.what = op;
         memcpy(change.addr, addr, sizeof(change.addr));
         memcpy(change.netmask, netmask, sizeof(change.netmask));
-        n = os_write_file(fd, &change, sizeof(change));
-        if(n != sizeof(change))
-                printk("etap_change - request failed, err = %d\n", -n);
-        output = um_kmalloc(page_size());
+        CATCH_EINTR(n = write(fd, &change, sizeof(change)));
+        if(n != sizeof(change)){
+                printk("etap_change - request failed, err = %d\n", errno);
+                return;
+        }
+
+        output = um_kmalloc(UM_KERN_PAGE_SIZE);
         if(output == NULL)
                 printk("etap_change : Failed to allocate output buffer\n");
-        read_output(fd, output, page_size());
+        read_output(fd, output, UM_KERN_PAGE_SIZE);
         if(output != NULL){
                 printk("%s", output);
                 kfree(output);
@@ -115,13 +119,15 @@ static int etap_tramp(char *dev, char *gate, int control_me,
         pe_data.data_me = data_me;
         pid = run_helper(etap_pre_exec, &pe_data, args, NULL);
 
-        if(pid < 0) err = pid;
+        if(pid < 0)
+                err = pid;
         os_close_file(data_remote);
         os_close_file(control_remote);
-        n = os_read_file(control_me, &c, sizeof(c));
+        CATCH_EINTR(n = read(control_me, &c, sizeof(c)));
         if(n != sizeof(c)){
-                printk("etap_tramp : read of status failed, err = %d\n", -n);
-                return(-EINVAL);
+                err = -errno;
+                printk("etap_tramp : read of status failed, err = %d\n", -err);
+                return err;
         }
         if(c != 1){
                 printk("etap_tramp : uml_net failed\n");
@@ -132,7 +138,7 @@ static int etap_tramp(char *dev, char *gate, int control_me,
                 else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 1))
                         printk("uml_net didn't exit with status 1\n");
         }
-        return(err);
+        return err;
 }
 
 static int etap_open(void *data)
@@ -142,23 +148,24 @@ static int etap_open(void *data)
         int data_fds[2], control_fds[2], err, output_len;
 
         err = tap_open_common(pri->dev, pri->gate_addr);
-        if(err) return(err);
+        if(err)
+                return err;
 
         err = os_pipe(data_fds, 0, 0);
         if(err < 0){
                 printk("data os_pipe failed - err = %d\n", -err);
-                return(err);
+                return err;
         }
 
         err = os_pipe(control_fds, 1, 0);
         if(err < 0){
                 printk("control os_pipe failed - err = %d\n", -err);
-                return(err);
+                return err;
         }
-        
+
         err = etap_tramp(pri->dev_name, pri->gate_addr, control_fds[0], 
                          control_fds[1], data_fds[0], data_fds[1]);
-        output_len = page_size();
+        output_len = UM_KERN_PAGE_SIZE;
         output = um_kmalloc(output_len);
         read_output(control_fds[0], output, output_len);
 
@@ -171,13 +178,13 @@ static int etap_open(void *data)
 
         if(err < 0){
                 printk("etap_tramp failed - err = %d\n", -err);
-                return(err);
+                return err;
         }
 
         pri->data_fd = data_fds[0];
         pri->control_fd = control_fds[0];
         iter_addresses(pri->dev, etap_open_addr, &pri->control_fd);
-        return(data_fds[0]);
+        return data_fds[0];
 }
 
 static void etap_close(int fd, void *data)
@@ -195,7 +202,7 @@ static void etap_close(int fd, void *data)
 
 static int etap_set_mtu(int mtu, void *data)
 {
-        return(mtu);
+        return mtu;
 }
 
 static void etap_add_addr(unsigned char *addr, unsigned char *netmask,
@@ -204,7 +211,8 @@ static void etap_add_addr(unsigned char *addr, unsigned char *netmask,
         struct ethertap_data *pri = data;
 
         tap_check_ips(pri->gate_addr, addr);
-        if(pri->control_fd == -1) return;
+        if(pri->control_fd == -1)
+                return;
         etap_open_addr(addr, netmask, &pri->control_fd);
 }
 
@@ -213,7 +221,8 @@ static void etap_del_addr(unsigned char *addr, unsigned char *netmask,
 {
         struct ethertap_data *pri = data;
 
-        if(pri->control_fd == -1) return;
+        if(pri->control_fd == -1)
+                return;
         etap_close_addr(addr, netmask, &pri->control_fd);
 }
 
@@ -227,14 +236,3 @@ const struct net_user_info ethertap_user_info = {
         .delete_address = etap_del_addr,
         .max_packet     = MAX_PACKET - ETH_HEADER_ETHERTAP
 };
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
index e846b23f7558..11a9779dc9f1 100644
--- a/arch/um/os-Linux/drivers/tuntap_user.c
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -18,17 +18,17 @@
 #include "net_user.h"
 #include "tuntap.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "user.h"
 #include "os.h"
 
 #define MAX_PACKET ETH_MAX_PACKET
 
-void tuntap_user_init(void *data, void *dev)
+static int tuntap_user_init(void *data, void *dev)
 {
         struct tuntap_data *pri = data;
 
         pri->dev = dev;
+        return 0;
 }
 
 static void tuntap_add_addr(unsigned char *addr, unsigned char *netmask,
@@ -37,7 +37,8 @@ static void tuntap_add_addr(unsigned char *addr, unsigned char *netmask,
         struct tuntap_data *pri = data;
 
         tap_check_ips(pri->gate_addr, addr);
-        if((pri->fd == -1) || pri->fixed_config) return;
+        if((pri->fd == -1) || pri->fixed_config)
+                return;
         open_addr(addr, netmask, pri->dev_name);
 }
 
@@ -46,7 +47,8 @@ static void tuntap_del_addr(unsigned char *addr, unsigned char *netmask,
 {
         struct tuntap_data *pri = data;
 
-        if((pri->fd == -1) || pri->fixed_config) return;
+        if((pri->fd == -1) || pri->fixed_config)
+                return;
         close_addr(addr, netmask, pri->dev_name);
 }
 
@@ -58,7 +60,7 @@ struct tuntap_pre_exec_data {
 static void tuntap_pre_exec(void *arg)
 {
         struct tuntap_pre_exec_data *data = arg;
-        
+
         dup2(data->stdout, 1);
         os_close_file(data->close_me);
 }
@@ -83,7 +85,8 @@ static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
 
         pid = run_helper(tuntap_pre_exec, &data, argv, NULL);
 
-        if(pid < 0) return(-pid);
+        if(pid < 0)
+                return -pid;
 
         os_close_file(remote);
 
@@ -114,16 +117,16 @@ static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
         cmsg = CMSG_FIRSTHDR(&msg);
         if(cmsg == NULL){
                 printk("tuntap_open_tramp : didn't receive a message\n");
-                return(-EINVAL);
+                return -EINVAL;
         }
         if((cmsg->cmsg_level != SOL_SOCKET) || 
            (cmsg->cmsg_type != SCM_RIGHTS)){
                 printk("tuntap_open_tramp : didn't receive a descriptor\n");
-                return(-EINVAL);
+                return -EINVAL;
         }
         *fd_out = ((int *) CMSG_DATA(cmsg))[0];
         os_set_exec_close(*fd_out, 1);
-        return(0);
+        return 0;
 }
 
 static int tuntap_open(void *data)
@@ -135,7 +138,7 @@ static int tuntap_open(void *data)
 
         err = tap_open_common(pri->dev, pri->gate_addr);
         if(err < 0)
-                return(err);
+                return err;
 
         if(pri->fixed_config){
                 pri->fd = os_open_file("/dev/net/tun",
@@ -143,7 +146,7 @@ static int tuntap_open(void *data)
                 if(pri->fd < 0){
                         printk("Failed to open /dev/net/tun, err = %d\n",
                                -pri->fd);
-                        return(pri->fd);
+                        return pri->fd;
                 }
                 memset(&ifr, 0, sizeof(ifr));
                 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
@@ -160,7 +163,7 @@ static int tuntap_open(void *data)
                 if(err < 0){
                         printk("tuntap_open : os_pipe failed - err = %d\n",
                                -err);
-                        return(err);
+                        return err;
                 }
 
                 buffer = get_output_buffer(&len);
@@ -175,7 +178,7 @@ static int tuntap_open(void *data)
                         printk("%s", output);
                         free_output_buffer(buffer);
                         printk("tuntap_open_tramp failed - err = %d\n", -err);
-                        return(err);
+                        return err;
                 }
 
                 pri->dev_name = uml_strdup(buffer);
@@ -187,7 +190,7 @@ static int tuntap_open(void *data)
                 iter_addresses(pri->dev, open_addr, pri->dev_name);
         }
 
-        return(pri->fd);
+        return pri->fd;
 }
 
 static void tuntap_close(int fd, void *data)
@@ -202,7 +205,7 @@ static void tuntap_close(int fd, void *data)
 
 static int tuntap_set_mtu(int mtu, void *data)
 {
-        return(mtu);
+        return mtu;
 }
 
 const struct net_user_info tuntap_user_info = {
@@ -215,14 +218,3 @@ const struct net_user_info tuntap_user_info = {
         .delete_address = tuntap_del_addr,
         .max_packet     = MAX_PACKET
 };
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/os-Linux/file.c b/arch/um/os-Linux/file.c
index 371b4335f46d..6f92f732d253 100644
--- a/arch/um/os-Linux/file.c
+++ b/arch/um/os-Linux/file.c
@@ -18,7 +18,6 @@
 #include "os.h"
 #include "user.h"
 #include "kern_util.h"
-#include "user_util.h"
 
 static void copy_stat(struct uml_stat *dst, struct stat64 *src)
 {
@@ -291,54 +290,22 @@ int os_seek_file(int fd, __u64 offset)
         return 0;
 }
 
-static int fault_buffer(void *start, int len,
-                        int (*copy_proc)(void *addr, void *buf, int len))
-{
-        int page = getpagesize(), i;
-        char c;
-
-        for(i = 0; i < len; i += page){
-                if((*copy_proc)(start + i, &c, sizeof(c)))
-                        return -EFAULT;
-        }
-        if((len % page) != 0){
-                if((*copy_proc)(start + len - 1, &c, sizeof(c)))
-                        return -EFAULT;
-        }
-        return 0;
-}
-
-static int file_io(int fd, void *buf, int len,
-                   int (*io_proc)(int fd, void *buf, int len),
-                   int (*copy_user_proc)(void *addr, void *buf, int len))
+int os_read_file(int fd, void *buf, int len)
 {
-        int n, err;
-
-        do {
-                n = (*io_proc)(fd, buf, len);
-                if((n < 0) && (errno == EFAULT)){
-                        err = fault_buffer(buf, len, copy_user_proc);
-                        if(err)
-                                return err;
-                        n = (*io_proc)(fd, buf, len);
-                }
-        } while((n < 0) && (errno == EINTR));
+        int n = read(fd, buf, len);
 
         if(n < 0)
                 return -errno;
         return n;
 }
 
-int os_read_file(int fd, void *buf, int len)
-{
-        return file_io(fd, buf, len, (int (*)(int, void *, int)) read,
-                       copy_from_user_proc);
-}
-
 int os_write_file(int fd, const void *buf, int len)
 {
-        return file_io(fd, (void *) buf, len,
-                       (int (*)(int, void *, int)) write, copy_to_user_proc);
+        int n = write(fd, (void *) buf, len);
+
+        if(n < 0)
+                return -errno;
+        return n;
 }
 
 int os_file_size(char *file, unsigned long long *size_out)
diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
index c7ad6306e22f..97bed16bf4c7 100644
--- a/arch/um/os-Linux/helper.c
+++ b/arch/um/os-Linux/helper.c
@@ -13,9 +13,9 @@
 #include <sys/wait.h>
 #include "user.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "os.h"
 #include "um_malloc.h"
+#include "kern_constants.h"
 
 struct helper_data {
         void (*pre_exec)(void*);
@@ -25,28 +25,18 @@ struct helper_data {
         char *buf;
 };
 
-/* Debugging aid, changed only from gdb */
-int helper_pause = 0;
-
-static void helper_hup(int sig)
-{
-}
-
 static int helper_child(void *arg)
 {
         struct helper_data *data = arg;
         char **argv = data->argv;
         int errval;
 
-        if (helper_pause){
-                signal(SIGHUP, helper_hup);
-                pause();
-        }
         if (data->pre_exec != NULL)
                 (*data->pre_exec)(data->pre_data);
         errval = execvp_noalloc(data->buf, argv[0], argv);
-        printk("helper_child - execvp of '%s' failed - errno = %d\n", argv[0], -errval);
-        os_write_file(data->fd, &errval, sizeof(errval));
+        printk("helper_child - execvp of '%s' failed - errno = %d\n", argv[0],
+               -errval);
+        write(data->fd, &errval, sizeof(errval));
         kill(os_getpid(), SIGKILL);
         return 0;
 }
@@ -81,7 +71,7 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
                 goto out_close;
         }
 
-        sp = stack + page_size() - sizeof(void *);
+        sp = stack + UM_KERN_PAGE_SIZE - sizeof(void *);
         data.pre_exec = pre_exec;
         data.pre_data = pre_data;
         data.argv = argv;
@@ -98,13 +88,16 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
         close(fds[1]);
         fds[1] = -1;
 
-        /* Read the errno value from the child, if the exec failed, or get 0 if
-         * the exec succeeded because the pipe fd was set as close-on-exec. */
-        n = os_read_file(fds[0], &ret, sizeof(ret));
+        /*
+         * Read the errno value from the child, if the exec failed, or get 0 if
+         * the exec succeeded because the pipe fd was set as close-on-exec.
+         */
+        n = read(fds[0], &ret, sizeof(ret));
         if (n == 0) {
                 ret = pid;
         } else {
                 if (n < 0) {
+                        n = -errno;
                         printk("run_helper : read on pipe failed, ret = %d\n",
                                -n);
                         ret = n;
@@ -135,7 +128,7 @@ int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags,
         if (stack == 0)
                 return -ENOMEM;
 
-        sp = stack + (page_size() << stack_order) - sizeof(void *);
+        sp = stack + (UM_KERN_PAGE_SIZE << stack_order) - sizeof(void *);
         pid = clone(proc, (void *) sp, flags | SIGCHLD, arg);
         if (pid < 0) {
                 err = -errno;
diff --git a/arch/um/os-Linux/irq.c b/arch/um/os-Linux/irq.c
index d1b61d474e0a..a633fa8e0a94 100644
--- a/arch/um/os-Linux/irq.c
+++ b/arch/um/os-Linux/irq.c
@@ -11,7 +11,6 @@
 #include <sys/poll.h>
 #include <sys/types.h>
 #include <sys/time.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "process.h"
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index 685feaab65d2..ea9a23696f36 100644
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -13,8 +13,8 @@
 #include <sys/mman.h>
 #include <sys/user.h>
 #include <asm/page.h>
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "mem_user.h"
 #include "irq_user.h"
 #include "user.h"
@@ -25,12 +25,7 @@
 #include "os.h"
 #include "um_malloc.h"
 
-/* Set in set_stklim, which is called from main and __wrap_malloc.
- * __wrap_malloc only calls it if main hasn't started.
- */
-unsigned long stacksizelim;
-
-/* Set in main */
+/* Set in main, unchanged thereafter */
 char *linux_prog;
 
 #define PGD_BOUND (4 * 1024 * 1024)
@@ -52,7 +47,6 @@ static void set_stklim(void)
                         exit(1);
                 }
         }
-        stacksizelim = (lim.rlim_cur + PGD_BOUND - 1) & ~(PGD_BOUND - 1);
 }
 
 static __init void do_uml_initcalls(void)
@@ -126,7 +120,7 @@ extern int uml_exitcode;
 
 extern void scan_elf_aux( char **envp);
 
-int main(int argc, char **argv, char **envp)
+int __init main(int argc, char **argv, char **envp)
 {
         char **new_argv;
         int ret, i, err;
@@ -224,7 +218,7 @@ int main(int argc, char **argv, char **envp)
                 ret = 1;
         }
         printf("\n");
-        return(uml_exitcode);
+        return uml_exitcode;
 }
 
 #define CAN_KMALLOC() \
@@ -237,7 +231,7 @@ void *__wrap_malloc(int size)
         void *ret;
 
         if(!CAN_KMALLOC())
-                return(__real_malloc(size));
+                return __real_malloc(size);
         else if(size <= PAGE_SIZE) /* finding contiguos pages can be hard*/
                 ret = um_kmalloc(size);
         else ret = um_vmalloc(size);
@@ -248,16 +242,17 @@ void *__wrap_malloc(int size)
         if(ret == NULL)
                 errno = ENOMEM;
 
-        return(ret);
+        return ret;
 }
 
 void *__wrap_calloc(int n, int size)
 {
         void *ptr = __wrap_malloc(n * size);
 
-        if(ptr == NULL) return(NULL);
+        if(ptr == NULL)
+                return NULL;
         memset(ptr, 0, n * size);
-        return(ptr);
+        return ptr;
 }
 
 extern void __real_free(void *);
diff --git a/arch/um/os-Linux/mem.c b/arch/um/os-Linux/mem.c
index f1ea169db85e..c6378c6d10d2 100644
--- a/arch/um/os-Linux/mem.c
+++ b/arch/um/os-Linux/mem.c
@@ -11,7 +11,6 @@
 #include <sys/statfs.h>
 #include "kern_util.h"
 #include "user.h"
-#include "user_util.h"
 #include "mem_user.h"
 #include "init.h"
 #include "os.h"
@@ -165,7 +164,8 @@ found:
  * (file: kernel/tt/ptproxy/proxy.c, proc: start_debugger).
  * So it isn't 'static' yet.
  */
-int make_tempfile(const char *template, char **out_tempname, int do_unlink)
+int __init make_tempfile(const char *template, char **out_tempname,
+                         int do_unlink)
 {
         char *tempname;
         int fd;
@@ -206,7 +206,7 @@ out:
  * This proc is used in start_up.c
  * So it isn't 'static'.
  */
-int create_tmp_file(unsigned long long len)
+int __init create_tmp_file(unsigned long long len)
 {
         int fd, err;
         char zero;
@@ -232,17 +232,16 @@ int create_tmp_file(unsigned long long len)
 
         zero = 0;
 
-        err = os_write_file(fd, &zero, 1);
+        err = write(fd, &zero, 1);
         if(err != 1){
-                errno = -err;
-                perror("os_write_file");
+                perror("write");
                 exit(1);
         }
 
         return fd;
 }
 
-int create_mem_file(unsigned long long len)
+int __init create_mem_file(unsigned long long len)
 {
         int err, fd;
 
@@ -257,7 +256,7 @@ int create_mem_file(unsigned long long len)
 }
 
 
-void check_tmpexec(void)
+void __init check_tmpexec(void)
 {
         void *addr;
         int err, fd = create_tmp_file(UM_KERN_PAGE_SIZE);
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index 76bdd6712417..92a7b59120d6 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -14,7 +14,6 @@
 #include "ptrace_user.h"
 #include "os.h"
 #include "user.h"
-#include "user_util.h"
 #include "process.h"
 #include "irq_user.h"
 #include "kern_util.h"
@@ -22,6 +21,7 @@
 #include "skas_ptrace.h"
 #include "kern_constants.h"
 #include "uml-config.h"
+#include "init.h"
 
 #define ARBITRARY_ADDR -1
 #define FAILURE_PID    -1
@@ -40,14 +40,14 @@ unsigned long os_process_pc(int pid)
         if(fd < 0){
                 printk("os_process_pc - couldn't open '%s', err = %d\n",
                        proc_stat, -fd);
-                return(ARBITRARY_ADDR);
+                return ARBITRARY_ADDR;
         }
-        err = os_read_file(fd, buf, sizeof(buf));
+        CATCH_EINTR(err = read(fd, buf, sizeof(buf)));
         if(err < 0){
                 printk("os_process_pc - couldn't read '%s', err = %d\n",
-                       proc_stat, -err);
+                       proc_stat, errno);
                 os_close_file(fd);
-                return(ARBITRARY_ADDR);
+                return ARBITRARY_ADDR;
         }
         os_close_file(fd);
         pc = ARBITRARY_ADDR;
@@ -56,7 +56,7 @@ unsigned long os_process_pc(int pid)
                   "%*d %*d %*d %*d %*d %lu", &pc) != 1){
                 printk("os_process_pc - couldn't find pc in '%s'\n", buf);
         }
-        return(pc);
+        return pc;
 }
 
 int os_process_parent(int pid)
@@ -65,21 +65,22 @@ int os_process_parent(int pid)
         char data[256];
         int parent, n, fd;
 
-        if(pid == -1) return(-1);
+        if(pid == -1)
+                return -1;
 
         snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
         fd = os_open_file(stat, of_read(OPENFLAGS()), 0);
         if(fd < 0){
                 printk("Couldn't open '%s', err = %d\n", stat, -fd);
-                return(FAILURE_PID);
+                return FAILURE_PID;
         }
 
-        n = os_read_file(fd, data, sizeof(data));
+        CATCH_EINTR(n = read(fd, data, sizeof(data)));
         os_close_file(fd);
 
         if(n < 0){
-                printk("Couldn't read '%s', err = %d\n", stat, -n);
-                return(FAILURE_PID);
+                printk("Couldn't read '%s', err = %d\n", stat, errno);
+                return FAILURE_PID;
         }
 
         parent = FAILURE_PID;
@@ -87,7 +88,7 @@ int os_process_parent(int pid)
         if(n != 1)
                 printk("Failed to scan '%s'\n", data);
 
-        return(parent);
+        return parent;
 }
 
 void os_stop_process(int pid)
@@ -145,7 +146,7 @@ void os_usr1_process(int pid)
 
 int os_getpid(void)
 {
-        return(syscall(__NR_getpid));
+        return syscall(__NR_getpid);
 }
 
 int os_getpgrp(void)
@@ -165,8 +166,8 @@ int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
         loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
                      fd, off);
         if(loc == MAP_FAILED)
-                return(-errno);
-        return(0);
+                return -errno;
+        return 0;
 }
 
 int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
@@ -175,8 +176,8 @@ int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
                     (x ? PROT_EXEC : 0));
 
         if(mprotect(addr, len, prot) < 0)
-                return(-errno);
-        return(0);
+                return -errno;
+        return 0;
 }
 
 int os_unmap_memory(void *addr, int len)
@@ -185,15 +186,15 @@ int os_unmap_memory(void *addr, int len)
 
         err = munmap(addr, len);
         if(err < 0)
-                return(-errno);
-        return(0);
+                return -errno;
+        return 0;
 }
 
 #ifndef MADV_REMOVE
 #define MADV_REMOVE KERNEL_MADV_REMOVE
 #endif
 
-int os_drop_memory(void *addr, int length)
+int __init os_drop_memory(void *addr, int length)
 {
         int err;
 
@@ -203,7 +204,7 @@ int os_drop_memory(void *addr, int length)
         return err;
 }
 
-int can_drop_memory(void)
+int __init can_drop_memory(void)
 {
         void *addr;
         int fd, ok = 0;
@@ -244,7 +245,7 @@ void init_new_thread_stack(void *sig_stack, void (*usr1_handler)(int))
 
         if(sig_stack != NULL){
                 pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER);
-                set_sigstack(sig_stack, pages * page_size());
+                set_sigstack(sig_stack, pages * UM_KERN_PAGE_SIZE);
                 flags = SA_ONSTACK;
         }
         if(usr1_handler){
diff --git a/arch/um/os-Linux/sigio.c b/arch/um/os-Linux/sigio.c
index 3fc43b33db66..8d4e0c6b8c92 100644
--- a/arch/um/os-Linux/sigio.c
+++ b/arch/um/os-Linux/sigio.c
@@ -8,6 +8,7 @@
 #include <termios.h>
 #include <pty.h>
 #include <signal.h>
+#include <fcntl.h>
 #include <errno.h>
 #include <string.h>
 #include <sched.h>
@@ -16,10 +17,10 @@
 #include "init.h"
 #include "user.h"
 #include "kern_util.h"
-#include "user_util.h"
 #include "sigio.h"
 #include "os.h"
 #include "um_malloc.h"
+#include "init.h"
 
 /* Protected by sigio_lock(), also used by sigio_cleanup, which is an
  * exitcall.
@@ -68,11 +69,12 @@ static int write_sigio_thread(void *unused)
                         p = &fds->poll[i];
                         if(p->revents == 0) continue;
                         if(p->fd == sigio_private[1]){
-                                n = os_read_file(sigio_private[1], &c, sizeof(c));
+                                CATCH_EINTR(n = read(sigio_private[1], &c,
+                                                     sizeof(c)));
                                 if(n != sizeof(c))
                                         printk("write_sigio_thread : "
                                                "read on socket failed, "
-                                               "err = %d\n", -n);
+                                               "err = %d\n", errno);
                                 tmp = current_poll;
                                 current_poll = next_poll;
                                 next_poll = tmp;
@@ -85,10 +87,10 @@ static int write_sigio_thread(void *unused)
                                         (fds->used - i) * sizeof(*fds->poll));
                         }
 
-                        n = os_write_file(respond_fd, &c, sizeof(c));
+                        CATCH_EINTR(n = write(respond_fd, &c, sizeof(c)));
                         if(n != sizeof(c))
                                 printk("write_sigio_thread : write on socket "
-                                       "failed, err = %d\n", -n);
+                                       "failed, err = %d\n", errno);
                 }
         }
 
@@ -126,15 +128,15 @@ static void update_thread(void)
         char c;
 
         flags = set_signals(0);
-        n = os_write_file(sigio_private[0], &c, sizeof(c));
+        n = write(sigio_private[0], &c, sizeof(c));
         if(n != sizeof(c)){
-                printk("update_thread : write failed, err = %d\n", -n);
+                printk("update_thread : write failed, err = %d\n", errno);
                 goto fail;
         }
 
-        n = os_read_file(sigio_private[0], &c, sizeof(c));
+        CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c)));
         if(n != sizeof(c)){
-                printk("update_thread : read failed, err = %d\n", -n);
+                printk("update_thread : read failed, err = %d\n", errno);
                 goto fail;
         }
 
@@ -320,6 +322,10 @@ out_close1:
         close(l_write_sigio_fds[1]);
 }
 
+/* Changed during early boot */
+static int pty_output_sigio = 0;
+static int pty_close_sigio = 0;
+
 void maybe_sigio_broken(int fd, int read)
 {
         int err;
@@ -357,3 +363,143 @@ static void sigio_cleanup(void)
 }
 
 __uml_exitcall(sigio_cleanup);
+
+/* Used as a flag during SIGIO testing early in boot */
+static volatile int got_sigio = 0;
+
+static void __init handler(int sig)
+{
+        got_sigio = 1;
+}
+
+struct openpty_arg {
+        int master;
+        int slave;
+        int err;
+};
+
+static void openpty_cb(void *arg)
+{
+        struct openpty_arg *info = arg;
+
+        info->err = 0;
+        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
+                info->err = -errno;
+}
+
+static int async_pty(int master, int slave)
+{
+        int flags;
+
+        flags = fcntl(master, F_GETFL);
+        if(flags < 0)
+                return -errno;
+
+        if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
+           (fcntl(master, F_SETOWN, os_getpid()) < 0))
+                return -errno;
+
+        if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
+                return -errno;
+
+        return(0);
+}
+
+static void __init check_one_sigio(void (*proc)(int, int))
+{
+        struct sigaction old, new;
+        struct openpty_arg pty = { .master = -1, .slave = -1 };
+        int master, slave, err;
+
+        initial_thread_cb(openpty_cb, &pty);
+        if(pty.err){
+                printk("openpty failed, errno = %d\n", -pty.err);
+                return;
+        }
+
+        master = pty.master;
+        slave = pty.slave;
+
+        if((master == -1) || (slave == -1)){
+                printk("openpty failed to allocate a pty\n");
+                return;
+        }
+
+        /* Not now, but complain so we now where we failed. */
+        err = raw(master);
+        if (err < 0)
+                panic("check_sigio : __raw failed, errno = %d\n", -err);
+
+        err = async_pty(master, slave);
+        if(err < 0)
+                panic("tty_fds : sigio_async failed, err = %d\n", -err);
+
+        if(sigaction(SIGIO, NULL, &old) < 0)
+                panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
+        new = old;
+        new.sa_handler = handler;
+        if(sigaction(SIGIO, &new, NULL) < 0)
+                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
+
+        got_sigio = 0;
+        (*proc)(master, slave);
+
+        close(master);
+        close(slave);
+
+        if(sigaction(SIGIO, &old, NULL) < 0)
+                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
+}
+
+static void tty_output(int master, int slave)
+{
+        int n;
+        char buf[512];
+
+        printk("Checking that host ptys support output SIGIO...");
+
+        memset(buf, 0, sizeof(buf));
+
+        while(write(master, buf, sizeof(buf)) > 0) ;
+        if(errno != EAGAIN)
+                panic("tty_output : write failed, errno = %d\n", errno);
+        while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
+
+        if(got_sigio){
+                printk("Yes\n");
+                pty_output_sigio = 1;
+        }
+        else if(n == -EAGAIN)
+                printk("No, enabling workaround\n");
+        else panic("tty_output : read failed, err = %d\n", n);
+}
+
+static void tty_close(int master, int slave)
+{
+        printk("Checking that host ptys support SIGIO on close...");
+
+        close(slave);
+        if(got_sigio){
+                printk("Yes\n");
+                pty_close_sigio = 1;
+        }
+        else printk("No, enabling workaround\n");
+}
+
+void __init check_sigio(void)
+{
+        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
+           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
+                printk("No pseudo-terminals available - skipping pty SIGIO "
+                       "check\n");
+                return;
+        }
+        check_one_sigio(tty_output);
+        check_one_sigio(tty_close);
+}
+
+/* Here because it only does the SIGIO testing for now */
+void __init os_check_bugs(void)
+{
+        check_sigio();
+}
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index 266768629fee..48d493415301 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -11,7 +11,6 @@
 #include <stdarg.h>
 #include <string.h>
 #include <sys/mman.h>
-#include "user_util.h"
 #include "user.h"
 #include "signal_kern.h"
 #include "sysdep/sigcontext.h"
diff --git a/arch/um/os-Linux/skas/mem.c b/arch/um/os-Linux/skas/mem.c
index 9383e8751ae7..8e490fff3d47 100644
--- a/arch/um/os-Linux/skas/mem.c
+++ b/arch/um/os-Linux/skas/mem.c
@@ -6,6 +6,7 @@
 #include <signal.h>
 #include <errno.h>
 #include <string.h>
+#include <unistd.h>
 #include <sys/mman.h>
 #include <sys/wait.h>
 #include <asm/page.h>
@@ -17,17 +18,17 @@
 #include "os.h"
 #include "proc_mm.h"
 #include "ptrace_user.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "task.h"
 #include "registers.h"
 #include "uml-config.h"
 #include "sysdep/ptrace.h"
 #include "sysdep/stub.h"
+#include "init.h"
 
 extern unsigned long batch_syscall_stub, __syscall_stub_start;
 
-extern void wait_stub_done(int pid, int sig, char * fname);
+extern void wait_stub_done(int pid);
 
 static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
                                               unsigned long *stack)
@@ -39,6 +40,19 @@ static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
         return stack;
 }
 
+static unsigned long syscall_regs[MAX_REG_NR];
+
+static int __init init_syscall_regs(void)
+{
+        get_safe_registers(syscall_regs, NULL);
+        syscall_regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
+                ((unsigned long) &batch_syscall_stub -
+                 (unsigned long) &__syscall_stub_start);
+        return 0;
+}
+
+__initcall(init_syscall_regs);
+
 extern int proc_mm;
 
 int single_count = 0;
@@ -47,12 +61,11 @@ int multi_op_count = 0;
 
 static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 {
-        unsigned long regs[MAX_REG_NR];
         int n, i;
         long ret, offset;
         unsigned long * data;
         unsigned long * syscall;
-        int pid = mm_idp->u.pid;
+        int err, pid = mm_idp->u.pid;
 
         if(proc_mm)
 #warning Need to look up userspace_pid by cpu
@@ -60,21 +73,21 @@ static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 
         multi_count++;
 
-        get_safe_registers(regs, NULL);
-        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
-                ((unsigned long) &batch_syscall_stub -
-                 (unsigned long) &__syscall_stub_start);
-
-        n = ptrace_setregs(pid, regs);
+        n = ptrace_setregs(pid, syscall_regs);
         if(n < 0){
                 printk("Registers - \n");
                 for(i = 0; i < MAX_REG_NR; i++)
-                        printk("\t%d\t0x%lx\n", i, regs[i]);
+                        printk("\t%d\t0x%lx\n", i, syscall_regs[i]);
                 panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n",
                       -n);
         }
 
-        wait_stub_done(pid, 0, "do_syscall_stub");
+        err = ptrace(PTRACE_CONT, pid, 0, 0);
+        if(err)
+                panic("Failed to continue stub, pid = %d, errno = %d\n", pid,
+                      errno);
+
+        wait_stub_done(pid);
 
         /* When the stub stops, we find the following values on the
          * beginning of the stack:
@@ -176,14 +189,10 @@ long syscall_stub_data(struct mm_id * mm_idp,
         return 0;
 }
 
-int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
-        int r, int w, int x, int phys_fd, unsigned long long offset,
-        int done, void **data)
+int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len, int prot,
+        int phys_fd, unsigned long long offset, int done, void **data)
 {
-        int prot, ret;
-
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
+        int ret;
 
         if(proc_mm){
                 struct proc_mm_op map;
@@ -200,9 +209,11 @@ int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
                                            .fd  = phys_fd,
                                            .offset= offset
                                          } } } );
-                ret = os_write_file(fd, &map, sizeof(map));
-                if(ret != sizeof(map))
+                CATCH_EINTR(ret = write(fd, &map, sizeof(map)));
+                if(ret != sizeof(map)){
+                        ret = -errno;
                         printk("map : /proc/mm map failed, err = %d\n", -ret);
+                }
                 else ret = 0;
         }
         else {
@@ -217,8 +228,8 @@ int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
         return ret;
 }
 
-int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
-          void **data)
+int unmap(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
+          int done, void **data)
 {
         int ret;
 
@@ -232,9 +243,11 @@ int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
                                            { .addr      =
                                              (unsigned long) addr,
                                              .len               = len } } } );
-                ret = os_write_file(fd, &unmap, sizeof(unmap));
-                if(ret != sizeof(unmap))
+                CATCH_EINTR(ret = write(fd, &unmap, sizeof(unmap)));
+                if(ret != sizeof(unmap)){
+                        ret = -errno;
                         printk("unmap - proc_mm write returned %d\n", ret);
+                }
                 else ret = 0;
         }
         else {
@@ -249,13 +262,11 @@ int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
 }
 
 int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
-            int r, int w, int x, int done, void **data)
+            unsigned int prot, int done, void **data)
 {
         struct proc_mm_op protect;
-        int prot, ret;
+        int ret;
 
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
         if(proc_mm){
                 int fd = mm_idp->u.mm_fd;
 
@@ -267,9 +278,11 @@ int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
                                                .len     = len,
                                                .prot    = prot } } } );
 
-                ret = os_write_file(fd, &protect, sizeof(protect));
-                if(ret != sizeof(protect))
+                CATCH_EINTR(ret = write(fd, &protect, sizeof(protect)));
+                if(ret != sizeof(protect)){
+                        ret = -errno;
                         printk("protect failed, err = %d", -ret);
+                }
                 else ret = 0;
         }
         else {
diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c
index 0564422c155f..5c088a55396c 100644
--- a/arch/um/os-Linux/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -18,7 +18,6 @@
 #include <asm/types.h>
 #include "user.h"
 #include "sysdep/ptrace.h"
-#include "user_util.h"
 #include "kern_util.h"
 #include "skas.h"
 #include "stub-data.h"
@@ -34,6 +33,8 @@
 #include "uml-config.h"
 #include "process.h"
 #include "longjmp.h"
+#include "kern_constants.h"
+#include "as-layout.h"
 
 int is_skas_winch(int pid, int fd, void *data)
 {
@@ -44,45 +45,58 @@ int is_skas_winch(int pid, int fd, void *data)
         return(1);
 }
 
-void wait_stub_done(int pid, int sig, char * fname)
+static int ptrace_dump_regs(int pid)
 {
-        int n, status, err;
+        unsigned long regs[MAX_REG_NR];
+        int i;
+
+        if(ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
+                return -errno;
+        else {
+                printk("Stub registers -\n");
+                for(i = 0; i < ARRAY_SIZE(regs); i++)
+                        printk("\t%d - %lx\n", i, regs[i]);
+        }
+
+        return 0;
+}
 
-        do {
-                if ( sig != -1 ) {
-                        err = ptrace(PTRACE_CONT, pid, 0, sig);
-                        if(err)
-                                panic("%s : continue failed, errno = %d\n",
-                                      fname, errno);
-                }
-                sig = 0;
+/*
+ * Signals that are OK to receive in the stub - we'll just continue it.
+ * SIGWINCH will happen when UML is inside a detached screen.
+ */
+#define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH))
+
+/* Signals that the stub will finish with - anything else is an error */
+#define STUB_DONE_MASK ((1 << SIGUSR1) | (1 << SIGTRAP))
+
+void wait_stub_done(int pid)
+{
+        int n, status, err;
 
+        while(1){
                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
-        } while((n >= 0) && WIFSTOPPED(status) &&
-                ((WSTOPSIG(status) == SIGVTALRM) ||
-                 /* running UML inside a detached screen can cause
-                  * SIGWINCHes
-                  */
-                 (WSTOPSIG(status) == SIGWINCH)));
-
-        if((n < 0) || !WIFSTOPPED(status) ||
-           (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGTRAP)){
-                unsigned long regs[MAX_REG_NR];
-
-                if(ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
-                        printk("Failed to get registers from stub, "
-                               "errno = %d\n", errno);
-                else {
-                        int i;
-
-                        printk("Stub registers -\n");
-                        for(i = 0; i < ARRAY_SIZE(regs); i++)
-                                printk("\t%d - %lx\n", i, regs[i]);
-                }
-                panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
-                      "pid = %d, n = %d, errno = %d, status = 0x%x\n",
-                      fname, pid, n, errno, status);
+                if((n < 0) || !WIFSTOPPED(status))
+                        goto bad_wait;
+
+                if(((1 << WSTOPSIG(status)) & STUB_SIG_MASK) == 0)
+                        break;
+
+                err = ptrace(PTRACE_CONT, pid, 0, 0);
+                if(err)
+                        panic("wait_stub_done : continue failed, errno = %d\n",
+                              errno);
         }
+
+        if(((1 << WSTOPSIG(status)) & STUB_DONE_MASK) != 0)
+                return;
+
+bad_wait:
+        err = ptrace_dump_regs(pid);
+        if(err)
+                printk("Failed to get registers from stub, errno = %d\n", -err);
+        panic("wait_stub_done : failed to wait for SIGUSR1/SIGTRAP, pid = %d, "
+              "n = %d, errno = %d, status = 0x%x\n", pid, n, errno, status);
 }
 
 extern unsigned long current_stub_stack(void);
@@ -104,7 +118,11 @@ void get_skas_faultinfo(int pid, struct faultinfo * fi)
                                sizeof(struct ptrace_faultinfo));
         }
         else {
-                wait_stub_done(pid, SIGSEGV, "get_skas_faultinfo");
+                err = ptrace(PTRACE_CONT, pid, 0, SIGSEGV);
+                if(err)
+                        panic("Failed to continue stub, pid = %d, errno = %d\n",
+                              pid, errno);
+                wait_stub_done(pid);
 
                 /* faultinfo is prepared by the stub-segv-handler at start of
                  * the stub stack page. We just have to copy it.
@@ -142,9 +160,14 @@ static void handle_trap(int pid, union uml_pt_regs *regs, int local_using_sysemu
 
                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
                 if((err < 0) || !WIFSTOPPED(status) ||
-                   (WSTOPSIG(status) != SIGTRAP + 0x80))
+                   (WSTOPSIG(status) != SIGTRAP + 0x80)){
+                        err = ptrace_dump_regs(pid);
+                        if(err)
+                                printk("Failed to get registers from process, "
+                                       "errno = %d\n", -err);
                         panic("handle_trap - failed to wait at end of syscall, "
                               "errno = %d, status = %d\n", errno, status);
+                }
         }
 
         handle_syscall(regs);
@@ -172,7 +195,7 @@ static int userspace_tramp(void *stack)
                 int fd;
                 __u64 offset;
                 fd = phys_mapping(to_phys(&__syscall_stub_start), &offset);
-                addr = mmap64((void *) UML_CONFIG_STUB_CODE, page_size(),
+                addr = mmap64((void *) UML_CONFIG_STUB_CODE, UM_KERN_PAGE_SIZE,
                               PROT_EXEC, MAP_FIXED | MAP_PRIVATE, fd, offset);
                 if(addr == MAP_FAILED){
                         printk("mapping mmap stub failed, errno = %d\n",
@@ -182,8 +205,8 @@ static int userspace_tramp(void *stack)
 
                 if(stack != NULL){
                         fd = phys_mapping(to_phys(stack), &offset);
-                        addr = mmap((void *) UML_CONFIG_STUB_DATA, page_size(),
-                                    PROT_READ | PROT_WRITE,
+                        addr = mmap((void *) UML_CONFIG_STUB_DATA,
+                                    UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
                                     MAP_FIXED | MAP_SHARED, fd, offset);
                         if(addr == MAP_FAILED){
                                 printk("mapping segfault stack failed, "
@@ -199,7 +222,7 @@ static int userspace_tramp(void *stack)
                                   (unsigned long) stub_segv_handler -
                                   (unsigned long) &__syscall_stub_start;
 
-                set_sigstack((void *) UML_CONFIG_STUB_DATA, page_size());
+                set_sigstack((void *) UML_CONFIG_STUB_DATA, UM_KERN_PAGE_SIZE);
                 sigemptyset(&sa.sa_mask);
                 sigaddset(&sa.sa_mask, SIGIO);
                 sigaddset(&sa.sa_mask, SIGWINCH);
@@ -291,10 +314,13 @@ void userspace(union uml_pt_regs *regs)
                 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
 
                 if(WIFSTOPPED(status)){
-                        switch(WSTOPSIG(status)){
+                        int sig = WSTOPSIG(status);
+                        switch(sig){
                         case SIGSEGV:
-                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo)
-                                        user_signal(SIGSEGV, regs, pid);
+                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo){
+                                        get_skas_faultinfo(pid, &regs->skas.faultinfo);
+                                        (*sig_info[SIGSEGV])(SIGSEGV, regs);
+                                }
                                 else handle_segv(pid, regs);
                                 break;
                         case SIGTRAP + 0x80:
@@ -309,11 +335,13 @@ void userspace(union uml_pt_regs *regs)
                         case SIGBUS:
                         case SIGFPE:
                         case SIGWINCH:
-                                user_signal(WSTOPSIG(status), regs, pid);
+                                block_signals();
+                                (*sig_info[sig])(sig, regs);
+                                unblock_signals();
                                 break;
                         default:
                                 printk("userspace - child stopped with signal "
-                                       "%d\n", WSTOPSIG(status));
+                                       "%d\n", sig);
                         }
                         pid = userspace_pid[0];
                         interrupt_end();
@@ -325,11 +353,29 @@ void userspace(union uml_pt_regs *regs)
         }
 }
 
+static unsigned long thread_regs[MAX_REG_NR];
+static unsigned long thread_fp_regs[HOST_FP_SIZE];
+
+static int __init init_thread_regs(void)
+{
+        get_safe_registers(thread_regs, thread_fp_regs);
+        /* Set parent's instruction pointer to start of clone-stub */
+        thread_regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
+                                (unsigned long) stub_clone_handler -
+                                (unsigned long) &__syscall_stub_start;
+        thread_regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
+                sizeof(void *);
+#ifdef __SIGNAL_FRAMESIZE
+        thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
+#endif
+        return 0;
+}
+
+__initcall(init_thread_regs);
+
 int copy_context_skas0(unsigned long new_stack, int pid)
 {
         int err;
-        unsigned long regs[MAX_REG_NR];
-        unsigned long fp_regs[HOST_FP_SIZE];
         unsigned long current_stack = current_stub_stack();
         struct stub_data *data = (struct stub_data *) current_stack;
         struct stub_data *child_data = (struct stub_data *) new_stack;
@@ -344,23 +390,12 @@ int copy_context_skas0(unsigned long new_stack, int pid)
                                       .timer    = ((struct itimerval)
                                                     { { 0, 1000000 / hz() },
                                                       { 0, 1000000 / hz() }})});
-        get_safe_registers(regs, fp_regs);
-
-        /* Set parent's instruction pointer to start of clone-stub */
-        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
-                                (unsigned long) stub_clone_handler -
-                                (unsigned long) &__syscall_stub_start;
-        regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
-                sizeof(void *);
-#ifdef __SIGNAL_FRAMESIZE
-        regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
-#endif
-        err = ptrace_setregs(pid, regs);
+        err = ptrace_setregs(pid, thread_regs);
         if(err < 0)
                 panic("copy_context_skas0 : PTRACE_SETREGS failed, "
                       "pid = %d, errno = %d\n", pid, -err);
 
-        err = ptrace_setfpregs(pid, fp_regs);
+        err = ptrace_setfpregs(pid, thread_fp_regs);
         if(err < 0)
                 panic("copy_context_skas0 : PTRACE_SETFPREGS failed, "
                       "pid = %d, errno = %d\n", pid, -err);
@@ -371,7 +406,11 @@ int copy_context_skas0(unsigned long new_stack, int pid)
         /* Wait, until parent has finished its work: read child's pid from
          * parent's stack, and check, if bad result.
          */
-        wait_stub_done(pid, 0, "copy_context_skas0");
+        err = ptrace(PTRACE_CONT, pid, 0, 0);
+        if(err)
+                panic("Failed to continue new process, pid = %d, "
+                      "errno = %d\n", pid, errno);
+        wait_stub_done(pid);
 
         pid = data->err;
         if(pid < 0)
@@ -381,7 +420,7 @@ int copy_context_skas0(unsigned long new_stack, int pid)
         /* Wait, until child has finished too: read child's result from
          * child's stack and check it.
          */
-        wait_stub_done(pid, -1, "copy_context_skas0");
+        wait_stub_done(pid);
         if (child_data->err != UML_CONFIG_STUB_DATA)
                 panic("copy_context_skas0 - stub-child reports error %ld\n",
                       child_data->err);
@@ -396,7 +435,7 @@ int copy_context_skas0(unsigned long new_stack, int pid)
 
 /*
  * This is used only, if stub pages are needed, while proc_mm is
- * availabl. Opening /proc/mm creates a new mm_context, which lacks
+ * available. Opening /proc/mm creates a new mm_context, which lacks
  * the stub-pages. Thus, we map them using /proc/mm-fd
  */
 void map_stub_pages(int fd, unsigned long code,
@@ -418,12 +457,13 @@ void map_stub_pages(int fd, unsigned long code,
                                           .fd      = code_fd,
                                           .offset  = code_offset
         } } });
-        n = os_write_file(fd, &mmop, sizeof(mmop));
+        CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
         if(n != sizeof(mmop)){
+                n = errno;
                 printk("mmap args - addr = 0x%lx, fd = %d, offset = %llx\n",
                        code, code_fd, (unsigned long long) code_offset);
                 panic("map_stub_pages : /proc/mm map for code failed, "
-                      "err = %d\n", -n);
+                      "err = %d\n", n);
         }
 
         if ( stack ) {
@@ -440,10 +480,10 @@ void map_stub_pages(int fd, unsigned long code,
                                       .fd      = map_fd,
                                       .offset  = map_offset
                 } } });
-                n = os_write_file(fd, &mmop, sizeof(mmop));
+                CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
                 if(n != sizeof(mmop))
                         panic("map_stub_pages : /proc/mm map for data failed, "
-                              "err = %d\n", -n);
+                              "err = %d\n", errno);
         }
 }
 
@@ -480,7 +520,15 @@ int start_idle_thread(void *stack, jmp_buf *switch_buf)
                     SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGALRM,
                     SIGVTALRM, -1);
 
-        n = UML_SETJMP(&initial_jmpbuf);
+        /*
+         * Can't use UML_SETJMP or UML_LONGJMP here because they save
+         * and restore signals, with the possible side-effect of
+         * trying to handle any signals which came when they were
+         * blocked, which can't be done on this stack.
+         * Signals must be blocked when jumping back here and restored
+         * after returning to the jumper.
+         */
+        n = setjmp(initial_jmpbuf);
         switch(n){
         case INIT_JMP_NEW_THREAD:
                 (*switch_buf)[0].JB_IP = (unsigned long) new_thread_handler;
@@ -490,7 +538,7 @@ int start_idle_thread(void *stack, jmp_buf *switch_buf)
                 break;
         case INIT_JMP_CALLBACK:
                 (*cb_proc)(cb_arg);
-                UML_LONGJMP(cb_back, 1);
+                longjmp(*cb_back, 1);
                 break;
         case INIT_JMP_HALT:
                 kmalloc_ok = 0;
@@ -501,7 +549,7 @@ int start_idle_thread(void *stack, jmp_buf *switch_buf)
         default:
                 panic("Bad sigsetjmp return in start_idle_thread - %d\n", n);
         }
-        UML_LONGJMP(switch_buf, 1);
+        longjmp(*switch_buf, 1);
 }
 
 void initial_thread_cb_skas(void (*proc)(void *), void *arg)
diff --git a/arch/um/os-Linux/skas/trap.c b/arch/um/os-Linux/skas/trap.c
index 9ad5fbec4593..3b600c2e63b8 100644
--- a/arch/um/os-Linux/skas/trap.c
+++ b/arch/um/os-Linux/skas/trap.c
@@ -5,8 +5,8 @@
 
 #include <signal.h>
 #include <errno.h>
-#include "user_util.h"
 #include "kern_util.h"
+#include "as-layout.h"
 #include "task.h"
 #include "sigcontext.h"
 #include "skas.h"
@@ -15,29 +15,39 @@
 #include "sysdep/ptrace_user.h"
 #include "os.h"
 
+static union uml_pt_regs ksig_regs[UM_NR_CPUS];
+
 void sig_handler_common_skas(int sig, void *sc_ptr)
 {
         struct sigcontext *sc = sc_ptr;
-        struct skas_regs *r;
+        union uml_pt_regs *r;
         void (*handler)(int, union uml_pt_regs *);
-        int save_errno = errno;
-        int save_user;
+        int save_user, save_errno = errno;
 
         /* This is done because to allow SIGSEGV to be delivered inside a SEGV
          * handler.  This can happen in copy_user, and if SEGV is disabled,
          * the process will die.
          * XXX Figure out why this is better than SA_NODEFER
          */
-        if(sig == SIGSEGV)
+        if(sig == SIGSEGV) {
                 change_sig(SIGSEGV, 1);
+                /* For segfaults, we want the data from the
+                 * sigcontext.  In this case, we don't want to mangle
+                 * the process registers, so use a static set of
+                 * registers.  For other signals, the process
+                 * registers are OK.
+                 */
+                r = &ksig_regs[cpu()];
+                copy_sc(r, sc_ptr);
+        }
+        else r = TASK_REGS(get_current());
 
-        r = &TASK_REGS(get_current())->skas;
-        save_user = r->is_user;
-        r->is_user = 0;
+        save_user = r->skas.is_user;
+        r->skas.is_user = 0;
         if ( sig == SIGFPE || sig == SIGSEGV ||
              sig == SIGBUS || sig == SIGILL ||
              sig == SIGTRAP ) {
-                GET_FAULTINFO_FROM_SC(r->faultinfo, sc);
+                GET_FAULTINFO_FROM_SC(r->skas.faultinfo, sc);
         }
 
         change_sig(SIGUSR1, 1);
@@ -49,25 +59,8 @@ void sig_handler_common_skas(int sig, void *sc_ptr)
             sig != SIGVTALRM && sig != SIGALRM)
                 unblock_signals();
 
-        handler(sig, (union uml_pt_regs *) r);
+        handler(sig, r);
 
         errno = save_errno;
-        r->is_user = save_user;
-}
-
-extern int ptrace_faultinfo;
-
-void user_signal(int sig, union uml_pt_regs *regs, int pid)
-{
-        void (*handler)(int, union uml_pt_regs *);
-        int segv = ((sig == SIGFPE) || (sig == SIGSEGV) || (sig == SIGBUS) ||
-                    (sig == SIGILL) || (sig == SIGTRAP));
-
-        if (segv)
-                get_skas_faultinfo(pid, &regs->skas.faultinfo);
-
-        handler = sig_info[sig];
-        handler(sig, (union uml_pt_regs *) regs);
-
-        unblock_signals();
+        r->skas.is_user = save_user;
 }
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index 5178eba9afa5..79471f85eb89 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -17,10 +17,10 @@
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <sys/mman.h>
+#include <sys/resource.h>
 #include <asm/unistd.h>
 #include <asm/page.h>
 #include <sys/types.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
@@ -329,8 +329,32 @@ static void __init check_ptrace(void)
 
 extern void check_tmpexec(void);
 
-void os_early_checks(void)
+static void __init check_coredump_limit(void)
 {
+        struct rlimit lim;
+        int err = getrlimit(RLIMIT_CORE, &lim);
+
+        if(err){
+                perror("Getting core dump limit");
+                return;
+        }
+
+        printf("Core dump limits :\n\tsoft - ");
+        if(lim.rlim_cur == RLIM_INFINITY)
+                printf("NONE\n");
+        else printf("%lu\n", lim.rlim_cur);
+
+        printf("\thard - ");
+        if(lim.rlim_max == RLIM_INFINITY)
+                printf("NONE\n");
+        else printf("%lu\n", lim.rlim_max);
+}
+
+void __init os_early_checks(void)
+{
+        /* Print out the core dump limits early */
+        check_coredump_limit();
+
         check_ptrace();
 
         /* Need to check this early because mmapping happens before the
@@ -528,148 +552,3 @@ int __init parse_iomem(char *str, int *add)
  out:
         return 1;
 }
-
-
-/* Changed during early boot */
-int pty_output_sigio = 0;
-int pty_close_sigio = 0;
-
-/* Used as a flag during SIGIO testing early in boot */
-static volatile int got_sigio = 0;
-
-static void __init handler(int sig)
-{
-        got_sigio = 1;
-}
-
-struct openpty_arg {
-        int master;
-        int slave;
-        int err;
-};
-
-static void openpty_cb(void *arg)
-{
-        struct openpty_arg *info = arg;
-
-        info->err = 0;
-        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
-                info->err = -errno;
-}
-
-static int async_pty(int master, int slave)
-{
-        int flags;
-
-        flags = fcntl(master, F_GETFL);
-        if(flags < 0)
-                return -errno;
-
-        if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
-           (fcntl(master, F_SETOWN, os_getpid()) < 0))
-                return -errno;
-
-        if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
-                return -errno;
-
-        return(0);
-}
-
-static void __init check_one_sigio(void (*proc)(int, int))
-{
-        struct sigaction old, new;
-        struct openpty_arg pty = { .master = -1, .slave = -1 };
-        int master, slave, err;
-
-        initial_thread_cb(openpty_cb, &pty);
-        if(pty.err){
-                printk("openpty failed, errno = %d\n", -pty.err);
-                return;
-        }
-
-        master = pty.master;
-        slave = pty.slave;
-
-        if((master == -1) || (slave == -1)){
-                printk("openpty failed to allocate a pty\n");
-                return;
-        }
-
-        /* Not now, but complain so we now where we failed. */
-        err = raw(master);
-        if (err < 0)
-                panic("check_sigio : __raw failed, errno = %d\n", -err);
-
-        err = async_pty(master, slave);
-        if(err < 0)
-                panic("tty_fds : sigio_async failed, err = %d\n", -err);
-
-        if(sigaction(SIGIO, NULL, &old) < 0)
-                panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
-        new = old;
-        new.sa_handler = handler;
-        if(sigaction(SIGIO, &new, NULL) < 0)
-                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
-
-        got_sigio = 0;
-        (*proc)(master, slave);
-
-        close(master);
-        close(slave);
-
-        if(sigaction(SIGIO, &old, NULL) < 0)
-                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
-}
-
-static void tty_output(int master, int slave)
-{
-        int n;
-        char buf[512];
-
-        printk("Checking that host ptys support output SIGIO...");
-
-        memset(buf, 0, sizeof(buf));
-
-        while(os_write_file(master, buf, sizeof(buf)) > 0) ;
-        if(errno != EAGAIN)
-                panic("check_sigio : write failed, errno = %d\n", errno);
-        while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
-
-        if(got_sigio){
-                printk("Yes\n");
-                pty_output_sigio = 1;
-        }
-        else if(n == -EAGAIN) printk("No, enabling workaround\n");
-        else panic("check_sigio : read failed, err = %d\n", n);
-}
-
-static void tty_close(int master, int slave)
-{
-        printk("Checking that host ptys support SIGIO on close...");
-
-        close(slave);
-        if(got_sigio){
-                printk("Yes\n");
-                pty_close_sigio = 1;
-        }
-        else printk("No, enabling workaround\n");
-}
-
-void __init check_sigio(void)
-{
-        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
-           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
-                printk("No pseudo-terminals available - skipping pty SIGIO "
-                       "check\n");
-                return;
-        }
-        check_one_sigio(tty_output);
-        check_one_sigio(tty_close);
-}
-
-void os_check_bugs(void)
-{
-        check_ptrace();
-        check_sigio();
-}
-
diff --git a/arch/um/os-Linux/sys-i386/tls.c b/arch/um/os-Linux/sys-i386/tls.c
index 256532034c62..32ed41ec1a3d 100644
--- a/arch/um/os-Linux/sys-i386/tls.c
+++ b/arch/um/os-Linux/sys-i386/tls.c
@@ -5,7 +5,7 @@
 #include <unistd.h>
 
 #include "sysdep/tls.h"
-#include "user_util.h"
+#include "user.h"
 
 /* Checks whether host supports TLS, and sets *tls_min according to the value
  * valid on the host.
diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
index 2115b8beb541..5de169b168f6 100644
--- a/arch/um/os-Linux/time.c
+++ b/arch/um/os-Linux/time.c
@@ -10,7 +10,6 @@
 #include <sys/time.h>
 #include <signal.h>
 #include <errno.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "process.h"
diff --git a/arch/um/os-Linux/trap.c b/arch/um/os-Linux/trap.c
index d221214d2ed5..295da657931a 100644
--- a/arch/um/os-Linux/trap.c
+++ b/arch/um/os-Linux/trap.c
@@ -6,7 +6,6 @@
 #include <stdlib.h>
 #include <signal.h>
 #include "kern_util.h"
-#include "user_util.h"
 #include "os.h"
 #include "mode.h"
 #include "longjmp.h"
diff --git a/arch/um/os-Linux/tt.c b/arch/um/os-Linux/tt.c
index 3dc3a02d6263..bcf9359c4e9f 100644
--- a/arch/um/os-Linux/tt.c
+++ b/arch/um/os-Linux/tt.c
@@ -18,7 +18,6 @@
 #include <asm/ptrace.h>
 #include <asm/unistd.h>
 #include <asm/page.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
@@ -32,6 +31,7 @@
 #include "choose-mode.h"
 #include "mode.h"
 #include "tempfile.h"
+#include "kern_constants.h"
 
 int protect_memory(unsigned long addr, unsigned long len, int r, int w, int x,
                    int must_succeed)
@@ -143,7 +143,7 @@ int outer_tramp(void *arg)
         int sig = sigkill;
 
         t = arg;
-        t->pid = clone(t->tramp, (void *) t->temp_stack + page_size()/2,
+        t->pid = clone(t->tramp, (void *) t->temp_stack + UM_KERN_PAGE_SIZE/2,
                        t->flags, t->tramp_data);
         if(t->pid > 0) wait_for_stop(t->pid, SIGSTOP, PTRACE_CONT, NULL);
         kill(os_getpid(), sig);
diff --git a/arch/um/os-Linux/tty_log.c b/arch/um/os-Linux/tty_log.c
index c6ba56c1560f..d11a55baa6bd 100644
--- a/arch/um/os-Linux/tty_log.c
+++ b/arch/um/os-Linux/tty_log.c
@@ -53,9 +53,9 @@ int open_tty_log(void *tty, void *current_tty)
                                                .direction = 0,
                                                .sec = tv.tv_sec,
                                                .usec = tv.tv_usec } );
-                os_write_file(tty_log_fd, &data, sizeof(data));
-                os_write_file(tty_log_fd, &current_tty, data.len);
-                return(tty_log_fd);
+                write(tty_log_fd, &data, sizeof(data));
+                write(tty_log_fd, &current_tty, data.len);
+                return tty_log_fd;
         }
 
         sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec,
@@ -67,7 +67,7 @@ int open_tty_log(void *tty, void *current_tty)
                 printk("open_tty_log : couldn't open '%s', errno = %d\n",
                        buf, -fd);
         }
-        return(fd);
+        return fd;
 }
 
 void close_tty_log(int fd, void *tty)
@@ -83,7 +83,7 @@ void close_tty_log(int fd, void *tty)
                                                .direction = 0,
                                                .sec = tv.tv_sec,
                                                .usec = tv.tv_usec } );
-                os_write_file(tty_log_fd, &data, sizeof(data));
+                write(tty_log_fd, &data, sizeof(data));
                 return;
         }
         os_close_file(fd);
@@ -98,21 +98,21 @@ static int log_chunk(int fd, const char *buf, int len)
                 try = (len > sizeof(chunk)) ? sizeof(chunk) : len;
                 missed = copy_from_user_proc(chunk, (char *) buf, try);
                 try -= missed;
-                n = os_write_file(fd, chunk, try);
+                n = write(fd, chunk, try);
                 if(n != try) {
                         if(n < 0)
-                                return(n);
-                        return(-EIO);
+                                return -errno;
+                        return -EIO;
                 }
                 if(missed != 0)
-                        return(-EFAULT);
+                        return -EFAULT;
 
                 len -= try;
                 total += try;
                 buf += try;
         }
 
-        return(total);
+        return total;
 }
 
 int write_tty_log(int fd, const char *buf, int len, void *tty, int is_read)
@@ -130,10 +130,10 @@ int write_tty_log(int fd, const char *buf, int len, void *tty, int is_read)
                                                .direction = direction,
                                                .sec = tv.tv_sec,
                                                .usec = tv.tv_usec } );
-                os_write_file(tty_log_fd, &data, sizeof(data));
+                write(tty_log_fd, &data, sizeof(data));
         }
 
-        return(log_chunk(fd, buf, len));
+        return log_chunk(fd, buf, len);
 }
 
 void log_exec(char **argv, void *tty)
@@ -161,7 +161,7 @@ void log_exec(char **argv, void *tty)
                                        .direction = 0,
                                        .sec = tv.tv_sec,
                                        .usec = tv.tv_usec } );
-        os_write_file(tty_log_fd, &data, sizeof(data));
+        write(tty_log_fd, &data, sizeof(data));
 
         for(ptr = argv; ; ptr++){
                 if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
@@ -179,7 +179,7 @@ extern void register_tty_logger(int (*opener)(void *, void *),
 static int register_logger(void)
 {
         register_tty_logger(open_tty_log, write_tty_log, close_tty_log);
-        return(0);
+        return 0;
 }
 
 __uml_initcall(register_logger);
diff --git a/arch/um/os-Linux/util.c b/arch/um/os-Linux/util.c
index 56b8a50e8bc2..c307a89ed259 100644
--- a/arch/um/os-Linux/util.c
+++ b/arch/um/os-Linux/util.c
@@ -21,7 +21,6 @@
 #include <sched.h>
 #include <termios.h>
 #include <string.h>
-#include "user_util.h"
 #include "kern_util.h"
 #include "user.h"
 #include "mem_user.h"
@@ -30,28 +29,29 @@
 #include "uml-config.h"
 #include "os.h"
 #include "longjmp.h"
+#include "kern_constants.h"
 
 void stack_protections(unsigned long address)
 {
         int prot = PROT_READ | PROT_WRITE | PROT_EXEC;
 
-        if(mprotect((void *) address, page_size(), prot) < 0)
+        if(mprotect((void *) address, UM_KERN_PAGE_SIZE, prot) < 0)
                 panic("protecting stack failed, errno = %d", errno);
 }
 
 void task_protections(unsigned long address)
 {
-        unsigned long guard = address + page_size();
-        unsigned long stack = guard + page_size();
+        unsigned long guard = address + UM_KERN_PAGE_SIZE;
+        unsigned long stack = guard + UM_KERN_PAGE_SIZE;
         int prot = 0, pages;
 
 #ifdef notdef
-        if(mprotect((void *) stack, page_size(), prot) < 0)
+        if(mprotect((void *) stack, UM_KERN_PAGE_SIZE, prot) < 0)
                 panic("protecting guard page failed, errno = %d", errno);
 #endif
         pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER) - 2;
         prot = PROT_READ | PROT_WRITE | PROT_EXEC;
-        if(mprotect((void *) stack, pages * page_size(), prot) < 0)
+        if(mprotect((void *) stack, pages * UM_KERN_PAGE_SIZE, prot) < 0)
                 panic("protecting stack failed, errno = %d", errno);
 }
 
@@ -96,15 +96,13 @@ void setup_machinename(char *machine_out)
         strcpy(machine_out, host.machine);
 }
 
-char host_info[(_UTSNAME_LENGTH + 1) * 4 + _UTSNAME_NODENAME_LENGTH + 1];
-
-void setup_hostinfo(void)
+void setup_hostinfo(char *buf, int len)
 {
         struct utsname host;
 
         uname(&host);
-        sprintf(host_info, "%s %s %s %s %s", host.sysname, host.nodename,
-                host.release, host.version, host.machine);
+        snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
+                 host.release, host.version, host.machine);
 }
 
 int setjmp_wrapper(void (*proc)(void *, void *), ...)
@@ -121,3 +119,9 @@ int setjmp_wrapper(void (*proc)(void *, void *), ...)
         va_end(args);
         return n;
 }
+
+void os_dump_core(void)
+{
+        signal(SIGSEGV, SIG_DFL);
+        abort();
+}
diff --git a/arch/um/sys-i386/bugs.c b/arch/um/sys-i386/bugs.c
index f1bcd399ac90..0393e44813e7 100644
--- a/arch/um/sys-i386/bugs.c
+++ b/arch/um/sys-i386/bugs.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -13,7 +13,6 @@
 #include "sysdep/ptrace.h"
 #include "task.h"
 #include "os.h"
-#include "user_util.h"
 
 #define MAXTOKEN 64
 
@@ -32,21 +31,21 @@ static char token(int fd, char *buf, int len, char stop)
                 n = os_read_file(fd, ptr, sizeof(*ptr));
                 c = *ptr++;
                 if(n != sizeof(*ptr)){
-                        if(n == 0) return(0);
+                        if(n == 0)
+                                return 0;
                         printk("Reading /proc/cpuinfo failed, err = %d\n", -n);
                         if(n < 0)
-                                return(n);
-                        else
-                                return(-EIO);
+                                return n;
+                        else return -EIO;
                 }
         } while((c != '\n') && (c != stop) && (ptr < end));
 
         if(ptr == end){
                 printk("Failed to find '%c' in /proc/cpuinfo\n", stop);
-                return(-1);
+                return -1;
         }
         *(ptr - 1) = '\0';
-        return(c);
+        return c;
 }
 
 static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
@@ -58,48 +57,25 @@ static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
         while(1){
                 c = token(fd, scratch, len - 1, ':');
                 if(c <= 0)
-                        return(0);
+                        return 0;
                 else if(c != ':'){
                         printk("Failed to find ':' in /proc/cpuinfo\n");
-                        return(0);
+                        return 0;
                 }
 
                 if(!strncmp(scratch, key, strlen(key)))
-                        return(1);
+                        return 1;
 
                 do {
                         n = os_read_file(fd, &c, sizeof(c));
                         if(n != sizeof(c)){
                                 printk("Failed to find newline in "
                                        "/proc/cpuinfo, err = %d\n", -n);
-                                return(0);
+                                return 0;
                         }
                 } while(c != '\n');
         }
-        return(0);
-}
-
-int cpu_feature(char *what, char *buf, int len)
-{
-        int fd, ret = 0;
-
-        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
-        if(fd < 0){
-                printk("Couldn't open /proc/cpuinfo, err = %d\n", -fd);
-                return(0);
-        }
-
-        if(!find_cpuinfo_line(fd, what, buf, len)){
-                printk("Couldn't find '%s' line in /proc/cpuinfo\n", what);
-                goto out_close;
-        }
-
-        token(fd, buf, len, '\n');
-        ret = 1;
-
- out_close:
-        os_close_file(fd);
-        return(ret);
+        return 0;
 }
 
 static int check_cpu_flag(char *feature, int *have_it)
@@ -119,7 +95,8 @@ static int check_cpu_flag(char *feature, int *have_it)
                 goto out;
 
         c = token(fd, buf, len - 1, ' ');
-        if(c < 0) goto out;
+        if(c < 0)
+                goto out;
         else if(c != ' '){
                 printk("Failed to find ' ' in /proc/cpuinfo\n");
                 goto out;
@@ -127,7 +104,8 @@ static int check_cpu_flag(char *feature, int *have_it)
 
         while(1){
                 c = token(fd, buf, len - 1, ' ');
-                if(c < 0) goto out;
+                if(c < 0)
+                        goto out;
                 else if(c == '\n') break;
 
                 if(!strcmp(buf, feature)){
@@ -136,8 +114,10 @@ static int check_cpu_flag(char *feature, int *have_it)
                 }
         }
  out:
-        if(*have_it == 0) printk("No\n");
-        else if(*have_it == 1) printk("Yes\n");
+        if(*have_it == 0)
+                printk("No\n");
+        else if(*have_it == 1)
+                printk("Yes\n");
         os_close_file(fd);
         return 1;
 }
@@ -189,12 +169,13 @@ int arch_handle_signal(int sig, union uml_pt_regs *regs)
         /* This is testing for a cmov (0x0f 0x4x) instruction causing a
          * SIGILL in init.
          */
-        if((sig != SIGILL) || (TASK_PID(get_current()) != 1)) return(0);
+        if((sig != SIGILL) || (TASK_PID(get_current()) != 1))
+                return 0;
 
         if (copy_from_user_proc(tmp, (void *) UPT_IP(regs), 2))
                 panic("SIGILL in init, could not read instructions!\n");
         if((tmp[0] != 0x0f) || ((tmp[1] & 0xf0) != 0x40))
-                return(0);
+                return 0;
 
         if(host_has_cmov == 0)
                 panic("SIGILL caused by cmov, which this processor doesn't "
@@ -208,16 +189,5 @@ int arch_handle_signal(int sig, union uml_pt_regs *regs)
                       "implements it, boot a filesystem compiled for older "
                       "processors");
         else panic("Bad value for host_has_cmov (%d)", host_has_cmov);
-        return(0);
+        return 0;
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-i386/fault.c b/arch/um/sys-i386/fault.c
index d0bbcdfdb53f..745b4fd49e9f 100644
--- a/arch/um/sys-i386/fault.c
+++ b/arch/um/sys-i386/fault.c
@@ -3,9 +3,7 @@
  * Licensed under the GPL
  */
 
-#include <signal.h>
 #include "sysdep/ptrace.h"
-#include "sysdep/sigcontext.h"
 
 /* These two are from asm-um/uaccess.h and linux/module.h, check them. */
 struct exception_table_entry
@@ -17,26 +15,14 @@ struct exception_table_entry
 const struct exception_table_entry *search_exception_tables(unsigned long add);
 
 /* Compare this to arch/i386/mm/extable.c:fixup_exception() */
-int arch_fixup(unsigned long address, void *sc_ptr)
+int arch_fixup(unsigned long address, union uml_pt_regs *regs)
 {
-        struct sigcontext *sc = sc_ptr;
         const struct exception_table_entry *fixup;
 
         fixup = search_exception_tables(address);
         if(fixup != 0){
-                sc->eip = fixup->fixup;
+                UPT_IP(regs) = fixup->fixup;
                 return(1);
         }
         return(0);
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-i386/ptrace_user.c b/arch/um/sys-i386/ptrace_user.c
index 01212c88fcc4..40ff0c831bd0 100644
--- a/arch/um/sys-i386/ptrace_user.c
+++ b/arch/um/sys-i386/ptrace_user.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -15,7 +15,6 @@
 #include "user.h"
 #include "os.h"
 #include "uml-config.h"
-#include "user_util.h"
 
 int ptrace_getregs(long pid, unsigned long *regs_out)
 {
@@ -45,7 +44,8 @@ int ptrace_setfpregs(long pid, unsigned long *regs)
         return 0;
 }
 
-/* All the below stuff is of interest for TT mode only */
+#ifdef UML_CONFIG_MODE_TT
+
 static void write_debugregs(int pid, unsigned long *regs)
 {
         struct user *dummy;
@@ -128,13 +128,4 @@ void update_debugregs(int seq)
 }
 #endif
 
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
+#endif
diff --git a/arch/um/sys-i386/signal.c b/arch/um/sys-i386/signal.c
index 3f6acd667717..1cbf95f6858a 100644
--- a/arch/um/sys-i386/signal.c
+++ b/arch/um/sys-i386/signal.c
@@ -18,6 +18,28 @@
 
 #include "skas.h"
 
+void copy_sc(union uml_pt_regs *regs, void *from)
+{
+        struct sigcontext *sc = from;
+
+        REGS_GS(regs->skas.regs) = sc->gs;
+        REGS_FS(regs->skas.regs) = sc->fs;
+        REGS_ES(regs->skas.regs) = sc->es;
+        REGS_DS(regs->skas.regs) = sc->ds;
+        REGS_EDI(regs->skas.regs) = sc->edi;
+        REGS_ESI(regs->skas.regs) = sc->esi;
+        REGS_EBP(regs->skas.regs) = sc->ebp;
+        REGS_SP(regs->skas.regs) = sc->esp;
+        REGS_EBX(regs->skas.regs) = sc->ebx;
+        REGS_EDX(regs->skas.regs) = sc->edx;
+        REGS_ECX(regs->skas.regs) = sc->ecx;
+        REGS_EAX(regs->skas.regs) = sc->eax;
+        REGS_IP(regs->skas.regs) = sc->eip;
+        REGS_CS(regs->skas.regs) = sc->cs;
+        REGS_EFLAGS(regs->skas.regs) = sc->eflags;
+        REGS_SS(regs->skas.regs) = sc->ss;
+}
+
 static int copy_sc_from_user_skas(struct pt_regs *regs,
                                   struct sigcontext __user *from)
 {
@@ -28,33 +50,18 @@ static int copy_sc_from_user_skas(struct pt_regs *regs,
         err = copy_from_user(&sc, from, sizeof(sc));
         err |= copy_from_user(fpregs, sc.fpstate, sizeof(fpregs));
         if(err)
-                return(err);
-
-        REGS_GS(regs->regs.skas.regs) = sc.gs;
-        REGS_FS(regs->regs.skas.regs) = sc.fs;
-        REGS_ES(regs->regs.skas.regs) = sc.es;
-        REGS_DS(regs->regs.skas.regs) = sc.ds;
-        REGS_EDI(regs->regs.skas.regs) = sc.edi;
-        REGS_ESI(regs->regs.skas.regs) = sc.esi;
-        REGS_EBP(regs->regs.skas.regs) = sc.ebp;
-        REGS_SP(regs->regs.skas.regs) = sc.esp;
-        REGS_EBX(regs->regs.skas.regs) = sc.ebx;
-        REGS_EDX(regs->regs.skas.regs) = sc.edx;
-        REGS_ECX(regs->regs.skas.regs) = sc.ecx;
-        REGS_EAX(regs->regs.skas.regs) = sc.eax;
-        REGS_IP(regs->regs.skas.regs) = sc.eip;
-        REGS_CS(regs->regs.skas.regs) = sc.cs;
-        REGS_EFLAGS(regs->regs.skas.regs) = sc.eflags;
-        REGS_SS(regs->regs.skas.regs) = sc.ss;
+                return err;
+
+        copy_sc(&regs->regs, &sc);
 
         err = restore_fp_registers(userspace_pid[0], fpregs);
-        if(err < 0){
+        if(err < 0) {
                 printk("copy_sc_from_user_skas - PTRACE_SETFPREGS failed, "
-                       "errno = %d\n", err);
-                return(1);
+                       "errno = %d\n", -err);
+                return err;
         }
 
-        return(0);
+        return 0;
 }
 
 int copy_sc_to_user_skas(struct sigcontext __user *to, struct _fpstate __user *to_fp,
@@ -90,16 +97,16 @@ int copy_sc_to_user_skas(struct sigcontext __user *to, struct _fpstate __user *t
         if(err < 0){
                 printk("copy_sc_to_user_skas - PTRACE_GETFPREGS failed, "
                        "errno = %d\n", err);
-                return(1);
+                return 1;
         }
         to_fp = (to_fp ? to_fp : (struct _fpstate __user *) (to + 1));
         sc.fpstate = to_fp;
 
         if(err)
-                return(err);
+                return err;
 
-        return(copy_to_user(to, &sc, sizeof(sc)) ||
-               copy_to_user(to_fp, fpregs, sizeof(fpregs)));
+        return copy_to_user(to, &sc, sizeof(sc)) ||
+               copy_to_user(to_fp, fpregs, sizeof(fpregs));
 }
 #endif
 
@@ -129,7 +136,7 @@ int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext __user *from,
         to->fpstate = to_fp;
         if(to_fp != NULL)
                 err |= copy_from_user(to_fp, from_fp, fpsize);
-        return(err);
+        return err;
 }
 
 int copy_sc_to_user_tt(struct sigcontext __user *to, struct _fpstate __user *fp,
@@ -164,15 +171,15 @@ static int copy_sc_from_user(struct pt_regs *to, void __user *from)
         ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from,
                                                sizeof(struct _fpstate)),
                           copy_sc_from_user_skas(to, from));
-        return(ret);
+        return ret;
 }
 
 static int copy_sc_to_user(struct sigcontext __user *to, struct _fpstate __user *fp,
                            struct pt_regs *from, unsigned long sp)
 {
-        return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
+        return CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
                                               sizeof(*fp), sp),
-                           copy_sc_to_user_skas(to, fp, from, sp)));
+                           copy_sc_to_user_skas(to, fp, from, sp));
 }
 
 static int copy_ucontext_to_user(struct ucontext __user *uc, struct _fpstate __user *fp,
@@ -185,7 +192,7 @@ static int copy_ucontext_to_user(struct ucontext __user *uc, struct _fpstate __u
         err |= put_user(current->sas_ss_size, &uc->uc_stack.ss_size);
         err |= copy_sc_to_user(&uc->uc_mcontext, fp, &current->thread.regs, sp);
         err |= copy_to_user(&uc->uc_sigmask, set, sizeof(*set));
-        return(err);
+        return err;
 }
 
 struct sigframe
@@ -359,7 +366,7 @@ long sys_sigreturn(struct pt_regs regs)
 
         /* Avoid ERESTART handling */
         PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
-        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+        return PT_REGS_SYSCALL_RET(&current->thread.regs);
 
  segfault:
         force_sig(SIGSEGV, current);
@@ -389,20 +396,9 @@ long sys_rt_sigreturn(struct pt_regs regs)
 
         /* Avoid ERESTART handling */
         PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
-        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+        return PT_REGS_SYSCALL_RET(&current->thread.regs);
 
  segfault:
         force_sig(SIGSEGV, current);
         return 0;
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-i386/tls.c b/arch/um/sys-i386/tls.c
index 643dab585727..fea8e5e15cc4 100644
--- a/arch/um/sys-i386/tls.c
+++ b/arch/um/sys-i386/tls.c
@@ -23,9 +23,13 @@
 #include "skas.h"
 #endif
 
-/* If needed we can detect when it's uninitialized. */
+/*
+ * If needed we can detect when it's uninitialized.
+ *
+ * These are initialized in an initcall and unchanged thereafter.
+ */
 static int host_supports_tls = -1;
-int host_gdt_entry_tls_min = -1;
+int host_gdt_entry_tls_min;
 
 #ifdef CONFIG_MODE_SKAS
 int do_set_thread_area_skas(struct user_desc *info)
@@ -361,7 +365,8 @@ out:
 
 /* XXX: This part is probably common to i386 and x86-64. Don't create a common
  * file for now, do that when implementing x86-64 support.*/
-static int __init __setup_host_supports_tls(void) {
+static int __init __setup_host_supports_tls(void)
+{
         check_host_supports_tls(&host_supports_tls, &host_gdt_entry_tls_min);
         if (host_supports_tls) {
                 printk(KERN_INFO "Host TLS support detected\n");
diff --git a/arch/um/sys-i386/user-offsets.c b/arch/um/sys-i386/user-offsets.c
index 447306b20aea..29118cf5ff25 100644
--- a/arch/um/sys-i386/user-offsets.c
+++ b/arch/um/sys-i386/user-offsets.c
@@ -1,9 +1,10 @@
 #include <stdio.h>
+#include <stddef.h>
 #include <signal.h>
+#include <sys/poll.h>
+#include <sys/mman.h>
 #include <asm/ptrace.h>
 #include <asm/user.h>
-#include <stddef.h>
-#include <sys/poll.h>
 
 #define DEFINE(sym, val) \
         asm volatile("\n->" #sym " %0 " #val : : "i" (val))
@@ -47,7 +48,6 @@ void foo(void)
         OFFSET(HOST_SC_FP_ST, _fpstate, _st);
         OFFSET(HOST_SC_FXSR_ENV, _fpstate, _fxsr_env);
 
-        DEFINE(HOST_FRAME_SIZE, FRAME_SIZE);
         DEFINE_LONGS(HOST_FP_SIZE, sizeof(struct user_i387_struct));
         DEFINE_LONGS(HOST_XFP_SIZE, sizeof(struct user_fxsr_struct));
 
@@ -73,4 +73,8 @@ void foo(void)
         DEFINE(UM_POLLIN, POLLIN);
         DEFINE(UM_POLLPRI, POLLPRI);
         DEFINE(UM_POLLOUT, POLLOUT);
+
+        DEFINE(UM_PROT_READ, PROT_READ);
+        DEFINE(UM_PROT_WRITE, PROT_WRITE);
+        DEFINE(UM_PROT_EXEC, PROT_EXEC);
 }
diff --git a/arch/um/sys-ppc/sigcontext.c b/arch/um/sys-ppc/sigcontext.c
index 5d430fc994af..4bdc15c89edd 100644
--- a/arch/um/sys-ppc/sigcontext.c
+++ b/arch/um/sys-ppc/sigcontext.c
@@ -1,7 +1,6 @@
 #include "asm/ptrace.h"
 #include "asm/sigcontext.h"
 #include "sysdep/ptrace.h"
-#include "user_util.h"
 
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
diff --git a/arch/um/sys-x86_64/bugs.c b/arch/um/sys-x86_64/bugs.c
index fdce7ea98ca7..095478890371 100644
--- a/arch/um/sys-x86_64/bugs.c
+++ b/arch/um/sys-x86_64/bugs.c
@@ -4,12 +4,7 @@
  * Licensed under the GPL
  */
 
-#include "linux/sched.h"
-#include "linux/errno.h"
-#include "asm/system.h"
-#include "asm/pda.h"
 #include "sysdep/ptrace.h"
-#include "os.h"
 
 void arch_init_thread(void)
 {
@@ -21,102 +16,5 @@ void arch_check_bugs(void)
 
 int arch_handle_signal(int sig, union uml_pt_regs *regs)
 {
-        return(0);
+        return 0;
 }
-
-#define MAXTOKEN 64
-
-/* Set during early boot */
-int host_has_cmov = 1;
-int host_has_xmm = 0;
-
-static char token(int fd, char *buf, int len, char stop)
-{
-        int n;
-        char *ptr, *end, c;
-
-        ptr = buf;
-        end = &buf[len];
-        do {
-                n = os_read_file(fd, ptr, sizeof(*ptr));
-                c = *ptr++;
-                if(n != sizeof(*ptr)){
-                        if(n == 0) return(0);
-                        printk("Reading /proc/cpuinfo failed, err = %d\n", -n);
-                        if(n < 0)
-                                return(n);
-                        else
-                                return(-EIO);
-                }
-        } while((c != '\n') && (c != stop) && (ptr < end));
-
-        if(ptr == end){
-                printk("Failed to find '%c' in /proc/cpuinfo\n", stop);
-                return(-1);
-        }
-        *(ptr - 1) = '\0';
-        return(c);
-}
-
-static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
-{
-        int n;
-        char c;
-
-        scratch[len - 1] = '\0';
-        while(1){
-                c = token(fd, scratch, len - 1, ':');
-                if(c <= 0)
-                        return(0);
-                else if(c != ':'){
-                        printk("Failed to find ':' in /proc/cpuinfo\n");
-                        return(0);
-                }
-
-                if(!strncmp(scratch, key, strlen(key)))
-                        return(1);
-
-                do {
-                        n = os_read_file(fd, &c, sizeof(c));
-                        if(n != sizeof(c)){
-                                printk("Failed to find newline in "
-                                       "/proc/cpuinfo, err = %d\n", -n);
-                                return(0);
-                        }
-                } while(c != '\n');
-        }
-        return(0);
-}
-
-int cpu_feature(char *what, char *buf, int len)
-{
-        int fd, ret = 0;
-
-        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
-        if(fd < 0){
-                printk("Couldn't open /proc/cpuinfo, err = %d\n", -fd);
-                return(0);
-        }
-
-        if(!find_cpuinfo_line(fd, what, buf, len)){
-                printk("Couldn't find '%s' line in /proc/cpuinfo\n", what);
-                goto out_close;
-        }
-
-        token(fd, buf, len, '\n');
-        ret = 1;
-
- out_close:
-        os_close_file(fd);
-        return(ret);
-}
-
-/* Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-x86_64/fault.c b/arch/um/sys-x86_64/fault.c
index cee1513c5c31..4636b1465b6c 100644
--- a/arch/um/sys-x86_64/fault.c
+++ b/arch/um/sys-x86_64/fault.c
@@ -4,20 +4,24 @@
  * Licensed under the GPL
  */
 
-#include "user.h"
+#include "sysdep/ptrace.h"
 
-int arch_fixup(unsigned long address, void *sc_ptr)
+/* These two are from asm-um/uaccess.h and linux/module.h, check them. */
+struct exception_table_entry
 {
-        /* XXX search_exception_tables() */
+        unsigned long insn;
+        unsigned long fixup;
+};
+
+const struct exception_table_entry *search_exception_tables(unsigned long add);
+int arch_fixup(unsigned long address, union uml_pt_regs *regs)
+{
+        const struct exception_table_entry *fixup;
+
+        fixup = search_exception_tables(address);
+        if(fixup != 0){
+                UPT_IP(regs) = fixup->fixup;
+                return(1);
+        }
         return(0);
 }
-
-/* Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-x86_64/signal.c b/arch/um/sys-x86_64/signal.c
index af2f017617b4..fe8ec04d35bb 100644
--- a/arch/um/sys-x86_64/signal.c
+++ b/arch/um/sys-x86_64/signal.c
@@ -20,6 +20,36 @@
 
 #include "skas.h"
 
+void copy_sc(union uml_pt_regs *regs, void *from)
+{
+        struct sigcontext *sc = from;
+
+#define GETREG(regs, regno, sc, regname) \
+       (regs)->skas.regs[(regno) / sizeof(unsigned long)] = (sc)->regname
+
+       GETREG(regs, R8, sc, r8);
+       GETREG(regs, R9, sc, r9);
+       GETREG(regs, R10, sc, r10);
+       GETREG(regs, R11, sc, r11);
+       GETREG(regs, R12, sc, r12);
+       GETREG(regs, R13, sc, r13);
+       GETREG(regs, R14, sc, r14);
+       GETREG(regs, R15, sc, r15);
+       GETREG(regs, RDI, sc, rdi);
+       GETREG(regs, RSI, sc, rsi);
+       GETREG(regs, RBP, sc, rbp);
+       GETREG(regs, RBX, sc, rbx);
+       GETREG(regs, RDX, sc, rdx);
+       GETREG(regs, RAX, sc, rax);
+       GETREG(regs, RCX, sc, rcx);
+       GETREG(regs, RSP, sc, rsp);
+       GETREG(regs, RIP, sc, rip);
+       GETREG(regs, EFLAGS, sc, eflags);
+       GETREG(regs, CS, sc, cs);
+
+#undef GETREG
+}
+
 static int copy_sc_from_user_skas(struct pt_regs *regs,
                                  struct sigcontext __user *from)
 {
@@ -51,7 +81,7 @@ static int copy_sc_from_user_skas(struct pt_regs *regs,
 
 #undef GETREG
 
-       return(err);
+       return err;
 }
 
 int copy_sc_to_user_skas(struct sigcontext __user *to,
diff --git a/arch/um/sys-x86_64/user-offsets.c b/arch/um/sys-x86_64/user-offsets.c
index 899cebb57c3f..0d5fd764c21f 100644
--- a/arch/um/sys-x86_64/user-offsets.c
+++ b/arch/um/sys-x86_64/user-offsets.c
@@ -2,6 +2,7 @@
 #include <stddef.h>
 #include <signal.h>
 #include <sys/poll.h>
+#include <sys/mman.h>
 #define __FRAME_OFFSETS
 #include <asm/ptrace.h>
 #include <asm/types.h>
@@ -57,7 +58,6 @@ void foo(void)
         OFFSET(HOST_SC_SS, sigcontext, ss);
 #endif
 
-        DEFINE_LONGS(HOST_FRAME_SIZE, FRAME_SIZE);
         DEFINE(HOST_FP_SIZE, sizeof(struct _fpstate) / sizeof(unsigned long));
         DEFINE(HOST_XFP_SIZE, 0);
         DEFINE_LONGS(HOST_RBX, RBX);
@@ -94,4 +94,8 @@ void foo(void)
         DEFINE(UM_POLLIN, POLLIN);
         DEFINE(UM_POLLPRI, POLLPRI);
         DEFINE(UM_POLLOUT, POLLOUT);
+
+        DEFINE(UM_PROT_READ, PROT_READ);
+        DEFINE(UM_PROT_WRITE, PROT_WRITE);
+        DEFINE(UM_PROT_EXEC, PROT_EXEC);
 }