Whamcloud - gitweb
- series for uml on 2.6.0
authoralex <alex>
Tue, 3 Feb 2004 18:21:47 +0000 (18:21 +0000)
committeralex <alex>
Tue, 3 Feb 2004 18:21:47 +0000 (18:21 +0000)
NOTE: subsytem initialize order problem is to be solved yet

lustre/kernel_patches/patches/uml-patch-2.6.0-1-fix1.patch [new file with mode: 0644]
lustre/kernel_patches/patches/uml-patch-2.6.0-1.patch [new file with mode: 0644]
lustre/kernel_patches/patches/vfs_nointent_2.6.0-uml1.patch [new file with mode: 0644]
lustre/kernel_patches/series/uml_2.6.0 [new file with mode: 0644]

diff --git a/lustre/kernel_patches/patches/uml-patch-2.6.0-1-fix1.patch b/lustre/kernel_patches/patches/uml-patch-2.6.0-1-fix1.patch
new file mode 100644 (file)
index 0000000..997cd49
--- /dev/null
@@ -0,0 +1,15 @@
+Index: linux-2.6.0/include/asm-um/unistd.h
+===================================================================
+--- linux-2.6.0.orig/include/asm-um/unistd.h   2004-02-03 18:07:34.000000000 +0300
++++ linux-2.6.0/include/asm-um/unistd.h        2004-02-03 20:29:49.000000000 +0300
+@@ -6,8 +6,10 @@
+ #ifndef _UM_UNISTD_H_
+ #define _UM_UNISTD_H_
++#ifdef __KERNEL__
+ #include "linux/resource.h"
+ #include "asm/uaccess.h"
++#endif
+ extern long sys_open(const char *filename, int flags, int mode);
+ extern long sys_dup(unsigned int fildes);
diff --git a/lustre/kernel_patches/patches/uml-patch-2.6.0-1.patch b/lustre/kernel_patches/patches/uml-patch-2.6.0-1.patch
new file mode 100644 (file)
index 0000000..8bfe6a2
--- /dev/null
@@ -0,0 +1,18163 @@
+diff -Naur a/arch/um/config.release b/arch/um/config.release
+--- a/arch/um/config.release   2004-01-08 22:31:37.000000000 -0500
++++ b/arch/um/config.release   2004-01-08 22:36:18.000000000 -0500
+@@ -228,7 +228,6 @@
+ CONFIG_EXT2_FS=y
+ CONFIG_SYSV_FS=m
+ CONFIG_UDF_FS=m
+-# CONFIG_UDF_RW is not set
+ CONFIG_UFS_FS=m
+ # CONFIG_UFS_FS_WRITE is not set
+diff -Naur a/arch/um/defconfig b/arch/um/defconfig
+--- a/arch/um/defconfig        2004-01-08 22:24:41.000000000 -0500
++++ b/arch/um/defconfig        2004-01-08 22:32:17.000000000 -0500
+@@ -3,29 +3,19 @@
+ #
+ CONFIG_USERMODE=y
+ CONFIG_MMU=y
+-CONFIG_SWAP=y
+ CONFIG_UID16=y
+ CONFIG_RWSEM_GENERIC_SPINLOCK=y
+-CONFIG_CONFIG_LOG_BUF_SHIFT=14
+ #
+-# Code maturity level options
+-#
+-CONFIG_EXPERIMENTAL=y
+-
+-#
+-# General Setup
++# UML-specific options
+ #
+ CONFIG_MODE_TT=y
+ CONFIG_MODE_SKAS=y
+ CONFIG_NET=y
+-CONFIG_SYSVIPC=y
+-CONFIG_BSD_PROCESS_ACCT=y
+-CONFIG_SYSCTL=y
+-CONFIG_BINFMT_AOUT=y
+ CONFIG_BINFMT_ELF=y
+ CONFIG_BINFMT_MISC=y
+ CONFIG_HOSTFS=y
++CONFIG_HPPFS=y
+ CONFIG_MCONSOLE=y
+ CONFIG_MAGIC_SYSRQ=y
+ # CONFIG_HOST_2G_2G is not set
+@@ -36,12 +26,41 @@
+ # CONFIG_HIGHMEM is not set
+ CONFIG_PROC_MM=y
+ CONFIG_KERNEL_STACK_ORDER=2
++CONFIG_UML_REAL_TIME_CLOCK=y
++
++#
++# Code maturity level options
++#
++CONFIG_EXPERIMENTAL=y
++CONFIG_CLEAN_COMPILE=y
++CONFIG_STANDALONE=y
++CONFIG_BROKEN_ON_SMP=y
++
++#
++# General setup
++#
++CONFIG_SWAP=y
++CONFIG_SYSVIPC=y
++CONFIG_BSD_PROCESS_ACCT=y
++CONFIG_SYSCTL=y
++CONFIG_LOG_BUF_SHIFT=14
++# CONFIG_IKCONFIG is not set
++# CONFIG_EMBEDDED is not set
++CONFIG_KALLSYMS=y
++CONFIG_FUTEX=y
++CONFIG_EPOLL=y
++CONFIG_IOSCHED_NOOP=y
++CONFIG_IOSCHED_AS=y
++CONFIG_IOSCHED_DEADLINE=y
+ #
+ # Loadable module support
+ #
+-CONFIG_MODULES=y
+-# CONFIG_KMOD is not set
++# CONFIG_MODULES is not set
++
++#
++# Generic Driver Options
++#
+ #
+ # Character Devices
+@@ -69,6 +88,7 @@
+ #
+ CONFIG_BLK_DEV_UBD=y
+ # CONFIG_BLK_DEV_UBD_SYNC is not set
++CONFIG_BLK_DEV_COW_COMMON=y
+ CONFIG_BLK_DEV_LOOP=y
+ CONFIG_BLK_DEV_NBD=y
+ CONFIG_BLK_DEV_RAM=y
+@@ -78,7 +98,7 @@
+ CONFIG_NETDEVICES=y
+ #
+-# Network Devices
++# UML Network Devices
+ #
+ CONFIG_UML_NET=y
+ CONFIG_UML_NET_ETHERTAP=y
+@@ -88,22 +108,6 @@
+ CONFIG_UML_NET_MCAST=y
+ # CONFIG_UML_NET_PCAP is not set
+ CONFIG_UML_NET_SLIRP=y
+-CONFIG_DUMMY=y
+-# CONFIG_BONDING is not set
+-# CONFIG_EQUALIZER is not set
+-CONFIG_TUN=y
+-# CONFIG_ETHERTAP is not set
+-CONFIG_PPP=y
+-# CONFIG_PPP_MULTILINK is not set
+-# CONFIG_PPP_ASYNC is not set
+-# CONFIG_PPP_SYNC_TTY is not set
+-# CONFIG_PPP_DEFLATE is not set
+-# CONFIG_PPP_BSDCOMP is not set
+-# CONFIG_PPPOE is not set
+-CONFIG_SLIP=y
+-# CONFIG_SLIP_COMPRESSED is not set
+-# CONFIG_SLIP_SMART is not set
+-# CONFIG_SLIP_MODE_SLIP6 is not set
+ #
+ # Networking support
+@@ -115,8 +119,6 @@
+ CONFIG_PACKET=y
+ CONFIG_PACKET_MMAP=y
+ # CONFIG_NETLINK_DEV is not set
+-# CONFIG_NETFILTER is not set
+-# CONFIG_FILTER is not set
+ CONFIG_UNIX=y
+ # CONFIG_NET_KEY is not set
+ CONFIG_INET=y
+@@ -130,8 +132,11 @@
+ # CONFIG_SYN_COOKIES is not set
+ # CONFIG_INET_AH is not set
+ # CONFIG_INET_ESP is not set
+-# CONFIG_XFRM_USER is not set
++# CONFIG_INET_IPCOMP is not set
+ # CONFIG_IPV6 is not set
++# CONFIG_DECNET is not set
++# CONFIG_BRIDGE is not set
++# CONFIG_NETFILTER is not set
+ #
+ # SCTP Configuration (EXPERIMENTAL)
+@@ -140,9 +145,9 @@
+ # CONFIG_IP_SCTP is not set
+ # CONFIG_ATM is not set
+ # CONFIG_VLAN_8021Q is not set
+-# CONFIG_LLC is not set
+-# CONFIG_DECNET is not set
+-# CONFIG_BRIDGE is not set
++# CONFIG_LLC2 is not set
++# CONFIG_IPX is not set
++# CONFIG_ATALK is not set
+ # CONFIG_X25 is not set
+ # CONFIG_LAPB is not set
+ # CONFIG_NET_DIVERT is not set
+@@ -160,6 +165,10 @@
+ # Network testing
+ #
+ # CONFIG_NET_PKTGEN is not set
++CONFIG_DUMMY=y
++# CONFIG_BONDING is not set
++# CONFIG_EQUALIZER is not set
++CONFIG_TUN=y
+ #
+ # Ethernet (10 or 100Mbit)
+@@ -171,12 +180,28 @@
+ #
+ #
++# Ethernet (10000 Mbit)
++#
++CONFIG_PPP=y
++# CONFIG_PPP_MULTILINK is not set
++# CONFIG_PPP_FILTER is not set
++# CONFIG_PPP_ASYNC is not set
++# CONFIG_PPP_SYNC_TTY is not set
++# CONFIG_PPP_DEFLATE is not set
++# CONFIG_PPP_BSDCOMP is not set
++# CONFIG_PPPOE is not set
++CONFIG_SLIP=y
++# CONFIG_SLIP_COMPRESSED is not set
++# CONFIG_SLIP_SMART is not set
++# CONFIG_SLIP_MODE_SLIP6 is not set
++
++#
+ # Wireless LAN (non-hamradio)
+ #
+ # CONFIG_NET_RADIO is not set
+ #
+-# Token Ring devices (depends on LLC=y)
++# Token Ring devices
+ #
+ # CONFIG_SHAPER is not set
+@@ -186,68 +211,101 @@
+ # CONFIG_WAN is not set
+ #
++# Amateur Radio support
++#
++# CONFIG_HAMRADIO is not set
++
++#
++# IrDA (infrared) support
++#
++# CONFIG_IRDA is not set
++
++#
++# Bluetooth support
++#
++# CONFIG_BT is not set
++
++#
+ # File systems
+ #
++CONFIG_EXT2_FS=y
++# CONFIG_EXT2_FS_XATTR is not set
++# CONFIG_EXT3_FS is not set
++# CONFIG_JBD is not set
++CONFIG_REISERFS_FS=y
++# CONFIG_REISERFS_CHECK is not set
++# CONFIG_REISERFS_PROC_INFO is not set
++# CONFIG_JFS_FS is not set
++# CONFIG_XFS_FS is not set
++CONFIG_MINIX_FS=y
++# CONFIG_ROMFS_FS is not set
+ CONFIG_QUOTA=y
+ # CONFIG_QFMT_V1 is not set
+ # CONFIG_QFMT_V2 is not set
+ CONFIG_QUOTACTL=y
+-CONFIG_AUTOFS_FS=m
+-CONFIG_AUTOFS4_FS=m
+-CONFIG_REISERFS_FS=m
+-# CONFIG_REISERFS_CHECK is not set
+-# CONFIG_REISERFS_PROC_INFO is not set
++CONFIG_AUTOFS_FS=y
++CONFIG_AUTOFS4_FS=y
++
++#
++# CD-ROM/DVD Filesystems
++#
++CONFIG_ISO9660_FS=y
++# CONFIG_JOLIET is not set
++# CONFIG_ZISOFS is not set
++# CONFIG_UDF_FS is not set
++
++#
++# DOS/FAT/NT Filesystems
++#
++CONFIG_FAT_FS=y
++CONFIG_MSDOS_FS=y
++CONFIG_VFAT_FS=y
++# CONFIG_NTFS_FS is not set
++
++#
++# Pseudo filesystems
++#
++CONFIG_PROC_FS=y
++CONFIG_PROC_KCORE=y
++CONFIG_DEVFS_FS=y
++CONFIG_DEVFS_MOUNT=y
++# CONFIG_DEVFS_DEBUG is not set
++CONFIG_DEVPTS_FS=y
++# CONFIG_DEVPTS_FS_XATTR is not set
++# CONFIG_TMPFS is not set
++# CONFIG_HUGETLB_PAGE is not set
++CONFIG_RAMFS=y
++
++#
++# Miscellaneous filesystems
++#
+ # CONFIG_ADFS_FS is not set
+ # CONFIG_AFFS_FS is not set
+ # CONFIG_HFS_FS is not set
+ # CONFIG_BEFS_FS is not set
+ # CONFIG_BFS_FS is not set
+-# CONFIG_EXT3_FS is not set
+-# CONFIG_JBD is not set
+-CONFIG_FAT_FS=m
+-CONFIG_MSDOS_FS=m
+-CONFIG_VFAT_FS=m
+ # CONFIG_EFS_FS is not set
+ CONFIG_JFFS_FS=y
+ CONFIG_JFFS_FS_VERBOSE=0
+-CONFIG_JFFS_PROC_FS=y
+ # CONFIG_JFFS2_FS is not set
+ # CONFIG_CRAMFS is not set
+-# CONFIG_TMPFS is not set
+-CONFIG_RAMFS=y
+-CONFIG_ISO9660_FS=m
+-# CONFIG_JOLIET is not set
+-# CONFIG_ZISOFS is not set
+-# CONFIG_JFS_FS is not set
+-CONFIG_MINIX_FS=m
+ # CONFIG_VXFS_FS is not set
+-# CONFIG_NTFS_FS is not set
+ # CONFIG_HPFS_FS is not set
+-CONFIG_PROC_FS=y
+-CONFIG_DEVFS_FS=y
+-CONFIG_DEVFS_MOUNT=y
+-# CONFIG_DEVFS_DEBUG is not set
+-CONFIG_DEVPTS_FS=y
+ # CONFIG_QNX4FS_FS is not set
+-# CONFIG_ROMFS_FS is not set
+-CONFIG_EXT2_FS=y
+-# CONFIG_EXT2_FS_XATTR is not set
+ # CONFIG_SYSV_FS is not set
+-# CONFIG_UDF_FS is not set
+ # CONFIG_UFS_FS is not set
+-# CONFIG_XFS_FS is not set
+ #
+ # Network File Systems
+ #
+-# CONFIG_CODA_FS is not set
+-# CONFIG_INTERMEZZO_FS is not set
+ # CONFIG_NFS_FS is not set
+ # CONFIG_NFSD is not set
+ # CONFIG_EXPORTFS is not set
+-# CONFIG_CIFS is not set
+ # CONFIG_SMB_FS is not set
++# CONFIG_CIFS is not set
+ # CONFIG_NCP_FS is not set
++# CONFIG_CODA_FS is not set
++# CONFIG_INTERMEZZO_FS is not set
+ # CONFIG_AFS_FS is not set
+ #
+@@ -317,28 +375,7 @@
+ #
+ # SCSI support
+ #
+-CONFIG_SCSI=y
+-CONFIG_GENERIC_ISA_DMA=y
+-
+-#
+-# SCSI support type (disk, tape, CD-ROM)
+-#
+-CONFIG_BLK_DEV_SD=y
+-CONFIG_SD_EXTRA_DEVS=40
+-CONFIG_CHR_DEV_ST=y
+-CONFIG_BLK_DEV_SR=y
+-CONFIG_BLK_DEV_SR_VENDOR=y
+-CONFIG_SR_EXTRA_DEVS=2
+-CONFIG_CHR_DEV_SG=y
+-
+-#
+-# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+-#
+-CONFIG_SCSI_DEBUG_QUEUES=y
+-CONFIG_SCSI_MULTI_LUN=y
+-CONFIG_SCSI_CONSTANTS=y
+-CONFIG_SCSI_LOGGING=y
+-CONFIG_SCSI_DEBUG=y
++# CONFIG_SCSI is not set
+ #
+ # Multi-device support (RAID and LVM)
+@@ -360,6 +397,7 @@
+ CONFIG_MTD_BLOCK=y
+ # CONFIG_FTL is not set
+ # CONFIG_NFTL is not set
++# CONFIG_INFTL is not set
+ #
+ # RAM/ROM/Flash chip drivers
+@@ -374,20 +412,21 @@
+ #
+ # Mapping drivers for chip access
+ #
++# CONFIG_MTD_COMPLEX_MAPPINGS is not set
+ #
+ # Self-contained MTD device drivers
+ #
+ # CONFIG_MTD_SLRAM is not set
+ # CONFIG_MTD_MTDRAM is not set
+-CONFIG_MTD_BLKMTD=m
++CONFIG_MTD_BLKMTD=y
+ #
+ # Disk-On-Chip Device Drivers
+ #
+-# CONFIG_MTD_DOC1000 is not set
+ # CONFIG_MTD_DOC2000 is not set
+ # CONFIG_MTD_DOC2001 is not set
++# CONFIG_MTD_DOC2001PLUS is not set
+ #
+ # NAND Flash Device Drivers
+diff -Naur a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
+--- a/arch/um/drivers/chan_kern.c      2004-01-08 22:32:12.000000000 -0500
++++ b/arch/um/drivers/chan_kern.c      2004-01-08 22:36:26.000000000 -0500
+@@ -8,6 +8,7 @@
+ #include <linux/list.h>
+ #include <linux/slab.h>
+ #include <linux/tty.h>
++#include <linux/string.h>
+ #include <linux/tty_flip.h>
+ #include <asm/irq.h>
+ #include "chan_kern.h"
+@@ -265,6 +266,11 @@
+ {
+       int n = 0;
++      if(chan == NULL){
++              CONFIG_CHUNK(str, size, n, "none", 1);
++              return(n);
++      }
++
+       CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
+       if(chan->dev == NULL){
+@@ -420,7 +426,8 @@
+               INIT_LIST_HEAD(chans);
+       }
+-      if((out = strchr(str, ',')) != NULL){
++      out = strchr(str, ',');
++      if(out != NULL){
+               in = str;
+               *out = '\0';
+               out++;
+@@ -475,12 +482,15 @@
+                               goto out;
+                       }
+                       err = chan->ops->read(chan->fd, &c, chan->data);
+-                      if(err > 0) tty_receive_char(tty, c);
++                      if(err > 0) 
++                              tty_receive_char(tty, c);
+               } while(err > 0);
++
+               if(err == 0) reactivate_fd(chan->fd, irq);
+               if(err == -EIO){
+                       if(chan->primary){
+-                              if(tty != NULL) tty_hangup(tty);
++                              if(tty != NULL) 
++                                      tty_hangup(tty);
+                               line_disable(dev, irq);
+                               close_chan(chans);
+                               free_chan(chans);
+diff -Naur a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
+--- a/arch/um/drivers/chan_user.c      2004-01-08 22:13:40.000000000 -0500
++++ b/arch/um/drivers/chan_user.c      2004-01-08 22:17:53.000000000 -0500
+@@ -1,5 +1,5 @@
+ /* 
+- * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+@@ -7,7 +7,6 @@
+ #include <stdlib.h>
+ #include <errno.h>
+ #include <termios.h>
+-#include <fcntl.h>
+ #include <string.h>
+ #include <signal.h>
+ #include <sys/stat.h>
+@@ -24,29 +23,27 @@
+ void generic_close(int fd, void *unused)
+ {
+-      close(fd);
++      os_close_file(fd);
+ }
+ int generic_read(int fd, char *c_out, void *unused)
+ {
+       int n;
+-      n = read(fd, c_out, sizeof(*c_out));
+-      if(n < 0){
+-              if(errno == EAGAIN) return(0);
+-              return(-errno);
+-      }
+-      else if(n == 0) return(-EIO);
+-      return(1);
++      n = os_read_file(fd, c_out, sizeof(*c_out));
++
++      if(n == -EAGAIN) 
++              return(0);
++      else if(n == 0) 
++              return(-EIO);
++      return(n);
+ }
++/* XXX Trivial wrapper around os_write_file */
++
+ int generic_write(int fd, const char *buf, int n, void *unused)
+ {
+-      int count;
+-
+-      count = write(fd, buf, n);
+-      if(count < 0) return(-errno);
+-      return(count);
++      return(os_write_file(fd, buf, n));
+ }
+ int generic_console_write(int fd, const char *buf, int n, void *unused)
+@@ -68,15 +65,18 @@
+ int generic_window_size(int fd, void *unused, unsigned short *rows_out,
+                       unsigned short *cols_out)
+ {
+-      struct winsize size;
+-      int ret = 0;
++      int rows, cols;
++      int ret;
++
++      ret = os_window_size(fd, &rows, &cols);
++      if(ret < 0)
++              return(ret);
++
++      ret = ((*rows_out != rows) || (*cols_out != cols));
++
++      *rows_out = rows;
++      *cols_out = cols;
+-      if(ioctl(fd, TIOCGWINSZ, &size) == 0){
+-              ret = ((*rows_out != size.ws_row) || 
+-                     (*cols_out != size.ws_col));
+-              *rows_out = size.ws_row;
+-              *cols_out = size.ws_col;
+-      }
+       return(ret);
+ }
+@@ -100,14 +100,16 @@
+       struct winch_data *data = arg;
+       sigset_t sigs;
+       int pty_fd, pipe_fd;
++      int count, err;
+       char c = 1;
+-      close(data->close_me);
++      os_close_file(data->close_me);
+       pty_fd = data->pty_fd;
+       pipe_fd = data->pipe_fd;
+-      if(write(pipe_fd, &c, sizeof(c)) != sizeof(c))
++      count = os_write_file(pipe_fd, &c, sizeof(c));
++      if(count != sizeof(c))
+               printk("winch_thread : failed to write synchronization "
+-                     "byte, errno = %d\n", errno);
++                     "byte, err = %d\n", -count);
+       signal(SIGWINCH, winch_handler);
+       sigfillset(&sigs);
+@@ -123,26 +125,24 @@
+               exit(1);
+       }
+-      if(ioctl(pty_fd, TIOCSCTTY, 0) < 0){
+-              printk("winch_thread : TIOCSCTTY failed, errno = %d\n", errno);
+-              exit(1);
+-      }
+-      if(tcsetpgrp(pty_fd, os_getpid()) < 0){
+-              printk("winch_thread : tcsetpgrp failed, errno = %d\n", errno);
++      err = os_new_tty_pgrp(pty_fd, os_getpid());
++      if(err < 0){
++              printk("winch_thread : new_tty_pgrp failed, err = %d\n", -err);
+               exit(1);
+       }
+-      if(read(pipe_fd, &c, sizeof(c)) != sizeof(c))
++      count = os_read_file(pipe_fd, &c, sizeof(c));
++      if(count != sizeof(c))
+               printk("winch_thread : failed to read synchronization byte, "
+-                     "errno = %d\n", errno);
++                     "err = %d\n", -count);
+       while(1){
+               pause();
+-              if(write(pipe_fd, &c, sizeof(c)) != sizeof(c)){
+-                      printk("winch_thread : write failed, errno = %d\n",
+-                             errno);
+-              }
++              count = os_write_file(pipe_fd, &c, sizeof(c));
++              if(count != sizeof(c))
++                      printk("winch_thread : write failed, err = %d\n",
++                             -count);
+       }
+ }
+@@ -154,8 +154,8 @@
+       char c;
+       err = os_pipe(fds, 1, 1);
+-      if(err){
+-              printk("winch_tramp : os_pipe failed, errno = %d\n", -err);
++      if(err < 0){
++              printk("winch_tramp : os_pipe failed, err = %d\n", -err);
+               return(err);
+       }
+@@ -168,12 +168,12 @@
+               return(pid);
+       }
+-      close(fds[1]);
++      os_close_file(fds[1]);
+       *fd_out = fds[0];
+-      n = read(fds[0], &c, sizeof(c));
++      n = os_read_file(fds[0], &c, sizeof(c));
+       if(n != sizeof(c)){
+               printk("winch_tramp : failed to read synchronization byte\n");
+-              printk("read returned %d, errno = %d\n", n, errno);
++              printk("read failed, err = %d\n", -n);
+               printk("fd %d will not support SIGWINCH\n", fd);
+               *fd_out = -1;
+       }
+@@ -183,20 +183,24 @@
+ void register_winch(int fd, void *device_data)
+ {
+       int pid, thread, thread_fd;
++      int count;
+       char c = 1;
+-      if(!isatty(fd)) return;
++      if(!isatty(fd)) 
++              return;
+       pid = tcgetpgrp(fd);
+-      if(!CHOOSE_MODE(is_tracer_winch(pid, fd, device_data), 0) && 
+-         (pid == -1)){
++      if(!CHOOSE_MODE_PROC(is_tracer_winch, is_skas_winch, pid, fd, 
++                           device_data) && (pid == -1)){
+               thread = winch_tramp(fd, device_data, &thread_fd);
+               if(fd != -1){
+                       register_winch_irq(thread_fd, fd, thread, device_data);
+-                      if(write(thread_fd, &c, sizeof(c)) != sizeof(c))
++                      count = os_write_file(thread_fd, &c, sizeof(c));
++                      if(count != sizeof(c))
+                               printk("register_winch : failed to write "
+-                                     "synchronization byte\n");
++                                     "synchronization byte, err = %d\n",
++                                      -count);
+               }
+       }
+ }
+diff -Naur a/arch/um/drivers/cow.h b/arch/um/drivers/cow.h
+--- a/arch/um/drivers/cow.h    1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/drivers/cow.h    2004-01-08 22:20:48.000000000 -0500
+@@ -0,0 +1,41 @@
++#ifndef __COW_H__
++#define __COW_H__
++
++#include <asm/types.h>
++
++#if __BYTE_ORDER == __BIG_ENDIAN
++# define ntohll(x) (x)
++# define htonll(x) (x)
++#elif __BYTE_ORDER == __LITTLE_ENDIAN
++# define ntohll(x)  bswap_64(x)
++# define htonll(x)  bswap_64(x)
++#else
++#error "__BYTE_ORDER not defined"
++#endif
++
++extern int init_cow_file(int fd, char *cow_file, char *backing_file, 
++                       int sectorsize, int alignment, int *bitmap_offset_out, 
++                       unsigned long *bitmap_len_out, int *data_offset_out);
++
++extern int file_reader(__u64 offset, char *buf, int len, void *arg);
++extern int read_cow_header(int (*reader)(__u64, char *, int, void *), 
++                         void *arg, __u32 *version_out, 
++                         char **backing_file_out, time_t *mtime_out, 
++                         __u64 *size_out, int *sectorsize_out, 
++                         __u32 *align_out, int *bitmap_offset_out);
++
++extern int write_cow_header(char *cow_file, int fd, char *backing_file, 
++                          int sectorsize, int alignment, long long *size);
++
++extern void cow_sizes(int version, __u64 size, int sectorsize, int align,
++                    int bitmap_offset, unsigned long *bitmap_len_out, 
++                    int *data_offset_out);
++
++#endif
++
++/*
++ * ---------------------------------------------------------------------------
++ * Local variables:
++ * c-file-style: "linux"
++ * End:
++ */
+diff -Naur a/arch/um/drivers/cow_kern.c b/arch/um/drivers/cow_kern.c
+--- a/arch/um/drivers/cow_kern.c       1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/drivers/cow_kern.c       2004-01-08 22:36:26.000000000 -0500
+@@ -0,0 +1,630 @@
++#define COW_MAJOR 60
++#define MAJOR_NR COW_MAJOR
++
++#include <linux/stddef.h>
++#include <linux/kernel.h>
++#include <linux/ctype.h>
++#include <linux/stat.h>
++#include <linux/vmalloc.h>
++#include <linux/blkdev.h>
++#include <linux/blk.h>
++#include <linux/fs.h>
++#include <linux/genhd.h>
++#include <linux/devfs_fs.h>
++#include <asm/uaccess.h>
++#include "2_5compat.h"
++#include "cow.h"
++#include "ubd_user.h"
++
++#define COW_SHIFT 4
++
++struct cow {
++      int count;
++      char *cow_path;
++      dev_t cow_dev;
++      struct block_device *cow_bdev;
++      char *backing_path;
++      dev_t backing_dev;
++      struct block_device *backing_bdev;
++      int sectorsize;
++      unsigned long *bitmap;
++      unsigned long bitmap_len;
++      int bitmap_offset;
++      int data_offset;
++      devfs_handle_t devfs;
++      struct semaphore sem;
++      struct semaphore io_sem;
++      atomic_t working;
++      spinlock_t io_lock;
++      struct buffer_head *bh;
++      struct buffer_head *bhtail;
++      void *end_io;
++};
++
++#define DEFAULT_COW { \
++      .count                  = 0, \
++      .cow_path               = NULL, \
++      .cow_dev                = 0, \
++      .backing_path           = NULL, \
++      .backing_dev            = 0, \
++        .bitmap                       = NULL, \
++      .bitmap_len             = 0, \
++      .bitmap_offset          = 0, \
++        .data_offset          = 0, \
++      .devfs                  = NULL, \
++      .working                = ATOMIC_INIT(0), \
++      .io_lock                = SPIN_LOCK_UNLOCKED, \
++}
++
++#define MAX_DEV (8)
++#define MAX_MINOR (MAX_DEV << COW_SHIFT)
++
++struct cow cow_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_COW };
++
++/* Not modified by this driver */
++static int blk_sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = BLOCK_SIZE };
++static int hardsect_sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = 512 };
++
++/* Protected by cow_lock */
++static int sizes[MAX_MINOR] = { [ 0 ... MAX_MINOR - 1 ] = 0 };
++
++static struct hd_struct       cow_part[MAX_MINOR] =
++      { [ 0 ... MAX_MINOR - 1 ] = { 0, 0, 0 } };
++
++/* Protected by io_request_lock */
++static request_queue_t *cow_queue;
++
++static int cow_open(struct inode *inode, struct file *filp);
++static int cow_release(struct inode * inode, struct file * file);
++static int cow_ioctl(struct inode * inode, struct file * file,
++                   unsigned int cmd, unsigned long arg);
++static int cow_revalidate(kdev_t rdev);
++
++static struct block_device_operations cow_blops = {
++       .open          = cow_open,
++       .release       = cow_release,
++       .ioctl         = cow_ioctl,
++       .revalidate    = cow_revalidate,
++};
++
++/* Initialized in an initcall, and unchanged thereafter */
++devfs_handle_t cow_dir_handle;
++
++#define INIT_GENDISK(maj, name, parts, shift, bsizes, max, blops) \
++{ \
++      .major          = maj, \
++      .major_name     = name, \
++      .minor_shift    = shift, \
++      .max_p          = 1 << shift, \
++      .part           = parts, \
++      .sizes          = bsizes, \
++      .nr_real        = max, \
++      .real_devices   = NULL, \
++      .next           = NULL, \
++      .fops           = blops, \
++      .de_arr         = NULL, \
++      .flags          = 0 \
++}
++
++static spinlock_t cow_lock = SPIN_LOCK_UNLOCKED;
++
++static struct gendisk cow_gendisk = INIT_GENDISK(MAJOR_NR, "cow", cow_part,
++                                               COW_SHIFT, sizes, MAX_DEV, 
++                                               &cow_blops);
++
++static int cow_add(int n)
++{
++      struct cow *dev = &cow_dev[n];
++      char name[sizeof("nnnnnn\0")];
++      int err = -ENODEV;
++
++      if(dev->cow_path == NULL)
++              goto out;
++
++      sprintf(name, "%d", n);
++      dev->devfs = devfs_register(cow_dir_handle, name, DEVFS_FL_REMOVABLE,
++                                  MAJOR_NR, n << COW_SHIFT, S_IFBLK | 
++                                  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
++                                  &cow_blops, NULL);
++
++      init_MUTEX_LOCKED(&dev->sem);
++      init_MUTEX(&dev->io_sem);
++
++      return(0);
++
++out:
++      return(err);
++}
++
++/*
++* Add buffer_head to back of pending list
++*/
++static void cow_add_bh(struct cow *cow, struct buffer_head *bh)
++{
++      unsigned long flags;
++
++      spin_lock_irqsave(&cow->io_lock, flags);
++      if(cow->bhtail != NULL){
++              cow->bhtail->b_reqnext = bh;
++              cow->bhtail = bh;
++      }
++      else {
++              cow->bh = bh;
++              cow->bhtail = bh;
++      }
++      spin_unlock_irqrestore(&cow->io_lock, flags);
++}
++
++/*
++* Grab first pending buffer
++*/
++static struct buffer_head *cow_get_bh(struct cow *cow)
++{
++      struct buffer_head *bh;
++
++      spin_lock_irq(&cow->io_lock);
++      bh = cow->bh;
++      if(bh != NULL){
++              if(bh == cow->bhtail)
++                      cow->bhtail = NULL;
++              cow->bh = bh->b_reqnext;
++              bh->b_reqnext = NULL;
++      }
++      spin_unlock_irq(&cow->io_lock);
++
++      return(bh);
++}
++
++static void cow_handle_bh(struct cow *cow, struct buffer_head *bh, 
++                        struct buffer_head **cow_bh, int ncow_bh)
++{
++      int i;
++
++      if(ncow_bh > 0)
++              ll_rw_block(WRITE, ncow_bh, cow_bh);
++
++      for(i = 0; i < ncow_bh ; i++){
++              wait_on_buffer(cow_bh[i]);
++              brelse(cow_bh[i]);
++      }
++
++      ll_rw_block(WRITE, 1, &bh);
++      brelse(bh);
++}
++
++static struct buffer_head *cow_new_bh(struct cow *dev, int sector)
++{
++      struct buffer_head *bh;
++
++      sector = (dev->bitmap_offset + sector / 8) / dev->sectorsize;
++      bh = getblk(dev->cow_dev, sector, dev->sectorsize);
++      memcpy(bh->b_data, dev->bitmap + sector / (8 * sizeof(dev->bitmap[0])),
++             dev->sectorsize);
++      return(bh);
++}
++
++/* Copied from loop.c, needed to avoid deadlocking in make_request. */
++
++static int cow_thread(void *data)
++{
++      struct cow *dev = data;
++      struct buffer_head *bh;
++
++      daemonize();
++      exit_files(current);
++
++      sprintf(current->comm, "cow%d", dev - cow_dev);
++
++      spin_lock_irq(&current->sigmask_lock);
++      sigfillset(&current->blocked);
++      flush_signals(current);
++      spin_unlock_irq(&current->sigmask_lock);
++
++      atomic_inc(&dev->working);
++
++      current->policy = SCHED_OTHER;
++      current->nice = -20;
++
++      current->flags |= PF_NOIO;
++
++      /*
++       * up sem, we are running
++       */
++      up(&dev->sem);
++
++      for(;;){
++              int start, len, nbh, i, update_bitmap = 0;
++              struct buffer_head *cow_bh[2];
++
++              down_interruptible(&dev->io_sem);
++              /*
++               * could be upped because of tear-down, not because of
++               * pending work
++               */
++              if(!atomic_read(&dev->working))
++                      break;
++
++              bh = cow_get_bh(dev);
++              if(bh == NULL){
++                      printk(KERN_ERR "cow: missing bh\n");
++                      continue;
++              }
++
++              start = bh->b_blocknr * bh->b_size / dev->sectorsize;
++              len = bh->b_size / dev->sectorsize;
++              for(i = 0; i < len ; i++){
++                      if(ubd_test_bit(start +ni, 
++                                      (unsigned char *) dev->bitmap))
++                              continue;
++
++                      update_bitmap = 1;
++                      ubd_set_bit(start + i, (unsigned char *) dev->bitmap);
++              }
++
++              cow_bh[0] = NULL;
++              cow_bh[1] = NULL;
++              nbh = 0;
++              if(update_bitmap){
++                      cow_bh[0] = cow_new_bh(dev, start);
++                      nbh++;
++                      if(start / dev->sectorsize != 
++                         (start + len) / dev->sectorsize){
++                              cow_bh[1] = cow_new_bh(dev, start + len);
++                              nbh++;
++                      }
++              }
++              
++              bh->b_dev = dev->cow_dev;
++              bh->b_blocknr += dev->data_offset / dev->sectorsize;
++
++              cow_handle_bh(dev, bh, cow_bh, nbh);
++
++              /*
++               * upped both for pending work and tear-down, lo_pending
++               * will hit zero then
++               */
++              if(atomic_dec_and_test(&dev->working))
++                      break;
++      }
++
++      up(&dev->sem);
++      return(0);
++}
++
++static int cow_make_request(request_queue_t *q, int rw, struct buffer_head *bh)
++{
++      struct cow *dev;
++      int n, minor;
++
++      minor = MINOR(bh->b_rdev);
++      n = minor >> COW_SHIFT;
++      dev = &cow_dev[n];
++
++      dev->end_io = NULL;
++      if(ubd_test_bit(bh->b_rsector, (unsigned char *) dev->bitmap)){
++              bh->b_rdev = dev->cow_dev;
++              bh->b_rsector += dev->data_offset / dev->sectorsize;
++      }
++      else if(rw == WRITE){
++              bh->b_dev = dev->cow_dev;
++              bh->b_blocknr += dev->data_offset / dev->sectorsize;
++
++              cow_add_bh(dev, bh);
++              up(&dev->io_sem);
++              return(0);
++      }
++      else {
++              bh->b_rdev = dev->backing_dev;
++      }
++
++      return(1);
++}
++
++int cow_init(void)
++{
++      int i;
++
++      cow_dir_handle = devfs_mk_dir (NULL, "cow", NULL);
++      if (devfs_register_blkdev(MAJOR_NR, "cow", &cow_blops)) {
++              printk(KERN_ERR "cow: unable to get major %d\n", MAJOR_NR);
++              return -1;
++      }
++      read_ahead[MAJOR_NR] = 8;               /* 8 sector (4kB) read-ahead */
++      blksize_size[MAJOR_NR] = blk_sizes;
++      blk_size[MAJOR_NR] = sizes;
++      INIT_HARDSECT(hardsect_size, MAJOR_NR, hardsect_sizes);
++
++      cow_queue = BLK_DEFAULT_QUEUE(MAJOR_NR);
++      blk_init_queue(cow_queue, NULL);
++      INIT_ELV(cow_queue, &cow_queue->elevator);
++      blk_queue_make_request(cow_queue, cow_make_request);
++
++       add_gendisk(&cow_gendisk);
++
++      for(i=0;i<MAX_DEV;i++) 
++              cow_add(i);
++
++      return(0);
++}
++
++__initcall(cow_init);
++
++static int reader(__u64 start, char *buf, int count, void *arg)
++{
++      dev_t dev = *((dev_t *) arg);
++      struct buffer_head *bh;
++      __u64 block;
++      int cur, offset, left, n, blocksize = get_hardsect_size(dev);
++
++      if(blocksize == 0)
++              panic("Zero blocksize");
++
++      block = start / blocksize;
++      offset = start % blocksize;
++      left = count;
++      cur = 0;
++      while(left > 0){
++              n = (left > blocksize) ? blocksize : left;
++
++              bh = bread(dev, block, (n < 512) ? 512 : n);
++              if(bh == NULL)
++                      return(-EIO);
++
++              n -= offset;
++              memcpy(&buf[cur], bh->b_data + offset, n);
++              block++;
++              left -= n;
++              cur += n;
++              offset = 0;
++              brelse(bh);
++      }
++
++      return(count);
++}
++
++static int cow_open(struct inode *inode, struct file *filp)
++{
++      int (*dev_ioctl)(struct inode *, struct file *, unsigned int, 
++                       unsigned long);
++      mm_segment_t fs;
++      struct cow *dev;
++      __u64 size;
++      __u32 version, align;
++      time_t mtime;
++      char *backing_file;
++      int n, offset, err = 0;
++
++      n = DEVICE_NR(inode->i_rdev);
++      if(n >= MAX_DEV)
++              return(-ENODEV);
++      dev = &cow_dev[n];
++      offset = n << COW_SHIFT;
++
++      spin_lock(&cow_lock);
++
++      if(dev->count == 0){
++              dev->cow_dev = name_to_kdev_t(dev->cow_path);
++              if(dev->cow_dev == 0){
++                      printk(KERN_ERR "cow_open - name_to_kdev_t(\"%s\") "
++                             "failed\n", dev->cow_path);
++                      err = -ENODEV;
++              }
++
++              dev->backing_dev = name_to_kdev_t(dev->backing_path);
++              if(dev->backing_dev == 0){
++                      printk(KERN_ERR "cow_open - name_to_kdev_t(\"%s\") "
++                             "failed\n", dev->backing_path);
++                      err = -ENODEV;
++              }
++
++              if(err) 
++                      goto out;
++
++              dev->cow_bdev = bdget(dev->cow_dev);
++              if(dev->cow_bdev == NULL){
++                      printk(KERN_ERR "cow_open - bdget(\"%s\") failed\n", 
++                             dev->cow_path);
++                      err = -ENOMEM;
++              }
++              dev->backing_bdev = bdget(dev->backing_dev);
++              if(dev->backing_bdev == NULL){
++                      printk(KERN_ERR "cow_open - bdget(\"%s\") failed\n", 
++                             dev->backing_path);
++                      err = -ENOMEM;
++              }
++
++              if(err) 
++                      goto out;
++
++              err = blkdev_get(dev->cow_bdev, FMODE_READ|FMODE_WRITE, 0, 
++                               BDEV_RAW);
++              if(err){
++                      printk("cow_open - blkdev_get of COW device failed, "
++                             "error = %d\n", err);
++                      goto out;
++              }
++              
++              err = blkdev_get(dev->backing_bdev, FMODE_READ, 0, BDEV_RAW);
++              if(err){
++                      printk("cow_open - blkdev_get of backing device "
++                             "failed, error = %d\n", err);
++                      goto out;
++              }
++              
++              err = read_cow_header(reader, &dev->cow_dev, &version, 
++                                    &backing_file, &mtime, &size,
++                                    &dev->sectorsize, &align, 
++                                    &dev->bitmap_offset);
++              if(err){
++                      printk(KERN_ERR "cow_open - read_cow_header failed, "
++                             "err = %d\n", err);
++                      goto out;
++              }
++
++              cow_sizes(version, size, dev->sectorsize, align, 
++                        dev->bitmap_offset, &dev->bitmap_len, 
++                        &dev->data_offset);
++              dev->bitmap = (void *) vmalloc(dev->bitmap_len);
++              if(dev->bitmap == NULL){
++                      err = -ENOMEM;
++                      printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
++                      goto out;
++              }
++              flush_tlb_kernel_vm();
++              
++              err = reader(dev->bitmap_offset, (char *) dev->bitmap, 
++                           dev->bitmap_len, &dev->cow_dev);
++              if(err < 0){
++                      printk(KERN_ERR "Failed to read COW bitmap\n");
++                      vfree(dev->bitmap);
++                      goto out;
++              }
++
++              dev_ioctl = dev->backing_bdev->bd_op->ioctl;
++              fs = get_fs();
++              set_fs(KERNEL_DS);
++              err = (*dev_ioctl)(inode, filp, BLKGETSIZE, 
++                                 (unsigned long) &sizes[offset]);
++              set_fs(fs);
++              if(err){
++                      printk(KERN_ERR "cow_open - BLKGETSIZE failed, "
++                             "error = %d\n", err);
++                      goto out;
++              }
++
++              kernel_thread(cow_thread, dev, 
++                            CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
++              down(&dev->sem);
++      }
++      dev->count++;
++out:
++      spin_unlock(&cow_lock);
++      return(err);
++}
++
++static int cow_release(struct inode * inode, struct file * file)
++{
++      struct cow *dev;
++      int n, err;
++
++      n = DEVICE_NR(inode->i_rdev);
++      if(n >= MAX_DEV)
++              return(-ENODEV);
++      dev = &cow_dev[n];
++
++      spin_lock(&cow_lock);
++
++      if(--dev->count > 0)
++              goto out;
++
++      err = blkdev_put(dev->cow_bdev, BDEV_RAW);
++      if(err)
++              printk("cow_release - blkdev_put of cow device failed, "
++                     "error = %d\n", err);
++      bdput(dev->cow_bdev);
++      dev->cow_bdev = 0;
++
++      err = blkdev_put(dev->backing_bdev, BDEV_RAW);
++      if(err)
++              printk("cow_release - blkdev_put of backing device failed, "
++                     "error = %d\n", err);
++      bdput(dev->backing_bdev);
++      dev->backing_bdev = 0;
++
++out:
++      spin_unlock(&cow_lock);
++      return(0);
++}
++
++static int cow_ioctl(struct inode * inode, struct file * file,
++                   unsigned int cmd, unsigned long arg)
++{
++      struct cow *dev;
++      int (*dev_ioctl)(struct inode *, struct file *, unsigned int, 
++                       unsigned long);
++      int n;
++
++      n = DEVICE_NR(inode->i_rdev);
++      if(n >= MAX_DEV)
++              return(-ENODEV);
++      dev = &cow_dev[n];
++
++      dev_ioctl = dev->backing_bdev->bd_op->ioctl;
++      return((*dev_ioctl)(inode, file, cmd, arg));
++}
++
++static int cow_revalidate(kdev_t rdev)
++{
++      printk(KERN_ERR "Need to implement cow_revalidate\n");
++      return(0);
++}
++
++static int parse_unit(char **ptr)
++{
++      char *str = *ptr, *end;
++      int n = -1;
++
++      if(isdigit(*str)) {
++              n = simple_strtoul(str, &end, 0);
++              if(end == str)
++                      return(-1);
++              *ptr = end;
++      }
++      else if (('a' <= *str) && (*str <= 'h')) {
++              n = *str - 'a';
++              str++;
++              *ptr = str;
++      }
++      return(n);
++}
++
++static int cow_setup(char *str)
++{
++      struct cow *dev;
++      char *cow_name, *backing_name;
++      int unit;
++
++      unit = parse_unit(&str);
++      if(unit < 0){
++              printk(KERN_ERR "cow_setup - Couldn't parse unit number\n");
++              return(1);
++      }
++
++      if(*str != '='){
++              printk(KERN_ERR "cow_setup - Missing '=' after unit "
++                     "number\n");
++              return(1);
++      }
++      str++;
++
++      cow_name = str;
++      backing_name = strchr(str, ',');
++      if(backing_name == NULL){
++              printk(KERN_ERR "cow_setup - missing backing device name\n");
++              return(0);
++      }
++      *backing_name = '\0';
++      backing_name++;
++
++      spin_lock(&cow_lock);
++
++      dev = &cow_dev[unit];
++      dev->cow_path = cow_name;
++      dev->backing_path = backing_name;
++      
++      spin_unlock(&cow_lock);
++      return(0);
++}
++
++__setup("cow", cow_setup);
++
++/*
++ * 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 -Naur a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
+--- a/arch/um/drivers/cow_sys.h        1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/drivers/cow_sys.h        2004-01-08 22:29:45.000000000 -0500
+@@ -0,0 +1,48 @@
++#ifndef __COW_SYS_H__
++#define __COW_SYS_H__
++
++#include "kern_util.h"
++#include "user_util.h"
++#include "os.h"
++#include "user.h"
++
++static inline void *cow_malloc(int size)
++{
++      return(um_kmalloc(size));
++}
++
++static inline void cow_free(void *ptr)
++{
++      kfree(ptr);
++}
++
++#define cow_printf printk
++
++static inline char *cow_strdup(char *str)
++{
++      return(uml_strdup(str));
++}
++
++static inline int cow_seek_file(int fd, __u64 offset)
++{
++      return(os_seek_file(fd, offset));
++}
++
++static inline int cow_file_size(char *file, __u64 *size_out)
++{
++      return(os_file_size(file, size_out));
++}
++
++static inline int cow_write_file(int fd, char *buf, int size)
++{
++      return(os_write_file(fd, buf, size));
++}
++
++#endif
++
++/*
++ * ---------------------------------------------------------------------------
++ * Local variables:
++ * c-file-style: "linux"
++ * End:
++ */
+diff -Naur a/arch/um/drivers/cow_user.c b/arch/um/drivers/cow_user.c
+--- a/arch/um/drivers/cow_user.c       1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/drivers/cow_user.c       2004-01-08 22:28:43.000000000 -0500
+@@ -0,0 +1,375 @@
++#include <stddef.h>
++#include <string.h>
++#include <errno.h>
++#include <unistd.h>
++#include <byteswap.h>
++#include <sys/time.h>
++#include <sys/param.h>
++#include <sys/user.h>
++#include <netinet/in.h>
++
++#include "os.h"
++
++#include "cow.h"
++#include "cow_sys.h"
++
++#define PATH_LEN_V1 256
++
++struct cow_header_v1 {
++      int magic;
++      int version;
++      char backing_file[PATH_LEN_V1];
++      time_t mtime;
++      __u64 size;
++      int sectorsize;
++};
++
++#define PATH_LEN_V2 MAXPATHLEN
++
++struct cow_header_v2 {
++      unsigned long magic;
++      unsigned long version;
++      char backing_file[PATH_LEN_V2];
++      time_t mtime;
++      __u64 size;
++      int sectorsize;
++};
++
++/* Define PATH_LEN_V3 as the usual value of MAXPATHLEN, just hard-code it in 
++ * case other systems have different values for MAXPATHLEN
++ */
++#define PATH_LEN_V3 4096
++
++/* Changes from V2 - 
++ *    PATH_LEN_V3 as described above
++ *    Explicitly specify field bit lengths for systems with different
++ *            lengths for the usual C types.  Not sure whether char or
++ *            time_t should be changed, this can be changed later without
++ *            breaking compatibility
++ *    Add alignment field so that different alignments can be used for the
++ *            bitmap and data
++ *    Add cow_format field to allow for the possibility of different ways
++ *            of specifying the COW blocks.  For now, the only value is 0,
++ *            for the traditional COW bitmap.
++ *    Move the backing_file field to the end of the header.  This allows
++ *            for the possibility of expanding it into the padding required
++ *            by the bitmap alignment.
++ *    The bitmap and data portions of the file will be aligned as specified
++ *            by the alignment field.  This is to allow COW files to be
++ *            put on devices with restrictions on access alignments, such as
++ *            /dev/raw, with a 512 byte alignment restriction.  This also
++ *            allows the data to be more aligned more strictly than on
++ *            sector boundaries.  This is needed for ubd-mmap, which needs
++ *            the data to be page aligned.
++ *    Fixed (finally!) the rounding bug
++ */
++
++struct cow_header_v3 {
++      __u32 magic;
++      __u32 version;
++      time_t mtime;
++      __u64 size;
++      __u32 sectorsize;
++      __u32 alignment;
++      __u32 cow_format;
++      char backing_file[PATH_LEN_V3];
++};
++
++/* COW format definitions - for now, we have only the usual COW bitmap */
++#define COW_BITMAP 0
++
++union cow_header {
++      struct cow_header_v1 v1;
++      struct cow_header_v2 v2;
++      struct cow_header_v3 v3;
++};
++
++#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
++#define COW_VERSION 3
++
++#define DIV_ROUND(x, len) (((x) + (len) - 1) / (len))
++#define ROUND_UP(x, align) DIV_ROUND(x, align) * (align)
++
++void cow_sizes(int version, __u64 size, int sectorsize, int align, 
++             int bitmap_offset, unsigned long *bitmap_len_out, 
++             int *data_offset_out)
++{
++      if(version < 3){
++              *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize);
++
++              *data_offset_out = bitmap_offset + *bitmap_len_out;
++              *data_offset_out = (*data_offset_out + sectorsize - 1) / 
++                      sectorsize;
++              *data_offset_out *= sectorsize;
++      }
++      else {
++              *bitmap_len_out = DIV_ROUND(size, sectorsize);
++              *bitmap_len_out = DIV_ROUND(*bitmap_len_out, 8);
++
++              *data_offset_out = bitmap_offset + *bitmap_len_out;
++              *data_offset_out = ROUND_UP(*data_offset_out, align);
++      }
++}
++
++static int absolutize(char *to, int size, char *from)
++{
++      char save_cwd[256], *slash;
++      int remaining;
++
++      if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) {
++              cow_printf("absolutize : unable to get cwd - errno = %d\n", 
++                         errno);
++              return(-1);
++      }
++      slash = strrchr(from, '/');
++      if(slash != NULL){
++              *slash = '\0';
++              if(chdir(from)){
++                      *slash = '/';
++                      cow_printf("absolutize : Can't cd to '%s' - " 
++                                 "errno = %d\n", from, errno);
++                      return(-1);
++              }
++              *slash = '/';
++              if(getcwd(to, size) == NULL){
++                      cow_printf("absolutize : unable to get cwd of '%s' - "
++                             "errno = %d\n", from, errno);
++                      return(-1);
++              }
++              remaining = size - strlen(to);
++              if(strlen(slash) + 1 > remaining){
++                      cow_printf("absolutize : unable to fit '%s' into %d "
++                             "chars\n", from, size);
++                      return(-1);
++              }
++              strcat(to, slash);
++      }
++      else {
++              if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){
++                      cow_printf("absolutize : unable to fit '%s' into %d "
++                             "chars\n", from, size);
++                      return(-1);
++              }
++              strcpy(to, save_cwd);
++              strcat(to, "/");
++              strcat(to, from);
++      }
++      chdir(save_cwd);
++      return(0);
++}
++
++int write_cow_header(char *cow_file, int fd, char *backing_file, 
++                   int sectorsize, int alignment, long long *size)
++{
++      struct cow_header_v3 *header;
++      unsigned long modtime;
++      int err;
++
++      err = cow_seek_file(fd, 0);
++      if(err < 0){
++              cow_printf("write_cow_header - lseek failed, err = %d\n", -err);
++              goto out;
++      }
++
++      err = -ENOMEM;
++      header = cow_malloc(sizeof(*header));
++      if(header == NULL){
++              cow_printf("Failed to allocate COW V3 header\n");
++              goto out;
++      }
++      header->magic = htonl(COW_MAGIC);
++      header->version = htonl(COW_VERSION);
++
++      err = -EINVAL;
++      if(strlen(backing_file) > sizeof(header->backing_file) - 1){
++              cow_printf("Backing file name \"%s\" is too long - names are "
++                         "limited to %d characters\n", backing_file, 
++                         sizeof(header->backing_file) - 1);
++              goto out_free;
++      }
++
++      if(absolutize(header->backing_file, sizeof(header->backing_file), 
++                    backing_file))
++              goto out_free;
++
++      err = os_file_modtime(header->backing_file, &modtime);
++      if(err < 0){
++              cow_printf("Backing file '%s' mtime request failed, "
++                         "err = %d\n", header->backing_file, -err);
++              goto out_free;
++      }
++
++      err = cow_file_size(header->backing_file, size);
++      if(err < 0){
++              cow_printf("Couldn't get size of backing file '%s', "
++                         "err = %d\n", header->backing_file, -err);
++              goto out_free;
++      }
++
++      header->mtime = htonl(modtime);
++      header->size = htonll(*size);
++      header->sectorsize = htonl(sectorsize);
++      header->alignment = htonl(alignment);
++      header->cow_format = COW_BITMAP;
++
++      err = os_write_file(fd, header, sizeof(*header));
++      if(err != sizeof(*header)){
++              cow_printf("Write of header to new COW file '%s' failed, "
++                         "err = %d\n", cow_file, -err);
++              goto out_free;
++      }
++      err = 0;
++ out_free:
++      cow_free(header);
++ out:
++      return(err);
++}
++
++int file_reader(__u64 offset, char *buf, int len, void *arg)
++{
++      int fd = *((int *) arg);
++
++      return(pread(fd, buf, len, offset));
++}
++
++/* XXX Need to sanity-check the values read from the header */
++
++int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg, 
++                  __u32 *version_out, char **backing_file_out, 
++                  time_t *mtime_out, __u64 *size_out, 
++                  int *sectorsize_out, __u32 *align_out, 
++                  int *bitmap_offset_out)
++{
++      union cow_header *header;
++      char *file;
++      int err, n;
++      unsigned long version, magic;
++
++      header = cow_malloc(sizeof(*header));
++      if(header == NULL){
++              cow_printf("read_cow_header - Failed to allocate header\n");
++              return(-ENOMEM);
++      }
++      err = -EINVAL;
++      n = (*reader)(0, (char *) header, sizeof(*header), arg);
++      if(n < offsetof(typeof(header->v1), backing_file)){
++              cow_printf("read_cow_header - short header\n");
++              goto out;
++      }
++
++      magic = header->v1.magic;
++      if(magic == COW_MAGIC) {
++              version = header->v1.version;
++      }
++      else if(magic == ntohl(COW_MAGIC)){
++              version = ntohl(header->v1.version);
++      }
++      /* No error printed because the non-COW case comes through here */
++      else goto out;
++
++      *version_out = version;
++
++      if(version == 1){
++              if(n < sizeof(header->v1)){
++                      cow_printf("read_cow_header - failed to read V1 "
++                                 "header\n");
++                      goto out;
++              }
++              *mtime_out = header->v1.mtime;
++              *size_out = header->v1.size;
++              *sectorsize_out = header->v1.sectorsize;
++              *bitmap_offset_out = sizeof(header->v1);
++              *align_out = *sectorsize_out;
++              file = header->v1.backing_file;
++      }
++      else if(version == 2){
++              if(n < sizeof(header->v2)){
++                      cow_printf("read_cow_header - failed to read V2 "
++                                 "header\n");
++                      goto out;
++              }
++              *mtime_out = ntohl(header->v2.mtime);
++              *size_out = ntohll(header->v2.size);
++              *sectorsize_out = ntohl(header->v2.sectorsize);
++              *bitmap_offset_out = sizeof(header->v2);
++              *align_out = *sectorsize_out;
++              file = header->v2.backing_file;
++      }
++      else if(version == 3){
++              if(n < sizeof(header->v3)){
++                      cow_printf("read_cow_header - failed to read V2 "
++                                 "header\n");
++                      goto out;
++              }
++              *mtime_out = ntohl(header->v3.mtime);
++              *size_out = ntohll(header->v3.size);
++              *sectorsize_out = ntohl(header->v3.sectorsize);
++              *align_out = ntohl(header->v3.alignment);
++              *bitmap_offset_out = ROUND_UP(sizeof(header->v3), *align_out);
++              file = header->v3.backing_file;
++      }
++      else {
++              cow_printf("read_cow_header - invalid COW version\n");
++              goto out;               
++      }
++      err = -ENOMEM;
++      *backing_file_out = cow_strdup(file);
++      if(*backing_file_out == NULL){
++              cow_printf("read_cow_header - failed to allocate backing "
++                         "file\n");
++              goto out;
++      }
++      err = 0;
++ out:
++      cow_free(header);
++      return(err);
++}
++
++int init_cow_file(int fd, char *cow_file, char *backing_file, int sectorsize,
++                int alignment, int *bitmap_offset_out, 
++                unsigned long *bitmap_len_out, int *data_offset_out)
++{
++      __u64 size, offset;
++      char zero = 0;
++      int err;
++
++      err = write_cow_header(cow_file, fd, backing_file, sectorsize, 
++                             alignment, &size);
++      if(err) 
++              goto out;
++      
++      *bitmap_offset_out = ROUND_UP(sizeof(struct cow_header_v3), alignment);
++      cow_sizes(COW_VERSION, size, sectorsize, alignment, *bitmap_offset_out,
++                bitmap_len_out, data_offset_out);
++
++      offset = *data_offset_out + size - sizeof(zero);
++      err = cow_seek_file(fd, offset);
++      if(err < 0){
++              cow_printf("cow bitmap lseek failed : err = %d\n", -err);
++              goto out;
++      }
++
++      /* does not really matter how much we write it is just to set EOF 
++       * this also sets the entire COW bitmap
++       * to zero without having to allocate it 
++       */
++      err = cow_write_file(fd, &zero, sizeof(zero));
++      if(err != sizeof(zero)){
++              cow_printf("Write of bitmap to new COW file '%s' failed, "
++                         "err = %d\n", cow_file, -err);
++              err = -EINVAL;
++              goto out;
++      }
++
++      return(0);
++
++ out:
++      return(err);
++}
++
++/*
++ * ---------------------------------------------------------------------------
++ * Local variables:
++ * c-file-style: "linux"
++ * End:
++ */
+diff -Naur a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
+--- a/arch/um/drivers/daemon_user.c    2004-01-08 22:19:18.000000000 -0500
++++ b/arch/um/drivers/daemon_user.c    2004-01-08 22:25:32.000000000 -0500
+@@ -53,7 +53,8 @@
+       struct request_v3 req;
+       int fd, n, err;
+-      if((pri->control = socket(AF_UNIX, SOCK_STREAM, 0)) < 0){
++      pri->control = socket(AF_UNIX, SOCK_STREAM, 0);
++      if(pri->control < 0){
+               printk("daemon_open : control socket failed, errno = %d\n", 
+                      errno);          
+               return(-errno);
+@@ -67,7 +68,8 @@
+               goto out;
+       }
+-      if((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0){
++      fd = socket(AF_UNIX, SOCK_DGRAM, 0);
++      if(fd < 0){
+               printk("daemon_open : data socket failed, errno = %d\n", 
+                      errno);
+               err = -errno;
+@@ -91,18 +93,18 @@
+       req.version = SWITCH_VERSION;
+       req.type = REQ_NEW_CONTROL;
+       req.sock = *local_addr;
+-      n = write(pri->control, &req, sizeof(req));
++      n = os_write_file(pri->control, &req, sizeof(req));
+       if(n != sizeof(req)){
+-              printk("daemon_open : control setup request returned %d, "
+-                     "errno = %d\n", n, errno);
++              printk("daemon_open : control setup request failed, err = %d\n",
++                     -n);
+               err = -ENOTCONN;
+               goto out;               
+       }
+-      n = read(pri->control, sun, sizeof(*sun));
++      n = os_read_file(pri->control, sun, sizeof(*sun));
+       if(n != sizeof(*sun)){
+-              printk("daemon_open : read of data socket returned %d, "
+-                     "errno = %d\n", n, errno);
++              printk("daemon_open : read of data socket failed, err = %d\n", 
++                     -n);
+               err = -ENOTCONN;
+               goto out_close;         
+       }
+@@ -111,9 +113,9 @@
+       return(fd);
+  out_close:
+-      close(fd);
++      os_close_file(fd);
+  out:
+-      close(pri->control);
++      os_close_file(pri->control);
+       return(err);
+ }
+@@ -153,8 +155,8 @@
+ {
+       struct daemon_data *pri = data;
+-      close(pri->fd);
+-      close(pri->control);
++      os_close_file(pri->fd);
++      os_close_file(pri->control);
+       if(pri->data_addr != NULL) kfree(pri->data_addr);
+       if(pri->ctl_addr != NULL) kfree(pri->ctl_addr);
+       if(pri->local_addr != NULL) kfree(pri->local_addr);
+diff -Naur a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
+--- a/arch/um/drivers/fd.c     2004-01-08 22:31:17.000000000 -0500
++++ b/arch/um/drivers/fd.c     2004-01-08 22:35:52.000000000 -0500
+@@ -35,7 +35,8 @@
+               printk("fd_init : couldn't parse file descriptor '%s'\n", str);
+               return(NULL);
+       }
+-      if((data = um_kmalloc(sizeof(*data))) == NULL) return(NULL);
++      data = um_kmalloc(sizeof(*data));
++      if(data == NULL) return(NULL);
+       *data = ((struct fd_chan) { .fd         = n,
+                                   .raw        = opts->raw });
+       return(data);
+diff -Naur a/arch/um/drivers/harddog_user.c b/arch/um/drivers/harddog_user.c
+--- a/arch/um/drivers/harddog_user.c   2004-01-08 22:17:52.000000000 -0500
++++ b/arch/um/drivers/harddog_user.c   2004-01-08 22:23:56.000000000 -0500
+@@ -27,10 +27,10 @@
+       dup2(data->stdin, 0);
+       dup2(data->stdout, 1);
+       dup2(data->stdout, 2);
+-      close(data->stdin);
+-      close(data->stdout);
+-      close(data->close_me[0]);
+-      close(data->close_me[1]);
++      os_close_file(data->stdin);
++      os_close_file(data->stdout);
++      os_close_file(data->close_me[0]);
++      os_close_file(data->close_me[1]);
+ }
+ int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock)
+@@ -44,15 +44,15 @@
+       char **args = NULL;
+       err = os_pipe(in_fds, 1, 0);
+-      if(err){
+-              printk("harddog_open - os_pipe failed, errno = %d\n", -err);
+-              return(err);
++      if(err < 0){
++              printk("harddog_open - os_pipe failed, err = %d\n", -err);
++              goto out;
+       }
+       err = os_pipe(out_fds, 1, 0);
+-      if(err){
+-              printk("harddog_open - os_pipe failed, errno = %d\n", -err);
+-              return(err);
++      if(err < 0){
++              printk("harddog_open - os_pipe failed, err = %d\n", -err);
++              goto out_close_in;
+       }
+       data.stdin = out_fds[0];
+@@ -72,42 +72,47 @@
+       pid = run_helper(pre_exec, &data, args, NULL);
+-      close(out_fds[0]);
+-      close(in_fds[1]);
++      os_close_file(out_fds[0]);
++      os_close_file(in_fds[1]);
+       if(pid < 0){
+               err = -pid;
+-              printk("harddog_open - run_helper failed, errno = %d\n", err);
+-              goto out;
++              printk("harddog_open - run_helper failed, errno = %d\n", -err);
++              goto out_close_out;
+       }
+-      n = read(in_fds[0], &c, sizeof(c));
++      n = os_read_file(in_fds[0], &c, sizeof(c));
+       if(n == 0){
+               printk("harddog_open - EOF on watchdog pipe\n");
+               helper_wait(pid);
+               err = -EIO;
+-              goto out;
++              goto out_close_out;
+       }
+       else if(n < 0){
+               printk("harddog_open - read of watchdog pipe failed, "
+-                     "errno = %d\n", errno);
++                     "err = %d\n", -n);
+               helper_wait(pid);
+-              err = -errno;
+-              goto out;
++              err = n;
++              goto out_close_out;
+       }
+       *in_fd_ret = in_fds[0];
+       *out_fd_ret = out_fds[1];
+       return(0);
++
++ out_close_in:
++      os_close_file(in_fds[0]);
++      os_close_file(in_fds[1]);
++ out_close_out:
++      os_close_file(out_fds[0]);
++      os_close_file(out_fds[1]);
+  out:
+-      close(out_fds[1]);
+-      close(in_fds[0]);
+       return(err);
+ }
+ void stop_watchdog(int in_fd, int out_fd)
+ {
+-      close(in_fd);
+-      close(out_fd);
++      os_close_file(in_fd);
++      os_close_file(out_fd);
+ }
+ int ping_watchdog(int fd)
+@@ -115,11 +120,12 @@
+       int n;
+       char c = '\n';
+-      n = write(fd, &c, sizeof(c));
+-      if(n < sizeof(c)){
+-              printk("ping_watchdog - write failed, errno = %d\n",
+-                     errno);
+-              return(-errno);
++      n = os_write_file(fd, &c, sizeof(c));
++      if(n != sizeof(c)){
++              printk("ping_watchdog - write failed, err = %d\n", -n);
++              if(n < 0) 
++                      return(n);
++              return(-EIO);
+       }
+       return 1;
+diff -Naur a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c
+--- a/arch/um/drivers/hostaudio_kern.c 2004-01-08 22:31:38.000000000 -0500
++++ b/arch/um/drivers/hostaudio_kern.c 2004-01-08 22:36:17.000000000 -0500
+@@ -5,12 +5,12 @@
+ #include "linux/config.h"
+ #include "linux/module.h"
+-#include "linux/version.h"
+ #include "linux/init.h"
+ #include "linux/slab.h"
+ #include "linux/fs.h"
+ #include "linux/sound.h"
+ #include "linux/soundcard.h"
++#include "asm/uaccess.h"
+ #include "kern_util.h"
+ #include "init.h"
+ #include "hostaudio.h"
+@@ -19,30 +19,39 @@
+ char *dsp = HOSTAUDIO_DEV_DSP;
+ char *mixer = HOSTAUDIO_DEV_MIXER;
++#define DSP_HELP \
++"    This is used to specify the host dsp device to the hostaudio driver.\n" \
++"    The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"
++
++#define MIXER_HELP \
++"    This is used to specify the host mixer device to the hostaudio driver.\n" \
++"    The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"
++
+ #ifndef MODULE
+ static int set_dsp(char *name, int *add)
+ {
+-      dsp = uml_strdup(name);
++      dsp = name;
+       return(0);
+ }
+-__uml_setup("dsp=", set_dsp,
+-"dsp=<dsp device>\n"
+-"    This is used to specify the host dsp device to the hostaudio driver.\n"
+-"    The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"
+-);
++__uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP);
+ static int set_mixer(char *name, int *add)
+ {
+-      mixer = uml_strdup(name);
++      mixer = name;
+       return(0);
+ }
+-__uml_setup("mixer=", set_mixer,
+-"mixer=<mixer device>\n"
+-"    This is used to specify the host mixer device to the hostaudio driver.\n"
+-"    The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"
+-);
++__uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP);
++
++#else /*MODULE*/
++
++MODULE_PARM(dsp, "s");
++MODULE_PARM_DESC(dsp, DSP_HELP);
++
++MODULE_PARM(mixer, "s");
++MODULE_PARM_DESC(mixer, MIXER_HELP);
++
+ #endif
+ /* /dev/dsp file operations */
+@@ -51,23 +60,55 @@
+                             loff_t *ppos)
+ {
+         struct hostaudio_state *state = file->private_data;
++      void *kbuf;
++      int err;
+ #ifdef DEBUG
+         printk("hostaudio: read called, count = %d\n", count);
+ #endif
+-        return(hostaudio_read_user(state, buffer, count, ppos));
++      kbuf = kmalloc(count, GFP_KERNEL);
++      if(kbuf == NULL)
++              return(-ENOMEM);
++
++        err = hostaudio_read_user(state, kbuf, count, ppos);
++      if(err < 0)
++              goto out;
++
++      if(copy_to_user(buffer, kbuf, err))
++              err = -EFAULT;
++
++ out:
++      kfree(kbuf);
++      return(err);
+ }
+ static ssize_t hostaudio_write(struct file *file, const char *buffer, 
+                              size_t count, loff_t *ppos)
+ {
+         struct hostaudio_state *state = file->private_data;
++      void *kbuf;
++      int err;
+ #ifdef DEBUG
+         printk("hostaudio: write called, count = %d\n", count);
+ #endif
+-        return(hostaudio_write_user(state, buffer, count, ppos));
++
++      kbuf = kmalloc(count, GFP_KERNEL);
++      if(kbuf == NULL)
++              return(-ENOMEM);
++
++      err = -EFAULT;
++      if(copy_from_user(kbuf, buffer, count))
++              goto out;
++
++        err = hostaudio_write_user(state, kbuf, count, ppos);
++      if(err < 0)
++              goto out;
++
++ out:
++      kfree(kbuf);
++      return(err);
+ }
+ static unsigned int hostaudio_poll(struct file *file, 
+@@ -86,12 +127,43 @@
+                          unsigned int cmd, unsigned long arg)
+ {
+         struct hostaudio_state *state = file->private_data;
++      unsigned long data = 0;
++      int err;
+ #ifdef DEBUG
+         printk("hostaudio: ioctl called, cmd = %u\n", cmd);
+ #endif
++      switch(cmd){
++      case SNDCTL_DSP_SPEED:
++      case SNDCTL_DSP_STEREO:
++      case SNDCTL_DSP_GETBLKSIZE:
++      case SNDCTL_DSP_CHANNELS:
++      case SNDCTL_DSP_SUBDIVIDE:
++      case SNDCTL_DSP_SETFRAGMENT:
++              if(get_user(data, (int *) arg))
++                      return(-EFAULT);
++              break;
++      default:
++              break;
++      }
++
++        err = hostaudio_ioctl_user(state, cmd, (unsigned long) &data);
++
++      switch(cmd){
++      case SNDCTL_DSP_SPEED:
++      case SNDCTL_DSP_STEREO:
++      case SNDCTL_DSP_GETBLKSIZE:
++      case SNDCTL_DSP_CHANNELS:
++      case SNDCTL_DSP_SUBDIVIDE:
++      case SNDCTL_DSP_SETFRAGMENT:
++              if(put_user(data, (int *) arg))
++                      return(-EFAULT);
++              break;
++      default:
++              break;
++      }
+-        return(hostaudio_ioctl_user(state, cmd, arg));
++      return(err);
+ }
+ static int hostaudio_open(struct inode *inode, struct file *file)
+@@ -225,7 +297,8 @@
+ static int __init hostaudio_init_module(void)
+ {
+-        printk(KERN_INFO "UML Audio Relay\n");
++        printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
++             dsp, mixer);
+       module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
+         if(module_data.dev_audio < 0){
+diff -Naur a/arch/um/drivers/hostaudio_user.c b/arch/um/drivers/hostaudio_user.c
+--- a/arch/um/drivers/hostaudio_user.c 2004-01-08 22:26:01.000000000 -0500
++++ b/arch/um/drivers/hostaudio_user.c 2004-01-08 22:33:41.000000000 -0500
+@@ -4,9 +4,6 @@
+  */
+ #include <sys/types.h>
+-#include <sys/stat.h>
+-#include <sys/ioctl.h>
+-#include <fcntl.h>
+ #include <unistd.h>
+ #include <errno.h>
+ #include "hostaudio.h"
+@@ -20,16 +17,11 @@
+ ssize_t hostaudio_read_user(struct hostaudio_state *state, char *buffer, 
+                           size_t count, loff_t *ppos)
+ {
+-      ssize_t ret;
+-
+ #ifdef DEBUG
+         printk("hostaudio: read_user called, count = %d\n", count);
+ #endif
+-        ret = read(state->fd, buffer, count);
+-
+-        if(ret < 0) return(-errno);
+-        return(ret);
++      return(os_read_file(state->fd, buffer, count));
+ }
+ ssize_t hostaudio_write_user(struct hostaudio_state *state, const char *buffer,
+@@ -41,24 +33,19 @@
+         printk("hostaudio: write_user called, count = %d\n", count);
+ #endif
+-        ret = write(state->fd, buffer, count);
++      return(os_write_file(state->fd, buffer, count));
+-        if(ret < 0) return(-errno);
+         return(ret);
+ }
+ int hostaudio_ioctl_user(struct hostaudio_state *state, unsigned int cmd, 
+                        unsigned long arg)
+ {
+-      int ret;
+ #ifdef DEBUG
+         printk("hostaudio: ioctl_user called, cmd = %u\n", cmd);
+ #endif
+-        ret = ioctl(state->fd, cmd, arg);
+-      
+-        if(ret < 0) return(-errno);
+-        return(ret);
++      return(os_ioctl_generic(state->fd, cmd, arg));
+ }
+ int hostaudio_open_user(struct hostaudio_state *state, int r, int w, char *dsp)
+@@ -69,12 +56,13 @@
+         state->fd = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
+-        if(state->fd >= 0) return(0);
+-
+-        printk("hostaudio_open_user failed to open '%s', errno = %d\n",
+-             dsp, errno);
++      if(state->fd < 0) {
++              printk("hostaudio_open_user failed to open '%s', err = %d\n",
++                     dsp, -state->fd);
++              return(state->fd); 
++      }
+         
+-        return(-errno); 
++      return(0);
+ }
+ int hostaudio_release_user(struct hostaudio_state *state)
+@@ -83,8 +71,8 @@
+         printk("hostaudio: release called\n");
+ #endif
+         if(state->fd >= 0){
+-              close(state->fd);
+-              state->fd=-1;
++              os_close_file(state->fd);
++              state->fd = -1;
+         }
+         return(0);
+@@ -95,15 +83,11 @@
+ int hostmixer_ioctl_mixdev_user(struct hostmixer_state *state, 
+                               unsigned int cmd, unsigned long arg)
+ {
+-      int ret;
+ #ifdef DEBUG
+         printk("hostmixer: ioctl_user called cmd = %u\n",cmd);
+ #endif
+-        ret = ioctl(state->fd, cmd, arg);
+-      if(ret < 0) 
+-              return(-errno);
+-      return(ret);
++      return(os_ioctl_generic(state->fd, cmd, arg));
+ }
+ int hostmixer_open_mixdev_user(struct hostmixer_state *state, int r, int w,
+@@ -115,12 +99,13 @@
+         state->fd = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
+-        if(state->fd >= 0) return(0);
+-
+-        printk("hostaudio_open_mixdev_user failed to open '%s', errno = %d\n",
+-             mixer, errno);
++      if(state->fd < 0) {
++              printk("hostaudio_open_mixdev_user failed to open '%s', "
++                     "err = %d\n", mixer, state->fd);
++              return(state->fd); 
++      }
+         
+-        return(-errno); 
++      return(0);
+ }
+ int hostmixer_release_mixdev_user(struct hostmixer_state *state)
+@@ -130,7 +115,7 @@
+ #endif
+         if(state->fd >= 0){
+-              close(state->fd);
++              os_close_file(state->fd);
+               state->fd = -1;
+         }
+diff -Naur a/arch/um/drivers/line.c b/arch/um/drivers/line.c
+--- a/arch/um/drivers/line.c   2004-01-08 22:29:48.000000000 -0500
++++ b/arch/um/drivers/line.c   2004-01-08 22:35:21.000000000 -0500
+@@ -6,8 +6,8 @@
+ #include "linux/sched.h"
+ #include "linux/slab.h"
+ #include "linux/list.h"
++#include "linux/interrupt.h"
+ #include "linux/devfs_fs_kernel.h"
+-#include "asm/irq.h"
+ #include "asm/uaccess.h"
+ #include "chan_kern.h"
+ #include "irq_user.h"
+@@ -16,38 +16,55 @@
+ #include "user_util.h"
+ #include "kern_util.h"
+ #include "os.h"
++#include "irq_kern.h"
+ #define LINE_BUFSIZE 4096
+-void line_interrupt(int irq, void *data, struct pt_regs *unused)
++static irqreturn_t line_interrupt(int irq, void *data, struct pt_regs *unused)
+ {
+       struct line *dev = data;
+       if(dev->count > 0) 
+               chan_interrupt(&dev->chan_list, &dev->task, dev->tty, irq, 
+                              dev);
++      return IRQ_HANDLED;
+ }
+-void line_timer_cb(void *arg)
++static void line_timer_cb(void *arg)
+ {
+       struct line *dev = arg;
+       line_interrupt(dev->driver->read_irq, dev, NULL);
+ }
+-static void buffer_data(struct line *line, const char *buf, int len)
++static int write_room(struct line *dev)
+ {
+-      int end;
++      int n;
++
++      if(dev->buffer == NULL) return(LINE_BUFSIZE - 1);
++
++      n = dev->head - dev->tail;
++      if(n <= 0) n = LINE_BUFSIZE + n;
++      return(n - 1);
++}
++
++static int buffer_data(struct line *line, const char *buf, int len)
++{
++      int end, room;
+       if(line->buffer == NULL){
+               line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC);
+               if(line->buffer == NULL){
+                       printk("buffer_data - atomic allocation failed\n");
+-                      return;
++                      return(0);
+               }
+               line->head = line->buffer;
+               line->tail = line->buffer;
+       }
++
++      room = write_room(line);
++      len = (len > room) ? room : len;
++
+       end = line->buffer + LINE_BUFSIZE - line->tail;
+       if(len < end){
+               memcpy(line->tail, buf, len);
+@@ -60,6 +77,8 @@
+               memcpy(line->buffer, buf, len);
+               line->tail = line->buffer + len;
+       }
++
++      return(len);
+ }
+ static int flush_buffer(struct line *line)
+@@ -95,7 +114,7 @@
+       struct line *line;
+       char *new;
+       unsigned long flags;
+-      int n, err, i;
++      int n, err, i, ret = 0;
+       if(tty->stopped) return 0;
+@@ -104,9 +123,13 @@
+               if(new == NULL)
+                       return(0);
+               n = copy_from_user(new, buf, len);
+-              if(n == len)
+-                      return(-EFAULT);
+               buf = new;
++              if(n == len){
++                      len = -EFAULT;
++                      goto out_free;
++              }
++
++              len -= n;
+       }
+       i = tty->index;
+@@ -115,41 +138,50 @@
+       down(&line->sem);
+       if(line->head != line->tail){
+               local_irq_save(flags);
+-              buffer_data(line, buf, len);
++              ret += buffer_data(line, buf, len);
+               err = flush_buffer(line);
+               local_irq_restore(flags);
+               if(err <= 0)
+-                      goto out;
++                      goto out_up;
+       }
+       else {
+               n = write_chan(&line->chan_list, buf, len, 
+                              line->driver->write_irq);
+               if(n < 0){
+-                      len = n;
+-                      goto out;
++                      ret = n;
++                      goto out_up;
+               }
+-              if(n < len)
+-                      buffer_data(line, buf + n, len - n);
++
++              len -= n;
++              ret += n;
++              if(len > 0)
++                      ret += buffer_data(line, buf + n, len);
+       }
+- out:
++ out_up:
+       up(&line->sem);
+-      return(len);
++ out_free:
++      if(from_user)
++              kfree(buf);
++      return(ret);
+ }
+-void line_write_interrupt(int irq, void *data, struct pt_regs *unused)
++static irqreturn_t line_write_interrupt(int irq, void *data, 
++                                      struct pt_regs *unused)
+ {
+       struct line *dev = data;
+       struct tty_struct *tty = dev->tty;
+       int err;
+       err = flush_buffer(dev);
+-      if(err == 0) return;
++      if(err == 0) 
++              return(IRQ_NONE);
+       else if(err < 0){
+               dev->head = dev->buffer;
+               dev->tail = dev->buffer;
+       }
+-      if(tty == NULL) return;
++      if(tty == NULL) 
++              return(IRQ_NONE);
+       if(test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
+          (tty->ldisc.write_wakeup != NULL))
+@@ -161,21 +193,9 @@
+        * writes.
+        */
+-      if (waitqueue_active(&tty->write_wait))
++      if(waitqueue_active(&tty->write_wait))
+               wake_up_interruptible(&tty->write_wait);
+-
+-}
+-
+-int line_write_room(struct tty_struct *tty)
+-{
+-      struct line *dev = tty->driver_data;
+-      int n;
+-
+-      if(dev->buffer == NULL) return(LINE_BUFSIZE - 1);
+-
+-      n = dev->head - dev->tail;
+-      if(n <= 0) n = LINE_BUFSIZE + n;
+-      return(n - 1);
++      return(IRQ_HANDLED);
+ }
+ int line_setup_irq(int fd, int input, int output, void *data)
+@@ -305,7 +325,7 @@
+               if(*end != '='){
+                       printk(KERN_ERR "line_setup failed to parse \"%s\"\n", 
+                              init);
+-                      return(1);
++                      return(0);
+               }
+               init = end;
+       }
+@@ -313,12 +333,12 @@
+       if((n >= 0) && (n >= num)){
+               printk("line_setup - %d out of range ((0 ... %d) allowed)\n",
+                      n, num);
+-              return(1);
++              return(0);
+       }
+       else if(n >= 0){
+               if(lines[n].count > 0){
+                       printk("line_setup - device %d is open\n", n);
+-                      return(1);
++                      return(0);
+               }
+               if(lines[n].init_pri <= INIT_ONE){
+                       lines[n].init_pri = INIT_ONE;
+@@ -332,7 +352,7 @@
+       else if(!all_allowed){
+               printk("line_setup - can't configure all devices from "
+                      "mconsole\n");
+-              return(1);
++              return(0);
+       }
+       else {
+               for(i = 0; i < num; i++){
+@@ -346,7 +366,7 @@
+                       }
+               }
+       }
+-      return(0);
++      return(1);
+ }
+ int line_config(struct line *lines, int num, char *str)
+@@ -357,7 +377,7 @@
+               printk("line_config - uml_strdup failed\n");
+               return(-ENOMEM);
+       }
+-      return(line_setup(lines, num, new, 0));
++      return(!line_setup(lines, num, new, 0));
+ }
+ int line_get_config(char *name, struct line *lines, int num, char *str, 
+@@ -369,7 +389,7 @@
+       dev = simple_strtoul(name, &end, 0);
+       if((*end != '\0') || (end == name)){
+-              *error_out = "line_setup failed to parse device number";
++              *error_out = "line_get_config failed to parse device number";
+               return(0);
+       }
+@@ -379,15 +399,15 @@
+       }
+       line = &lines[dev];
++
+       down(&line->sem);
+-      
+       if(!line->valid)
+               CONFIG_CHUNK(str, size, n, "none", 1);
+       else if(line->count == 0)
+               CONFIG_CHUNK(str, size, n, line->init_str, 1);
+       else n = chan_config_string(&line->chan_list, str, size, error_out);
+-
+       up(&line->sem);
++
+       return(n);
+ }
+@@ -396,7 +416,14 @@
+       char config[sizeof("conxxxx=none\0")];
+       sprintf(config, "%s=none", str);
+-      return(line_setup(lines, num, config, 0));
++      return(!line_setup(lines, num, config, 0));
++}
++
++int line_write_room(struct tty_struct *tty)
++{
++      struct line *dev = tty->driver_data;
++
++      return(write_room(dev));
+ }
+ struct tty_driver *line_register_devfs(struct lines *set,
+@@ -412,7 +439,8 @@
+               return NULL;
+       driver->driver_name = line_driver->name;
+-      driver->name = line_driver->devfs_name;
++      driver->name = line_driver->device_name;
++      driver->devfs_name = line_driver->devfs_name;
+       driver->major = line_driver->major;
+       driver->minor_start = line_driver->minor_start;
+       driver->type = line_driver->type;
+@@ -432,7 +460,7 @@
+       for(i = 0; i < nlines; i++){
+               if(!lines[i].valid) 
+-                      tty_unregister_devfs(driver, i);
++                      tty_unregister_device(driver, i);
+       }
+       mconsole_register_dev(&line_driver->mc);
+@@ -465,24 +493,25 @@
+       struct line *line;
+ };
+-void winch_interrupt(int irq, void *data, struct pt_regs *unused)
++irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
+ {
+       struct winch *winch = data;
+       struct tty_struct *tty;
+       int err;
+       char c;
+-      err = generic_read(winch->fd, &c, NULL);
+-      if(err < 0){
+-              if(err != -EAGAIN){
+-                      printk("winch_interrupt : read failed, errno = %d\n", 
+-                             -err);
+-                      printk("fd %d is losing SIGWINCH support\n", 
+-                             winch->tty_fd);
+-                      free_irq(irq, data);
+-                      return;
++      if(winch->fd != -1){
++              err = generic_read(winch->fd, &c, NULL);
++              if(err < 0){
++                      if(err != -EAGAIN){
++                              printk("winch_interrupt : read failed, "
++                                     "errno = %d\n", -err);
++                              printk("fd %d is losing SIGWINCH support\n", 
++                                     winch->tty_fd);
++                              return(IRQ_HANDLED);
++                      }
++                      goto out;
+               }
+-              goto out;
+       }
+       tty = winch->line->tty;
+       if(tty != NULL){
+@@ -492,7 +521,9 @@
+               kill_pg(tty->pgrp, SIGWINCH, 1);
+       }
+  out:
+-      reactivate_fd(winch->fd, WINCH_IRQ);
++      if(winch->fd != -1)
++              reactivate_fd(winch->fd, WINCH_IRQ);
++      return(IRQ_HANDLED);
+ }
+ DECLARE_MUTEX(winch_handler_sem);
+@@ -529,7 +560,10 @@
+       list_for_each(ele, &winch_handlers){
+               winch = list_entry(ele, struct winch, list);
+-              close(winch->fd);
++              if(winch->fd != -1){
++                      deactivate_fd(winch->fd, WINCH_IRQ);
++                      os_close_file(winch->fd);
++              }
+               if(winch->pid != -1) 
+                       os_kill_process(winch->pid, 1);
+       }
+diff -Naur a/arch/um/drivers/Makefile b/arch/um/drivers/Makefile
+--- a/arch/um/drivers/Makefile 2004-01-08 22:23:04.000000000 -0500
++++ b/arch/um/drivers/Makefile 2004-01-08 22:30:06.000000000 -0500
+@@ -1,5 +1,5 @@
+ # 
+-# Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
++# Copyright (C) 2000, 2002, 2003 Jeff Dike (jdike@karaya.com)
+ # Licensed under the GPL
+ #
+@@ -39,6 +39,8 @@
+ obj-$(CONFIG_TTY_CHAN) += tty.o 
+ obj-$(CONFIG_XTERM_CHAN) += xterm.o xterm_kern.o
+ obj-$(CONFIG_UML_WATCHDOG) += harddog.o
++obj-$(CONFIG_BLK_DEV_COW) += cow_kern.o
++obj-$(CONFIG_BLK_DEV_COW_COMMON) += cow_user.o
+ obj-y += stdio_console.o $(CHAN_OBJS)
+@@ -46,7 +48,7 @@
+ USER_OBJS := $(filter %_user.o,$(obj-y) $(obj-m) $(USER_SINGLE_OBJS)) fd.o \
+       null.o pty.o tty.o xterm.o
+-USER_OBJS := $(foreach file,$(USER_OBJS),arch/um/drivers/$(file))
++USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
+ $(USER_OBJS) : %.o: %.c
+       $(CC) $(CFLAGS_$(notdir $@)) $(USER_CFLAGS) -c -o $@ $<
+diff -Naur a/arch/um/drivers/mcast_user.c b/arch/um/drivers/mcast_user.c
+--- a/arch/um/drivers/mcast_user.c     2004-01-08 22:22:02.000000000 -0500
++++ b/arch/um/drivers/mcast_user.c     2004-01-08 22:28:53.000000000 -0500
+@@ -23,6 +23,7 @@
+ #include "kern_util.h"
+ #include "user_util.h"
+ #include "user.h"
++#include "os.h"
+ #define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+@@ -62,7 +63,8 @@
+               goto out;
+       }
+-      if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){
++      fd = socket(AF_INET, SOCK_DGRAM, 0);
++      if (fd < 0){
+               printk("mcast_open : data socket failed, errno = %d\n", 
+                      errno);
+               fd = -ENOMEM;
+@@ -72,7 +74,7 @@
+       if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
+               printk("mcast_open: SO_REUSEADDR failed, errno = %d\n",
+                       errno);
+-              close(fd);
++              os_close_file(fd);
+               fd = -EINVAL;
+               goto out;
+       }
+@@ -82,7 +84,7 @@
+                      sizeof(pri->ttl)) < 0) {
+               printk("mcast_open: IP_MULTICAST_TTL failed, error = %d\n",
+                       errno);
+-              close(fd);
++              os_close_file(fd);
+               fd = -EINVAL;
+               goto out;
+       }
+@@ -91,7 +93,7 @@
+       if (setsockopt(fd, SOL_IP, IP_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
+               printk("mcast_open: IP_MULTICAST_LOOP failed, error = %d\n",
+                       errno);
+-              close(fd);
++              os_close_file(fd);
+               fd = -EINVAL;
+               goto out;
+       }
+@@ -99,7 +101,7 @@
+       /* bind socket to mcast address */
+       if (bind(fd, (struct sockaddr *) sin, sizeof(*sin)) < 0) {
+               printk("mcast_open : data bind failed, errno = %d\n", errno);
+-              close(fd);
++              os_close_file(fd);
+               fd = -EINVAL;
+               goto out;
+       }               
+@@ -115,7 +117,7 @@
+                      "interface on the host.\n");
+               printk("eth0 should be configured in order to use the "
+                      "multicast transport.\n");
+-              close(fd);
++              os_close_file(fd);
+               fd = -EINVAL;
+       }
+@@ -137,7 +139,7 @@
+                       errno);
+       }
+-      close(fd);
++      os_close_file(fd);
+ }
+ int mcast_user_write(int fd, void *buf, int len, struct mcast_data *pri)
+diff -Naur a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
+--- a/arch/um/drivers/mconsole_kern.c  2004-01-08 22:13:41.000000000 -0500
++++ b/arch/um/drivers/mconsole_kern.c  2004-01-08 22:17:57.000000000 -0500
+@@ -1,6 +1,6 @@
+ /*
+  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+@@ -15,6 +15,9 @@
+ #include "linux/sysrq.h"
+ #include "linux/workqueue.h"
+ #include "linux/module.h"
++#include "linux/file.h"
++#include "linux/fs.h"
++#include "linux/namei.h"
+ #include "linux/proc_fs.h"
+ #include "asm/irq.h"
+ #include "asm/uaccess.h"
+@@ -27,6 +30,7 @@
+ #include "init.h"
+ #include "os.h"
+ #include "umid.h"
++#include "irq_kern.h"
+ static int do_unlink_socket(struct notifier_block *notifier, 
+                           unsigned long what, void *data)
+@@ -67,7 +71,7 @@
+ DECLARE_WORK(mconsole_work, mc_work_proc, NULL);
+-void mconsole_interrupt(int irq, void *dev_id, struct pt_regs *regs)
++irqreturn_t mconsole_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+ {
+       int fd;
+       struct mconsole_entry *new;
+@@ -75,9 +79,10 @@
+       fd = (int) dev_id;
+       while (mconsole_get_request(fd, &req)){
+-              if(req.cmd->as_interrupt) (*req.cmd->handler)(&req);
++              if(req.cmd->context == MCONSOLE_INTR) 
++                      (*req.cmd->handler)(&req);
+               else {
+-                      new = kmalloc(sizeof(req), GFP_ATOMIC);
++                      new = kmalloc(sizeof(*new), GFP_ATOMIC);
+                       if(new == NULL)
+                               mconsole_reply(&req, "Out of memory", 1, 0);
+                       else {
+@@ -88,6 +93,7 @@
+       }
+       if(!list_empty(&mc_requests)) schedule_work(&mconsole_work);
+       reactivate_fd(fd, MCONSOLE_IRQ);
++      return(IRQ_HANDLED);
+ }
+ void mconsole_version(struct mc_request *req)
+@@ -100,20 +106,110 @@
+       mconsole_reply(req, version, 0, 0);
+ }
++void mconsole_log(struct mc_request *req)
++{
++      int len;
++      char *ptr = req->request.data;
++      
++      ptr += strlen("log");
++      while(isspace(*ptr)) ptr++;
++
++      len = req->len - (ptr - req->request.data);
++      printk("%.*s", len, ptr);
++      mconsole_reply(req, "", 0, 0);
++}
++
++void mconsole_proc(struct mc_request *req)
++{
++      struct nameidata nd;
++      struct file_system_type *proc;
++      struct super_block *super;
++      struct file *file;
++      int n, err;
++      char *ptr = req->request.data, *buf;
++      
++      ptr += strlen("proc");
++      while(isspace(*ptr)) ptr++;
++
++      proc = get_fs_type("proc");
++      if(proc == NULL){
++              mconsole_reply(req, "procfs not registered", 1, 0);
++              goto out;
++      }
++
++      super = (*proc->get_sb)(proc, 0, NULL, NULL);
++      put_filesystem(proc);
++      if(super == NULL){
++              mconsole_reply(req, "Failed to get procfs superblock", 1, 0);
++              goto out;
++      }
++      up_write(&super->s_umount);
++
++      nd.dentry = super->s_root;
++      nd.mnt = NULL;
++      nd.flags = O_RDONLY + 1;
++      nd.last_type = LAST_ROOT;
++
++      err = link_path_walk(ptr, &nd);
++      if(err){
++              mconsole_reply(req, "Failed to look up file", 1, 0);
++              goto out_kill;
++      }
++
++      file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
++      if(IS_ERR(file)){
++              mconsole_reply(req, "Failed to open file", 1, 0);
++              goto out_kill;
++      }
++
++      buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
++      if(buf == NULL){
++              mconsole_reply(req, "Failed to allocate buffer", 1, 0);
++              goto out_fput;
++      }
++
++      if((file->f_op != NULL) && (file->f_op->read != NULL)){
++              do {
++                      n = (*file->f_op->read)(file, buf, PAGE_SIZE - 1, 
++                                              &file->f_pos);
++                      if(n >= 0){
++                              buf[n] = '\0';
++                              mconsole_reply(req, buf, 0, (n > 0));
++                      }
++                      else {
++                              mconsole_reply(req, "Read of file failed", 
++                                             1, 0);
++                              goto out_free;
++                      }
++              } while(n > 0);
++      }
++      else mconsole_reply(req, "", 0, 0);
++
++ out_free:
++      kfree(buf);
++ out_fput:
++      fput(file);
++ out_kill:
++      deactivate_super(super);
++ out: ;
++}
++
+ #define UML_MCONSOLE_HELPTEXT \
+-"Commands:
+-    version - Get kernel version
+-    help - Print this message
+-    halt - Halt UML
+-    reboot - Reboot UML
+-    config <dev>=<config> - Add a new device to UML; 
+-      same syntax as command line
+-    config <dev> - Query the configuration of a device
+-    remove <dev> - Remove a device from UML
+-    sysrq <letter> - Performs the SysRq action controlled by the letter
+-    cad - invoke the Ctl-Alt-Del handler
+-    stop - pause the UML; it will do nothing until it receives a 'go'
+-    go - continue the UML after a 'stop'
++"Commands: \n\
++    version - Get kernel version \n\
++    help - Print this message \n\
++    halt - Halt UML \n\
++    reboot - Reboot UML \n\
++    config <dev>=<config> - Add a new device to UML;  \n\
++      same syntax as command line \n\
++    config <dev> - Query the configuration of a device \n\
++    remove <dev> - Remove a device from UML \n\
++    sysrq <letter> - Performs the SysRq action controlled by the letter \n\
++    cad - invoke the Ctl-Alt-Del handler \n\
++    stop - pause the UML; it will do nothing until it receives a 'go' \n\
++    go - continue the UML after a 'stop' \n\
++    log <string> - make UML enter <string> into the kernel log\n\
++    proc <file> - returns the contents of the UML's /proc/<file>\n\
+ "
+ void mconsole_help(struct mc_request *req)
+@@ -302,7 +398,7 @@
+       if(umid_file_name("mconsole", file, sizeof(file))) return(-1);
+       snprintf(mconsole_socket_name, sizeof(file), "%s", file);
+-      sock = create_unix_socket(file, sizeof(file));
++      sock = os_create_unix_socket(file, sizeof(file), 1);
+       if (sock < 0){
+               printk("Failed to initialize management console\n");
+               return(1);
+@@ -344,11 +440,16 @@
+       if(buf == NULL) 
+               return(-ENOMEM);
+-      if(copy_from_user(buf, buffer, count))
+-              return(-EFAULT);
++      if(copy_from_user(buf, buffer, count)){
++              count = -EFAULT;
++              goto out;
++      }
++
+       buf[count] = '\0';
+       mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
++ out:
++      kfree(buf);
+       return(count);
+ }
+diff -Naur a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
+--- a/arch/um/drivers/mconsole_user.c  2004-01-08 22:15:23.000000000 -0500
++++ b/arch/um/drivers/mconsole_user.c  2004-01-08 22:21:13.000000000 -0500
+@@ -1,6 +1,6 @@
+ /*
+  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+@@ -18,16 +18,18 @@
+ #include "umid.h"
+ static struct mconsole_command commands[] = {
+-      { "version", mconsole_version, 1 },
+-      { "halt", mconsole_halt, 0 },
+-      { "reboot", mconsole_reboot, 0 },
+-      { "config", mconsole_config, 0 },
+-      { "remove", mconsole_remove, 0 },
+-      { "sysrq", mconsole_sysrq, 1 },
+-      { "help", mconsole_help, 1 },
+-      { "cad", mconsole_cad, 1 },
+-      { "stop", mconsole_stop, 0 },
+-      { "go", mconsole_go, 1 },
++      { "version", mconsole_version, MCONSOLE_INTR },
++      { "halt", mconsole_halt, MCONSOLE_PROC },
++      { "reboot", mconsole_reboot, MCONSOLE_PROC },
++      { "config", mconsole_config, MCONSOLE_PROC },
++      { "remove", mconsole_remove, MCONSOLE_PROC },
++      { "sysrq", mconsole_sysrq, MCONSOLE_INTR },
++      { "help", mconsole_help, MCONSOLE_INTR },
++      { "cad", mconsole_cad, MCONSOLE_INTR },
++      { "stop", mconsole_stop, MCONSOLE_PROC },
++      { "go", mconsole_go, MCONSOLE_INTR },
++      { "log", mconsole_log, MCONSOLE_INTR },
++      { "proc", mconsole_proc, MCONSOLE_PROC },
+ };
+ /* Initialized in mconsole_init, which is an initcall */
+@@ -139,6 +141,7 @@
+               memcpy(reply.data, str, len);
+               reply.data[len] = '\0';
+               total -= len;
++              str += len;
+               reply.len = len + 1;
+               len = sizeof(reply) + reply.len - sizeof(reply.data);
+diff -Naur a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
+--- a/arch/um/drivers/mmapper_kern.c   2004-01-08 22:14:57.000000000 -0500
++++ b/arch/um/drivers/mmapper_kern.c   2004-01-08 22:20:27.000000000 -0500
+@@ -120,7 +120,10 @@
+       printk(KERN_INFO "Mapper v0.1\n");
+       v_buf = (char *) find_iomem("mmapper", &mmapper_size);
+-      if(mmapper_size == 0) return(0);
++      if(mmapper_size == 0){
++              printk(KERN_ERR "mmapper_init - find_iomem failed\n");
++              return(0);
++      }
+       p_buf = __pa(v_buf);
+diff -Naur a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
+--- a/arch/um/drivers/net_kern.c       2004-01-08 22:20:39.000000000 -0500
++++ b/arch/um/drivers/net_kern.c       2004-01-08 22:27:13.000000000 -0500
+@@ -26,6 +26,7 @@
+ #include "mconsole_kern.h"
+ #include "init.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ static spinlock_t opened_lock = SPIN_LOCK_UNLOCKED;
+ LIST_HEAD(opened);
+@@ -37,7 +38,8 @@
+       struct sk_buff *skb;
+       /* If we can't allocate memory, try again next round. */
+-      if ((skb = dev_alloc_skb(dev->mtu)) == NULL) {
++      skb = dev_alloc_skb(dev->mtu);
++      if (skb == NULL) {
+               lp->stats.rx_dropped++;
+               return 0;
+       }
+@@ -61,14 +63,14 @@
+       return pkt_len;
+ }
+-void uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
++irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+ {
+       struct net_device *dev = dev_id;
+       struct uml_net_private *lp = dev->priv;
+       int err;
+       if(!netif_running(dev))
+-              return;
++              return(IRQ_NONE);
+       spin_lock(&lp->lock);
+       while((err = uml_net_rx(dev)) > 0) ;
+@@ -83,6 +85,7 @@
+  out:
+       spin_unlock(&lp->lock);
++      return(IRQ_HANDLED);
+ }
+ static int uml_net_open(struct net_device *dev)
+@@ -252,37 +255,6 @@
+ #endif
+ }
+-/*
+- * default do nothing hard header packet routines for struct net_device init.
+- * real ethernet transports will overwrite with real routines.
+- */
+-static int uml_net_hard_header(struct sk_buff *skb, struct net_device *dev,
+-                 unsigned short type, void *daddr, void *saddr, unsigned len)
+-{
+-      return(0); /* no change */
+-}
+-
+-static int uml_net_rebuild_header(struct sk_buff *skb)
+-{
+-      return(0); /* ignore */ 
+-}
+-
+-static int uml_net_header_cache(struct neighbour *neigh, struct hh_cache *hh)
+-{
+-      return(-1); /* fail */
+-}
+-
+-static void uml_net_header_cache_update(struct hh_cache *hh,
+-                 struct net_device *dev, unsigned char * haddr)
+-{
+-      /* ignore */
+-}
+-
+-static int uml_net_header_parse(struct sk_buff *skb, unsigned char *haddr)
+-{
+-      return(0); /* nothing */
+-}
+-
+ static spinlock_t devices_lock = SPIN_LOCK_UNLOCKED;
+ static struct list_head devices = LIST_HEAD_INIT(devices);
+@@ -292,7 +264,7 @@
+       struct uml_net *device;
+       struct net_device *dev;
+       struct uml_net_private *lp;
+-      int err, size;
++      int save, err, size;
+       size = transport->private_size + sizeof(struct uml_net_private) + 
+               sizeof(((struct uml_net_private *) 0)->user);
+@@ -334,12 +306,6 @@
+       snprintf(dev->name, sizeof(dev->name), "eth%d", n);
+       device->dev = dev;
+-        dev->hard_header = uml_net_hard_header;
+-        dev->rebuild_header = uml_net_rebuild_header;
+-        dev->hard_header_cache = uml_net_header_cache;
+-        dev->header_cache_update= uml_net_header_cache_update;
+-        dev->hard_header_parse = uml_net_header_parse;
+-
+       (*transport->kern->init)(dev, init);
+       dev->mtu = transport->user->max_packet;
+@@ -362,21 +328,29 @@
+               return 1;
+       lp = dev->priv;
+-      INIT_LIST_HEAD(&lp->list);
+-      spin_lock_init(&lp->lock);
+-      lp->dev = dev;
+-      lp->fd = -1;
+-      lp->mac = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0 };
+-      lp->have_mac = device->have_mac;
+-      lp->protocol = transport->kern->protocol;
+-      lp->open = transport->user->open;
+-      lp->close = transport->user->close;
+-      lp->remove = transport->user->remove;
+-      lp->read = transport->kern->read;
+-      lp->write = transport->kern->write;
+-      lp->add_address = transport->user->add_address;
+-      lp->delete_address = transport->user->delete_address;
+-      lp->set_mtu = transport->user->set_mtu;
++      /* 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),
++                .lock                 = SPIN_LOCK_UNLOCKED,
++                .dev                  = dev,
++                .fd                   = -1,
++                .mac                  = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
++                .have_mac             = device->have_mac,
++                .protocol             = transport->kern->protocol,
++                .open                 = transport->user->open,
++                .close                = transport->user->close,
++                .remove               = transport->user->remove,
++                .read                 = transport->kern->read,
++                .write                = transport->kern->write,
++                .add_address          = transport->user->add_address,
++                .delete_address       = transport->user->delete_address,
++                .set_mtu              = transport->user->set_mtu,
++                .user                 = { save } });
+       init_timer(&lp->tl);
+       lp->tl.function = uml_net_user_timer_expire;
+@@ -609,7 +583,8 @@
+       unregister_netdev(dev);
+       list_del(&device->list);
+-      free_netdev(device);
++      kfree(device);
++      free_netdev(dev);
+       return(0);
+ }
+diff -Naur a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
+--- a/arch/um/drivers/net_user.c       2004-01-08 22:16:01.000000000 -0500
++++ b/arch/um/drivers/net_user.c       2004-01-08 22:21:37.000000000 -0500
+@@ -26,8 +26,7 @@
+       if(gate_addr == NULL) return(0);
+       if(sscanf(gate_addr, "%d.%d.%d.%d", &tap_addr[0], 
+                 &tap_addr[1], &tap_addr[2], &tap_addr[3]) != 4){
+-              printk("Invalid tap IP address - '%s'\n", 
+-                     gate_addr);
++              printk("Invalid tap IP address - '%s'\n", gate_addr);
+               return(-EINVAL);
+       }
+       return(0);
+@@ -60,18 +59,18 @@
+       }
+               
+       *output = '\0';
+-      if(read(fd, &remain, sizeof(remain)) != sizeof(remain)){
+-              printk("read_output - read of length failed, errno = %d\n",
+-                     errno);
++      n = os_read_file(fd, &remain, sizeof(remain));
++      if(n != sizeof(remain)){
++              printk("read_output - read of length failed, err = %d\n", -n);
+               return;
+       }
+       while(remain != 0){
+               n = (remain < len) ? remain : len;
+-              actual = read(fd, output, n);
++              actual = os_read_file(fd, output, n);
+               if(actual != n){
+                       printk("read_output - read of data failed, "
+-                             "errno = %d\n", errno);
++                             "err = %d\n", -actual);
+                       return;
+               }
+               remain -= actual;
+@@ -83,13 +82,12 @@
+ {
+       int n;
+-      while(((n = read(fd,  buf,  len)) < 0) && (errno == EINTR)) ;
++      n = os_read_file(fd,  buf,  len);
+-      if(n < 0){
+-              if(errno == EAGAIN) return(0);
+-              return(-errno);
+-      }
+-      else if(n == 0) return(-ENOTCONN);
++      if(n == -EAGAIN) 
++              return(0);
++      else if(n == 0) 
++              return(-ENOTCONN);
+       return(n);
+ }
+@@ -112,13 +110,13 @@
+ {
+       int n;
+-      while(((n = write(fd, buf, len)) < 0) && (errno == EINTR)) ;
+-      if(n < 0){
+-              if(errno == EAGAIN) return(0);
+-              return(-errno);
+-      }
+-      else if(n == 0) return(-ENOTCONN);
+-      return(n);      
++      n = os_write_file(fd, buf, len);
++
++      if(n == -EAGAIN) 
++              return(0);
++      else if(n == 0) 
++              return(-ENOTCONN);
++      return(n);
+ }
+ int net_send(int fd, void *buf, int len)
+@@ -157,7 +155,7 @@
+ {
+       struct change_pre_exec_data *data = arg;
+-      close(data->close_me);
++      os_close_file(data->close_me);
+       dup2(data->stdout, 1);
+ }
+@@ -167,15 +165,15 @@
+       struct change_pre_exec_data pe_data;
+       err = os_pipe(fds, 1, 0);
+-      if(err){
+-              printk("change_tramp - pipe failed, errno = %d\n", -err);
++      if(err < 0){
++              printk("change_tramp - pipe failed, err = %d\n", -err);
+               return(err);
+       }
+       pe_data.close_me = fds[0];
+       pe_data.stdout = fds[1];
+       pid = run_helper(change_pre_exec, &pe_data, argv, NULL);
+-      close(fds[1]);
++      os_close_file(fds[1]);
+       read_output(fds[0], output, output_len);
+       waitpid(pid, NULL, 0);  
+       return(pid);
+diff -Naur a/arch/um/drivers/null.c b/arch/um/drivers/null.c
+--- a/arch/um/drivers/null.c   2004-01-08 22:14:29.000000000 -0500
++++ b/arch/um/drivers/null.c   2004-01-08 22:19:28.000000000 -0500
+@@ -5,7 +5,6 @@
+ #include <stdlib.h>
+ #include <errno.h>
+-#include <fcntl.h>
+ #include "chan_user.h"
+ #include "os.h"
+diff -Naur a/arch/um/drivers/port_kern.c b/arch/um/drivers/port_kern.c
+--- a/arch/um/drivers/port_kern.c      2004-01-08 22:13:51.000000000 -0500
++++ b/arch/um/drivers/port_kern.c      2004-01-08 22:18:54.000000000 -0500
+@@ -6,6 +6,7 @@
+ #include "linux/list.h"
+ #include "linux/sched.h"
+ #include "linux/slab.h"
++#include "linux/interrupt.h"
+ #include "linux/irq.h"
+ #include "linux/spinlock.h"
+ #include "linux/errno.h"
+@@ -14,6 +15,7 @@
+ #include "kern_util.h"
+ #include "kern.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ #include "port.h"
+ #include "init.h"
+ #include "os.h"
+@@ -44,7 +46,7 @@
+       struct port_list *port;
+ };
+-static void pipe_interrupt(int irq, void *data, struct pt_regs *regs)
++static irqreturn_t pipe_interrupt(int irq, void *data, struct pt_regs *regs)
+ {
+       struct connection *conn = data;
+       int fd;
+@@ -52,7 +54,7 @@
+       fd = os_rcv_fd(conn->socket[0], &conn->helper_pid);
+       if(fd < 0){
+               if(fd == -EAGAIN)
+-                      return;
++                      return(IRQ_NONE);
+               printk(KERN_ERR "pipe_interrupt : os_rcv_fd returned %d\n", 
+                      -fd);
+@@ -65,6 +67,7 @@
+       list_add(&conn->list, &conn->port->connections);
+       up(&conn->port->sem);
++      return(IRQ_HANDLED);
+ }
+ static int port_accept(struct port_list *port)
+@@ -138,12 +141,13 @@
+ DECLARE_WORK(port_work, port_work_proc, NULL);
+-static void port_interrupt(int irq, void *data, struct pt_regs *regs)
++static irqreturn_t port_interrupt(int irq, void *data, struct pt_regs *regs)
+ {
+       struct port_list *port = data;
+       port->has_connection = 1;
+       schedule_work(&port_work);
++      return(IRQ_HANDLED);
+ } 
+ void *port_data(int port_num)
+diff -Naur a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
+--- a/arch/um/drivers/port_user.c      2004-01-08 22:24:12.000000000 -0500
++++ b/arch/um/drivers/port_user.c      2004-01-08 22:31:27.000000000 -0500
+@@ -47,10 +47,12 @@
+               return(NULL);
+       }
+-      if((kern_data = port_data(port)) == NULL) 
++      kern_data = port_data(port);
++      if(kern_data == NULL) 
+               return(NULL);
+-      if((data = um_kmalloc(sizeof(*data))) == NULL) 
++      data = um_kmalloc(sizeof(*data));
++      if(data == NULL) 
+               goto err;
+       *data = ((struct port_chan) { .raw              = opts->raw,
+@@ -90,7 +92,7 @@
+       struct port_chan *data = d;
+       port_remove_dev(data->kernel_data);
+-      close(fd);
++      os_close_file(fd);
+ }
+ int port_console_write(int fd, const char *buf, int n, void *d)
+@@ -130,11 +132,15 @@
+               goto out;
+       }
+   
+-      if((listen(fd, 1) < 0) || (os_set_fd_block(fd, 0))){
++      if(listen(fd, 1) < 0){
+               err = -errno;
+               goto out;
+       }
++      err = os_set_fd_block(fd, 0);
++      if(err < 0)
++              goto out;
++
+       return(fd);
+  out:
+       os_close_file(fd);
+@@ -153,10 +159,10 @@
+       dup2(data->sock_fd, 0);
+       dup2(data->sock_fd, 1);
+       dup2(data->sock_fd, 2);
+-      close(data->sock_fd);
++      os_close_file(data->sock_fd);
+       dup2(data->pipe_fd, 3);
+       os_shutdown_socket(3, 1, 0);
+-      close(data->pipe_fd);
++      os_close_file(data->pipe_fd);
+ }
+ int port_connection(int fd, int *socket, int *pid_out)
+@@ -166,11 +172,12 @@
+                        "/usr/lib/uml/port-helper", NULL };
+       struct port_pre_exec_data data;
+-      if((new = os_accept_connection(fd)) < 0)
+-              return(-errno);
++      new = os_accept_connection(fd);
++      if(new < 0)
++              return(new);
+       err = os_pipe(socket, 0, 0);
+-      if(err) 
++      if(err < 0) 
+               goto out_close;
+       data = ((struct port_pre_exec_data)
+@@ -186,11 +193,11 @@
+  out_shutdown:
+       os_shutdown_socket(socket[0], 1, 1);
+-      close(socket[0]);
++      os_close_file(socket[0]);
+       os_shutdown_socket(socket[1], 1, 1);    
+-      close(socket[1]);
++      os_close_file(socket[1]);
+  out_close:
+-      close(new);
++      os_close_file(new);
+       return(err);
+ }
+diff -Naur a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
+--- a/arch/um/drivers/pty.c    2004-01-08 22:29:41.000000000 -0500
++++ b/arch/um/drivers/pty.c    2004-01-08 22:35:17.000000000 -0500
+@@ -7,12 +7,12 @@
+ #include <unistd.h>
+ #include <string.h>
+ #include <errno.h>
+-#include <fcntl.h>
+ #include <termios.h>
+ #include "chan_user.h"
+ #include "user.h"
+ #include "user_util.h"
+ #include "kern_util.h"
++#include "os.h"
+ struct pty_chan {
+       void (*announce)(char *dev_name, int dev);
+@@ -26,7 +26,8 @@
+ {
+       struct pty_chan *data;
+-      if((data = um_kmalloc(sizeof(*data))) == NULL) return(NULL);
++      data = um_kmalloc(sizeof(*data));
++      if(data == NULL) return(NULL);
+       *data = ((struct pty_chan) { .announce          = opts->announce, 
+                                    .dev               = device,
+                                    .raw               = opts->raw });
+@@ -39,7 +40,8 @@
+       char *dev;
+       int fd;
+-      if((fd = get_pty()) < 0){
++      fd = get_pty();
++      if(fd < 0){
+               printk("open_pts : Failed to open pts\n");
+               return(-errno);
+       }
+@@ -57,29 +59,27 @@
+ int getmaster(char *line)
+ {
+-      struct stat stb;
+       char *pty, *bank, *cp;
+-      int master;
++      int master, err;
+       pty = &line[strlen("/dev/ptyp")];
+       for (bank = "pqrs"; *bank; bank++) {
+               line[strlen("/dev/pty")] = *bank;
+               *pty = '0';
+-              if (stat(line, &stb) < 0)
++              if (os_stat_file(line, NULL) < 0)
+                       break;
+               for (cp = "0123456789abcdef"; *cp; cp++) {
+                       *pty = *cp;
+-                      master = open(line, O_RDWR);
++                      master = os_open_file(line, of_rdwr(OPENFLAGS()), 0);
+                       if (master >= 0) {
+                               char *tp = &line[strlen("/dev/")];
+-                              int ok;
+                               /* verify slave side is usable */
+                               *tp = 't';
+-                              ok = access(line, R_OK|W_OK) == 0;
++                              err = os_access(line, OS_ACC_RW_OK);
+                               *tp = 'p';
+-                              if (ok) return(master);
+-                              (void) close(master);
++                              if(err == 0) return(master);
++                              (void) os_close_file(master);
+                       }
+               }
+       }
+diff -Naur a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
+--- a/arch/um/drivers/slip_user.c      2004-01-08 22:29:41.000000000 -0500
++++ b/arch/um/drivers/slip_user.c      2004-01-08 22:35:17.000000000 -0500
+@@ -4,11 +4,9 @@
+ #include <stddef.h>
+ #include <sched.h>
+ #include <string.h>
+-#include <sys/fcntl.h>
+ #include <sys/errno.h>
+ #include <sys/termios.h>
+ #include <sys/wait.h>
+-#include <sys/ioctl.h>
+ #include <sys/signal.h>
+ #include "user_util.h"
+ #include "kern_util.h"
+@@ -65,9 +63,9 @@
+ {
+       struct slip_pre_exec_data *data = arg;
+-      if(data->stdin != -1) dup2(data->stdin, 0);
++      if(data->stdin >= 0) dup2(data->stdin, 0);
+       dup2(data->stdout, 1);
+-      if(data->close_me != -1) close(data->close_me);
++      if(data->close_me >= 0) os_close_file(data->close_me);
+ }
+ static int slip_tramp(char **argv, int fd)
+@@ -77,8 +75,8 @@
+       int status, pid, fds[2], err, output_len;
+       err = os_pipe(fds, 1, 0);
+-      if(err){
+-              printk("slip_tramp : pipe failed, errno = %d\n", -err);
++      if(err < 0){
++              printk("slip_tramp : pipe failed, err = %d\n", -err);
+               return(err);
+       }
+@@ -96,7 +94,7 @@
+                       printk("slip_tramp : failed to allocate output "
+                              "buffer\n");
+-              close(fds[1]);
++              os_close_file(fds[1]);
+               read_output(fds[0], output, output_len);
+               if(output != NULL){
+                       printk("%s", output);
+@@ -105,7 +103,7 @@
+               if(waitpid(pid, &status, 0) < 0) err = errno;
+               else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
+                       printk("'%s' didn't exit with status 0\n", argv[0]);
+-                      err = EINVAL;
++                      err = -EINVAL;
+               }
+       }
+       return(err);
+@@ -118,15 +116,17 @@
+       char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
+       char *argv[] = { "uml_net", version_buf, "slip", "up", gate_buf, 
+                        NULL };
+-      int sfd, mfd, disc, sencap, err;
++      int sfd, mfd, err;
+-      if((mfd = get_pty()) < 0){
+-              printk("umn : Failed to open pty\n");
+-              return(-1);
++      mfd = get_pty();
++      if(mfd < 0){
++              printk("umn : Failed to open pty, err = %d\n", -mfd);
++              return(mfd);
+       }
+-      if((sfd = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0)) < 0){
+-              printk("Couldn't open tty for slip line\n");
+-              return(-1);
++      sfd = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0);
++      if(sfd < 0){
++              printk("Couldn't open tty for slip line, err = %d\n", -sfd);
++              return(sfd);
+       }
+       if(set_up_tty(sfd)) return(-1);
+       pri->slave = sfd;
+@@ -138,28 +138,23 @@
+               err = slip_tramp(argv, sfd);
+-              if(err != 0){
+-                      printk("slip_tramp failed - errno = %d\n", err);
+-                      return(-err);
++              if(err < 0){
++                      printk("slip_tramp failed - err = %d\n", -err);
++                      return(err);
+               }
+-              if(ioctl(pri->slave, SIOCGIFNAME, pri->name) < 0){
+-                      printk("SIOCGIFNAME failed, errno = %d\n", errno);
+-                      return(-errno);
++              err = os_get_ifname(pri->slave, pri->name);
++              if(err < 0){
++                      printk("get_ifname failed, err = %d\n", -err);
++                      return(err);
+               }
+               iter_addresses(pri->dev, open_addr, pri->name);
+       }
+       else {
+-              disc = N_SLIP;
+-              if(ioctl(sfd, TIOCSETD, &disc) < 0){
+-                      printk("Failed to set slip line discipline - "
+-                             "errno = %d\n", errno);
+-                      return(-errno);
+-              }
+-              sencap = 0;
+-              if(ioctl(sfd, SIOCSIFENCAP, &sencap) < 0){
+-                      printk("Failed to set slip encapsulation - "
+-                             "errno = %d\n", errno);
+-                      return(-errno);
++              err = os_set_slip(sfd);
++              if(err < 0){
++                      printk("Failed to set slip discipline encapsulation - "
++                             "err = %d\n", -err);
++                      return(err);
+               }
+       }
+       return(mfd);
+@@ -181,9 +176,9 @@
+       err = slip_tramp(argv, -1);
+       if(err != 0)
+-              printk("slip_tramp failed - errno = %d\n", err);
+-      close(fd);
+-      close(pri->slave);
++              printk("slip_tramp failed - errno = %d\n", -err);
++      os_close_file(fd);
++      os_close_file(pri->slave);
+       pri->slave = -1;
+ }
+@@ -243,7 +238,7 @@
+ {
+       struct slip_data *pri = data;
+-      if(pri->slave == -1) return;
++      if(pri->slave < 0) return;
+       open_addr(addr, netmask, pri->name);
+ }
+@@ -252,7 +247,7 @@
+ {
+       struct slip_data *pri = data;
+-      if(pri->slave == -1) return;
++      if(pri->slave < 0) return;
+       close_addr(addr, netmask, pri->name);
+ }
+diff -Naur a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
+--- a/arch/um/drivers/slirp_user.c     2004-01-08 22:25:11.000000000 -0500
++++ b/arch/um/drivers/slirp_user.c     2004-01-08 22:32:27.000000000 -0500
+@@ -4,7 +4,6 @@
+ #include <stddef.h>
+ #include <sched.h>
+ #include <string.h>
+-#include <sys/fcntl.h>
+ #include <sys/errno.h>
+ #include <sys/wait.h>
+ #include <sys/signal.h>
+@@ -48,15 +47,15 @@
+       return(pid);
+ }
+- 
++
++/* XXX This is just a trivial wrapper around os_pipe */ 
+ static int slirp_datachan(int *mfd, int *sfd)
+ {
+       int fds[2], err;
+       err = os_pipe(fds, 1, 1);
+-      if(err){
+-              printk("slirp_datachan: Failed to open pipe, errno = %d\n",
+-                     -err);
++      if(err < 0){
++              printk("slirp_datachan: Failed to open pipe, err = %d\n", -err);
+               return(err);
+       }
+@@ -77,7 +76,7 @@
+       pid = slirp_tramp(pri->argw.argv, sfd);
+       if(pid < 0){
+-              printk("slirp_tramp failed - errno = %d\n", pid);
++              printk("slirp_tramp failed - errno = %d\n", -pid);
+               os_close_file(sfd);     
+               os_close_file(mfd);     
+               return(pid);
+@@ -97,8 +96,8 @@
+       struct slirp_data *pri = data;
+       int status,err;
+-      close(fd);
+-      close(pri->slave);
++      os_close_file(fd);
++      os_close_file(pri->slave);
+       pri->slave = -1;
+diff -Naur a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
+--- a/arch/um/drivers/ssl.c    2004-01-08 22:21:29.000000000 -0500
++++ b/arch/um/drivers/ssl.c    2004-01-08 22:28:16.000000000 -0500
+@@ -10,6 +10,7 @@
+ #include "linux/major.h"
+ #include "linux/mm.h"
+ #include "linux/init.h"
++#include "linux/console.h"
+ #include "asm/termbits.h"
+ #include "asm/irq.h"
+ #include "line.h"
+@@ -53,8 +54,9 @@
+ static struct line_driver driver = {
+       .name                   = "UML serial line",
+-      .devfs_name             = "tts/%d",
+-      .major                  = TTYAUX_MAJOR,
++      .device_name            = "ttS",
++      .devfs_name             = "tts/",
++      .major                  = TTY_MAJOR,
+       .minor_start            = 64,
+       .type                   = TTY_DRIVER_TYPE_SERIAL,
+       .subtype                = 0,
+@@ -149,6 +151,9 @@
+       case TCSETSW:
+       case TCGETA:
+       case TIOCMGET:
++      case TCSBRK:
++      case TCSBRKP:
++      case TIOCMSET:
+               ret = -ENOIOCTLCMD;
+               break;
+       default:
+@@ -212,6 +217,39 @@
+  */
+ static int ssl_init_done = 0;
++extern int tty_init(void);
++
++static void ssl_console_write(struct console *c, const char *string, 
++                            unsigned len)
++{
++      struct line *line = &serial_lines[c->index];
++      if(ssl_init_done)
++              down(&line->sem);
++      console_write_chan(&line->chan_list, string, len);
++      if(ssl_init_done)
++              up(&line->sem);
++}
++
++static struct tty_driver *ssl_console_device(struct console *c, int *index)
++{
++      *index = c->index;
++      return ssl_driver;
++}
++
++static int ssl_console_setup(struct console *co, char *options)
++{
++      return(0);
++}
++
++static struct console ssl_cons = {
++      name:           "ttyS",
++      write:          ssl_console_write,
++      device:         ssl_console_device,
++      setup:          ssl_console_setup,
++      flags:          CON_PRINTBUFFER,
++      index:          -1,
++};
++
+ int ssl_init(void)
+ {
+       char *new_title;
+@@ -219,6 +257,8 @@
+       printk(KERN_INFO "Initializing software serial port version %d\n", 
+              ssl_version);
++      tty_init();
++
+       ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops,
+               serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0]));
+@@ -227,6 +267,7 @@
+       new_title = add_xterm_umid(opts.xterm_title);
+       if(new_title != NULL) opts.xterm_title = new_title;
++      register_console(&ssl_cons);
+       ssl_init_done = 1;
+       return(0);
+ }
+@@ -235,9 +276,9 @@
+ static int ssl_chan_setup(char *str)
+ {
+-      line_setup(serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0]),
+-                 str, 1);
+-      return(1);
++      return(line_setup(serial_lines, 
++                        sizeof(serial_lines)/sizeof(serial_lines[0]), 
++                        str, 1));
+ }
+ __setup("ssl", ssl_chan_setup);
+diff -Naur a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
+--- a/arch/um/drivers/stdio_console.c  2004-01-08 22:16:37.000000000 -0500
++++ b/arch/um/drivers/stdio_console.c  2004-01-08 22:22:42.000000000 -0500
+@@ -83,7 +83,8 @@
+ static struct line_driver driver = {
+       .name                   = "UML console",
+-      .devfs_name             = "vc/%d",
++      .device_name            = "tty",
++      .devfs_name             = "vc/",
+       .major                  = TTY_MAJOR,
+       .minor_start            = 0,
+       .type                   = TTY_DRIVER_TYPE_CONSOLE,
+@@ -159,14 +160,28 @@
+ static int con_init_done = 0;
++static struct tty_operations console_ops = {
++      .open                   = con_open,
++      .close                  = con_close,
++      .write                  = con_write,
++      .chars_in_buffer        = chars_in_buffer,
++      .set_termios            = set_termios,
++      .write_room             = line_write_room,
++};
++
++extern int tty_init(void);
++
+ int stdio_init(void)
+ {
+       char *new_title;
+       printk(KERN_INFO "Initializing stdio console driver\n");
++      tty_init();
++
+       console_driver = line_register_devfs(&console_lines, &driver,
+-                              &console_ops, vts, sizeof(vts)/sizeof(vts[0]));
++                                           &console_ops, vts,
++                                           sizeof(vts)/sizeof(vts[0]));
+       lines_init(vts, sizeof(vts)/sizeof(vts[0]));
+@@ -183,19 +198,14 @@
+ static void console_write(struct console *console, const char *string, 
+                         unsigned len)
+ {
+-      if(con_init_done) down(&vts[console->index].sem);
+-      console_write_chan(&vts[console->index].chan_list, string, len);
+-      if(con_init_done) up(&vts[console->index].sem);
+-}
++      struct line *line = &vts[console->index];
+-static struct tty_operations console_ops = {
+-      .open                   = con_open,
+-      .close                  = con_close,
+-      .write                  = con_write,
+-      .chars_in_buffer        = chars_in_buffer,
+-      .set_termios            = set_termios,
+-      .write_room             = line_write_room,
+-};
++      if(con_init_done)
++              down(&line->sem);
++      console_write_chan(&line->chan_list, string, len);
++      if(con_init_done)
++              up(&line->sem);
++}
+ static struct tty_driver *console_device(struct console *c, int *index)
+ {
+@@ -208,22 +218,28 @@
+       return(0);
+ }
+-static struct console stdiocons = INIT_CONSOLE("tty", console_write, 
+-                                             console_device, console_setup,
+-                                             CON_PRINTBUFFER);
++static struct console stdiocons = {
++      name:           "tty",
++      write:          console_write,
++      device:         console_device,
++      setup:          console_setup,
++      flags:          CON_PRINTBUFFER,
++      index:          -1,
++};
+-static void __init stdio_console_init(void)
++static int __init stdio_console_init(void)
+ {
+       INIT_LIST_HEAD(&vts[0].chan_list);
+       list_add(&init_console_chan.list, &vts[0].chan_list);
+       register_console(&stdiocons);
++      return(0);
+ }
++
+ console_initcall(stdio_console_init);
+ static int console_chan_setup(char *str)
+ {
+-      line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1);
+-      return(1);
++      return(line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1));
+ }
+ __setup("con", console_chan_setup);
+diff -Naur a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
+--- a/arch/um/drivers/tty.c    2004-01-08 22:18:51.000000000 -0500
++++ b/arch/um/drivers/tty.c    2004-01-08 22:24:43.000000000 -0500
+@@ -5,7 +5,6 @@
+ #include <stdio.h>
+ #include <termios.h>
+-#include <fcntl.h>
+ #include <errno.h>
+ #include <unistd.h>
+ #include "chan_user.h"
+@@ -30,7 +29,8 @@
+       }
+       str++;
+-      if((data = um_kmalloc(sizeof(*data))) == NULL) 
++      data = um_kmalloc(sizeof(*data)); 
++      if(data == NULL) 
+               return(NULL);
+       *data = ((struct tty_chan) { .dev       = str,
+                                    .raw       = opts->raw });
+diff -Naur a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
+--- a/arch/um/drivers/ubd_kern.c       2004-01-08 22:21:09.000000000 -0500
++++ b/arch/um/drivers/ubd_kern.c       2004-01-08 22:27:27.000000000 -0500
+@@ -8,6 +8,13 @@
+  * old style ubd by setting UBD_SHIFT to 0
+  * 2002-09-27...2002-10-18 massive tinkering for 2.5
+  * partitions have changed in 2.5
++ * 2003-01-29 more tinkering for 2.5.59-1
++ * This should now address the sysfs problems and has
++ * the symlink for devfs to allow for booting with
++ * the common /dev/ubd/discX/... names rather than
++ * only /dev/ubdN/discN this version also has lots of
++ * clean ups preparing for ubd-many.
++ * James McMechan
+  */
+ #define MAJOR_NR UBD_MAJOR
+@@ -40,9 +47,12 @@
+ #include "mconsole_kern.h"
+ #include "init.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ #include "ubd_user.h"
+ #include "2_5compat.h"
+ #include "os.h"
++#include "mem.h"
++#include "mem_kern.h"
+ static spinlock_t ubd_io_lock = SPIN_LOCK_UNLOCKED;
+ static spinlock_t ubd_lock = SPIN_LOCK_UNLOCKED;
+@@ -56,6 +66,10 @@
+ #define MAX_DEV (8)
++/* Changed in early boot */
++static int ubd_do_mmap = 0;
++#define UBD_MMAP_BLOCK_SIZE PAGE_SIZE
++
+ static struct block_device_operations ubd_blops = {
+         .owner                = THIS_MODULE,
+         .open         = ubd_open,
+@@ -67,7 +81,7 @@
+ static request_queue_t *ubd_queue;
+ /* Protected by ubd_lock */
+-static int fake_major = 0;
++static int fake_major = MAJOR_NR;
+ static struct gendisk *ubd_gendisk[MAX_DEV];
+ static struct gendisk *fake_gendisk[MAX_DEV];
+@@ -96,13 +110,19 @@
+ struct ubd {
+       char *file;
+-      int is_dir;
+       int count;
+       int fd;
+       __u64 size;
+       struct openflags boot_openflags;
+       struct openflags openflags;
++      int no_cow;
+       struct cow cow;
++
++      int map_writes;
++      int map_reads;
++      int nomap_writes;
++      int nomap_reads;
++      int write_maps;
+ };
+ #define DEFAULT_COW { \
+@@ -115,21 +135,28 @@
+ #define DEFAULT_UBD { \
+       .file =                 NULL, \
+-      .is_dir =               0, \
+       .count =                0, \
+       .fd =                   -1, \
+       .size =                 -1, \
+       .boot_openflags =       OPEN_FLAGS, \
+       .openflags =            OPEN_FLAGS, \
++        .no_cow =               0, \
+         .cow =                        DEFAULT_COW, \
++      .map_writes             = 0, \
++      .map_reads              = 0, \
++      .nomap_writes           = 0, \
++      .nomap_reads            = 0, \
++      .write_maps             = 0, \
+ }
+ struct ubd ubd_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_UBD };
+ static int ubd0_init(void)
+ {
+-      if(ubd_dev[0].file == NULL)
+-              ubd_dev[0].file = "root_fs";
++      struct ubd *dev = &ubd_dev[0];
++
++      if(dev->file == NULL)
++              dev->file = "root_fs";
+       return(0);
+ }
+@@ -196,19 +223,46 @@
+ "    Create ide0 entries that map onto ubd devices.\n\n"
+ );
++static int parse_unit(char **ptr)
++{
++      char *str = *ptr, *end;
++      int n = -1;
++
++      if(isdigit(*str)) {
++              n = simple_strtoul(str, &end, 0);
++              if(end == str)
++                      return(-1);
++              *ptr = end;
++      }
++      else if (('a' <= *str) && (*str <= 'h')) {
++              n = *str - 'a';
++              str++;
++              *ptr = str;
++      }
++      return(n);
++}
++
+ static int ubd_setup_common(char *str, int *index_out)
+ {
++      struct ubd *dev;
+       struct openflags flags = global_openflags;
+       char *backing_file;
+       int n, err;
+       if(index_out) *index_out = -1;
+-      n = *str++;
++      n = *str;
+       if(n == '='){
+-              static int fake_major_allowed = 1;
+               char *end;
+               int major;
++              str++;
++              if(!strcmp(str, "mmap")){
++                      CHOOSE_MODE(printk("mmap not supported by the ubd "
++                                         "driver in tt mode\n"),
++                                  ubd_do_mmap = 1);
++                      return(0);
++              }
++
+               if(!strcmp(str, "sync")){
+                       global_openflags.s = 1;
+                       return(0);
+@@ -220,20 +274,14 @@
+                       return(1);
+               }
+-              if(!fake_major_allowed){
+-                      printk(KERN_ERR "Can't assign a fake major twice\n");
+-                      return(1);
+-              }
+-
+               err = 1;
+               spin_lock(&ubd_lock);
+-              if(!fake_major_allowed){
++              if(fake_major != MAJOR_NR){
+                       printk(KERN_ERR "Can't assign a fake major twice\n");
+                       goto out1;
+               }
+  
+               fake_major = major;
+-              fake_major_allowed = 0;
+               printk(KERN_INFO "Setting extra ubd major number to %d\n",
+                      major);
+@@ -243,25 +291,23 @@
+               return(err);
+       }
+-      if(n < '0'){
+-              printk(KERN_ERR "ubd_setup : index out of range\n"); }
+-
+-      if((n >= '0') && (n <= '9')) n -= '0';
+-      else if((n >= 'a') && (n <= 'z')) n -= 'a';
+-      else {
+-              printk(KERN_ERR "ubd_setup : device syntax invalid\n");
++      n = parse_unit(&str);
++      if(n < 0){
++              printk(KERN_ERR "ubd_setup : couldn't parse unit number "
++                     "'%s'\n", str);
+               return(1);
+       }
+       if(n >= MAX_DEV){
+-              printk(KERN_ERR "ubd_setup : index out of range "
+-                     "(%d devices)\n", MAX_DEV);      
++              printk(KERN_ERR "ubd_setup : index %d out of range "
++                     "(%d devices)\n", n, MAX_DEV);
+               return(1);
+       }
+       err = 1;
+       spin_lock(&ubd_lock);
+-      if(ubd_dev[n].file != NULL){
++      dev = &ubd_dev[n];
++      if(dev->file != NULL){
+               printk(KERN_ERR "ubd_setup : device already configured\n");
+               goto out2;
+       }
+@@ -276,6 +322,11 @@
+               flags.s = 1;
+               str++;
+       }
++      if (*str == 'd'){
++              dev->no_cow = 1;
++              str++;
++      }
++
+       if(*str++ != '='){
+               printk(KERN_ERR "ubd_setup : Expected '='\n");
+               goto out2;
+@@ -284,14 +335,17 @@
+       err = 0;
+       backing_file = strchr(str, ',');
+       if(backing_file){
+-              *backing_file = '\0';
+-              backing_file++;
++              if(dev->no_cow)
++                      printk(KERN_ERR "Can't specify both 'd' and a "
++                             "cow file\n");
++              else {
++                      *backing_file = '\0';
++                      backing_file++;
++              }
+       }
+-      ubd_dev[n].file = str;
+-      if(ubd_is_dir(ubd_dev[n].file))
+-              ubd_dev[n].is_dir = 1;
+-      ubd_dev[n].cow.file = backing_file;
+-      ubd_dev[n].boot_openflags = flags;
++      dev->file = str;
++      dev->cow.file = backing_file;
++      dev->boot_openflags = flags;
+  out2:
+       spin_unlock(&ubd_lock);
+       return(err);
+@@ -321,8 +375,7 @@
+ static int fakehd_set = 0;
+ static int fakehd(char *str)
+ {
+-      printk(KERN_INFO 
+-             "fakehd : Changing ubd name to \"hd\".\n");
++      printk(KERN_INFO "fakehd : Changing ubd name to \"hd\".\n");
+       fakehd_set = 1;
+       return 1;
+ }
+@@ -368,32 +421,42 @@
+ {
+       struct io_thread_req req;
+       struct request *rq = elv_next_request(ubd_queue);
+-      int n;
++      int n, err;
+       do_ubd = NULL;
+       intr_count++;
+       n = read_ubd_fs(thread_fd, &req, sizeof(req));
+       if(n != sizeof(req)){
+               printk(KERN_ERR "Pid %d - spurious interrupt in ubd_handler, "
+-                     "errno = %d\n", os_getpid(), -n);
++                     "err = %d\n", os_getpid(), -n);
+               spin_lock(&ubd_io_lock);
+               end_request(rq, 0);
+               spin_unlock(&ubd_io_lock);
+               return;
+       }
+         
+-        if((req.offset != ((__u64) (rq->sector)) << 9) ||
+-         (req.length != (rq->current_nr_sectors) << 9))
++      if((req.op != UBD_MMAP) && 
++         ((req.offset != ((__u64) (rq->sector)) << 9) ||
++          (req.length != (rq->current_nr_sectors) << 9)))
+               panic("I/O op mismatch");
+       
++      if(req.map_fd != -1){
++              err = physmem_subst_mapping(req.buffer, req.map_fd, 
++                                          req.map_offset, 1);
++              if(err)
++                      printk("ubd_handler - physmem_subst_mapping failed, "
++                             "err = %d\n", -err);
++      }
++
+       ubd_finish(rq, req.error);
+       reactivate_fd(thread_fd, UBD_IRQ);      
+       do_ubd_request(ubd_queue);
+ }
+-static void ubd_intr(int irq, void *dev, struct pt_regs *unused)
++static irqreturn_t ubd_intr(int irq, void *dev, struct pt_regs *unused)
+ {
+       ubd_handler();
++      return(IRQ_HANDLED);
+ }
+ /* Only changed by ubd_init, which is an initcall. */
+@@ -429,18 +492,20 @@
+ static int ubd_open_dev(struct ubd *dev)
+ {
+       struct openflags flags;
+-      int err, n, create_cow, *create_ptr;
++      char **back_ptr;
++      int err, create_cow, *create_ptr;
++      dev->openflags = dev->boot_openflags;
+       create_cow = 0;
+       create_ptr = (dev->cow.file != NULL) ? &create_cow : NULL;
+-      dev->fd = open_ubd_file(dev->file, &dev->openflags, &dev->cow.file,
++      back_ptr = dev->no_cow ? NULL : &dev->cow.file;
++      dev->fd = open_ubd_file(dev->file, &dev->openflags, back_ptr,
+                               &dev->cow.bitmap_offset, &dev->cow.bitmap_len, 
+                               &dev->cow.data_offset, create_ptr);
+       if((dev->fd == -ENOENT) && create_cow){
+-              n = dev - ubd_dev;
+               dev->fd = create_cow_file(dev->file, dev->cow.file, 
+-                                        dev->openflags, 1 << 9,
++                                        dev->openflags, 1 << 9, PAGE_SIZE,
+                                         &dev->cow.bitmap_offset, 
+                                         &dev->cow.bitmap_len,
+                                         &dev->cow.data_offset);
+@@ -455,13 +520,17 @@
+       if(dev->cow.file != NULL){
+               err = -ENOMEM;
+               dev->cow.bitmap = (void *) vmalloc(dev->cow.bitmap_len);
+-              if(dev->cow.bitmap == NULL) goto error;
++              if(dev->cow.bitmap == NULL){
++                      printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
++                      goto error;
++              }
+               flush_tlb_kernel_vm();
+               err = read_cow_bitmap(dev->fd, dev->cow.bitmap, 
+                                     dev->cow.bitmap_offset, 
+                                     dev->cow.bitmap_len);
+-              if(err) goto error;
++              if(err < 0)
++                      goto error;
+               flags = dev->openflags;
+               flags.w = 0;
+@@ -481,17 +550,31 @@
+                       
+ {
+       struct gendisk *disk;
++      char from[sizeof("ubd/nnnnn\0")], to[sizeof("discnnnnn/disc\0")];
++      int err;
+       disk = alloc_disk(1 << UBD_SHIFT);
+-      if (!disk)
+-              return -ENOMEM;
++      if(disk == NULL)
++              return(-ENOMEM);
+       disk->major = major;
+       disk->first_minor = unit << UBD_SHIFT;
+       disk->fops = &ubd_blops;
+       set_capacity(disk, size / 512);
+-      sprintf(disk->disk_name, "ubd");
+-      sprintf(disk->devfs_name, "ubd/disc%d", unit);
++      if(major == MAJOR_NR){
++              sprintf(disk->disk_name, "ubd%c", 'a' + unit);
++              sprintf(disk->devfs_name, "ubd/disc%d", unit);
++              sprintf(from, "ubd/%d", unit);
++              sprintf(to, "disc%d/disc", unit);
++              err = devfs_mk_symlink(from, to);
++              if(err)
++                      printk("ubd_new_disk failed to make link from %s to "
++                             "%s, error = %d\n", from, to, err);
++      }
++      else {
++              sprintf(disk->disk_name, "ubd_fake%d", unit);
++              sprintf(disk->devfs_name, "ubd_fake/disc%d", unit);
++      }
+       disk->private_data = &ubd_dev[unit];
+       disk->queue = ubd_queue;
+@@ -506,24 +589,21 @@
+       struct ubd *dev = &ubd_dev[n];
+       int err;
+-      if(dev->is_dir)
+-              return(-EISDIR);
+-
+-      if (!dev->file)
++      if(dev->file == NULL)
+               return(-ENODEV);
+       if (ubd_open_dev(dev))
+               return(-ENODEV);
+       err = ubd_file_size(dev, &dev->size);
+-      if(err)
++      if(err < 0)
+               return(err);
+       err = ubd_new_disk(MAJOR_NR, dev->size, n, &ubd_gendisk[n]);
+       if(err) 
+               return(err);
+  
+-      if(fake_major)
++      if(fake_major != MAJOR_NR)
+               ubd_new_disk(fake_major, dev->size, n, 
+                            &fake_gendisk[n]);
+@@ -561,42 +641,42 @@
+       return(err);
+ }
+-static int ubd_get_config(char *dev, char *str, int size, char **error_out)
++static int ubd_get_config(char *name, char *str, int size, char **error_out)
+ {
+-      struct ubd *ubd;
++      struct ubd *dev;
+       char *end;
+-      int major, n = 0;
++      int n, len = 0;
+-      major = simple_strtoul(dev, &end, 0);
+-      if((*end != '\0') || (end == dev)){
+-              *error_out = "ubd_get_config : didn't parse major number";
++      n = simple_strtoul(name, &end, 0);
++      if((*end != '\0') || (end == name)){
++              *error_out = "ubd_get_config : didn't parse device number";
+               return(-1);
+       }
+-      if((major >= MAX_DEV) || (major < 0)){
+-              *error_out = "ubd_get_config : major number out of range";
++      if((n >= MAX_DEV) || (n < 0)){
++              *error_out = "ubd_get_config : device number out of range";
+               return(-1);
+       }
+-      ubd = &ubd_dev[major];
++      dev = &ubd_dev[n];
+       spin_lock(&ubd_lock);
+-      if(ubd->file == NULL){
+-              CONFIG_CHUNK(str, size, n, "", 1);
++      if(dev->file == NULL){
++              CONFIG_CHUNK(str, size, len, "", 1);
+               goto out;
+       }
+-      CONFIG_CHUNK(str, size, n, ubd->file, 0);
++      CONFIG_CHUNK(str, size, len, dev->file, 0);
+-      if(ubd->cow.file != NULL){
+-              CONFIG_CHUNK(str, size, n, ",", 0);
+-              CONFIG_CHUNK(str, size, n, ubd->cow.file, 1);
++      if(dev->cow.file != NULL){
++              CONFIG_CHUNK(str, size, len, ",", 0);
++              CONFIG_CHUNK(str, size, len, dev->cow.file, 1);
+       }
+-      else CONFIG_CHUNK(str, size, n, "", 1);
++      else CONFIG_CHUNK(str, size, len, "", 1);
+  out:
+       spin_unlock(&ubd_lock);
+-      return(n);
++      return(len);
+ }
+ static int ubd_remove(char *str)
+@@ -604,11 +684,9 @@
+       struct ubd *dev;
+       int n, err = -ENODEV;
+-      if(!isdigit(*str))
+-              return(err);    /* it should be a number 0-7/a-h */
++      n = parse_unit(&str);
+-      n = *str - '0';
+-      if(n >= MAX_DEV) 
++      if((n < 0) || (n >= MAX_DEV))
+               return(err);
+       dev = &ubd_dev[n];
+@@ -669,7 +747,7 @@
+               
+       elevator_init(ubd_queue, &elevator_noop);
+-      if (fake_major != 0) {
++      if (fake_major != MAJOR_NR) {
+               char name[sizeof("ubd_nnn\0")];
+               snprintf(name, sizeof(name), "ubd_%d", fake_major);
+@@ -696,6 +774,7 @@
+       io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), 
+                                &thread_fd);
+       if(io_pid < 0){
++              io_pid = -1;
+               printk(KERN_ERR 
+                      "ubd : Failed to start I/O thread (errno = %d) - "
+                      "falling back to synchronous I/O\n", -io_pid);
+@@ -703,8 +782,8 @@
+       }
+       err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr, 
+                            SA_INTERRUPT, "ubd", ubd_dev);
+-      if(err != 0) printk(KERN_ERR 
+-                          "um_request_irq failed - errno = %d\n", -err);
++      if(err != 0) 
++              printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
+       return(err);
+ }
+@@ -714,15 +793,9 @@
+ {
+       struct gendisk *disk = inode->i_bdev->bd_disk;
+       struct ubd *dev = disk->private_data;
+-      int err = -EISDIR;
+-
+-      if(dev->is_dir == 1)
+-              goto out;
++      int err = 0;
+-      err = 0;
+       if(dev->count == 0){
+-              dev->openflags = dev->boot_openflags;
+-
+               err = ubd_open_dev(dev);
+               if(err){
+                       printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",
+@@ -749,62 +822,156 @@
+       return(0);
+ }
+-void cowify_req(struct io_thread_req *req, struct ubd *dev)
++static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask, 
++                        __u64 *cow_offset, unsigned long *bitmap, 
++                        __u64 bitmap_offset, unsigned long *bitmap_words,
++                        __u64 bitmap_len)
++{
++      __u64 sector = io_offset >> 9;
++      int i, update_bitmap = 0;
++
++      for(i = 0; i < length >> 9; i++){
++              if(cow_mask != NULL)
++                      ubd_set_bit(i, (unsigned char *) cow_mask);
++              if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
++                      continue;
++
++              update_bitmap = 1;
++              ubd_set_bit(sector + i, (unsigned char *) bitmap);
++      }
++
++      if(!update_bitmap)
++              return;
++
++      *cow_offset = sector / (sizeof(unsigned long) * 8);
++
++      /* This takes care of the case where we're exactly at the end of the
++       * device, and *cow_offset + 1 is off the end.  So, just back it up
++       * by one word.  Thanks to Lynn Kerby for the fix and James McMechan
++       * for the original diagnosis.
++       */
++      if(*cow_offset == ((bitmap_len + sizeof(unsigned long) - 1) / 
++                         sizeof(unsigned long) - 1))
++              (*cow_offset)--;
++
++      bitmap_words[0] = bitmap[*cow_offset];
++      bitmap_words[1] = bitmap[*cow_offset + 1];
++
++      *cow_offset *= sizeof(unsigned long);
++      *cow_offset += bitmap_offset;
++}
++
++static void cowify_req(struct io_thread_req *req, unsigned long *bitmap, 
++                     __u64 bitmap_offset, __u64 bitmap_len)
+ {
+-        int i, update_bitmap, sector = req->offset >> 9;
++      __u64 sector = req->offset >> 9;
++      int i;
+       if(req->length > (sizeof(req->sector_mask) * 8) << 9)
+               panic("Operation too long");
++
+       if(req->op == UBD_READ) {
+               for(i = 0; i < req->length >> 9; i++){
+-                      if(ubd_test_bit(sector + i, (unsigned char *) 
+-                                      dev->cow.bitmap)){
++                      if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
+                               ubd_set_bit(i, (unsigned char *) 
+                                           &req->sector_mask);
+-                      }
+                 }
+-        } 
+-        else {
+-              update_bitmap = 0;
+-              for(i = 0; i < req->length >> 9; i++){
+-                      ubd_set_bit(i, (unsigned char *) 
+-                                  &req->sector_mask);
+-                      if(!ubd_test_bit(sector + i, (unsigned char *) 
+-                                       dev->cow.bitmap))
+-                              update_bitmap = 1;
+-                      ubd_set_bit(sector + i, (unsigned char *) 
+-                                  dev->cow.bitmap);
+-              }
+-              if(update_bitmap){
+-                      req->cow_offset = sector / (sizeof(unsigned long) * 8);
+-                      req->bitmap_words[0] = 
+-                              dev->cow.bitmap[req->cow_offset];
+-                      req->bitmap_words[1] = 
+-                              dev->cow.bitmap[req->cow_offset + 1];
+-                      req->cow_offset *= sizeof(unsigned long);
+-                      req->cow_offset += dev->cow.bitmap_offset;
++      }
++      else cowify_bitmap(req->offset, req->length, &req->sector_mask,
++                         &req->cow_offset, bitmap, bitmap_offset, 
++                         req->bitmap_words, bitmap_len);
++}
++
++static int mmap_fd(struct request *req, struct ubd *dev, __u64 offset)
++{
++      __u64 sector;
++      unsigned char *bitmap;
++      int bit, i;
++
++      /* mmap must have been requested on the command line */
++      if(!ubd_do_mmap)
++              return(-1);
++
++      /* The buffer must be page aligned */
++      if(((unsigned long) req->buffer % UBD_MMAP_BLOCK_SIZE) != 0)
++              return(-1);
++
++      /* The request must be a page long */
++      if((req->current_nr_sectors << 9) != PAGE_SIZE)
++              return(-1);
++
++      if(dev->cow.file == NULL)
++              return(dev->fd);
++
++      sector = offset >> 9;
++      bitmap = (unsigned char *) dev->cow.bitmap;
++      bit = ubd_test_bit(sector, bitmap);
++
++      for(i = 1; i < req->current_nr_sectors; i++){
++              if(ubd_test_bit(sector + i, bitmap) != bit)
++                      return(-1);
++      }
++
++      if(bit || (rq_data_dir(req) == WRITE))
++              offset += dev->cow.data_offset;
++
++      /* The data on disk must be page aligned */
++      if((offset % UBD_MMAP_BLOCK_SIZE) != 0)
++              return(-1);
++
++      return(bit ? dev->fd : dev->cow.fd);
++}
++
++static int prepare_mmap_request(struct ubd *dev, int fd, __u64 offset, 
++                              struct request *req, 
++                              struct io_thread_req *io_req)
++{
++      int err;
++
++      if(rq_data_dir(req) == WRITE){
++              /* Writes are almost no-ops since the new data is already in the
++               * host page cache
++               */
++              dev->map_writes++;
++              if(dev->cow.file != NULL)
++                      cowify_bitmap(io_req->offset, io_req->length, 
++                                    &io_req->sector_mask, &io_req->cow_offset,
++                                    dev->cow.bitmap, dev->cow.bitmap_offset,
++                                    io_req->bitmap_words, 
++                                    dev->cow.bitmap_len);
++      }
++      else {
++              int w;
++
++              if((dev->cow.file != NULL) && (fd == dev->cow.fd))
++                      w = 0;
++              else w = dev->openflags.w;
++
++              if((dev->cow.file != NULL) && (fd == dev->fd))
++                      offset += dev->cow.data_offset;
++
++              err = physmem_subst_mapping(req->buffer, fd, offset, w);
++              if(err){
++                      printk("physmem_subst_mapping failed, err = %d\n", 
++                             -err);
++                      return(1);
+               }
++              dev->map_reads++;
+       }
++      io_req->op = UBD_MMAP;
++      io_req->buffer = req->buffer;
++      return(0);
+ }
+ static int prepare_request(struct request *req, struct io_thread_req *io_req)
+ {
+       struct gendisk *disk = req->rq_disk;
+       struct ubd *dev = disk->private_data;
+-      __u64 block;
+-      int nsect;
++      __u64 offset;
++      int len, fd;
+       if(req->rq_status == RQ_INACTIVE) return(1);
+-      if(dev->is_dir){
+-              strcpy(req->buffer, "HOSTFS:");
+-              strcat(req->buffer, dev->file);
+-              spin_lock(&ubd_io_lock);
+-              end_request(req, 1);
+-              spin_unlock(&ubd_io_lock);
+-              return(1);
+-      }
+-
+       if((rq_data_dir(req) == WRITE) && !dev->openflags.w){
+               printk("Write attempted on readonly ubd device %s\n", 
+                      disk->disk_name);
+@@ -814,23 +981,49 @@
+               return(1);
+       }
+-        block = req->sector;
+-        nsect = req->current_nr_sectors;
++      offset = ((__u64) req->sector) << 9;
++      len = req->current_nr_sectors << 9;
+-      io_req->op = rq_data_dir(req) == READ ? UBD_READ : UBD_WRITE;
+       io_req->fds[0] = (dev->cow.file != NULL) ? dev->cow.fd : dev->fd;
+       io_req->fds[1] = dev->fd;
++      io_req->map_fd = -1;
++      io_req->cow_offset = -1;
++      io_req->offset = offset;
++      io_req->length = len;
++      io_req->error = 0;
++      io_req->sector_mask = 0;
++
++      fd = mmap_fd(req, dev, io_req->offset);
++      if(fd > 0){
++              /* If mmapping is otherwise OK, but the first access to the 
++               * page is a write, then it's not mapped in yet.  So we have 
++               * to write the data to disk first, then we can map the disk
++               * page in and continue normally from there.
++               */
++              if((rq_data_dir(req) == WRITE) && !is_remapped(req->buffer)){
++                      io_req->map_fd = dev->fd;
++                      io_req->map_offset = io_req->offset + 
++                              dev->cow.data_offset;
++                      dev->write_maps++;
++              }
++              else return(prepare_mmap_request(dev, fd, io_req->offset, req, 
++                                               io_req));
++      }
++
++      if(rq_data_dir(req) == READ)
++              dev->nomap_reads++;
++      else dev->nomap_writes++;
++
++      io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;
+       io_req->offsets[0] = 0;
+       io_req->offsets[1] = dev->cow.data_offset;
+-      io_req->offset = ((__u64) block) << 9;
+-      io_req->length = nsect << 9;
+       io_req->buffer = req->buffer;
+       io_req->sectorsize = 1 << 9;
+-      io_req->sector_mask = 0;
+-      io_req->cow_offset = -1;
+-      io_req->error = 0;
+-        if(dev->cow.file != NULL) cowify_req(io_req, dev);
++      if(dev->cow.file != NULL) 
++              cowify_req(io_req, dev->cow.bitmap, dev->cow.bitmap_offset,
++                         dev->cow.bitmap_len);
++
+       return(0);
+ }
+@@ -885,7 +1078,7 @@
+               g.heads = 128;
+               g.sectors = 32;
+               g.cylinders = dev->size / (128 * 32 * 512);
+-              g.start = 2;
++              g.start = get_start_sect(inode->i_bdev);
+               return(copy_to_user(loc, &g, sizeof(g)) ? -EFAULT : 0);
+       case HDIO_SET_UNMASKINTR:
+@@ -935,6 +1128,142 @@
+       return(-EINVAL);
+ }
++static int ubd_check_remapped(int fd, unsigned long address, int is_write,
++                            __u64 offset)
++{
++      __u64 bitmap_offset;
++      unsigned long new_bitmap[2];
++      int i, err, n;
++
++      /* If it's not a write access, we can't do anything about it */
++      if(!is_write)
++              return(0);
++
++      /* We have a write */
++      for(i = 0; i < sizeof(ubd_dev) / sizeof(ubd_dev[0]); i++){
++              struct ubd *dev = &ubd_dev[i];
++
++              if((dev->fd != fd) && (dev->cow.fd != fd))
++                      continue;
++
++              /* It's a write to a ubd device */
++
++              if(!dev->openflags.w){
++                      /* It's a write access on a read-only device - probably
++                       * shouldn't happen.  If the kernel is trying to change
++                       * something with no intention of writing it back out,
++                       * then this message will clue us in that this needs
++                       * fixing
++                       */
++                      printk("Write access to mapped page from readonly ubd "
++                             "device %d\n", i);
++                      return(0);
++              }
++
++              /* It's a write to a writeable ubd device - it must be COWed
++               * because, otherwise, the page would have been mapped in 
++               * writeable
++               */
++
++              if(!dev->cow.file)
++                      panic("Write fault on writeable non-COW ubd device %d",
++                            i);
++
++              /* It should also be an access to the backing file since the 
++               * COW pages should be mapped in read-write
++               */
++
++              if(fd == dev->fd)
++                      panic("Write fault on a backing page of ubd "
++                            "device %d\n", i);
++
++              /* So, we do the write, copying the backing data to the COW 
++               * file... 
++               */
++
++              err = os_seek_file(dev->fd, offset + dev->cow.data_offset);
++              if(err < 0)
++                      panic("Couldn't seek to %lld in COW file of ubd "
++                            "device %d, err = %d", 
++                            offset + dev->cow.data_offset, i, -err);
++
++              n = os_write_file(dev->fd, (void *) address, PAGE_SIZE);
++              if(n != PAGE_SIZE)
++                      panic("Couldn't copy data to COW file of ubd "
++                            "device %d, err = %d", i, -n);
++
++              /* ... updating the COW bitmap... */
++
++              cowify_bitmap(offset, PAGE_SIZE, NULL, &bitmap_offset, 
++                            dev->cow.bitmap, dev->cow.bitmap_offset, 
++                            new_bitmap, dev->cow.bitmap_len);
++
++              err = os_seek_file(dev->fd, bitmap_offset);
++              if(err < 0)
++                      panic("Couldn't seek to %lld in COW file of ubd "
++                            "device %d, err = %d", bitmap_offset, i, -err);
++
++              n = os_write_file(dev->fd, new_bitmap, sizeof(new_bitmap));
++              if(n != sizeof(new_bitmap))
++                      panic("Couldn't update bitmap  of ubd device %d, "
++                            "err = %d", i, -n);
++              
++              /* Maybe we can map the COW page in, and maybe we can't.  If
++               * it is a pre-V3 COW file, we can't, since the alignment will 
++               * be wrong.  If it is a V3 or later COW file which has been 
++               * moved to a system with a larger page size, then maybe we 
++               * can't, depending on the exact location of the page.
++               */
++
++              offset += dev->cow.data_offset;
++
++              /* Remove the remapping, putting the original anonymous page
++               * back.  If the COW file can be mapped in, that is done.
++               * Otherwise, the COW page is read in.
++               */
++
++              if(!physmem_remove_mapping((void *) address))
++                      panic("Address 0x%lx not remapped by ubd device %d", 
++                            address, i);
++              if((offset % UBD_MMAP_BLOCK_SIZE) == 0)
++                      physmem_subst_mapping((void *) address, dev->fd, 
++                                            offset, 1);
++              else {
++                      err = os_seek_file(dev->fd, offset);
++                      if(err < 0)
++                              panic("Couldn't seek to %lld in COW file of "
++                                    "ubd device %d, err = %d", offset, i, 
++                                    -err);
++
++                      n = os_read_file(dev->fd, (void *) address, PAGE_SIZE);
++                      if(n != PAGE_SIZE)
++                              panic("Failed to read page from offset %llx of "
++                                    "COW file of ubd device %d, err = %d",
++                                    offset, i, -n);
++              }
++
++              return(1);
++      }
++
++      /* It's not a write on a ubd device */
++      return(0);
++}
++
++static struct remapper ubd_remapper = {
++      .list   = LIST_HEAD_INIT(ubd_remapper.list),
++      .proc   = ubd_check_remapped,
++};
++
++static int ubd_remapper_setup(void)
++{
++      if(ubd_do_mmap)
++              register_remapper(&ubd_remapper);
++
++      return(0);
++}
++
++__initcall(ubd_remapper_setup);
++
+ /*
+  * Overrides for Emacs so that we follow Linus's tabbing style.
+  * Emacs will notice this stuff at the end of the file and automatically
+diff -Naur a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
+--- a/arch/um/drivers/ubd_user.c       2004-01-08 22:16:38.000000000 -0500
++++ b/arch/um/drivers/ubd_user.c       2004-01-08 22:22:42.000000000 -0500
+@@ -11,11 +11,8 @@
+ #include <signal.h>
+ #include <string.h>
+ #include <netinet/in.h>
+-#include <sys/stat.h>
+ #include <sys/time.h>
+-#include <sys/fcntl.h>
+ #include <sys/socket.h>
+-#include <string.h>
+ #include <sys/mman.h>
+ #include <sys/param.h>
+ #include "asm/types.h"
+@@ -24,146 +21,30 @@
+ #include "user.h"
+ #include "ubd_user.h"
+ #include "os.h"
++#include "cow.h"
+ #include <endian.h>
+ #include <byteswap.h>
+-#if __BYTE_ORDER == __BIG_ENDIAN
+-# define ntohll(x) (x)
+-# define htonll(x) (x)
+-#elif __BYTE_ORDER == __LITTLE_ENDIAN
+-# define ntohll(x)  bswap_64(x)
+-# define htonll(x)  bswap_64(x)
+-#else
+-#error "__BYTE_ORDER not defined"
+-#endif
+-
+-#define PATH_LEN_V1 256
+-
+-struct cow_header_v1 {
+-      int magic;
+-      int version;
+-      char backing_file[PATH_LEN_V1];
+-      time_t mtime;
+-      __u64 size;
+-      int sectorsize;
+-};
+-
+-#define PATH_LEN_V2 MAXPATHLEN
+-
+-struct cow_header_v2 {
+-      unsigned long magic;
+-      unsigned long version;
+-      char backing_file[PATH_LEN_V2];
+-      time_t mtime;
+-      __u64 size;
+-      int sectorsize;
+-};
+-
+-union cow_header {
+-      struct cow_header_v1 v1;
+-      struct cow_header_v2 v2;
+-};
+-
+-#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
+-#define COW_VERSION 2
+-
+-static void sizes(__u64 size, int sectorsize, int bitmap_offset, 
+-                unsigned long *bitmap_len_out, int *data_offset_out)
+-{
+-      *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize);
+-
+-      *data_offset_out = bitmap_offset + *bitmap_len_out;
+-      *data_offset_out = (*data_offset_out + sectorsize - 1) / sectorsize;
+-      *data_offset_out *= sectorsize;
+-}
+-
+-static int read_cow_header(int fd, int *magic_out, char **backing_file_out, 
+-                         time_t *mtime_out, __u64 *size_out, 
+-                         int *sectorsize_out, int *bitmap_offset_out)
+-{
+-      union cow_header *header;
+-      char *file;
+-      int err, n;
+-      unsigned long version, magic;
+-
+-      header = um_kmalloc(sizeof(*header));
+-      if(header == NULL){
+-              printk("read_cow_header - Failed to allocate header\n");
+-              return(-ENOMEM);
+-      }
+-      err = -EINVAL;
+-      n = read(fd, header, sizeof(*header));
+-      if(n < offsetof(typeof(header->v1), backing_file)){
+-              printk("read_cow_header - short header\n");
+-              goto out;
+-      }
+-
+-      magic = header->v1.magic;
+-      if(magic == COW_MAGIC) {
+-              version = header->v1.version;
+-      }
+-      else if(magic == ntohl(COW_MAGIC)){
+-              version = ntohl(header->v1.version);
+-      }
+-      else goto out;
+-
+-      *magic_out = COW_MAGIC;
+-
+-      if(version == 1){
+-              if(n < sizeof(header->v1)){
+-                      printk("read_cow_header - failed to read V1 header\n");
+-                      goto out;
+-              }
+-              *mtime_out = header->v1.mtime;
+-              *size_out = header->v1.size;
+-              *sectorsize_out = header->v1.sectorsize;
+-              *bitmap_offset_out = sizeof(header->v1);
+-              file = header->v1.backing_file;
+-      }
+-      else if(version == 2){
+-              if(n < sizeof(header->v2)){
+-                      printk("read_cow_header - failed to read V2 header\n");
+-                      goto out;
+-              }
+-              *mtime_out = ntohl(header->v2.mtime);
+-              *size_out = ntohll(header->v2.size);
+-              *sectorsize_out = ntohl(header->v2.sectorsize);
+-              *bitmap_offset_out = sizeof(header->v2);
+-              file = header->v2.backing_file;
+-      }
+-      else {
+-              printk("read_cow_header - invalid COW version\n");
+-              goto out;
+-      }
+-      err = -ENOMEM;
+-      *backing_file_out = uml_strdup(file);
+-      if(*backing_file_out == NULL){
+-              printk("read_cow_header - failed to allocate backing file\n");
+-              goto out;
+-      }
+-      err = 0;
+- out:
+-      kfree(header);
+-      return(err);
+-}
+ static int same_backing_files(char *from_cmdline, char *from_cow, char *cow)
+ {
+-      struct stat buf1, buf2;
++      struct uml_stat buf1, buf2;
++      int err;
+       if(from_cmdline == NULL) return(1);
+       if(!strcmp(from_cmdline, from_cow)) return(1);
+-      if(stat(from_cmdline, &buf1) < 0){
+-              printk("Couldn't stat '%s', errno = %d\n", from_cmdline, 
+-                     errno);
++      err = os_stat_file(from_cmdline, &buf1);
++      if(err < 0){
++              printk("Couldn't stat '%s', err = %d\n", from_cmdline, -err);
+               return(1);
+       }
+-      if(stat(from_cow, &buf2) < 0){
+-              printk("Couldn't stat '%s', errno = %d\n", from_cow, errno);
++      err = os_stat_file(from_cow, &buf2);
++      if(err < 0){
++              printk("Couldn't stat '%s', err = %d\n", from_cow, -err);
+               return(1);
+       }
+-      if((buf1.st_dev == buf2.st_dev) && (buf1.st_ino == buf2.st_ino))
++      if((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino))
+               return(1);
+       printk("Backing file mismatch - \"%s\" requested,\n"
+@@ -174,20 +55,21 @@
+ static int backing_file_mismatch(char *file, __u64 size, time_t mtime)
+ {
+-      struct stat64 buf;
++      unsigned long modtime;
+       long long actual;
+       int err;
+-      if(stat64(file, &buf) < 0){
+-              printk("Failed to stat backing file \"%s\", errno = %d\n",
+-                     file, errno);
+-              return(-errno);
++      err = os_file_modtime(file, &modtime);
++      if(err < 0){
++              printk("Failed to get modification time of backing file "
++                     "\"%s\", err = %d\n", file, -err);
++              return(err);
+       }
+       err = os_file_size(file, &actual);
+-      if(err){
++      if(err < 0){
+               printk("Failed to get size of backing file \"%s\", "
+-                     "errno = %d\n", file, -err);
++                     "err = %d\n", file, -err);
+               return(err);
+       }
+@@ -196,9 +78,9 @@
+                      "file\n", size, actual);
+               return(-EINVAL);
+       }
+-      if(buf.st_mtime != mtime){
++      if(modtime != mtime){
+               printk("mtime mismatch (%ld vs %ld) of COW header vs backing "
+-                     "file\n", mtime, buf.st_mtime);
++                     "file\n", mtime, modtime);
+               return(-EINVAL);
+       }
+       return(0);
+@@ -209,124 +91,16 @@
+       int err;
+       err = os_seek_file(fd, offset);
+-      if(err != 0) return(-errno);
+-      err = read(fd, buf, len);
+-      if(err < 0) return(-errno);
+-      return(0);
+-}
++      if(err < 0) 
++              return(err);
+-static int absolutize(char *to, int size, char *from)
+-{
+-      char save_cwd[256], *slash;
+-      int remaining;
++      err = os_read_file(fd, buf, len);
++      if(err < 0) 
++              return(err);
+-      if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) {
+-              printk("absolutize : unable to get cwd - errno = %d\n", errno);
+-              return(-1);
+-      }
+-      slash = strrchr(from, '/');
+-      if(slash != NULL){
+-              *slash = '\0';
+-              if(chdir(from)){
+-                      *slash = '/';
+-                      printk("absolutize : Can't cd to '%s' - errno = %d\n",
+-                             from, errno);
+-                      return(-1);
+-              }
+-              *slash = '/';
+-              if(getcwd(to, size) == NULL){
+-                      printk("absolutize : unable to get cwd of '%s' - "
+-                             "errno = %d\n", from, errno);
+-                      return(-1);
+-              }
+-              remaining = size - strlen(to);
+-              if(strlen(slash) + 1 > remaining){
+-                      printk("absolutize : unable to fit '%s' into %d "
+-                             "chars\n", from, size);
+-                      return(-1);
+-              }
+-              strcat(to, slash);
+-      }
+-      else {
+-              if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){
+-                      printk("absolutize : unable to fit '%s' into %d "
+-                             "chars\n", from, size);
+-                      return(-1);
+-              }
+-              strcpy(to, save_cwd);
+-              strcat(to, "/");
+-              strcat(to, from);
+-      }
+-      chdir(save_cwd);
+       return(0);
+ }
+-static int write_cow_header(char *cow_file, int fd, char *backing_file, 
+-                          int sectorsize, long long *size)
+-{
+-        struct cow_header_v2 *header;
+-      struct stat64 buf;
+-      int err;
+-
+-      err = os_seek_file(fd, 0);
+-      if(err != 0){
+-              printk("write_cow_header - lseek failed, errno = %d\n", errno);
+-              return(-errno);
+-      }
+-
+-      err = -ENOMEM;
+-      header = um_kmalloc(sizeof(*header));
+-      if(header == NULL){
+-              printk("Failed to allocate COW V2 header\n");
+-              goto out;
+-      }
+-      header->magic = htonl(COW_MAGIC);
+-      header->version = htonl(COW_VERSION);
+-
+-      err = -EINVAL;
+-      if(strlen(backing_file) > sizeof(header->backing_file) - 1){
+-              printk("Backing file name \"%s\" is too long - names are "
+-                     "limited to %d characters\n", backing_file, 
+-                     sizeof(header->backing_file) - 1);
+-              goto out_free;
+-      }
+-
+-      if(absolutize(header->backing_file, sizeof(header->backing_file), 
+-                    backing_file))
+-              goto out_free;
+-
+-      err = stat64(header->backing_file, &buf);
+-      if(err < 0){
+-              printk("Stat of backing file '%s' failed, errno = %d\n",
+-                     header->backing_file, errno);
+-              err = -errno;
+-              goto out_free;
+-      }
+-
+-      err = os_file_size(header->backing_file, size);
+-      if(err){
+-              printk("Couldn't get size of backing file '%s', errno = %d\n",
+-                     header->backing_file, -*size);
+-              goto out_free;
+-      }
+-
+-      header->mtime = htonl(buf.st_mtime);
+-      header->size = htonll(*size);
+-      header->sectorsize = htonl(sectorsize);
+-
+-      err = write(fd, header, sizeof(*header));
+-      if(err != sizeof(*header)){
+-              printk("Write of header to new COW file '%s' failed, "
+-                     "errno = %d\n", cow_file, errno);
+-              goto out_free;
+-      }
+-      err = 0;
+- out_free:
+-      kfree(header);
+- out:
+-      return(err);
+-}
+-
+ int open_ubd_file(char *file, struct openflags *openflags, 
+                 char **backing_file_out, int *bitmap_offset_out, 
+                 unsigned long *bitmap_len_out, int *data_offset_out, 
+@@ -334,26 +108,36 @@
+ {
+       time_t mtime;
+       __u64 size;
++      __u32 version, align;
+       char *backing_file;
+-        int fd, err, sectorsize, magic, same, mode = 0644;
++      int fd, err, sectorsize, same, mode = 0644;
+-        if((fd = os_open_file(file, *openflags, mode)) < 0){
++      fd = os_open_file(file, *openflags, mode);
++      if(fd < 0){
+               if((fd == -ENOENT) && (create_cow_out != NULL))
+                       *create_cow_out = 1;
+                 if(!openflags->w ||
+                    ((errno != EROFS) && (errno != EACCES))) return(-errno);
+               openflags->w = 0;
+-                if((fd = os_open_file(file, *openflags, mode)) < 0) 
++              fd = os_open_file(file, *openflags, mode); 
++              if(fd < 0) 
+                       return(fd);
+         }
++
++      err = os_lock_file(fd, openflags->w);
++      if(err < 0){
++              printk("Failed to lock '%s', err = %d\n", file, -err);
++              goto out_close;
++      }
++      
+       if(backing_file_out == NULL) return(fd);
+-      err = read_cow_header(fd, &magic, &backing_file, &mtime, &size, 
+-                            &sectorsize, bitmap_offset_out);
++      err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
++                            &size, &sectorsize, &align, bitmap_offset_out);
+       if(err && (*backing_file_out != NULL)){
+               printk("Failed to read COW header from COW file \"%s\", "
+-                     "errno = %d\n", file, err);
+-              goto error;
++                     "errno = %d\n", file, -err);
++              goto out_close;
+       }
+       if(err) return(fd);
+@@ -363,36 +147,33 @@
+       if(!same && !backing_file_mismatch(*backing_file_out, size, mtime)){
+               printk("Switching backing file to '%s'\n", *backing_file_out);
+-              err = write_cow_header(file, fd, *backing_file_out, 
+-                                     sectorsize, &size);
++              err = write_cow_header(file, fd, *backing_file_out,
++                                     sectorsize, align, &size);
+               if(err){
+-                      printk("Switch failed, errno = %d\n", err);
++                      printk("Switch failed, errno = %d\n", -err);
+                       return(err);
+               }
+       }
+       else {
+               *backing_file_out = backing_file;
+               err = backing_file_mismatch(*backing_file_out, size, mtime);
+-              if(err) goto error;
++              if(err) goto out_close;
+       }
+-      sizes(size, sectorsize, *bitmap_offset_out, bitmap_len_out, 
+-            data_offset_out);
++      cow_sizes(version, size, sectorsize, align, *bitmap_offset_out, 
++                bitmap_len_out, data_offset_out);
+         return(fd);
+- error:
+-      close(fd);
++ out_close:
++      os_close_file(fd);
+       return(err);
+ }
+ int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
+-                  int sectorsize, int *bitmap_offset_out, 
++                  int sectorsize, int alignment, int *bitmap_offset_out, 
+                   unsigned long *bitmap_len_out, int *data_offset_out)
+ {
+-      __u64 blocks;
+-      long zero;
+-      int err, fd, i;
+-      long long size;
++      int err, fd;
+       flags.c = 1;
+       fd = open_ubd_file(cow_file, &flags, NULL, NULL, NULL, NULL, NULL);
+@@ -403,57 +184,49 @@
+               goto out;
+       }
+-      err = write_cow_header(cow_file, fd, backing_file, sectorsize, &size);
+-      if(err) goto out_close;
+-
+-      blocks = (size + sectorsize - 1) / sectorsize;
+-      blocks = (blocks + sizeof(long) * 8 - 1) / (sizeof(long) * 8);
+-      zero = 0;
+-      for(i = 0; i < blocks; i++){
+-              err = write(fd, &zero, sizeof(zero));
+-              if(err != sizeof(zero)){
+-                      printk("Write of bitmap to new COW file '%s' failed, "
+-                             "errno = %d\n", cow_file, errno);
+-                      goto out_close;
+-              }
+-      }
+-
+-      sizes(size, sectorsize, sizeof(struct cow_header_v2), 
+-            bitmap_len_out, data_offset_out);
+-      *bitmap_offset_out = sizeof(struct cow_header_v2);
+-
+-      return(fd);
+-
+- out_close:
+-      close(fd);
++      err = init_cow_file(fd, cow_file, backing_file, sectorsize, alignment,
++                          bitmap_offset_out, bitmap_len_out, 
++                          data_offset_out);
++      if(!err)
++              return(fd);
++      os_close_file(fd);
+  out:
+       return(err);
+ }
++/* XXX Just trivial wrappers around os_read_file and os_write_file */
+ int read_ubd_fs(int fd, void *buffer, int len)
+ {
+-      int n;
+-
+-      n = read(fd, buffer, len);
+-      if(n < 0) return(-errno);
+-      else return(n);
++      return(os_read_file(fd, buffer, len));
+ }
+ int write_ubd_fs(int fd, char *buffer, int len)
+ {
+-      int n;
+-
+-      n = write(fd, buffer, len);
+-      if(n < 0) return(-errno);
+-      else return(n);
++      return(os_write_file(fd, buffer, len));
+ }
+-int ubd_is_dir(char *file)
++static int update_bitmap(struct io_thread_req *req)
+ {
+-      struct stat64 buf;
++      int n;
++
++      if(req->cow_offset == -1)
++              return(0);
++
++      n = os_seek_file(req->fds[1], req->cow_offset);
++      if(n < 0){
++              printk("do_io - bitmap lseek failed : err = %d\n", -n);
++              return(1);
++      }
++
++      n = os_write_file(req->fds[1], &req->bitmap_words,
++                        sizeof(req->bitmap_words));
++      if(n != sizeof(req->bitmap_words)){
++              printk("do_io - bitmap update failed, err = %d fd = %d\n", -n,
++                     req->fds[1]);
++              return(1);
++      }
+-      if(stat64(file, &buf) < 0) return(0);
+-      return(S_ISDIR(buf.st_mode));
++      return(0);
+ }
+ void do_io(struct io_thread_req *req)
+@@ -461,8 +234,18 @@
+       char *buf;
+       unsigned long len;
+       int n, nsectors, start, end, bit;
++      int err;
+       __u64 off;
++      if(req->op == UBD_MMAP){
++              /* Touch the page to force the host to do any necessary IO to 
++               * get it into memory 
++               */
++              n = *((volatile int *) req->buffer);
++              req->error = update_bitmap(req);
++              return;
++      }
++
+       nsectors = req->length / req->sectorsize;
+       start = 0;
+       do {
+@@ -473,15 +256,14 @@
+                                   &req->sector_mask) == bit))
+                       end++;
+-              if(end != nsectors)
+-                      printk("end != nsectors\n");
+               off = req->offset + req->offsets[bit] + 
+                       start * req->sectorsize;
+               len = (end - start) * req->sectorsize;
+               buf = &req->buffer[start * req->sectorsize];
+-              if(os_seek_file(req->fds[bit], off) != 0){
+-                      printk("do_io - lseek failed : errno = %d\n", errno);
++              err = os_seek_file(req->fds[bit], off);
++              if(err < 0){
++                      printk("do_io - lseek failed : err = %d\n", -err);
+                       req->error = 1;
+                       return;
+               }
+@@ -490,11 +272,10 @@
+                       do {
+                               buf = &buf[n];
+                               len -= n;
+-                              n = read(req->fds[bit], buf, len);
++                              n = os_read_file(req->fds[bit], buf, len);
+                               if (n < 0) {
+-                                      printk("do_io - read returned %d : "
+-                                             "errno = %d fd = %d\n", n,
+-                                             errno, req->fds[bit]);
++                                      printk("do_io - read failed, err = %d "
++                                             "fd = %d\n", -n, req->fds[bit]);
+                                       req->error = 1;
+                                       return;
+                               }
+@@ -502,11 +283,10 @@
+                       if (n < len) memset(&buf[n], 0, len - n);
+               }
+               else {
+-                      n = write(req->fds[bit], buf, len);
++                      n = os_write_file(req->fds[bit], buf, len);
+                       if(n != len){
+-                              printk("do_io - write returned %d : "
+-                                     "errno = %d fd = %d\n", n, 
+-                                     errno, req->fds[bit]);
++                              printk("do_io - write failed err = %d "
++                                     "fd = %d\n", -n, req->fds[bit]);
+                               req->error = 1;
+                               return;
+                       }
+@@ -515,24 +295,7 @@
+               start = end;
+       } while(start < nsectors);
+-      if(req->cow_offset != -1){
+-              if(os_seek_file(req->fds[1], req->cow_offset) != 0){
+-                      printk("do_io - bitmap lseek failed : errno = %d\n",
+-                             errno);
+-                      req->error = 1;
+-                      return;
+-              }
+-              n = write(req->fds[1], &req->bitmap_words, 
+-                        sizeof(req->bitmap_words));
+-              if(n != sizeof(req->bitmap_words)){
+-                      printk("do_io - bitmap update returned %d : "
+-                             "errno = %d fd = %d\n", n, errno, req->fds[1]);
+-                      req->error = 1;
+-                      return;
+-              }
+-      }
+-      req->error = 0;
+-      return;
++      req->error = update_bitmap(req);
+ }
+ /* Changed in start_io_thread, which is serialized by being called only
+@@ -550,19 +313,23 @@
+       signal(SIGWINCH, SIG_IGN);
+       while(1){
+-              n = read(kernel_fd, &req, sizeof(req));
+-              if(n < 0) printk("io_thread - read returned %d, errno = %d\n",
+-                               n, errno);
+-              else if(n < sizeof(req)){
+-                      printk("io_thread - short read : length = %d\n", n);
++              n = os_read_file(kernel_fd, &req, sizeof(req));
++              if(n != sizeof(req)){
++                      if(n < 0)
++                              printk("io_thread - read failed, fd = %d, "
++                                     "err = %d\n", kernel_fd, -n);
++                      else {
++                              printk("io_thread - short read, fd = %d, "
++                                     "length = %d\n", kernel_fd, n);
++                      }
+                       continue;
+               }
+               io_count++;
+               do_io(&req);
+-              n = write(kernel_fd, &req, sizeof(req));
++              n = os_write_file(kernel_fd, &req, sizeof(req));
+               if(n != sizeof(req))
+-                      printk("io_thread - write failed, errno = %d\n",
+-                             errno);
++                      printk("io_thread - write failed, fd = %d, err = %d\n",
++                             kernel_fd, -n);
+       }
+ }
+@@ -571,10 +338,11 @@
+       int pid, fds[2], err;
+       err = os_pipe(fds, 1, 1);
+-      if(err){
+-              printk("start_io_thread - os_pipe failed, errno = %d\n", -err);
+-              return(-1);
++      if(err < 0){
++              printk("start_io_thread - os_pipe failed, err = %d\n", -err);
++              goto out;
+       }
++
+       kernel_fd = fds[0];
+       *fd_out = fds[1];
+@@ -582,32 +350,19 @@
+                   NULL);
+       if(pid < 0){
+               printk("start_io_thread - clone failed : errno = %d\n", errno);
+-              return(-errno);
+-      }
+-      return(pid);
+-}
+-
+-#ifdef notdef
+-int start_io_thread(unsigned long sp, int *fd_out)
+-{
+-      int pid;
+-
+-      if((kernel_fd = get_pty()) < 0) return(-1);
+-      raw(kernel_fd, 0);
+-      if((*fd_out = open(ptsname(kernel_fd), O_RDWR)) < 0){
+-              printk("Couldn't open tty for IO\n");
+-              return(-1);
++              goto out_close;
+       }
+-      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);
+-              return(-errno);
+-      }
+       return(pid);
++
++ out_close:
++      os_close_file(fds[0]);
++      os_close_file(fds[1]);
++      kernel_fd = -1;
++      *fd_out = -1;
++out:
++      return(err);
+ }
+-#endif
+ /*
+  * Overrides for Emacs so that we follow Linus's tabbing style.
+diff -Naur a/arch/um/drivers/xterm.c b/arch/um/drivers/xterm.c
+--- a/arch/um/drivers/xterm.c  2004-01-08 22:13:50.000000000 -0500
++++ b/arch/um/drivers/xterm.c  2004-01-08 22:18:48.000000000 -0500
+@@ -8,7 +8,6 @@
+ #include <unistd.h>
+ #include <string.h>
+ #include <errno.h>
+-#include <fcntl.h>
+ #include <termios.h>
+ #include <signal.h>
+ #include <sched.h>
+@@ -36,7 +35,8 @@
+ {
+       struct xterm_chan *data;
+-      if((data = malloc(sizeof(*data))) == NULL) return(NULL);
++      data = malloc(sizeof(*data));
++      if(data == NULL) return(NULL);
+       *data = ((struct xterm_chan) { .pid             = -1, 
+                                      .helper_pid      = -1,
+                                      .device          = device, 
+@@ -93,7 +93,7 @@
+                        "/usr/lib/uml/port-helper", "-uml-socket",
+                        file, NULL };
+-      if(access(argv[4], X_OK))
++      if(os_access(argv[4], OS_ACC_X_OK) < 0)
+               argv[4] = "port-helper";
+       fd = mkstemp(file);
+@@ -106,13 +106,13 @@
+               printk("xterm_open : unlink failed, errno = %d\n", errno);
+               return(-errno);
+       }
+-      close(fd);
++      os_close_file(fd);
+-      fd = create_unix_socket(file, sizeof(file));
++      fd = os_create_unix_socket(file, sizeof(file), 1);
+       if(fd < 0){
+               printk("xterm_open : create_unix_socket failed, errno = %d\n", 
+                      -fd);
+-              return(-fd);
++              return(fd);
+       }
+       sprintf(title, data->title, data->device);
+@@ -128,15 +128,16 @@
+       if(data->direct_rcv)
+               new = os_rcv_fd(fd, &data->helper_pid);
+       else {
+-              if((err = os_set_fd_block(fd, 0)) != 0){
++              err = os_set_fd_block(fd, 0);
++              if(err < 0){
+                       printk("xterm_open : failed to set descriptor "
+-                             "non-blocking, errno = %d\n", err);
++                             "non-blocking, err = %d\n", -err);
+                       return(err);
+               }
+               new = xterm_fd(fd, &data->helper_pid);
+       }
+       if(new < 0){
+-              printk("xterm_open : os_rcv_fd failed, errno = %d\n", -new);
++              printk("xterm_open : os_rcv_fd failed, err = %d\n", -new);
+               goto out;
+       }
+@@ -160,7 +161,7 @@
+       if(data->helper_pid != -1) 
+               os_kill_process(data->helper_pid, 0);
+       data->helper_pid = -1;
+-      close(fd);
++      os_close_file(fd);
+ }
+ void xterm_free(void *d)
+diff -Naur a/arch/um/drivers/xterm_kern.c b/arch/um/drivers/xterm_kern.c
+--- a/arch/um/drivers/xterm_kern.c     2004-01-08 22:26:26.000000000 -0500
++++ b/arch/um/drivers/xterm_kern.c     2004-01-08 22:33:48.000000000 -0500
+@@ -5,9 +5,12 @@
+ #include "linux/errno.h"
+ #include "linux/slab.h"
++#include "linux/signal.h"
++#include "linux/interrupt.h"
+ #include "asm/semaphore.h"
+ #include "asm/irq.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ #include "kern_util.h"
+ #include "os.h"
+ #include "xterm.h"
+@@ -19,17 +22,18 @@
+       int new_fd;
+ };
+-static void xterm_interrupt(int irq, void *data, struct pt_regs *regs)
++static irqreturn_t xterm_interrupt(int irq, void *data, struct pt_regs *regs)
+ {
+       struct xterm_wait *xterm = data;
+       int fd;
+       fd = os_rcv_fd(xterm->fd, &xterm->pid);
+       if(fd == -EAGAIN)
+-              return;
++              return(IRQ_NONE);
+       xterm->new_fd = fd;
+       up(&xterm->sem);
++      return(IRQ_HANDLED);
+ }
+ int xterm_fd(int socket, int *pid_out)
+@@ -54,7 +58,8 @@
+       if(err){
+               printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, "
+                      "err = %d\n",  err);
+-              return(err);
++              ret = err;
++              goto out;
+       }
+       down(&data->sem);
+@@ -62,6 +67,7 @@
+       ret = data->new_fd;
+       *pid_out = data->pid;
++ out:
+       kfree(data);
+       return(ret);
+diff -Naur a/arch/um/dyn.lds.S b/arch/um/dyn.lds.S
+--- a/arch/um/dyn.lds.S        2004-01-08 22:21:42.000000000 -0500
++++ b/arch/um/dyn.lds.S        2004-01-08 22:28:31.000000000 -0500
+@@ -10,12 +10,15 @@
+ {
+   . = START + SIZEOF_HEADERS;
+   .interp         : { *(.interp) }
+-  . = ALIGN(4096);
+   __binary_start = .;
+   . = ALIGN(4096);            /* Init code and data */
+   _stext = .;
+   __init_begin = .;
+-  .text.init : { *(.text.init) }
++  .init.text : { 
++      _sinittext = .;
++      *(.init.text)
++      _einittext = .;
++  }
+   . = ALIGN(4096);
+@@ -67,7 +70,7 @@
+   #include "asm/common.lds.S"
+-  .data.init : { *(.data.init) }
++  init.data : { *(.init.data) }
+   /* Ensure the __preinit_array_start label is properly aligned.  We
+      could instead move the label definition inside the section, but
+diff -Naur a/arch/um/include/2_5compat.h b/arch/um/include/2_5compat.h
+--- a/arch/um/include/2_5compat.h      2004-01-08 22:20:37.000000000 -0500
++++ b/arch/um/include/2_5compat.h      2004-01-08 22:27:07.000000000 -0500
+@@ -6,20 +6,6 @@
+ #ifndef __2_5_COMPAT_H__
+ #define __2_5_COMPAT_H__
+-#include "linux/version.h"
+-
+-#define INIT_CONSOLE(dev_name, write_proc, device_proc, setup_proc, f) { \
+-      name :          dev_name, \
+-      write :         write_proc, \
+-      read :          NULL, \
+-      device :        device_proc, \
+-      setup :         setup_proc, \
+-      flags :         f, \
+-      index :         -1, \
+-      cflag :         0, \
+-      next :          NULL \
+-}
+-
+ #define INIT_HARDSECT(arr, maj, sizes)
+ #define SET_PRI(task) do ; while(0)
+diff -Naur a/arch/um/include/irq_kern.h b/arch/um/include/irq_kern.h
+--- a/arch/um/include/irq_kern.h       1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/include/irq_kern.h       2004-01-08 22:27:54.000000000 -0500
+@@ -0,0 +1,28 @@
++/* 
++ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __IRQ_KERN_H__
++#define __IRQ_KERN_H__
++
++#include "linux/interrupt.h"
++
++extern int um_request_irq(unsigned int irq, int fd, int type,
++                        irqreturn_t (*handler)(int, void *, 
++                                               struct pt_regs *),
++                        unsigned long irqflags,  const char * devname,
++                        void *dev_id);
++
++#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 -Naur a/arch/um/include/kern_util.h b/arch/um/include/kern_util.h
+--- a/arch/um/include/kern_util.h      2004-01-08 22:18:49.000000000 -0500
++++ b/arch/um/include/kern_util.h      2004-01-08 22:24:38.000000000 -0500
+@@ -63,10 +63,9 @@
+ extern void *syscall_sp(void *t);
+ extern void syscall_trace(void);
+ extern int hz(void);
+-extern void idle_timer(void);
++extern void uml_idle_timer(void);
+ extern unsigned int do_IRQ(int irq, union uml_pt_regs *regs);
+ extern int external_pid(void *t);
+-extern int pid_to_processor_id(int pid);
+ extern void boot_timer_handler(int sig);
+ extern void interrupt_end(void);
+ extern void initial_thread_cb(void (*proc)(void *), void *arg);
+@@ -90,9 +89,7 @@
+ extern char *uml_strdup(char *string);
+ extern void unprotect_kernel_mem(void);
+ extern void protect_kernel_mem(void);
+-extern void set_kmem_end(unsigned long);
+ extern void uml_cleanup(void);
+-extern int pid_to_processor_id(int pid);
+ extern void set_current(void *t);
+ extern void lock_signalled_task(void *t);
+ extern void IPI_handler(int cpu);
+@@ -101,7 +98,9 @@
+ extern int clear_user_proc(void *buf, int size);
+ extern int copy_to_user_proc(void *to, void *from, int size);
+ extern int copy_from_user_proc(void *to, void *from, int size);
++extern int strlen_user_proc(char *str);
+ extern void bus_handler(int sig, union uml_pt_regs *regs);
++extern void winch(int sig, union uml_pt_regs *regs);
+ extern long execute_syscall(void *r);
+ extern int smp_sigio_handler(void);
+ extern void *get_current(void);
+@@ -112,6 +111,8 @@
+ extern void free_irq(unsigned int, void *);
+ extern int um_in_interrupt(void);
+ extern int cpu(void);
++extern unsigned long long time_stamp(void);
++
+ #endif
+ /*
+diff -Naur a/arch/um/include/line.h b/arch/um/include/line.h
+--- a/arch/um/include/line.h   2004-01-08 22:27:12.000000000 -0500
++++ b/arch/um/include/line.h   2004-01-08 22:34:07.000000000 -0500
+@@ -9,12 +9,14 @@
+ #include "linux/list.h"
+ #include "linux/workqueue.h"
+ #include "linux/tty.h"
++#include "linux/interrupt.h"
+ #include "asm/semaphore.h"
+ #include "chan_user.h"
+ #include "mconsole_kern.h"
+ struct line_driver {
+       char *name;
++      char *device_name;
+       char *devfs_name;
+       short major;
+       short minor_start;
+@@ -67,8 +69,6 @@
+ #define LINES_INIT(n) {  num :                n }
+-extern void line_interrupt(int irq, void *data, struct pt_regs *unused);
+-extern void line_write_interrupt(int irq, void *data, struct pt_regs *unused);
+ extern void line_close(struct line *lines, struct tty_struct *tty);
+ extern int line_open(struct line *lines, struct tty_struct *tty, 
+                    struct chan_opts *opts);
+diff -Naur a/arch/um/include/mconsole.h b/arch/um/include/mconsole.h
+--- a/arch/um/include/mconsole.h       2004-01-08 22:19:58.000000000 -0500
++++ b/arch/um/include/mconsole.h       2004-01-08 22:25:57.000000000 -0500
+@@ -41,11 +41,13 @@
+ struct mc_request;
++enum mc_context { MCONSOLE_INTR, MCONSOLE_PROC };
++
+ struct mconsole_command
+ {
+       char *command;
+       void (*handler)(struct mc_request *req);
+-      int as_interrupt;
++      enum mc_context context;
+ };
+ struct mc_request
+@@ -77,6 +79,8 @@
+ extern void mconsole_cad(struct mc_request *req);
+ extern void mconsole_stop(struct mc_request *req);
+ extern void mconsole_go(struct mc_request *req);
++extern void mconsole_log(struct mc_request *req);
++extern void mconsole_proc(struct mc_request *req);
+ extern int mconsole_get_request(int fd, struct mc_request *req);
+ extern int mconsole_notify(char *sock_name, int type, const void *data, 
+diff -Naur a/arch/um/include/mem.h b/arch/um/include/mem.h
+--- a/arch/um/include/mem.h    2004-01-08 22:32:37.000000000 -0500
++++ b/arch/um/include/mem.h    2004-01-08 22:36:37.000000000 -0500
+@@ -1,19 +1,17 @@
+ /* 
+- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2002, 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+ #ifndef __MEM_H__
+ #define __MEM_H__
+-struct vm_reserved {
+-      struct list_head list;
+-      unsigned long start;
+-      unsigned long end;
+-};
++#include "linux/types.h"
+-extern void set_usable_vm(unsigned long start, unsigned long end);
+-extern void set_kmem_end(unsigned long new);
++extern int phys_mapping(unsigned long phys, __u64 *offset_out);
++extern int physmem_subst_mapping(void *virt, int fd, __u64 offset, int w);
++extern int is_remapped(void *virt);
++extern int physmem_remove_mapping(void *virt);
+ #endif
+diff -Naur a/arch/um/include/mem_kern.h b/arch/um/include/mem_kern.h
+--- a/arch/um/include/mem_kern.h       1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/include/mem_kern.h       2004-01-08 22:29:31.000000000 -0500
+@@ -0,0 +1,30 @@
++/* 
++ * Copyright (C) 2003 Jeff Dike (jdike@addtoit.com)
++ * Licensed under the GPL
++ */
++
++#ifndef __MEM_KERN_H__
++#define __MEM_KERN_H__
++
++#include "linux/list.h"
++#include "linux/types.h"
++
++struct remapper {
++      struct list_head list;
++      int (*proc)(int, unsigned long, int, __u64);
++};
++
++extern void register_remapper(struct remapper *info);
++
++#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 -Naur a/arch/um/include/mem_user.h b/arch/um/include/mem_user.h
+--- a/arch/um/include/mem_user.h       2004-01-08 22:25:06.000000000 -0500
++++ b/arch/um/include/mem_user.h       2004-01-08 22:32:22.000000000 -0500
+@@ -32,43 +32,38 @@
+ #ifndef _MEM_USER_H
+ #define _MEM_USER_H
+-struct mem_region {
++struct iomem_region {
++      struct iomem_region *next;
+       char *driver;
+-      unsigned long start_pfn;
+-      unsigned long start;
+-      unsigned long len;
+-      void *mem_map;
+       int fd;
++      int size;
++      unsigned long phys;
++      unsigned long virt;
+ };
+-extern struct mem_region *regions[];
+-extern struct mem_region physmem_region;
++extern struct iomem_region *iomem_regions;
++extern int iomem_size;
+ #define ROUND_4M(n) ((((unsigned long) (n)) + (1 << 22)) & ~((1 << 22) - 1))
+ extern unsigned long host_task_size;
+ extern unsigned long task_size;
++extern void check_devanon(void);
+ extern int init_mem_user(void);
+ extern int create_mem_file(unsigned long len);
+-extern void setup_range(int fd, char *driver, unsigned long start,
+-                      unsigned long pfn, unsigned long total, int need_vm, 
+-                      struct mem_region *region, void *reserved);
+ extern void setup_memory(void *entry);
+ extern unsigned long find_iomem(char *driver, unsigned long *len_out);
+-extern int init_maps(struct mem_region *region);
+-extern int nregions(void);
+-extern int reserve_vm(unsigned long start, unsigned long end, void *e);
++extern int init_maps(unsigned long physmem, unsigned long iomem, 
++                   unsigned long highmem);
+ extern unsigned long get_vm(unsigned long len);
+ extern void setup_physmem(unsigned long start, unsigned long usable,
+-                        unsigned long len);
+-extern int setup_region(struct mem_region *region, void *entry);
++                        unsigned long len, unsigned long highmem);
+ extern void add_iomem(char *name, int fd, unsigned long size);
+-extern struct mem_region *phys_region(unsigned long phys);
+ extern unsigned long phys_offset(unsigned long phys);
+ extern void unmap_physmem(void);
+-extern int map_memory(unsigned long virt, unsigned long phys, 
+-                    unsigned long len, int r, int w, int x);
++extern void map_memory(unsigned long virt, unsigned long phys, 
++                     unsigned long len, int r, int w, int x);
+ extern int protect_memory(unsigned long addr, unsigned long len, 
+                         int r, int w, int x, int must_succeed);
+ extern unsigned long get_kmem_end(void);
+diff -Naur a/arch/um/include/os.h b/arch/um/include/os.h
+--- a/arch/um/include/os.h     2004-01-08 22:16:19.000000000 -0500
++++ b/arch/um/include/os.h     2004-01-08 22:22:02.000000000 -0500
+@@ -17,6 +17,32 @@
+ #define OS_TYPE_FIFO 6
+ #define OS_TYPE_SOCK 7
++/* os_access() flags */
++#define OS_ACC_F_OK    0       /* Test for existence.  */
++#define OS_ACC_X_OK    1       /* Test for execute permission.  */
++#define OS_ACC_W_OK    2       /* Test for write permission.  */
++#define OS_ACC_R_OK    4       /* Test for read permission.  */
++#define OS_ACC_RW_OK   (OS_ACC_W_OK | OS_ACC_R_OK) /* Test for RW permission */
++
++/*
++ * types taken from stat_file() in hostfs_user.c
++ * (if they are wrong here, they are wrong there...).
++`*/
++struct uml_stat {
++      int                ust_dev;        /* device */
++      unsigned long long ust_ino;        /* inode */
++      int                ust_mode;       /* protection */
++      int                ust_nlink;      /* number of hard links */
++      int                ust_uid;        /* user ID of owner */
++      int                ust_gid;        /* group ID of owner */
++      unsigned long long ust_size;       /* total size, in bytes */
++      int                ust_blksize;    /* blocksize for filesystem I/O */
++      unsigned long long ust_blocks;     /* number of blocks allocated */
++      unsigned long      ust_atime;      /* time of last access */
++      unsigned long      ust_mtime;      /* time of last modification */
++      unsigned long      ust_ctime;      /* time of last change */
++};
++
+ struct openflags {
+       unsigned int r : 1;
+       unsigned int w : 1;
+@@ -91,22 +117,40 @@
+       return(flags); 
+ }
+   
++extern int os_stat_file(const char *file_name, struct uml_stat *buf);
++extern int os_stat_fd(const int fd, struct uml_stat *buf);
++extern int os_access(const char *file, int mode);
++extern void os_print_error(int error, const char* str);
++extern int os_get_exec_close(int fd, int *close_on_exec);
++extern int os_set_exec_close(int fd, int close_on_exec);
++extern int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg);
++extern int os_window_size(int fd, int *rows, int *cols);
++extern int os_new_tty_pgrp(int fd, int pid);
++extern int os_get_ifname(int fd, char *namebuf);
++extern int os_set_slip(int fd);
++extern int os_set_owner(int fd, int pid);
++extern int os_sigio_async(int master, int slave);
++extern int os_mode_fd(int fd, int mode);
++
+ extern int os_seek_file(int fd, __u64 offset);
+ extern int os_open_file(char *file, struct openflags flags, int mode);
+ extern int os_read_file(int fd, void *buf, int len);
+-extern int os_write_file(int fd, void *buf, int count);
++extern int os_write_file(int fd, const void *buf, int count);
+ extern int os_file_size(char *file, long long *size_out);
++extern int os_file_modtime(char *file, unsigned long *modtime);
+ extern int os_pipe(int *fd, int stream, int close_on_exec);
+ extern int os_set_fd_async(int fd, int owner);
+ extern int os_set_fd_block(int fd, int blocking);
+ extern int os_accept_connection(int fd);
++extern int os_create_unix_socket(char *file, int len, int close_on_exec);
+ extern int os_shutdown_socket(int fd, int r, int w);
+ extern void os_close_file(int fd);
+ extern int os_rcv_fd(int fd, int *helper_pid_out);
+-extern int create_unix_socket(char *file, int len);
++extern int create_unix_socket(char *file, int len, int close_on_exec);
+ extern int os_connect_socket(char *name);
+ extern int os_file_type(char *file);
+ extern int os_file_mode(char *file, struct openflags *mode_out);
++extern int os_lock_file(int fd, int excl);
+ extern unsigned long os_process_pc(int pid);
+ extern int os_process_parent(int pid);
+@@ -115,11 +159,12 @@
+ extern void os_usr1_process(int pid);
+ extern int os_getpid(void);
+-extern int os_map_memory(void *virt, int fd, unsigned long off, 
++extern int os_map_memory(void *virt, int fd, unsigned long long off, 
+                        unsigned long len, int r, int w, int x);
+ extern int os_protect_memory(void *addr, unsigned long len, 
+                            int r, int w, int x);
+ extern int os_unmap_memory(void *addr, int len);
++extern void os_flush_stdout(void);
+ #endif
+diff -Naur a/arch/um/include/sysdep-i386/sigcontext.h b/arch/um/include/sysdep-i386/sigcontext.h
+--- a/arch/um/include/sysdep-i386/sigcontext.h 2004-01-08 22:26:00.000000000 -0500
++++ b/arch/um/include/sysdep-i386/sigcontext.h 2004-01-08 22:33:43.000000000 -0500
+@@ -28,8 +28,8 @@
+  */
+ #define SC_START_SYSCALL(sc) do SC_EAX(sc) = -ENOSYS; while(0)
+-/* These are General Protection and Page Fault */
+-#define SEGV_IS_FIXABLE(trap) ((trap == 13) || (trap == 14))
++/* This is Page Fault */
++#define SEGV_IS_FIXABLE(trap) (trap == 14)
+ #define SC_SEGV_IS_FIXABLE(sc) (SEGV_IS_FIXABLE(SC_TRAPNO(sc)))
+diff -Naur a/arch/um/include/ubd_user.h b/arch/um/include/ubd_user.h
+--- a/arch/um/include/ubd_user.h       2004-01-08 22:22:40.000000000 -0500
++++ b/arch/um/include/ubd_user.h       2004-01-08 22:29:35.000000000 -0500
+@@ -9,7 +9,7 @@
+ #include "os.h"
+-enum ubd_req { UBD_READ, UBD_WRITE };
++enum ubd_req { UBD_READ, UBD_WRITE, UBD_MMAP };
+ struct io_thread_req {
+       enum ubd_req op;
+@@ -20,8 +20,10 @@
+       char *buffer;
+       int sectorsize;
+       unsigned long sector_mask;
+-      unsigned long cow_offset;
++      unsigned long long cow_offset;
+       unsigned long bitmap_words[2];
++      int map_fd;
++      unsigned long long map_offset;
+       int error;
+ };
+@@ -31,7 +33,7 @@
+                        int *create_cow_out);
+ extern int create_cow_file(char *cow_file, char *backing_file, 
+                          struct openflags flags, int sectorsize, 
+-                         int *bitmap_offset_out, 
++                         int alignment, int *bitmap_offset_out, 
+                          unsigned long *bitmap_len_out,
+                          int *data_offset_out);
+ extern int read_cow_bitmap(int fd, void *buf, int offset, int len);
+@@ -39,7 +41,6 @@
+ extern int write_ubd_fs(int fd, char *buffer, int len);
+ extern int start_io_thread(unsigned long sp, int *fds_out);
+ extern void do_io(struct io_thread_req *req);
+-extern int ubd_is_dir(char *file);
+ static inline int ubd_test_bit(__u64 bit, unsigned char *data)
+ {
+diff -Naur a/arch/um/include/um_uaccess.h b/arch/um/include/um_uaccess.h
+--- a/arch/um/include/um_uaccess.h     2004-01-08 22:25:51.000000000 -0500
++++ b/arch/um/include/um_uaccess.h     2004-01-08 22:33:28.000000000 -0500
+@@ -38,22 +38,73 @@
+                               from, n));
+ }
++/*
++ * strncpy_from_user: - Copy a NUL terminated string from userspace.
++ * @dst:   Destination address, in kernel space.  This buffer must be at
++ *         least @count bytes long.
++ * @src:   Source address, in user space.
++ * @count: Maximum number of bytes to copy, including the trailing NUL.
++ * 
++ * Copies a NUL-terminated string from userspace to kernel space.
++ *
++ * On success, returns the length of the string (not including the trailing
++ * NUL).
++ *
++ * If access to userspace fails, returns -EFAULT (some data may have been
++ * copied).
++ *
++ * If @count is smaller than the length of the string, copies @count bytes
++ * and returns @count.
++ */
++
+ static inline int strncpy_from_user(char *dst, const char *src, int count)
+ {
+       return(CHOOSE_MODE_PROC(strncpy_from_user_tt, strncpy_from_user_skas,
+                               dst, src, count));
+ }
++/*
++ * __clear_user: - Zero a block of memory in user space, with less checking.
++ * @to:   Destination address, in user space.
++ * @n:    Number of bytes to zero.
++ *
++ * Zero a block of memory in user space.  Caller must check
++ * the specified block with access_ok() before calling this function.
++ *
++ * Returns number of bytes that could not be cleared.
++ * On success, this will be zero.
++ */
+ static inline int __clear_user(void *mem, int len)
+ {
+       return(CHOOSE_MODE_PROC(__clear_user_tt, __clear_user_skas, mem, len));
+ }
++/*
++ * clear_user: - Zero a block of memory in user space.
++ * @to:   Destination address, in user space.
++ * @n:    Number of bytes to zero.
++ *
++ * Zero a block of memory in user space.
++ *
++ * Returns number of bytes that could not be cleared.
++ * On success, this will be zero.
++ */
+ static inline int clear_user(void *mem, int len)
+ {
+       return(CHOOSE_MODE_PROC(clear_user_tt, clear_user_skas, mem, len));
+ }
++/*
++ * strlen_user: - Get the size of a string in user space.
++ * @str: The string to measure.
++ * @n:   The maximum valid length
++ *
++ * Get the size of a NUL-terminated string in user space.
++ *
++ * Returns the size of the string INCLUDING the terminating NUL.
++ * On exception, returns 0.
++ * If the string is too long, returns a value greater than @n.
++ */
+ static inline int strnlen_user(const void *str, int len)
+ {
+       return(CHOOSE_MODE_PROC(strnlen_user_tt, strnlen_user_skas, str, len));
+diff -Naur a/arch/um/include/user.h b/arch/um/include/user.h
+--- a/arch/um/include/user.h   2004-01-08 22:13:48.000000000 -0500
++++ b/arch/um/include/user.h   2004-01-08 22:18:35.000000000 -0500
+@@ -14,6 +14,7 @@
+ extern void kfree(void *ptr);
+ extern int in_aton(char *str);
+ extern int open_gdb_chan(void);
++extern int strlcpy(char *, const char *, int);
+ #endif
+diff -Naur a/arch/um/include/user_util.h b/arch/um/include/user_util.h
+--- a/arch/um/include/user_util.h      2004-01-08 22:14:54.000000000 -0500
++++ b/arch/um/include/user_util.h      2004-01-08 22:20:21.000000000 -0500
+@@ -14,8 +14,6 @@
+ extern int unlockpt(int __fd);
+ extern char *ptsname(int __fd);
+-enum { OP_NONE, OP_EXEC, OP_FORK, OP_TRACE_ON, OP_REBOOT, OP_HALT, OP_CB };
+-
+ struct cpu_task {
+       int pid;
+       void *task;
+@@ -59,7 +57,6 @@
+ extern void *add_signal_handler(int sig, void (*handler)(int));
+ extern int start_fork_tramp(void *arg, unsigned long temp_stack, 
+                           int clone_flags, int (*tramp)(void *));
+-extern int clone_and_wait(int (*fn)(void *), void *arg, void *sp, int flags);
+ 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);
+@@ -86,11 +83,13 @@
+ extern int run_kernel_thread(int (*fn)(void *), void *arg, void **jmp_ptr);
+ extern void write_sigio_workaround(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 forward_pending_sigio(int target);
+ extern int can_do_skas(void);
+- 
++extern void arch_init_thread(void);
++
+ #endif
+ /*
+diff -Naur a/arch/um/Kconfig b/arch/um/Kconfig
+--- a/arch/um/Kconfig  2004-01-08 22:21:13.000000000 -0500
++++ b/arch/um/Kconfig  2004-01-08 22:27:33.000000000 -0500
+@@ -61,6 +61,20 @@
+ config NET
+       bool "Networking support"
++      help
++      Unless you really know what you are doing, you should say Y here.
++      The reason is that some programs need kernel networking support even
++      when running on a stand-alone machine that isn't connected to any
++      other computer. If you are upgrading from an older kernel, you
++      should consider updating your networking tools too because changes
++      in the kernel and the tools often go hand in hand. The tools are
++      contained in the package net-tools, the location and version number
++      of which are given in Documentation/Changes.
++
++      For a general introduction to Linux networking, it is highly
++      recommended to read the NET-HOWTO, available from
++      <http://www.tldp.org/docs.html#howto>.
++
+ source "fs/Kconfig.binfmt"
+@@ -85,6 +99,19 @@
+         If you'd like to be able to work with files stored on the host, 
+         say Y or M here; otherwise say N.
++config HPPFS
++      tristate "HoneyPot ProcFS"
++      help
++      hppfs (HoneyPot ProcFS) is a filesystem which allows UML /proc 
++      entries to be overridden, removed, or fabricated from the host.
++      Its purpose is to allow a UML to appear to be a physical machine
++      by removing or changing anything in /proc which gives away the
++      identity of a UML.
++
++      See http://user-mode-linux.sf.net/hppfs.html for more information.
++
++      You only need this if you are setting up a UML honeypot.  Otherwise,
++      it is safe to say 'N' here.
+ config MCONSOLE
+       bool "Management console"
+@@ -105,6 +132,16 @@
+ config MAGIC_SYSRQ
+       bool "Magic SysRq key"
+       depends on MCONSOLE
++      help
++      If you say Y here, you will have some control over the system even
++      if the system crashes for example during kernel debugging (e.g., you
++      will be able to flush the buffer cache to disk, reboot the system
++      immediately or dump some status information). This is accomplished
++      by pressing various keys while holding SysRq (Alt+PrintScreen). It
++      also works on a serial console (on PC hardware at least), if you
++      send a BREAK and then within 5 seconds a command keypress. The
++      keys are documented in Documentation/sysrq.txt. Don't say Y
++      unless you really know what this hack does.
+ config HOST_2G_2G
+       bool "2G/2G host address space split"
+@@ -159,6 +196,9 @@
+ config HIGHMEM
+       bool "Highmem support"
++config PROC_MM
++      bool "/proc/mm support"
++
+ config KERNEL_STACK_ORDER
+       int "Kernel stack size order"
+       default 2
+@@ -167,6 +207,17 @@
+       be 1 << order pages.  The default is OK unless you're running Valgrind
+       on UML, in which case, set this to 3.
++config UML_REAL_TIME_CLOCK
++      bool "Real-time Clock"
++      default y
++      help
++      This option makes UML time deltas match wall clock deltas.  This should
++      normally be enabled.  The exception would be if you are debugging with
++      UML and spend long times with UML stopped at a breakpoint.  In this
++      case, when UML is restarted, it will call the timer enough times to make
++      up for the time spent at the breakpoint.  This could result in a 
++      noticable lag.  If this is a problem, then disable this option.
++
+ endmenu
+ source "init/Kconfig"
+@@ -239,6 +290,10 @@
+ config PT_PROXY
+       bool "Enable ptrace proxy"
+       depends on XTERM_CHAN && DEBUG_INFO
++      help
++      This option enables a debugging interface which allows gdb to debug
++      the kernel without needing to actually attach to kernel threads.
++      If you want to do kernel debugging, say Y here; otherwise say N.
+ config GPROF
+       bool "Enable gprof support"
+diff -Naur a/arch/um/Kconfig_block b/arch/um/Kconfig_block
+--- a/arch/um/Kconfig_block    2004-01-08 22:25:21.000000000 -0500
++++ b/arch/um/Kconfig_block    2004-01-08 22:32:41.000000000 -0500
+@@ -29,6 +29,20 @@
+         wise choice too.  In all other cases (for example, if you're just
+         playing around with User-Mode Linux) you can choose N.
++# Turn this back on when the driver actually works
++#
++#config BLK_DEV_COW
++#     tristate "COW block device"
++#     help
++#     This is a layered driver which sits above two other block devices.
++#     One is read-only, and the other is a read-write layer which stores
++#     all changes.  This provides the illusion that the read-only layer
++#     can be mounted read-write and changed.
++
++config BLK_DEV_COW_COMMON
++      bool
++      default BLK_DEV_COW || BLK_DEV_UBD
++
+ config BLK_DEV_LOOP
+       tristate "Loopback device support"
+diff -Naur a/arch/um/Kconfig_net b/arch/um/Kconfig_net
+--- a/arch/um/Kconfig_net      2004-01-08 22:23:21.000000000 -0500
++++ b/arch/um/Kconfig_net      2004-01-08 22:30:48.000000000 -0500
+@@ -1,5 +1,5 @@
+-menu "Network Devices"
++menu "UML Network Devices"
+       depends on NET
+ # UML virtual driver
+@@ -176,73 +176,5 @@
+       
+         Startup example: "eth0=slirp,FE:FD:01:02:03:04,/usr/local/bin/slirp"
+-
+-# Below are hardware-independent drivers mirrored from
+-# drivers/net/Config.in. It would be nice if Linux
+-# had HW independent drivers separated from the other
+-# but it does not. Until then each non-ISA/PCI arch
+-# needs to provide it's own menu of network drivers
+-config DUMMY
+-      tristate "Dummy net driver support"
+-
+-config BONDING
+-      tristate "Bonding driver support"
+-
+-config EQUALIZER
+-      tristate "EQL (serial line load balancing) support"
+-
+-config TUN
+-      tristate "Universal TUN/TAP device driver support"
+-
+-config ETHERTAP
+-      tristate "Ethertap network tap (OBSOLETE)"
+-      depends on EXPERIMENTAL && NETLINK
+-
+-config PPP
+-      tristate "PPP (point-to-point protocol) support"
+-
+-config PPP_MULTILINK
+-      bool "PPP multilink support (EXPERIMENTAL)"
+-      depends on PPP && EXPERIMENTAL
+-
+-config PPP_FILTER
+-      bool "PPP filtering"
+-      depends on PPP && FILTER
+-
+-config PPP_ASYNC
+-      tristate "PPP support for async serial ports"
+-      depends on PPP
+-
+-config PPP_SYNC_TTY
+-      tristate "PPP support for sync tty ports"
+-      depends on PPP
+-
+-config PPP_DEFLATE
+-      tristate "PPP Deflate compression"
+-      depends on PPP
+-
+-config PPP_BSDCOMP
+-      tristate "PPP BSD-Compress compression"
+-      depends on PPP
+-
+-config PPPOE
+-      tristate "PPP over Ethernet (EXPERIMENTAL)"
+-      depends on PPP && EXPERIMENTAL
+-
+-config SLIP
+-      tristate "SLIP (serial line) support"
+-
+-config SLIP_COMPRESSED
+-      bool "CSLIP compressed headers"
+-      depends on SLIP=y
+-
+-config SLIP_SMART
+-      bool "Keepalive and linefill"
+-      depends on SLIP=y
+-
+-config SLIP_MODE_SLIP6
+-      bool "Six bit SLIP encapsulation"
+-      depends on SLIP=y
+-
+ endmenu
+diff -Naur a/arch/um/kernel/config.c.in b/arch/um/kernel/config.c.in
+--- a/arch/um/kernel/config.c.in       2004-01-08 22:26:26.000000000 -0500
++++ b/arch/um/kernel/config.c.in       2004-01-08 22:33:49.000000000 -0500
+@@ -7,9 +7,7 @@
+ #include <stdlib.h>
+ #include "init.h"
+-static __initdata char *config = "
+-CONFIG
+-";
++static __initdata char *config = "CONFIG";
+ static int __init print_config(char *line, int *add)
+ {
+diff -Naur a/arch/um/kernel/exec_kern.c b/arch/um/kernel/exec_kern.c
+--- a/arch/um/kernel/exec_kern.c       2004-01-08 22:17:18.000000000 -0500
++++ b/arch/um/kernel/exec_kern.c       2004-01-08 22:23:06.000000000 -0500
+@@ -32,10 +32,15 @@
+       CHOOSE_MODE_PROC(start_thread_tt, start_thread_skas, regs, eip, esp);
+ }
++extern void log_exec(char **argv, void *tty);
++
+ static int execve1(char *file, char **argv, char **env)
+ {
+         int error;
++#ifdef CONFIG_TTY_LOG
++      log_exec(argv, current->tty);
++#endif
+         error = do_execve(file, argv, env, &current->thread.regs);
+         if (error == 0){
+                 current->ptrace &= ~PT_DTRACE;
+diff -Naur a/arch/um/kernel/frame.c b/arch/um/kernel/frame.c
+--- a/arch/um/kernel/frame.c   2004-01-08 22:18:38.000000000 -0500
++++ b/arch/um/kernel/frame.c   2004-01-08 22:24:26.000000000 -0500
+@@ -279,7 +279,7 @@
+       struct sc_frame_raw raw_sc;
+       struct si_frame_raw raw_si;
+       void *stack, *sigstack;
+-      unsigned long top, sig_top, base;
++      unsigned long top, base;
+       stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
+                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+@@ -292,7 +292,6 @@
+       }
+       top = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
+-      sig_top = (unsigned long) sigstack + PAGE_SIZE;
+       /* Get the sigcontext, no sigrestorer layout */
+       raw_sc.restorer = 0;
+diff -Naur a/arch/um/kernel/frame_kern.c b/arch/um/kernel/frame_kern.c
+--- a/arch/um/kernel/frame_kern.c      2004-01-08 22:33:46.000000000 -0500
++++ b/arch/um/kernel/frame_kern.c      2004-01-08 22:36:57.000000000 -0500
+@@ -6,7 +6,6 @@
+ #include "asm/ptrace.h"
+ #include "asm/uaccess.h"
+ #include "asm/signal.h"
+-#include "asm/uaccess.h"
+ #include "asm/ucontext.h"
+ #include "frame_kern.h"
+ #include "sigcontext.h"
+@@ -29,12 +28,15 @@
+                           sizeof(restorer)));
+ }
++extern int userspace_pid[];
++
+ static int copy_sc_to_user(void *to, void *fp, struct pt_regs *from, 
+                          struct arch_frame_data *arch)
+ {
+       return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs), 
+                                             arch),
+-                         copy_sc_to_user_skas(to, fp, &from->regs,
++                         copy_sc_to_user_skas(userspace_pid[0], to, fp, 
++                                              &from->regs,
+                                               current->thread.cr2,
+                                               current->thread.err)));
+ }
+diff -Naur a/arch/um/kernel/helper.c b/arch/um/kernel/helper.c
+--- a/arch/um/kernel/helper.c  2004-01-08 22:21:10.000000000 -0500
++++ b/arch/um/kernel/helper.c  2004-01-08 22:27:27.000000000 -0500
+@@ -7,7 +7,6 @@
+ #include <stdlib.h>
+ #include <unistd.h>
+ #include <errno.h>
+-#include <fcntl.h>
+ #include <sched.h>
+ #include <sys/signal.h>
+ #include <sys/wait.h>
+@@ -33,6 +32,7 @@
+ {
+       struct helper_data *data = arg;
+       char **argv = data->argv;
++      int errval;
+       if(helper_pause){
+               signal(SIGHUP, helper_hup);
+@@ -41,8 +41,9 @@
+       if(data->pre_exec != NULL)
+               (*data->pre_exec)(data->pre_data);
+       execvp(argv[0], argv);
++      errval = errno;
+       printk("execvp of '%s' failed - errno = %d\n", argv[0], errno);
+-      write(data->fd, &errno, sizeof(errno));
++      os_write_file(data->fd, &errval, sizeof(errval));
+       os_kill_process(os_getpid(), 0);
+       return(0);
+ }
+@@ -59,17 +60,20 @@
+       if((stack_out != NULL) && (*stack_out != 0))
+               stack = *stack_out;
+       else stack = alloc_stack(0, um_in_interrupt());
+-      if(stack == 0) return(-ENOMEM);
++      if(stack == 0) 
++              return(-ENOMEM);
+       err = os_pipe(fds, 1, 0);
+-      if(err){
+-              printk("run_helper : pipe failed, errno = %d\n", -err);
+-              return(err);
++      if(err < 0){
++              printk("run_helper : pipe failed, err = %d\n", -err);
++              goto out_free;
+       }
+-      if(fcntl(fds[1], F_SETFD, 1) != 0){
+-              printk("run_helper : setting FD_CLOEXEC failed, errno = %d\n",
+-                     errno);
+-              return(-errno);
++
++      err = os_set_exec_close(fds[1], 1);
++      if(err < 0){
++              printk("run_helper : setting FD_CLOEXEC failed, err = %d\n",
++                     -err);
++              goto out_close;
+       }
+       sp = stack + page_size() - sizeof(void *);
+@@ -80,23 +84,34 @@
+       pid = clone(helper_child, (void *) sp, CLONE_VM | SIGCHLD, &data);
+       if(pid < 0){
+               printk("run_helper : clone failed, errno = %d\n", errno);
+-              return(-errno);
++              err = -errno;
++              goto out_close;
+       }
+-      close(fds[1]);
+-      n = read(fds[0], &err, sizeof(err));
++
++      os_close_file(fds[1]);
++      n = os_read_file(fds[0], &err, sizeof(err));
+       if(n < 0){
+-              printk("run_helper : read on pipe failed, errno = %d\n", 
+-                     errno);
+-              return(-errno);
++              printk("run_helper : read on pipe failed, err = %d\n", -n);
++              err = n;
++              goto out_kill;
+       }
+       else if(n != 0){
+               waitpid(pid, NULL, 0);
+-              pid = -err;
++              pid = -errno;
+       }
+       if(stack_out == NULL) free_stack(stack, 0);
+         else *stack_out = stack;
+       return(pid);
++
++ out_kill:
++      os_kill_process(pid, 1);
++ out_close:
++      os_close_file(fds[0]);
++      os_close_file(fds[1]);
++ out_free:
++      free_stack(stack, 0);
++      return(err);
+ }
+ int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags, 
+@@ -117,9 +132,11 @@
+       }
+       if(stack_out == NULL){
+               pid = waitpid(pid, &status, 0);
+-              if(pid < 0)
++              if(pid < 0){
+                       printk("run_helper_thread - wait failed, errno = %d\n",
+-                             pid);
++                             errno);
++                      pid = -errno;
++              }
+               if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
+                       printk("run_helper_thread - thread returned status "
+                              "0x%x\n", status);
+diff -Naur a/arch/um/kernel/initrd_user.c b/arch/um/kernel/initrd_user.c
+--- a/arch/um/kernel/initrd_user.c     2004-01-08 22:15:54.000000000 -0500
++++ b/arch/um/kernel/initrd_user.c     2004-01-08 22:21:30.000000000 -0500
+@@ -6,7 +6,6 @@
+ #include <unistd.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+-#include <fcntl.h>
+ #include <errno.h>
+ #include "user_util.h"
+@@ -19,13 +18,15 @@
+ {
+       int fd, n;
+-      if((fd = os_open_file(filename, of_read(OPENFLAGS()), 0)) < 0){
+-              printk("Opening '%s' failed - errno = %d\n", filename, errno);
++      fd = os_open_file(filename, of_read(OPENFLAGS()), 0);
++      if(fd < 0){
++              printk("Opening '%s' failed - err = %d\n", filename, -fd);
+               return(-1);
+       }
+-      if((n = read(fd, buf, size)) != size){
+-              printk("Read of %d bytes from '%s' returned %d, errno = %d\n",
+-                     size, filename, n, errno);
++      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(0);
+diff -Naur a/arch/um/kernel/init_task.c b/arch/um/kernel/init_task.c
+--- a/arch/um/kernel/init_task.c       2004-01-08 22:32:58.000000000 -0500
++++ b/arch/um/kernel/init_task.c       2004-01-08 22:36:48.000000000 -0500
+@@ -8,7 +8,6 @@
+ #include "linux/module.h"
+ #include "linux/sched.h"
+ #include "linux/init_task.h"
+-#include "linux/version.h"
+ #include "asm/uaccess.h"
+ #include "asm/pgtable.h"
+ #include "user_util.h"
+@@ -18,7 +17,7 @@
+ struct mm_struct init_mm = INIT_MM(init_mm);
+ static struct files_struct init_files = INIT_FILES;
+ static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
+-
++static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
+ EXPORT_SYMBOL(init_mm);
+ /*
+@@ -43,26 +42,12 @@
+ __attribute__((__section__(".data.init_task"))) = 
+ { INIT_THREAD_INFO(init_task) };
+-struct task_struct *alloc_task_struct(void)
+-{
+-      return((struct task_struct *) 
+-             __get_free_pages(GFP_KERNEL, CONFIG_KERNEL_STACK_ORDER));
+-}
+-
+ void unprotect_stack(unsigned long stack)
+ {
+       protect_memory(stack, (1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE, 
+                      1, 1, 0, 1);
+ }
+-void free_task_struct(struct task_struct *task)
+-{
+-      /* free_pages decrements the page counter and only actually frees
+-       * the pages if they are now not accessed by anything.
+-       */
+-      free_pages((unsigned long) task, CONFIG_KERNEL_STACK_ORDER);
+-}
+-
+ /*
+  * Overrides for Emacs so that we follow Linus's tabbing style.
+  * Emacs will notice this stuff at the end of the file and automatically
+diff -Naur a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
+--- a/arch/um/kernel/irq.c     2004-01-08 22:28:24.000000000 -0500
++++ b/arch/um/kernel/irq.c     2004-01-08 22:34:33.000000000 -0500
+@@ -29,6 +29,7 @@
+ #include "user_util.h"
+ #include "kern_util.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ static void register_irq_proc (unsigned int irq);
+@@ -83,65 +84,52 @@
+       end_none
+ };
+-/* Not changed */
+-volatile unsigned long irq_err_count;
+-
+ /*
+  * Generic, controller-independent functions:
+  */
+-int get_irq_list(char *buf)
++int show_interrupts(struct seq_file *p, void *v)
+ {
+       int i, j;
+-      unsigned long flags;
+       struct irqaction * action;
+-      char *p = buf;
++      unsigned long flags;
+-      p += sprintf(p, "           ");
+-      for (j=0; j<num_online_cpus(); j++)
+-              p += sprintf(p, "CPU%d       ",j);
+-      *p++ = '\n';
++      seq_printf(p, "           ");
++      for (j=0; j<NR_CPUS; j++)
++              if (cpu_online(j))
++                      seq_printf(p, "CPU%d       ",j);
++      seq_putc(p, '\n');
+       for (i = 0 ; i < NR_IRQS ; i++) {
+               spin_lock_irqsave(&irq_desc[i].lock, flags);
+               action = irq_desc[i].action;
+               if (!action) 
+-                      goto end;
+-              p += sprintf(p, "%3d: ",i);
++                      goto skip;
++              seq_printf(p, "%3d: ",i);
+ #ifndef CONFIG_SMP
+-              p += sprintf(p, "%10u ", kstat_irqs(i));
++              seq_printf(p, "%10u ", kstat_irqs(i));
+ #else
+-              for (j = 0; j < num_online_cpus(); j++)
+-                      p += sprintf(p, "%10u ",
+-                              kstat_cpu(cpu_logical_map(j)).irqs[i]);
++              for (j = 0; j < NR_CPUS; j++)
++                      if (cpu_online(j))
++                              seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+ #endif
+-              p += sprintf(p, " %14s", irq_desc[i].handler->typename);
+-              p += sprintf(p, "  %s", action->name);
++              seq_printf(p, " %14s", irq_desc[i].handler->typename);
++              seq_printf(p, "  %s", action->name);
+               for (action=action->next; action; action = action->next)
+-                      p += sprintf(p, ", %s", action->name);
+-              *p++ = '\n';
+-      end:
++                      seq_printf(p, ", %s", action->name);
++
++              seq_putc(p, '\n');
++skip:
+               spin_unlock_irqrestore(&irq_desc[i].lock, flags);
+       }
+-      p += sprintf(p, "\n");
+-#ifdef notdef
+-#ifdef CONFIG_SMP
+-      p += sprintf(p, "LOC: ");
+-      for (j = 0; j < num_online_cpus(); j++)
+-              p += sprintf(p, "%10u ",
+-                      apic_timer_irqs[cpu_logical_map(j)]);
+-      p += sprintf(p, "\n");
+-#endif
+-#endif
+-      p += sprintf(p, "ERR: %10lu\n", irq_err_count);
+-      return p - buf;
+-}
++      seq_printf(p, "NMI: ");
++      for (j = 0; j < NR_CPUS; j++)
++              if (cpu_online(j))
++                      seq_printf(p, "%10u ", nmi_count(j));
++      seq_putc(p, '\n');
+-
+-int show_interrupts(struct seq_file *p, void *v)
+-{
+-      return(0);
++      return 0;
+ }
+ /*
+@@ -230,8 +218,11 @@
+  
+ void disable_irq(unsigned int irq)
+ {
++      irq_desc_t *desc = irq_desc + irq;
++
+       disable_irq_nosync(irq);
+-      synchronize_irq(irq);
++      if(desc->action)
++              synchronize_irq(irq);
+ }
+ /**
+@@ -252,7 +243,7 @@
+       spin_lock_irqsave(&desc->lock, flags);
+       switch (desc->depth) {
+       case 1: {
+-              unsigned int status = desc->status & ~IRQ_DISABLED;
++              unsigned int status = desc->status & IRQ_DISABLED;
+               desc->status = status;
+               if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
+                       desc->status = status | IRQ_REPLAY;
+@@ -282,13 +273,12 @@
+        * 0 return value means that this irq is already being
+        * handled by some other CPU. (or is disabled)
+        */
+-      int cpu = smp_processor_id();
+       irq_desc_t *desc = irq_desc + irq;
+       struct irqaction * action;
+       unsigned int status;
+       irq_enter();
+-      kstat_cpu(cpu).irqs[irq]++;
++      kstat_this_cpu.irqs[irq]++;
+       spin_lock(&desc->lock);
+       desc->handler->ack(irq);
+       /*
+@@ -385,7 +375,7 @@
+  */
+  
+ int request_irq(unsigned int irq,
+-              void (*handler)(int, void *, struct pt_regs *),
++              irqreturn_t (*handler)(int, void *, struct pt_regs *),
+               unsigned long irqflags, 
+               const char * devname,
+               void *dev_id)
+@@ -433,15 +423,19 @@
+ EXPORT_SYMBOL(request_irq);
+ int um_request_irq(unsigned int irq, int fd, int type,
+-                 void (*handler)(int, void *, struct pt_regs *),
++                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
+                  unsigned long irqflags, const char * devname,
+                  void *dev_id)
+ {
+-      int retval;
++      int err;
+-      retval = request_irq(irq, handler, irqflags, devname, dev_id);
+-      if(retval) return(retval);
+-      return(activate_fd(irq, fd, type, dev_id));
++      err = request_irq(irq, handler, irqflags, devname, dev_id);
++      if(err) 
++              return(err);
++
++      if(fd != -1)
++              err = activate_fd(irq, fd, type, dev_id);
++      return(err);
+ }
+ /* this was setup_x86_irq but it seems pretty generic */
+@@ -474,7 +468,8 @@
+        */
+       spin_lock_irqsave(&desc->lock,flags);
+       p = &desc->action;
+-      if ((old = *p) != NULL) {
++      old = *p;
++      if (old != NULL) {
+               /* Can't share interrupts unless both agree to */
+               if (!(old->flags & new->flags & SA_SHIRQ)) {
+                       spin_unlock_irqrestore(&desc->lock,flags);
+@@ -597,8 +592,8 @@
+               return -EFAULT;
+       /*
+-       * Parse the first 8 characters as a hex string, any non-hex char
+-       * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
++       * Parse the first HEX_DIGITS characters as a hex string, any non-hex 
++       * char is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
+        */
+       for (i = 0; i < count; i++) {
+@@ -625,12 +620,14 @@
+                                       unsigned long count, void *data)
+ {
+       int irq = (long) data, full_count = count, err;
+-      cpumask_t new_value, tmp;
++      cpumask_t new_value;
+       if (!irq_desc[irq].handler->set_affinity)
+               return -EIO;
+       err = parse_hex_value(buffer, count, &new_value);
++      if(err)
++              return(err);
+ #ifdef CONFIG_SMP
+       /*
+@@ -659,7 +656,7 @@
+               return -EINVAL;
+       tmp = *mask;
+       for (k = 0; k < sizeof(cpumask_t)/sizeof(u16); ++k) {
+-              int j = sprintf(page, "%04hx", cpus_coerce(tmp));
++              int j = sprintf(page, "%04hx", (short) cpus_coerce(tmp));
+               len += j;
+               page += j;
+               cpus_shift_right(tmp, tmp, 16);
+diff -Naur a/arch/um/kernel/irq_user.c b/arch/um/kernel/irq_user.c
+--- a/arch/um/kernel/irq_user.c        2004-01-08 22:20:11.000000000 -0500
++++ b/arch/um/kernel/irq_user.c        2004-01-08 22:26:28.000000000 -0500
+@@ -6,7 +6,6 @@
+ #include <stdlib.h>
+ #include <unistd.h>
+ #include <errno.h>
+-#include <fcntl.h>
+ #include <signal.h>
+ #include <string.h>
+ #include <sys/poll.h>
+@@ -49,7 +48,8 @@
+       if(smp_sigio_handler()) return;
+       while(1){
+-              if((n = poll(pollfds, pollfds_num, 0)) < 0){
++              n = poll(pollfds, pollfds_num, 0);
++              if(n < 0){
+                       if(errno == EINTR) continue;
+                       printk("sigio_handler : poll returned %d, "
+                              "errno = %d\n", n, errno);
+@@ -366,34 +366,31 @@
+ void forward_ipi(int fd, int pid)
+ {
+-      if(fcntl(fd, F_SETOWN, pid) < 0){
+-              int save_errno = errno;
+-              if(fcntl(fd, F_GETOWN, 0) != pid){
+-                      printk("forward_ipi: F_SETOWN failed, fd = %d, "
+-                             "me = %d, target = %d, errno = %d\n", fd, 
+-                             os_getpid(), pid, save_errno);
+-              }
+-      }
++      int err;
++
++      err = os_set_owner(fd, pid);
++      if(err < 0)
++              printk("forward_ipi: set_owner failed, fd = %d, me = %d, "
++                     "target = %d, err = %d\n", fd, os_getpid(), pid, -err);
+ }
+ void forward_interrupts(int pid)
+ {
+       struct irq_fd *irq;
+       unsigned long flags;
++      int err;
+       flags = irq_lock();
+       for(irq=active_fds;irq != NULL;irq = irq->next){
+-              if(fcntl(irq->fd, F_SETOWN, pid) < 0){
+-                      int save_errno = errno;
+-                      if(fcntl(irq->fd, F_GETOWN, 0) != pid){
+-                              /* XXX Just remove the irq rather than
+-                               * print out an infinite stream of these
+-                               */
+-                              printk("Failed to forward %d to pid %d, "
+-                                     "errno = %d\n", irq->fd, pid, 
+-                                     save_errno);
+-                      }
++              err = os_set_owner(irq->fd, pid);
++              if(err < 0){
++                      /* XXX Just remove the irq rather than
++                       * print out an infinite stream of these
++                       */
++                      printk("Failed to forward %d to pid %d, err = %d\n",
++                             irq->fd, pid, -err);
+               }
++
+               irq->pid = pid;
+       }
+       irq_unlock(flags);
+diff -Naur a/arch/um/kernel/ksyms.c b/arch/um/kernel/ksyms.c
+--- a/arch/um/kernel/ksyms.c   2004-01-08 22:13:48.000000000 -0500
++++ b/arch/um/kernel/ksyms.c   2004-01-08 22:18:39.000000000 -0500
+@@ -1,5 +1,5 @@
+ /* 
+- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+@@ -34,34 +34,62 @@
+ EXPORT_SYMBOL(flush_tlb_range);
+ EXPORT_SYMBOL(host_task_size);
+ EXPORT_SYMBOL(arch_validate);
++EXPORT_SYMBOL(get_kmem_end);
+-EXPORT_SYMBOL(region_pa);
+-EXPORT_SYMBOL(region_va);
+-EXPORT_SYMBOL(phys_mem_map);
+-EXPORT_SYMBOL(page_mem_map);
+ EXPORT_SYMBOL(page_to_phys);
+ EXPORT_SYMBOL(phys_to_page);
+ EXPORT_SYMBOL(high_physmem);
+ EXPORT_SYMBOL(empty_zero_page);
+ EXPORT_SYMBOL(um_virt_to_phys);
++EXPORT_SYMBOL(__virt_to_page);
++EXPORT_SYMBOL(to_phys);
++EXPORT_SYMBOL(to_virt);
+ EXPORT_SYMBOL(mode_tt);
+ EXPORT_SYMBOL(handle_page_fault);
++#ifdef CONFIG_MODE_TT
++EXPORT_SYMBOL(copy_from_user_tt);
++EXPORT_SYMBOL(copy_to_user_tt);
++#endif
++
++#ifdef CONFIG_MODE_SKAS
++EXPORT_SYMBOL(copy_to_user_skas);
++EXPORT_SYMBOL(copy_from_user_skas);
++#endif
++
++EXPORT_SYMBOL(os_stat_fd);
++EXPORT_SYMBOL(os_stat_file);
++EXPORT_SYMBOL(os_access);
++EXPORT_SYMBOL(os_print_error);
++EXPORT_SYMBOL(os_get_exec_close);
++EXPORT_SYMBOL(os_set_exec_close);
+ EXPORT_SYMBOL(os_getpid);
+ EXPORT_SYMBOL(os_open_file);
+ EXPORT_SYMBOL(os_read_file);
+ EXPORT_SYMBOL(os_write_file);
+ EXPORT_SYMBOL(os_seek_file);
++EXPORT_SYMBOL(os_lock_file);
+ EXPORT_SYMBOL(os_pipe);
+ EXPORT_SYMBOL(os_file_type);
++EXPORT_SYMBOL(os_file_mode);
++EXPORT_SYMBOL(os_file_size);
++EXPORT_SYMBOL(os_flush_stdout);
+ EXPORT_SYMBOL(os_close_file);
++EXPORT_SYMBOL(os_set_fd_async);
++EXPORT_SYMBOL(os_set_fd_block);
+ EXPORT_SYMBOL(helper_wait);
+ EXPORT_SYMBOL(os_shutdown_socket);
++EXPORT_SYMBOL(os_create_unix_socket);
+ EXPORT_SYMBOL(os_connect_socket);
++EXPORT_SYMBOL(os_accept_connection);
++EXPORT_SYMBOL(os_rcv_fd);
+ EXPORT_SYMBOL(run_helper);
+ EXPORT_SYMBOL(start_thread);
+ EXPORT_SYMBOL(dump_thread);
++EXPORT_SYMBOL(do_gettimeofday);
++EXPORT_SYMBOL(do_settimeofday);
++
+ /* This is here because UML expands open to sys_open, not to a system
+  * call instruction.
+  */
+@@ -90,3 +118,13 @@
+ EXPORT_SYMBOL(kmap_atomic_to_page);
+ #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 -Naur a/arch/um/kernel/Makefile b/arch/um/kernel/Makefile
+--- a/arch/um/kernel/Makefile  2004-01-08 22:25:20.000000000 -0500
++++ b/arch/um/kernel/Makefile  2004-01-08 22:32:41.000000000 -0500
+@@ -7,11 +7,11 @@
+ obj-y = checksum.o config.o exec_kern.o exitcode.o frame_kern.o frame.o \
+       helper.o init_task.o irq.o irq_user.o ksyms.o mem.o mem_user.o \
+-      process.o process_kern.o ptrace.o reboot.o resource.o sigio_user.o \
+-      sigio_kern.o signal_kern.o signal_user.o smp.o syscall_kern.o \
+-      syscall_user.o sysrq.o sys_call_table.o tempfile.o time.o \
+-      time_kern.o tlb.o trap_kern.o trap_user.o uaccess_user.o um_arch.o \
+-      umid.o user_syms.o user_util.o
++      physmem.o process.o process_kern.o ptrace.o reboot.o resource.o \
++      sigio_user.o sigio_kern.o signal_kern.o signal_user.o smp.o \
++      syscall_kern.o syscall_user.o sysrq.o sys_call_table.o tempfile.o \
++      time.o time_kern.o tlb.o trap_kern.o trap_user.o uaccess_user.o \
++      um_arch.o umid.o user_syms.o user_util.o
+ obj-$(CONFIG_BLK_DEV_INITRD) += initrd_kern.o initrd_user.o
+ obj-$(CONFIG_GPROF)   += gprof_syms.o
+@@ -21,6 +21,8 @@
+ obj-$(CONFIG_MODE_TT) += tt/
+ obj-$(CONFIG_MODE_SKAS) += skas/
++clean-files   := config.c
++
+ user-objs-$(CONFIG_TTY_LOG) += tty_log.o
+ USER_OBJS := $(filter %_user.o,$(obj-y))  $(user-objs-y) config.o helper.o \
+@@ -45,17 +47,13 @@
+ $(obj)/frame.o: $(src)/frame.c
+       $(CC) $(CFLAGS_$(notdir $@)) -c -o $@ $<
+-QUOTE = 'my $$config=`cat $(TOPDIR)/.config`; $$config =~ s/"/\\"/g ; while(<STDIN>) { $$_ =~ s/CONFIG/$$config/; print $$_ }'
++QUOTE = 'my $$config=`cat $(TOPDIR)/.config`; $$config =~ s/"/\\"/g ; $$config =~ s/\n/\\n"\n"/g ; while(<STDIN>) { $$_ =~ s/CONFIG/$$config/; print $$_ }'
+ $(obj)/config.c : $(src)/config.c.in $(TOPDIR)/.config
+       $(PERL) -e $(QUOTE) < $(src)/config.c.in > $@
+ $(obj)/config.o : $(obj)/config.c
+-clean:
+-      rm -f config.c
+-      for dir in $(subdir-y) ; do $(MAKE) -C $$dir clean; done
+-
+ modules:
+ fastdep:
+diff -Naur a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
+--- a/arch/um/kernel/mem.c     2004-01-08 22:19:21.000000000 -0500
++++ b/arch/um/kernel/mem.c     2004-01-08 22:25:37.000000000 -0500
+@@ -1,74 +1,67 @@
+ /* 
+- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
++ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+  * Licensed under the GPL
+  */
+-#include "linux/config.h"
+-#include "linux/module.h"
+-#include "linux/types.h"
++#include "linux/stddef.h"
++#include "linux/kernel.h"
+ #include "linux/mm.h"
+-#include "linux/fs.h"
+-#include "linux/init.h"
+ #include "linux/bootmem.h"
+ #include "linux/swap.h"
+-#include "linux/slab.h"
+-#include "linux/vmalloc.h"
+ #include "linux/highmem.h"
++#include "linux/gfp.h"
+ #include "asm/page.h"
+-#include "asm/pgtable.h"
++#include "asm/fixmap.h"
+ #include "asm/pgalloc.h"
+-#include "asm/bitops.h"
+-#include "asm/uaccess.h"
+-#include "asm/tlb.h"
+ #include "user_util.h"
+ #include "kern_util.h"
+-#include "mem_user.h"
+-#include "mem.h"
+ #include "kern.h"
+-#include "init.h"
+-#include "os.h"
+-#include "mode_kern.h"
++#include "mem_user.h"
+ #include "uml_uaccess.h"
++#include "os.h"
++
++extern char __binary_start;
+ /* Changed during early boot */
+-pgd_t swapper_pg_dir[1024];
+-unsigned long high_physmem;
+-unsigned long vm_start;
+-unsigned long vm_end;
+-unsigned long highmem;
+ unsigned long *empty_zero_page = NULL;
+ unsigned long *empty_bad_page = NULL;
+-
+-/* Not modified */
+-const char bad_pmd_string[] = "Bad pmd in pte_alloc: %08lx\n";
+-
+-extern char __init_begin, __init_end;
+-extern long physmem_size;
+-
+-/* Not changed by UML */
+-DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
+-
+-/* Changed during early boot */
++pgd_t swapper_pg_dir[1024];
++unsigned long highmem;
+ int kmalloc_ok = 0;
+-#define NREGIONS (phys_region_index(0xffffffff) - phys_region_index(0x0) + 1)
+-struct mem_region *regions[NREGIONS] = { [ 0 ... NREGIONS - 1 ] = NULL };
+-#define REGION_SIZE ((0xffffffff & ~REGION_MASK) + 1)
+-
+-/* Changed during early boot */
+ static unsigned long brk_end;
++static unsigned long totalram_pages = 0;
++
++void unmap_physmem(void)
++{
++      os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
++}
+ static void map_cb(void *unused)
+ {
+       map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
+ }
+-void unmap_physmem(void)
++#ifdef CONFIG_HIGHMEM
++static void setup_highmem(unsigned long highmem_start, 
++                        unsigned long highmem_len)
+ {
+-      os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
+-}
++      struct page *page;
++      unsigned long highmem_pfn;
++      int i;
+-extern char __binary_start;
++      highmem_start_page = virt_to_page(highmem_start);
++
++      highmem_pfn = __pa(highmem_start) >> PAGE_SHIFT;
++      for(i = 0; i < highmem_len >> PAGE_SHIFT; i++){
++              page = &mem_map[highmem_pfn + i];
++              ClearPageReserved(page);
++              set_bit(PG_highmem, &page->flags);
++              atomic_set(&page->count, 1);
++              __free_page(page);
++      }
++}
++#endif
+ void mem_init(void)
+ {
+@@ -103,50 +96,15 @@
+       totalhigh_pages = highmem >> PAGE_SHIFT;
+       totalram_pages += totalhigh_pages;
+       num_physpages = totalram_pages;
+-      max_mapnr = totalram_pages;
+       max_pfn = totalram_pages;
+       printk(KERN_INFO "Memory: %luk available\n", 
+              (unsigned long) nr_free_pages() << (PAGE_SHIFT-10));
+       kmalloc_ok = 1;
+-}
+-
+-/* Changed during early boot */
+-static unsigned long kmem_top = 0;
+-
+-unsigned long get_kmem_end(void)
+-{
+-      if(kmem_top == 0)
+-              kmem_top = CHOOSE_MODE(kmem_end_tt, kmem_end_skas);
+-      return(kmem_top);
+-}
+-
+-void set_kmem_end(unsigned long new)
+-{
+-      kmem_top = new;
+-}
+ #ifdef CONFIG_HIGHMEM
+-/* Changed during early boot */
+-pte_t *kmap_pte;
+-pgprot_t kmap_prot;
+-
+-EXPORT_SYMBOL(kmap_prot);
+-EXPORT_SYMBOL(kmap_pte);
+-
+-#define kmap_get_fixmap_pte(vaddr)                                    \
+-      pte_offset_kernel(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
+-
+-void __init kmap_init(void)
+-{
+-      unsigned long kmap_vstart;
+-
+-      /* cache the first kmap pte */
+-      kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
+-      kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
+-
+-      kmap_prot = PAGE_KERNEL;
++      setup_highmem(end_iomem, highmem);
++#endif
+ }
+-#endif /* CONFIG_HIGHMEM */
+ static void __init fixrange_init(unsigned long start, unsigned long end, 
+                                pgd_t *pgd_base)
+@@ -178,76 +136,24 @@
+       }
+ }
+-int init_maps(struct mem_region *region)
+-{
+-      struct page *p, *map;
+-      int i, n, len;
+-
+-      if(region == &physmem_region){
+-              region->mem_map = mem_map;
+-              return(0);
+-      }
+-      else if(region->mem_map != NULL) return(0);
+-
+-      n = region->len >> PAGE_SHIFT;
+-      len = n * sizeof(struct page);
+-      if(kmalloc_ok){
+-              map = kmalloc(len, GFP_KERNEL);
+-              if(map == NULL) map = vmalloc(len);
+-      }
+-      else map = alloc_bootmem_low_pages(len);
+-
+-      if(map == NULL)
+-              return(-ENOMEM);
+-      for(i = 0; i < n; i++){
+-              p = &map[i];
+-              set_page_count(p, 0);
+-              SetPageReserved(p);
+-              INIT_LIST_HEAD(&p->list);
+-      }
+-      region->mem_map = map;
+-      return(0);
+-}
++#if CONFIG_HIGHMEM
++pte_t *kmap_pte;
++pgprot_t kmap_prot;
+-DECLARE_MUTEX(regions_sem);
++#define kmap_get_fixmap_pte(vaddr)                                    \
++      pte_offset(pmd_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr))
+-static int setup_one_range(int fd, char *driver, unsigned long start, 
+-                         unsigned long pfn, int len, 
+-                         struct mem_region *region)
++void __init kmap_init(void)
+ {
+-      int i;
+-
+-      down(&regions_sem);
+-      for(i = 0; i < NREGIONS; i++){
+-              if(regions[i] == NULL) break;           
+-      }
+-      if(i == NREGIONS){
+-              printk("setup_range : no free regions\n");
+-              i = -1;
+-              goto out;
+-      }
+-
+-      if(fd == -1)
+-              fd = create_mem_file(len);
++      unsigned long kmap_vstart;
+-      if(region == NULL){
+-              region = alloc_bootmem_low_pages(sizeof(*region));
+-              if(region == NULL)
+-                      panic("Failed to allocating mem_region");
+-      }
++      /* cache the first kmap pte */
++      kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
++      kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
+-      *region = ((struct mem_region) { .driver        = driver,
+-                                       .start_pfn     = pfn,
+-                                       .start         = start, 
+-                                       .len           = len, 
+-                                       .fd            = fd } );
+-      regions[i] = region;
+- out:
+-      up(&regions_sem);
+-      return(i);
++      kmap_prot = PAGE_KERNEL;
+ }
+-#ifdef CONFIG_HIGHMEM
+ static void init_highmem(void)
+ {
+       pgd_t *pgd;
+@@ -268,63 +174,20 @@
+       kmap_init();
+ }
+-
+-void setup_highmem(unsigned long len)
+-{
+-      struct mem_region *region;
+-      struct page *page, *map;
+-      unsigned long phys;
+-      int i, cur, index;
+-
+-      phys = physmem_size;
+-      do {
+-              cur = min(len, (unsigned long) REGION_SIZE);
+-              i = setup_one_range(-1, NULL, -1, phys >> PAGE_SHIFT, cur, 
+-                                  NULL);
+-              if(i == -1){
+-                      printk("setup_highmem - setup_one_range failed\n");
+-                      return;
+-              }
+-              region = regions[i];
+-              index = phys / PAGE_SIZE;
+-              region->mem_map = &mem_map[index];
+-
+-              map = region->mem_map;
+-              for(i = 0; i < (cur >> PAGE_SHIFT); i++){
+-                      page = &map[i];
+-                      ClearPageReserved(page);
+-                      set_bit(PG_highmem, &page->flags);
+-                      atomic_set(&page->count, 1);
+-                      __free_page(page);
+-              }
+-              phys += cur;
+-              len -= cur;
+-      } while(len > 0);
+-}
+-#endif
++#endif /* CONFIG_HIGHMEM */
+ void paging_init(void)
+ {
+-      struct mem_region *region;
+-      unsigned long zones_size[MAX_NR_ZONES], start, end, vaddr;
+-      int i, index;
++      unsigned long zones_size[MAX_NR_ZONES], vaddr;
++      int i;
+       empty_zero_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
+       empty_bad_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
+       for(i=0;i<sizeof(zones_size)/sizeof(zones_size[0]);i++) 
+               zones_size[i] = 0;
+-      zones_size[0] = (high_physmem >> PAGE_SHIFT) - 
+-              (uml_physmem >> PAGE_SHIFT);
++      zones_size[0] = (end_iomem >> PAGE_SHIFT) - (uml_physmem >> PAGE_SHIFT);
+       zones_size[2] = highmem >> PAGE_SHIFT;
+       free_area_init(zones_size);
+-      start = phys_region_index(__pa(uml_physmem));
+-      end = phys_region_index(__pa(high_physmem - 1));
+-      for(i = start; i <= end; i++){
+-              region = regions[i];
+-              index = (region->start - uml_physmem) / PAGE_SIZE;
+-              region->mem_map = &mem_map[index];
+-              if(i > start) free_bootmem(__pa(region->start), region->len);
+-      }
+       /*
+        * Fixed mappings, only the page table structure has to be
+@@ -335,15 +198,33 @@
+ #ifdef CONFIG_HIGHMEM
+       init_highmem();
+-      setup_highmem(highmem);
+ #endif
+ }
+-pte_t __bad_page(void)
++struct page *arch_validate(struct page *page, int mask, int order)
+ {
+-      clear_page(empty_bad_page);
+-        return pte_mkdirty(mk_pte((struct page *) empty_bad_page, 
+-                                PAGE_SHARED));
++      unsigned long addr, zero = 0;
++      int i;
++
++ again:
++      if(page == NULL) return(page);
++      if(PageHighMem(page)) return(page);
++
++      addr = (unsigned long) page_address(page);
++      for(i = 0; i < (1 << order); i++){
++              current->thread.fault_addr = (void *) addr;
++              if(__do_copy_to_user((void *) addr, &zero, 
++                                   sizeof(zero),
++                                   &current->thread.fault_addr,
++                                   &current->thread.fault_catcher)){
++                      if(!(mask & __GFP_WAIT)) return(NULL);
++                      else break;
++              }
++              addr += PAGE_SIZE;
++      }
++      if(i == (1 << order)) return(page);
++      page = alloc_pages(mask, order);
++      goto again;
+ }
+ /* This can't do anything because nothing in the kernel image can be freed
+@@ -401,395 +282,6 @@
+         printk("%d pages swap cached\n", cached);
+ }
+-static int __init uml_mem_setup(char *line, int *add)
+-{
+-      char *retptr;
+-      physmem_size = memparse(line,&retptr);
+-      return 0;
+-}
+-__uml_setup("mem=", uml_mem_setup,
+-"mem=<Amount of desired ram>\n"
+-"    This controls how much \"physical\" memory the kernel allocates\n"
+-"    for the system. The size is specified as a number followed by\n"
+-"    one of 'k', 'K', 'm', 'M', which have the obvious meanings.\n"
+-"    This is not related to the amount of memory in the physical\n"
+-"    machine. It can be more, and the excess, if it's ever used, will\n"
+-"    just be swapped out.\n        Example: mem=64M\n\n"
+-);
+-
+-struct page *arch_validate(struct page *page, int mask, int order)
+-{
+-      unsigned long addr, zero = 0;
+-      int i;
+-
+- again:
+-      if(page == NULL) return(page);
+-      if(PageHighMem(page)) return(page);
+-
+-      addr = (unsigned long) page_address(page);
+-      for(i = 0; i < (1 << order); i++){
+-              current->thread.fault_addr = (void *) addr;
+-              if(__do_copy_to_user((void *) addr, &zero, 
+-                                   sizeof(zero),
+-                                   &current->thread.fault_addr,
+-                                   &current->thread.fault_catcher)){
+-                      if(!(mask & __GFP_WAIT)) return(NULL);
+-                      else break;
+-              }
+-              addr += PAGE_SIZE;
+-      }
+-      if(i == (1 << order)) return(page);
+-      page = alloc_pages(mask, order);
+-      goto again;
+-}
+-
+-DECLARE_MUTEX(vm_reserved_sem);
+-static struct list_head vm_reserved = LIST_HEAD_INIT(vm_reserved);
+-
+-/* Static structures, linked in to the list in early boot */
+-static struct vm_reserved head = {
+-      .list           = LIST_HEAD_INIT(head.list),
+-      .start          = 0,
+-      .end            = 0xffffffff
+-};
+-
+-static struct vm_reserved tail = {
+-      .list           = LIST_HEAD_INIT(tail.list),
+-      .start          = 0,
+-      .end            = 0xffffffff
+-};
+-
+-void set_usable_vm(unsigned long start, unsigned long end)
+-{
+-      list_add(&head.list, &vm_reserved);
+-      list_add(&tail.list, &head.list);
+-      head.end = start;
+-      tail.start = end;
+-}
+-
+-int reserve_vm(unsigned long start, unsigned long end, void *e)
+-             
+-{
+-      struct vm_reserved *entry = e, *reserved, *prev;
+-      struct list_head *ele;
+-      int err;
+-
+-      down(&vm_reserved_sem);
+-      list_for_each(ele, &vm_reserved){
+-              reserved = list_entry(ele, struct vm_reserved, list);
+-              if(reserved->start >= end) goto found;
+-      }
+-      panic("Reserved vm out of range");
+- found:
+-      prev = list_entry(ele->prev, struct vm_reserved, list);
+-      if(prev->end > start)
+-              panic("Can't reserve vm");
+-      if(entry == NULL)
+-              entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+-      if(entry == NULL){
+-              printk("reserve_vm : Failed to allocate entry\n");
+-              err = -ENOMEM;
+-              goto out;
+-      }
+-      *entry = ((struct vm_reserved) 
+-              { .list         = LIST_HEAD_INIT(entry->list),
+-                .start        = start,
+-                .end          = end });
+-      list_add(&entry->list, &prev->list);
+-      err = 0;
+- out:
+-      up(&vm_reserved_sem);
+-      return(0);
+-}
+-
+-unsigned long get_vm(unsigned long len)
+-{
+-      struct vm_reserved *this, *next;
+-      struct list_head *ele;
+-      unsigned long start;
+-      int err;
+-      
+-      down(&vm_reserved_sem);
+-      list_for_each(ele, &vm_reserved){
+-              this = list_entry(ele, struct vm_reserved, list);
+-              next = list_entry(ele->next, struct vm_reserved, list);
+-              if((this->start < next->start) && 
+-                 (this->end + len + PAGE_SIZE <= next->start))
+-                      goto found;
+-      }
+-      up(&vm_reserved_sem);
+-      return(0);
+- found:
+-      up(&vm_reserved_sem);
+-      start = (unsigned long) UML_ROUND_UP(this->end) + PAGE_SIZE;
+-      err = reserve_vm(start, start + len, NULL);
+-      if(err) return(0);
+-      return(start);
+-}
+-
+-int nregions(void)
+-{
+-      return(NREGIONS);
+-}
+-
+-void setup_range(int fd, char *driver, unsigned long start, unsigned long pfn,
+-               unsigned long len, int need_vm, struct mem_region *region, 
+-               void *reserved)
+-{
+-      int i, cur;
+-
+-      do {
+-              cur = min(len, (unsigned long) REGION_SIZE);
+-              i = setup_one_range(fd, driver, start, pfn, cur, region);
+-              region = regions[i];
+-              if(need_vm && setup_region(region, reserved)){
+-                      kfree(region);
+-                      regions[i] = NULL;
+-                      return;
+-              }
+-              start += cur;
+-              if(pfn != -1) pfn += cur;
+-              len -= cur;
+-      } while(len > 0);
+-}
+-
+-struct iomem {
+-      char *name;
+-      int fd;
+-      unsigned long size;
+-};
+-
+-/* iomem regions can only be added on the command line at the moment.  
+- * Locking will be needed when they can be added via mconsole.
+- */
+-
+-struct iomem iomem_regions[NREGIONS] = { [ 0 ... NREGIONS - 1 ] =
+-                                       { .name        = NULL,
+-                                         .fd          = -1,
+-                                         .size        = 0 } };
+-
+-int num_iomem_regions = 0;
+-
+-void add_iomem(char *name, int fd, unsigned long size)
+-{
+-      if(num_iomem_regions == sizeof(iomem_regions)/sizeof(iomem_regions[0]))
+-              return;
+-      size = (size + PAGE_SIZE - 1) & PAGE_MASK;
+-      iomem_regions[num_iomem_regions++] = 
+-              ((struct iomem) { .name         = name,
+-                                .fd           = fd,
+-                                .size         = size } );
+-}
+-
+-int setup_iomem(void)
+-{
+-      struct iomem *iomem;
+-      int i;
+-
+-      for(i = 0; i < num_iomem_regions; i++){
+-              iomem = &iomem_regions[i];
+-              setup_range(iomem->fd, iomem->name, -1, -1, iomem->size, 1, 
+-                          NULL, NULL);
+-      }
+-      return(0);
+-}
+-
+-__initcall(setup_iomem);
+-
+-#define PFN_UP(x)     (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
+-#define PFN_DOWN(x)   ((x) >> PAGE_SHIFT)
+-
+-/* Changed during early boot */
+-static struct mem_region physmem_region;
+-static struct vm_reserved physmem_reserved;
+-
+-void setup_physmem(unsigned long start, unsigned long reserve_end,
+-                 unsigned long len)
+-{
+-      struct mem_region *region = &physmem_region;
+-      struct vm_reserved *reserved = &physmem_reserved;
+-      unsigned long cur, pfn = 0;
+-      int do_free = 1, bootmap_size;
+-
+-      do {
+-              cur = min(len, (unsigned long) REGION_SIZE);
+-              if(region == NULL) 
+-                      region = alloc_bootmem_low_pages(sizeof(*region));
+-              if(reserved == NULL) 
+-                      reserved = alloc_bootmem_low_pages(sizeof(*reserved));
+-              if((region == NULL) || (reserved == NULL))
+-                      panic("Couldn't allocate physmem region or vm "
+-                            "reservation\n");
+-              setup_range(-1, NULL, start, pfn, cur, 1, region, reserved);
+-
+-              if(do_free){
+-                      unsigned long reserve = reserve_end - start;
+-                      int pfn = PFN_UP(__pa(reserve_end));
+-                      int delta = (len - reserve) >> PAGE_SHIFT;
+-
+-                      bootmap_size = init_bootmem(pfn, pfn + delta);
+-                      free_bootmem(__pa(reserve_end) + bootmap_size,
+-                                   cur - bootmap_size - reserve);
+-                      do_free = 0;
+-              }
+-              start += cur;
+-              pfn += cur >> PAGE_SHIFT;
+-              len -= cur;
+-              region = NULL;
+-              reserved = NULL;
+-      } while(len > 0);
+-}
+-
+-struct mem_region *phys_region(unsigned long phys)
+-{
+-      unsigned int n = phys_region_index(phys);
+-
+-      if(regions[n] == NULL) 
+-              panic("Physical address in uninitialized region");
+-      return(regions[n]);
+-}
+-
+-unsigned long phys_offset(unsigned long phys)
+-{
+-      return(phys_addr(phys));
+-}
+-
+-struct page *phys_mem_map(unsigned long phys)
+-{
+-      return((struct page *) phys_region(phys)->mem_map);
+-}
+-
+-struct page *pte_mem_map(pte_t pte)
+-{
+-      return(phys_mem_map(pte_val(pte)));
+-}
+-
+-struct mem_region *page_region(struct page *page, int *index_out)
+-{
+-      int i;
+-      struct mem_region *region;
+-      struct page *map;
+-
+-      for(i = 0; i < NREGIONS; i++){
+-              region = regions[i];
+-              if(region == NULL) continue;
+-              map = region->mem_map;
+-              if((page >= map) && (page < &map[region->len >> PAGE_SHIFT])){
+-                      if(index_out != NULL) *index_out = i;
+-                      return(region);
+-              }
+-      }
+-      panic("No region found for page");
+-      return(NULL);
+-}
+-
+-unsigned long page_to_pfn(struct page *page)
+-{
+-      struct mem_region *region = page_region(page, NULL);
+-
+-      return(region->start_pfn + (page - (struct page *) region->mem_map));
+-}
+-
+-struct mem_region *pfn_to_region(unsigned long pfn, int *index_out)
+-{
+-      struct mem_region *region;
+-      int i;
+-
+-      for(i = 0; i < NREGIONS; i++){
+-              region = regions[i];
+-              if(region == NULL)
+-                      continue;
+-
+-              if((region->start_pfn <= pfn) &&
+-                 (region->start_pfn + (region->len >> PAGE_SHIFT) > pfn)){
+-                      if(index_out != NULL) 
+-                              *index_out = i;
+-                      return(region);
+-              }
+-      }
+-      return(NULL);
+-}
+-
+-struct page *pfn_to_page(unsigned long pfn)
+-{
+-      struct mem_region *region = pfn_to_region(pfn, NULL);
+-      struct page *mem_map = (struct page *) region->mem_map;
+-
+-      return(&mem_map[pfn - region->start_pfn]);
+-}
+-
+-unsigned long phys_to_pfn(unsigned long p)
+-{
+-      struct mem_region *region = regions[phys_region_index(p)];
+-
+-      return(region->start_pfn + (phys_addr(p) >> PAGE_SHIFT));
+-}
+-
+-unsigned long pfn_to_phys(unsigned long pfn)
+-{
+-      int n;
+-      struct mem_region *region = pfn_to_region(pfn, &n);
+-
+-      return(mk_phys((pfn - region->start_pfn) << PAGE_SHIFT, n));
+-}
+-
+-struct page *page_mem_map(struct page *page)
+-{
+-      return((struct page *) page_region(page, NULL)->mem_map);
+-}
+-
+-extern unsigned long region_pa(void *virt)
+-{
+-      struct mem_region *region;
+-      unsigned long addr = (unsigned long) virt;
+-      int i;
+-
+-      for(i = 0; i < NREGIONS; i++){
+-              region = regions[i];
+-              if(region == NULL) continue;
+-              if((region->start <= addr) && 
+-                 (addr <= region->start + region->len))
+-                      return(mk_phys(addr - region->start, i));
+-      }
+-      panic("region_pa : no region for virtual address");
+-      return(0);
+-}
+-
+-extern void *region_va(unsigned long phys)
+-{
+-      return((void *) (phys_region(phys)->start + phys_addr(phys)));
+-}
+-
+-unsigned long page_to_phys(struct page *page)
+-{
+-      int n;
+-      struct mem_region *region = page_region(page, &n);
+-      struct page *map = region->mem_map;
+-      return(mk_phys((page - map) << PAGE_SHIFT, n));
+-}
+-
+-struct page *phys_to_page(unsigned long phys)
+-{
+-      struct page *mem_map;
+-
+-      mem_map = phys_mem_map(phys);
+-      return(mem_map + (phys_offset(phys) >> PAGE_SHIFT));
+-}
+-
+-static int setup_mem_maps(void)
+-{
+-      struct mem_region *region;
+-      int i;
+-
+-      for(i = 0; i < NREGIONS; i++){
+-              region = regions[i];
+-              if((region != NULL) && (region->fd > 0)) init_maps(region);
+-      }
+-      return(0);
+-}
+-
+-__initcall(setup_mem_maps);
+-
+ /*
+  * Allocate and free page tables.
+  */
+diff -Naur a/arch/um/kernel/mem_user.c b/arch/um/kernel/mem_user.c
+--- a/arch/um/kernel/mem_user.c        2004-01-08 22:22:10.000000000 -0500
++++ b/arch/um/kernel/mem_user.c        2004-01-08 22:29:21.000000000 -0500
+@@ -34,10 +34,9 @@
+ #include <stddef.h>
+ #include <stdarg.h>
+ #include <unistd.h>
+-#include <fcntl.h>
+ #include <errno.h>
+ #include <string.h>
+-#include <sys/stat.h>
++#include <fcntl.h>
+ #include <sys/types.h>
+ #include <sys/mman.h>
+ #include "kern_util.h"
+@@ -47,105 +46,145 @@
+ #include "init.h"
+ #include "os.h"
+ #include "tempfile.h"
++#include "kern_constants.h"
+ extern struct mem_region physmem_region;
+ #define TEMPNAME_TEMPLATE "vm_file-XXXXXX"
+-int create_mem_file(unsigned long len)
++static int create_tmp_file(unsigned long len)
+ {
+-      int fd;
++      int fd, err;
+       char zero;
+       fd = make_tempfile(TEMPNAME_TEMPLATE, NULL, 1);
+-      if (fchmod(fd, 0777) < 0){
+-              perror("fchmod");
++      if(fd < 0) {
++              os_print_error(fd, "make_tempfile");
++              exit(1);
++      }
++
++      err = os_mode_fd(fd, 0777);
++      if(err < 0){
++              os_print_error(err, "os_mode_fd");
+               exit(1);
+       }
+-      if(os_seek_file(fd, len) < 0){
+-              perror("lseek");
++      err = os_seek_file(fd, len);
++      if(err < 0){
++              os_print_error(err, "os_seek_file");
+               exit(1);
+       }
+       zero = 0;
+-      if(write(fd, &zero, 1) != 1){
+-              perror("write");
++      err = os_write_file(fd, &zero, 1);
++      if(err != 1){
++              os_print_error(err, "os_write_file");
+               exit(1);
+       }
+-      if(fcntl(fd, F_SETFD, 1) != 0)
+-              perror("Setting FD_CLOEXEC failed");
++
+       return(fd);
+ }
+-int setup_region(struct mem_region *region, void *entry)
++static int have_devanon = 0;
++
++void check_devanon(void)
++{
++      int fd;
++
++      printk("Checking for /dev/anon on the host...");
++      fd = open("/dev/anon", O_RDWR);
++      if(fd < 0){
++              printk("Not available (open failed with errno %d)\n", errno);
++              return;
++      }
++
++      printk("OK\n");
++      have_devanon = 1;
++}
++
++static int create_anon_file(unsigned long len)
+ {
+-      void *loc, *start;
+-      char *driver;
+-      int err, offset;
+-
+-      if(region->start != -1){
+-              err = reserve_vm(region->start, 
+-                               region->start + region->len, entry);
+-              if(err){
+-                      printk("setup_region : failed to reserve "
+-                             "0x%x - 0x%x for driver '%s'\n",
+-                             region->start, 
+-                             region->start + region->len,
+-                             region->driver);
+-                      return(-1);
+-              }
+-      }
+-      else region->start = get_vm(region->len);
+-      if(region->start == 0){
+-              if(region->driver == NULL) driver = "physmem";
+-              else driver = region->driver;
+-              printk("setup_region : failed to find vm for "
+-                     "driver '%s' (length %d)\n", driver, region->len);
+-              return(-1);
+-      }
+-      if(region->start == uml_physmem){
+-              start = (void *) uml_reserved;
+-              offset = uml_reserved - uml_physmem;
+-      }
+-      else {
+-              start = (void *) region->start;
+-              offset = 0;
+-      }
+-
+-      loc = mmap(start, region->len - offset, PROT_READ | PROT_WRITE, 
+-                 MAP_SHARED | MAP_FIXED, region->fd, offset);
+-      if(loc != start){
+-              perror("Mapping memory");
++      void *addr;
++      int fd;
++
++      fd = open("/dev/anon", O_RDWR);
++      if(fd < 0) {
++              os_print_error(fd, "opening /dev/anon");
+               exit(1);
+       }
+-      return(0);
++
++      addr = mmap(NULL, len, PROT_READ | PROT_WRITE , MAP_PRIVATE, fd, 0);
++      if(addr == MAP_FAILED){
++              os_print_error((int) addr, "mapping physmem file");
++              exit(1);
++      }
++      munmap(addr, len);
++
++      return(fd);
++}
++
++int create_mem_file(unsigned long len)
++{
++      int err, fd;
++
++      if(have_devanon)
++              fd = create_anon_file(len);
++      else fd = create_tmp_file(len);
++
++      err = os_set_exec_close(fd, 1);
++      if(err < 0)
++              os_print_error(err, "exec_close");
++      return(fd);
+ }
++struct iomem_region *iomem_regions = NULL;
++int iomem_size = 0;
++
+ static int __init parse_iomem(char *str, int *add)
+ {
+-      struct stat buf;
++      struct iomem_region *new;
++      struct uml_stat buf;
+       char *file, *driver;
+-      int fd;
++      int fd, err;
+       driver = str;
+       file = strchr(str,',');
+       if(file == NULL){
+-              printk("parse_iomem : failed to parse iomem\n");
+-              return(1);
++              printf("parse_iomem : failed to parse iomem\n");
++              goto out;
+       }
+       *file = '\0';
+       file++;
+       fd = os_open_file(file, of_rdwr(OPENFLAGS()), 0);
+       if(fd < 0){
+-              printk("parse_iomem - Couldn't open io file, errno = %d\n", 
+-                     errno);
+-              return(1);
+-      }
+-      if(fstat(fd, &buf) < 0) {
+-              printk("parse_iomem - cannot fstat file, errno = %d\n", errno);
+-              return(1);
++              os_print_error(fd, "parse_iomem - Couldn't open io file");
++              goto out;
+       }
+-      add_iomem(driver, fd, buf.st_size);
++
++      err = os_stat_fd(fd, &buf);
++      if(err < 0){
++              os_print_error(err, "parse_iomem - cannot stat_fd file");
++              goto out_close;
++      }
++
++      new = malloc(sizeof(*new));
++      if(new == NULL){
++              perror("Couldn't allocate iomem_region struct");
++              goto out_close;
++      }
++
++      *new = ((struct iomem_region) { .next           = iomem_regions,
++                                      .driver         = driver,
++                                      .fd             = fd,
++                                      .size           = buf.ust_size,
++                                      .phys           = 0,
++                                      .virt           = 0 });
++      iomem_regions = new;
++      iomem_size += new->size + UM_KERN_PAGE_SIZE;
++
+       return(0);
++ out_close:
++      os_close_file(fd);
++ out:
++      return(1);
+ }
+ __uml_setup("iomem=", parse_iomem,
+@@ -153,73 +192,20 @@
+ "    Configure <file> as an IO memory region named <name>.\n\n"
+ );
+-#ifdef notdef
+-int logging = 0;
+-int logging_fd = -1;
+-
+-int logging_line = 0;
+-char logging_buf[256];
+-
+-void log(char *fmt, ...)
+-{
+-      va_list ap;
+-      struct timeval tv;
+-      struct openflags flags;
+-
+-      if(logging == 0) return;
+-      if(logging_fd < 0){
+-              flags = of_create(of_trunc(of_rdrw(OPENFLAGS())));
+-              logging_fd = os_open_file("log", flags, 0644);
+-      }
+-      gettimeofday(&tv, NULL);
+-      sprintf(logging_buf, "%d\t %u.%u  ", logging_line++, tv.tv_sec, 
+-              tv.tv_usec);
+-      va_start(ap, fmt);
+-      vsprintf(&logging_buf[strlen(logging_buf)], fmt, ap);
+-      va_end(ap);
+-      write(logging_fd, logging_buf, strlen(logging_buf));
+-}
+-#endif
+-
+-int map_memory(unsigned long virt, unsigned long phys, unsigned long len, 
+-             int r, int w, int x)
+-{
+-      struct mem_region *region = phys_region(phys);
+-
+-      return(os_map_memory((void *) virt, region->fd, phys_offset(phys), len,
+-                           r, w, x));
+-}
+-
+ int protect_memory(unsigned long addr, unsigned long len, int r, int w, int x,
+                  int must_succeed)
+ {
+-      if(os_protect_memory((void *) addr, len, r, w, x) < 0){
++      int err;
++
++      err = os_protect_memory((void *) addr, len, r, w, x);
++      if(err < 0){
+                 if(must_succeed)
+-                        panic("protect failed, errno = %d", errno);
+-                else return(-errno);
++                      panic("protect failed, err = %d", -err);
++              else return(err);
+       }
+       return(0);
+ }
+-unsigned long find_iomem(char *driver, unsigned long *len_out)
+-{
+-      struct mem_region *region;
+-      int i, n;
+-
+-      n = nregions();
+-      for(i = 0; i < n; i++){
+-              region = regions[i];
+-              if(region == NULL) continue;
+-              if((region->driver != NULL) &&
+-                 !strcmp(region->driver, driver)){
+-                      *len_out = region->len;
+-                      return(region->start);
+-              }
+-      }
+-      *len_out = 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
+diff -Naur a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
+--- a/arch/um/kernel/physmem.c 1969-12-31 19:00:00.000000000 -0500
++++ b/arch/um/kernel/physmem.c 2004-01-08 22:20:43.000000000 -0500
+@@ -0,0 +1,349 @@
++/* 
++ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
++ * Licensed under the GPL
++ */
++
++#include "linux/mm.h"
++#include "linux/ghash.h"
++#include "linux/slab.h"
++#include "linux/vmalloc.h"
++#include "linux/bootmem.h"
++#include "asm/types.h"
++#include "asm/pgtable.h"
++#include "kern_util.h"
++#include "user_util.h"
++#include "mode_kern.h"
++#include "mem.h"
++#include "mem_user.h"
++#include "os.h"
++#include "kern.h"
++#include "init.h"
++
++#define PHYS_HASHSIZE (8192)
++
++struct phys_desc;
++
++DEF_HASH_STRUCTS(virtmem, PHYS_HASHSIZE, struct phys_desc);
++
++struct phys_desc {
++      struct virtmem_ptrs virt_ptrs;
++      int fd;
++      __u64 offset;
++      void *virt;
++      unsigned long phys;
++};
++
++struct virtmem_table virtmem_hash;
++
++static int virt_cmp(void *virt1, void *virt2)
++{
++      return(virt1 != virt2);
++}
++
++static int virt_hash(void *virt)
++{
++      unsigned long addr = ((unsigned long) virt) >> PAGE_SHIFT;
++      return(addr % PHYS_HASHSIZE);
++}
++
++DEF_HASH(static, virtmem, struct phys_desc, virt_ptrs, void *, virt, virt_cmp, 
++       virt_hash);
++
++int physmem_subst_mapping(void *virt, int fd, __u64 offset, int w)
++{
++      struct phys_desc *desc;
++      unsigned long phys;
++      int err;
++
++      virt = (void *) ((unsigned long) virt & PAGE_MASK);
++      err = os_map_memory(virt, fd, offset, PAGE_SIZE, 1, w, 0);
++      if(err)
++              goto out;
++
++      phys = __pa(virt);
++      if(find_virtmem_hash(&virtmem_hash, virt) != 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) { .virt_ptrs =      { NULL, NULL },
++                                    .fd =             fd,
++                                    .offset =         offset,
++                                    .virt =           virt,
++                                    .phys =           __pa(virt) });
++      insert_virtmem_hash(&virtmem_hash, desc);
++      err = 0;
++ out:
++      return(err);
++}
++
++static int physmem_fd = -1;
++
++int physmem_remove_mapping(void *virt)
++{
++      struct phys_desc *desc;
++      int err;
++
++      virt = (void *) ((unsigned long) virt & PAGE_MASK);
++      desc = find_virtmem_hash(&virtmem_hash, virt);
++      if(desc == NULL)
++              return(0);
++
++      remove_virtmem_hash(&virtmem_hash, desc);
++      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);
++      return(1);
++}
++
++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)
++{
++      return(find_virtmem_hash(&virtmem_hash, virt) != NULL);
++}
++
++/* Changed during early boot */
++unsigned long high_physmem;
++
++extern unsigned long physmem_size;
++
++void *to_virt(unsigned long phys)
++{
++      return((void *) uml_physmem + phys);
++}
++
++unsigned long to_phys(void *virt)
++{
++      return(((unsigned long) virt) - uml_physmem);
++}
++
++int init_maps(unsigned long physmem, unsigned long iomem, unsigned long highmem)
++{
++      struct page *p, *map;
++      unsigned long phys_len, phys_pages, highmem_len, highmem_pages;
++      unsigned long iomem_len, iomem_pages, total_len, total_pages;
++      int i;
++
++      phys_pages = physmem >> PAGE_SHIFT;
++      phys_len = phys_pages * sizeof(struct page);
++
++      iomem_pages = iomem >> PAGE_SHIFT;
++      iomem_len = iomem_pages * sizeof(struct page);
++
++      highmem_pages = highmem >> PAGE_SHIFT;
++      highmem_len = highmem_pages * sizeof(struct page);
++
++      total_pages = phys_pages + iomem_pages + highmem_pages;
++      total_len = phys_len + iomem_pages + highmem_len;
++
++      if(kmalloc_ok){
++              map = kmalloc(total_len, GFP_KERNEL);
++              if(map == NULL) 
++                      map = vmalloc(total_len);
++      }
++      else map = alloc_bootmem_low_pages(total_len);
++
++      if(map == NULL)
++              return(-ENOMEM);
++
++      for(i = 0; i < total_pages; i++){
++              p = &map[i];
++              set_page_count(p, 0);
++              SetPageReserved(p);
++              INIT_LIST_HEAD(&p->list);
++      }
++
++      mem_map = map;
++      max_mapnr = total_pages;
++      return(0);
++}
++
++struct page *phys_to_page(const unsigned long phys)
++{
++      return(&mem_map[phys >> PAGE_SHIFT]);
++}
++
++struct page *__virt_to_page(const unsigned long virt)
++{
++      return(&mem_map[__pa(virt) >> PAGE_SHIFT]);
++}
++
++unsigned long page_to_phys(struct page *page)
++{
++      return((page - mem_map) << PAGE_SHIFT);
++}
++
++pte_t mk_pte(struct page *page, pgprot_t pgprot)
++{
++      pte_t pte;
++
++      pte_val(pte) = page_to_phys(page) + pgprot_val(pgprot);
++      if(pte_present(pte)) pte_mknewprot(pte_mknewpage(pte));
++      return(pte);
++}
++
++/* Changed during early boot */
++static unsigned long kmem_top = 0;
++
++unsigned long get_kmem_end(void)
++{
++      if(kmem_top == 0) 
++              kmem_top = CHOOSE_MODE(kmem_end_tt, kmem_end_skas);
++      return(kmem_top);
++}
++
++void map_memory(unsigned long virt, unsigned long phys, unsigned long len, 
++              int r, int w, int x)
++{
++      __u64 offset;
++      int fd, err;
++
++      fd = phys_mapping(phys, &offset);
++      err = os_map_memory((void *) virt, fd, offset, len, r, w, x);
++      if(err)
++              panic("map_memory(0x%lx, %d, 0x%llx, %ld, %d, %d, %d) failed, "
++                    "err = %d\n", virt, fd, offset, len, r, w, x, err);
++}
++
++#define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
++
++void setup_physmem(unsigned long start, unsigned long reserve_end,
++                 unsigned long len, unsigned long highmem)
++{
++      unsigned long reserve = reserve_end - start;
++      int pfn = PFN_UP(__pa(reserve_end));
++      int delta = (len - reserve) >> PAGE_SHIFT;
++      int err, offset, bootmap_size;
++
++      physmem_fd = create_mem_file(len + highmem);
++
++      offset = uml_reserved - uml_physmem;
++      err = os_map_memory((void *) uml_reserved, physmem_fd, offset, 
++                          len - offset, 1, 1, 0);
++      if(err < 0){
++              os_print_error(err, "Mapping memory");
++              exit(1);
++      }
++
++      bootmap_size = init_bootmem(pfn, pfn + delta);
++      free_bootmem(__pa(reserve_end) + bootmap_size,
++                   len - bootmap_size - reserve);
++}
++
++int phys_mapping(unsigned long phys, __u64 *offset_out)
++{
++      struct phys_desc *desc = find_virtmem_hash(&virtmem_hash, 
++                                                 __va(phys & PAGE_MASK));
++      int fd = -1;
++
++      if(desc != NULL){
++              fd = desc->fd;
++              *offset_out = desc->offset;
++      }
++      else if(phys < physmem_size){
++              fd = physmem_fd;
++              *offset_out = phys;
++      }
++      else if(phys < __pa(end_iomem)){
++              struct iomem_region *region = iomem_regions;
++      
++              while(region != NULL){
++                      if((phys >= region->phys) && 
++                         (phys < region->phys + region->size)){
++                              fd = region->fd;
++                              *offset_out = phys - region->phys;
++                              break;
++                      }
++                      region = region->next;
++              }
++      }
++      else if(phys < __pa(end_iomem) + highmem){
++              fd = physmem_fd;
++              *offset_out = phys - iomem_size;
++      }
++
++      return(fd);
++}
++
++static int __init uml_mem_setup(char *line, int *add)
++{
++      char *retptr;
++      physmem_size = memparse(line,&retptr);
++      return 0;
++}
++__uml_setup("mem=", uml_mem_setup,
++"mem=<Amount of desired ram>\n"
++"    This controls how much \"physical\" memory the kernel allocates\n"
++"    for the system. The size is specified as a number followed by\n"
++"    one of 'k', 'K', 'm', 'M', which have the obvious meanings.\n"
++"    This is not related to the amount of memory in the host.  It can\n"
++"    be more, and the excess, if it's ever used, will just be swapped out.\n"
++"     Example: mem=64M\n\n"
++);
++
++unsigned long find_iomem(char *driver, unsigned long *len_out)
++{
++      struct iomem_region *region = iomem_regions;
++      
++      while(region != NULL){
++              if(!strcmp(region->driver, driver)){
++                      *len_out = region->size;
++                      return(region->virt);
++              }
++      }
++
++      return(0);
++}
++
++int setup_iomem(void)
++{
++      struct iomem_region *region = iomem_regions;
++      unsigned long iomem_start = high_physmem + PAGE_SIZE;
++      int err;
++
++      while(region != NULL){
++              err = os_map_memory((void *) iomem_start, region->fd, 0, 
++                                  region->size, 1, 1, 0);
++              if(err)
++                      printk("Mapping iomem region for driver '%s' failed, "
++                             "errno = %d\n", region->driver, -err);
++              else {
++                      region->virt = iomem_start;
++                      region->phys = __pa(region->virt);
++              }
++
++              iomem_start += region->size + PAGE_SIZE;
++              region = region->next;
++      }
++
++      return(0);
++}
++
++__initcall(setup_iomem);
++
++/*
++ * 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 -Naur a/arch/um/kernel/process.c b/arch/um/kernel/process.c
+--- a/arch/um/kernel/process.c 2004-01-08 22:29:24.000000000 -0500
++++ b/arch/um/kernel/process.c 2004-01-08 22:35:08.000000000 -0500
+@@ -9,12 +9,10 @@
+ #include <sched.h>
+ #include <errno.h>
+ #include <stdarg.h>
+-#include <fcntl.h>
+ #include <stdlib.h>
+ #include <setjmp.h>
+ #include <sys/time.h>
+ #include <sys/ptrace.h>
+-#include <sys/ioctl.h>
+ #include <sys/wait.h>
+ #include <sys/mman.h>
+ #include <asm/ptrace.h>
+@@ -58,7 +56,11 @@
+ {
+       int flags = altstack ? SA_ONSTACK : 0;
+-      set_handler(SIGSEGV, (__sighandler_t) sig_handler, flags,
++      /* NODEFER is set here because SEGV isn't turned back on when the 
++       * handler is ready to receive signals.  This causes any segfault
++       * during a copy_user to kill the process because the fault is blocked.
++       */
++      set_handler(SIGSEGV, (__sighandler_t) sig_handler, flags | SA_NODEFER,
+                   SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+       set_handler(SIGTRAP, (__sighandler_t) sig_handler, flags, 
+                   SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+@@ -72,7 +74,6 @@
+                   SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+       set_handler(SIGUSR2, (__sighandler_t) sig_handler, 
+                   SA_NOMASK | flags, -1);
+-      (void) CHOOSE_MODE(signal(SIGCHLD, SIG_IGN), (void *) 0);
+       signal(SIGHUP, SIG_IGN);
+       init_irq_signals(altstack);
+@@ -123,11 +124,12 @@
+       /* Start the process and wait for it to kill itself */
+       new_pid = clone(outer_tramp, (void *) sp, clone_flags, &arg);
+       if(new_pid < 0) return(-errno);
+-      while((err = waitpid(new_pid, &status, 0) < 0) && (errno == EINTR)) ;
++      while(((err = waitpid(new_pid, &status, 0)) < 0) && (errno == EINTR)) ;
+       if(err < 0) panic("Waiting for outer trampoline failed - errno = %d", 
+                         errno);
+       if(!WIFSIGNALED(status) || (WTERMSIG(status) != SIGKILL))
+-              panic("outer trampoline didn't exit with SIGKILL");
++              panic("outer trampoline didn't exit with SIGKILL, "
++                    "status = %d", status);
+       return(arg.pid);
+ }
+@@ -138,7 +140,7 @@
+       os_stop_process(os_getpid());
+-      if(read(fd, &c, sizeof(c)) != sizeof(c))
++      if(os_read_file(fd, &c, sizeof(c)) != sizeof(c))
+               panic("read failed in suspend_new_thread");
+ }
+@@ -233,7 +235,7 @@
+       int n;
+       *jmp_ptr = &buf;
+-      n = setjmp(buf);
++      n = sigsetjmp(buf, 1);
+       if(n != 0)
+               return(n);
+       (*fn)(arg);
+@@ -273,7 +275,7 @@
+       stop_ptraced_child(pid, stack, 1);
+       printf("Checking for /proc/mm...");
+-      if(access("/proc/mm", W_OK)){
++      if(os_access("/proc/mm", OS_ACC_W_OK) < 0){
+               printf("not found\n");
+               ret = 0;
+       }
+diff -Naur a/arch/um/kernel/process_kern.c b/arch/um/kernel/process_kern.c
+--- a/arch/um/kernel/process_kern.c    2004-01-08 22:21:59.000000000 -0500
++++ b/arch/um/kernel/process_kern.c    2004-01-08 22:28:53.000000000 -0500
+@@ -16,6 +16,7 @@
+ #include "linux/module.h"
+ #include "linux/init.h"
+ #include "linux/capability.h"
++#include "linux/spinlock.h"
+ #include "asm/unistd.h"
+ #include "asm/mman.h"
+ #include "asm/segment.h"
+@@ -23,7 +24,6 @@
+ #include "asm/pgtable.h"
+ #include "asm/processor.h"
+ #include "asm/tlbflush.h"
+-#include "asm/spinlock.h"
+ #include "asm/uaccess.h"
+ #include "asm/user.h"
+ #include "user_util.h"
+@@ -52,17 +52,12 @@
+ struct task_struct *get_task(int pid, int require)
+ {
+-        struct task_struct *task, *ret;
++        struct task_struct *ret;
+-        ret = NULL;
+         read_lock(&tasklist_lock);
+-        for_each_process(task){
+-                if(task->pid == pid){
+-                        ret = task;
+-                        break;
+-                }
+-        }
++      ret = find_task_by_pid(pid);
+         read_unlock(&tasklist_lock);
++
+         if(require && (ret == NULL)) panic("get_task couldn't find a task\n");
+         return(ret);
+ }
+@@ -95,7 +90,8 @@
+       int flags = GFP_KERNEL;
+       if(atomic) flags |= GFP_ATOMIC;
+-      if((page = __get_free_pages(flags, order)) == 0)
++      page = __get_free_pages(flags, order);
++      if(page == 0)
+               return(0);
+       stack_protections(page);
+       return(page);
+@@ -103,13 +99,15 @@
+ int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+ {
+-      struct task_struct *p;
++      int pid;
+       current->thread.request.u.thread.proc = fn;
+       current->thread.request.u.thread.arg = arg;
+-      p = do_fork(CLONE_VM | flags, 0, NULL, 0, NULL, NULL);
+-      if(IS_ERR(p)) panic("do_fork failed in kernel_thread");
+-      return(p->pid);
++      pid = do_fork(CLONE_VM | CLONE_UNTRACED | flags, 0, NULL, 0, NULL, 
++                    NULL);
++      if(pid < 0)
++              panic("do_fork failed in kernel_thread, errno = %d", pid);
++      return(pid);
+ }
+ void switch_mm(struct mm_struct *prev, struct mm_struct *next, 
+@@ -129,7 +127,7 @@
+               { external_pid(task), task });
+ }
+-void *switch_to(void *prev, void *next, void *last)
++void *_switch_to(void *prev, void *next, void *last)
+ {
+       return(CHOOSE_MODE(switch_to_tt(prev, next), 
+                          switch_to_skas(prev, next)));
+@@ -149,7 +147,7 @@
+ void exit_thread(void)
+ {
+       CHOOSE_MODE(exit_thread_tt(), exit_thread_skas());
+-      unprotect_stack((unsigned long) current->thread_info);
++      unprotect_stack((unsigned long) current_thread);
+ }
+  
+ void *get_current(void)
+@@ -157,6 +155,10 @@
+       return(current);
+ }
++void prepare_to_copy(struct task_struct *tsk)
++{
++}
++
+ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
+               unsigned long stack_top, struct task_struct * p, 
+               struct pt_regs *regs)
+@@ -190,7 +192,7 @@
+ void default_idle(void)
+ {
+-      idle_timer();
++      uml_idle_timer();
+       atomic_inc(&init_mm.mm_count);
+       current->mm = &init_mm;
+@@ -367,10 +369,15 @@
+       return(clear_user(buf, size));
+ }
++int strlen_user_proc(char *str)
++{
++      return(strlen_user(str));
++}
++
+ int smp_sigio_handler(void)
+ {
+ #ifdef CONFIG_SMP
+-      int cpu = current->thread_info->cpu;
++      int cpu = current_thread->cpu;
+       IPI_handler(cpu);
+       if(cpu != 0)
+               return(1);
+@@ -385,7 +392,7 @@
+ int cpu(void)
+ {
+-      return(current->thread_info->cpu);
++      return(current_thread->cpu);
+ }
+ /*
+diff -Naur a/arch/um/kernel/ptrace.c b/arch/um/kernel/ptrace.c
+--- a/arch/um/kernel/ptrace.c  2004-01-08 22:15:02.000000000 -0500
++++ b/arch/um/kernel/ptrace.c  2004-01-08 22:20:32.000000000 -0500
+@@ -311,11 +311,8 @@
+       /* the 0x80 provides a way for the tracing parent to distinguish
+          between a syscall stop and SIGTRAP delivery */
+-      current->exit_code = SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
+-                                      ? 0x80 : 0);
+-      current->state = TASK_STOPPED;
+-      notify_parent(current, SIGCHLD);
+-      schedule();
++      ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
++                               ? 0x80 : 0));
+       /*
+        * this isn't the same as continuing with a signal, but it will do
+diff -Naur a/arch/um/kernel/reboot.c b/arch/um/kernel/reboot.c
+--- a/arch/um/kernel/reboot.c  2004-01-08 22:21:48.000000000 -0500
++++ b/arch/um/kernel/reboot.c  2004-01-08 22:28:40.000000000 -0500
+@@ -15,6 +15,7 @@
+ #ifdef CONFIG_SMP
+ static void kill_idlers(int me)
+ {
++#ifdef CONFIG_MODE_TT
+       struct task_struct *p;
+       int i;
+@@ -23,6 +24,7 @@
+               if((p != NULL) && (p->thread.mode.tt.extern_pid != me))
+                       os_kill_process(p->thread.mode.tt.extern_pid, 0);
+       }
++#endif
+ }
+ #endif
+diff -Naur a/arch/um/kernel/sigio_kern.c b/arch/um/kernel/sigio_kern.c
+--- a/arch/um/kernel/sigio_kern.c      2004-01-08 22:16:51.000000000 -0500
++++ b/arch/um/kernel/sigio_kern.c      2004-01-08 22:22:53.000000000 -0500
+@@ -6,18 +6,21 @@
+ #include "linux/kernel.h"
+ #include "linux/list.h"
+ #include "linux/slab.h"
+-#include "asm/irq.h"
++#include "linux/signal.h"
++#include "linux/interrupt.h"
+ #include "init.h"
+ #include "sigio.h"
+ #include "irq_user.h"
++#include "irq_kern.h"
+ /* Protected by sigio_lock() called from write_sigio_workaround */
+ static int sigio_irq_fd = -1;
+-void sigio_interrupt(int irq, void *data, struct pt_regs *unused)
++irqreturn_t sigio_interrupt(int irq, void *data, struct pt_regs *unused)
+ {
+       read_sigio_fd(sigio_irq_fd);
+       reactivate_fd(sigio_irq_fd, SIGIO_WRITE_IRQ);
++      return(IRQ_HANDLED);
+ }
+ int write_sigio_irq(int fd)
+diff -Naur a/arch/um/kernel/sigio_user.c b/arch/um/kernel/sigio_user.c
+--- a/arch/um/kernel/sigio_user.c      2004-01-08 22:31:33.000000000 -0500
++++ b/arch/um/kernel/sigio_user.c      2004-01-08 22:36:15.000000000 -0500
+@@ -7,7 +7,6 @@
+ #include <stdlib.h>
+ #include <termios.h>
+ #include <pty.h>
+-#include <fcntl.h>
+ #include <signal.h>
+ #include <errno.h>
+ #include <string.h>
+@@ -26,7 +25,7 @@
+ int pty_close_sigio = 0;
+ /* Used as a flag during SIGIO testing early in boot */
+-static int got_sigio = 0;
++static volatile int got_sigio = 0;
+ void __init handler(int sig)
+ {
+@@ -45,7 +44,7 @@
+       info->err = 0;
+       if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
+-              info->err = errno;
++              info->err = -errno;
+ }
+ void __init check_one_sigio(void (*proc)(int, int))
+@@ -53,11 +52,11 @@
+       struct sigaction old, new;
+       struct termios tt;
+       struct openpty_arg pty = { .master = -1, .slave = -1 };
+-      int master, slave, flags;
++      int master, slave, err;
+       initial_thread_cb(openpty_cb, &pty);
+       if(pty.err){
+-              printk("openpty failed, errno = %d\n", pty.err);
++              printk("openpty failed, errno = %d\n", -pty.err);
+               return;
+       }
+@@ -69,23 +68,16 @@
+               return;
+       }
++      /* XXX These can fail with EINTR */
+       if(tcgetattr(master, &tt) < 0)
+               panic("check_sigio : tcgetattr failed, errno = %d\n", errno);
+       cfmakeraw(&tt);
+       if(tcsetattr(master, TCSADRAIN, &tt) < 0)
+               panic("check_sigio : tcsetattr failed, errno = %d\n", errno);
+-      if((flags = fcntl(master, F_GETFL)) < 0)
+-              panic("tty_fds : fcntl F_GETFL failed, errno = %d\n", errno);
+-
+-      if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
+-         (fcntl(master, F_SETOWN, os_getpid()) < 0))
+-              panic("check_sigio : fcntl F_SETFL or F_SETOWN failed, "
+-                    "errno = %d\n", errno);
+-
+-      if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
+-              panic("check_sigio : fcntl F_SETFL failed, errno = %d\n", 
+-                    errno);
++      err = os_sigio_async(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);
+@@ -97,8 +89,8 @@
+       got_sigio = 0;
+       (*proc)(master, slave);
+               
+-      close(master);
+-      close(slave);
++      os_close_file(master);
++      os_close_file(slave);
+       if(sigaction(SIGIO, &old, NULL) < 0)
+               panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
+@@ -112,25 +104,25 @@
+       printk("Checking that host ptys support output SIGIO...");
+       memset(buf, 0, sizeof(buf));
+-      while(write(master, buf, sizeof(buf)) > 0) ;
++
++      while(os_write_file(master, buf, sizeof(buf)) > 0) ;
+       if(errno != EAGAIN)
+               panic("check_sigio : write failed, errno = %d\n", errno);
+-
+-      while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
++      while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
+       if(got_sigio){
+               printk("Yes\n");
+               pty_output_sigio = 1;
+       }
+-      else if(errno == EAGAIN) printk("No, enabling workaround\n");
+-      else panic("check_sigio : read failed, errno = %d\n", errno);
++      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);
++      os_close_file(slave);
+       if(got_sigio){
+               printk("Yes\n");
+               pty_close_sigio = 1;
+@@ -140,7 +132,8 @@
+ void __init check_sigio(void)
+ {
+-      if(access("/dev/ptmx", R_OK) && access("/dev/ptyp0", R_OK)){
++      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;
+@@ -201,11 +194,10 @@
+                       p = &fds->poll[i];
+                       if(p->revents == 0) continue;
+                       if(p->fd == sigio_private[1]){
+-                              n = read(sigio_private[1], &c, sizeof(c));
++                              n = os_read_file(sigio_private[1], &c, sizeof(c));
+                               if(n != sizeof(c))
+                                       printk("write_sigio_thread : "
+-                                             "read failed, errno = %d\n",
+-                                             errno);
++                                             "read failed, err = %d\n", -n);
+                               tmp = current_poll;
+                               current_poll = next_poll;
+                               next_poll = tmp;
+@@ -218,10 +210,10 @@
+                                       (fds->used - i) * sizeof(*fds->poll));
+                       }
+-                      n = write(respond_fd, &c, sizeof(c));
++                      n = os_write_file(respond_fd, &c, sizeof(c));
+                       if(n != sizeof(c))
+                               printk("write_sigio_thread : write failed, "
+-                                     "errno = %d\n", errno);
++                                     "err = %d\n", -n);
+               }
+       }
+ }
+@@ -252,15 +244,15 @@
+       char c;
+       flags = set_signals(0);
+-      n = write(sigio_private[0], &c, sizeof(c));
++      n = os_write_file(sigio_private[0], &c, sizeof(c));
+       if(n != sizeof(c)){
+-              printk("update_thread : write failed, errno = %d\n", errno);
++              printk("update_thread : write failed, err = %d\n", -n);
+               goto fail;
+       }
+-      n = read(sigio_private[0], &c, sizeof(c));
++      n = os_read_file(sigio_private[0], &c, sizeof(c));
+       if(n != sizeof(c)){
+-              printk("update_thread : read failed, errno = %d\n", errno);
++              printk("update_thread : read failed, err = %d\n", -n);
+               goto fail;
+       }
+@@ -271,10 +263,10 @@
+       if(write_sigio_pid != -1) 
+               os_kill_process(write_sigio_pid, 1);
+       write_sigio_pid = -1;
+-      close(sigio_private[0]);
+-      close(sigio_private[1]);        
+-      close(write_sigio_fds[0]);
+-      close(write_sigio_fds[1]);
++      os_close_file(sigio_private[0]);
++      os_close_file(sigio_private[1]);        
++      os_close_file(write_sigio_fds[0]);
++      os_close_file(write_sigio_fds[1]);
+       sigio_unlock();
+       set_signals(flags);
+ }
+@@ -369,15 +361,15 @@
+               goto out;
+       err = os_pipe(write_sigio_fds, 1, 1);
+-      if(err){
++      if(err < 0){
+               printk("write_sigio_workaround - os_pipe 1 failed, "
+-                     "errno = %d\n", -err);
++                     "err = %d\n", -err);
+               goto out;
+       }
+       err = os_pipe(sigio_private, 1, 1);
+-      if(err){
++      if(err < 0){
+               printk("write_sigio_workaround - os_pipe 2 failed, "
+-                     "errno = %d\n", -err);
++                     "err = %d\n", -err);
+               goto out_close1;
+       }
+       if(setup_initial_poll(sigio_private[1]))
+@@ -399,11 +391,11 @@
+       os_kill_process(write_sigio_pid, 1);
+       write_sigio_pid = -1;
+  out_close2:
+-      close(sigio_private[0]);
+-      close(sigio_private[1]);        
++      os_close_file(sigio_private[0]);
++      os_close_file(sigio_private[1]);        
+  out_close1:
+-      close(write_sigio_fds[0]);
+-      close(write_sigio_fds[1]);
++      os_close_file(write_sigio_fds[0]);
++      os_close_file(write_sigio_fds[1]);
+       sigio_unlock();
+ }
+@@ -412,10 +404,16 @@
+       int n;
+       char c;
+-      n = read(fd, &c, sizeof(c));
++      n = os_read_file(fd, &c, sizeof(c));
+       if(n != sizeof(c)){
+-              printk("read_sigio_fd - read failed, errno = %d\n", errno);
+-              return(-errno);
++              if(n < 0) {
++                      printk("read_sigio_fd - read failed, err = %d\n", -n);
++                      return(n);
++              } 
++              else { 
++                      printk("read_sigio_fd - short read, bytes = %d\n", n);
++                      return(-EIO);
++              }
+       }
+       return(n);
+ }
+diff -Naur a/arch/um/kernel/signal_kern.c b/arch/um/kernel/signal_kern.c
+--- a/arch/um/kernel/signal_kern.c     2004-01-08 22:22:59.000000000 -0500
++++ b/arch/um/kernel/signal_kern.c     2004-01-08 22:29:59.000000000 -0500
+@@ -36,7 +36,7 @@
+       if(sig == SIGSEGV){
+               struct k_sigaction *ka;
+-              ka = &current->sig->action[SIGSEGV - 1];
++              ka = &current->sighand->action[SIGSEGV - 1];
+               ka->sa.sa_handler = SIG_DFL;
+       }
+       force_sig(SIGSEGV, current);
+@@ -60,10 +60,10 @@
+       int err, ret;
+       ret = 0;
++      /* Always make any pending restarted system calls return -EINTR */
++      current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       switch(error){
+       case -ERESTART_RESTARTBLOCK:
+-              current_thread_info()->restart_block.fn = 
+-                      do_no_restart_syscall;
+       case -ERESTARTNOHAND:
+               ret = -EINTR;
+               break;
+@@ -142,7 +142,7 @@
+               return(0);
+       /* Whee!  Actually deliver the signal.  */
+-      ka = &current->sig->action[sig -1 ];
++      ka = &current->sighand->action[sig -1 ];
+       err = handle_signal(regs, sig, ka, &info, oldset, error);
+       if(!err) return(1);
+@@ -201,7 +201,7 @@
+       }
+ }
+-int sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize)
++int sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
+ {
+       sigset_t saveset, newset;
+@@ -227,20 +227,59 @@
+       }
+ }
++int sys_sigaction(int sig, const struct old_sigaction __user *act,
++                       struct old_sigaction __user *oact)
++{
++      struct k_sigaction new_ka, old_ka;
++      int ret;
++
++      if (act) {
++              old_sigset_t mask;
++              if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
++                  __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
++                  __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
++                      return -EFAULT;
++              __get_user(new_ka.sa.sa_flags, &act->sa_flags);
++              __get_user(mask, &act->sa_mask);
++              siginitset(&new_ka.sa.sa_mask, mask);
++      }
++
++      ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
++
++      if (!ret && oact) {
++              if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
++                  __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
++                  __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
++                      return -EFAULT;
++              __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
++              __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
++      }
++
++      return ret;
++}
++
++int sys_sigaltstack(const stack_t *uss, stack_t *uoss)
++{
++      return(do_sigaltstack(uss, uoss, PT_REGS_SP(&current->thread.regs)));
++}
++
++extern int userspace_pid[];
++
+ static int copy_sc_from_user(struct pt_regs *to, void *from, 
+                            struct arch_frame_data *arch)
+ {
+       int ret;
+       ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from, arch),
+-                        copy_sc_from_user_skas(&to->regs, from));
++                        copy_sc_from_user_skas(userspace_pid[0], 
++                                               &to->regs, from));
+       return(ret);
+ }
+ int sys_sigreturn(struct pt_regs regs)
+ {
+-      void *sc = sp_to_sc(PT_REGS_SP(&current->thread.regs));
+-      void *mask = sp_to_mask(PT_REGS_SP(&current->thread.regs));
++      void __user *sc = sp_to_sc(PT_REGS_SP(&current->thread.regs));
++      void __user *mask = sp_to_mask(PT_REGS_SP(&current->thread.regs));
+       int sig_size = (_NSIG_WORDS - 1) * sizeof(unsigned long);
+       spin_lock_irq(&current->sighand->siglock);
+@@ -257,8 +296,8 @@
+ int sys_rt_sigreturn(struct pt_regs regs)
+ {
+-      struct ucontext *uc = sp_to_uc(PT_REGS_SP(&current->thread.regs));
+-      void *fp;
++      unsigned long sp = PT_REGS_SP(&current->thread.regs);
++      struct ucontext __user *uc = sp_to_uc(sp);
+       int sig_size = _NSIG_WORDS * sizeof(unsigned long);
+       spin_lock_irq(&current->sighand->siglock);
+@@ -266,7 +305,6 @@
+       sigdelsetmask(&current->blocked, ~_BLOCKABLE);
+       recalc_sigpending();
+       spin_unlock_irq(&current->sighand->siglock);
+-      fp = (void *) (((unsigned long) uc) + sizeof(struct ucontext));
+       copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext,
+                         &signal_frame_si.common.arch);
+       return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+diff -Naur a/arch/um/kernel/skas/include/mode.h b/arch/um/kernel/skas/include/mode.h
+--- a/arch/um/kernel/skas/include/mode.h       2004-01-08 22:22:40.000000000 -0500
++++ b/arch/um/kernel/skas/include/mode.h       2004-01-08 22:29:35.000000000 -0500
+@@ -12,14 +12,16 @@
+ extern int have_fpx_regs;
+ extern void user_time_init_skas(void);
+-extern int copy_sc_from_user_skas(union uml_pt_regs *regs, void *from_ptr);
+-extern int copy_sc_to_user_skas(void *to_ptr, void *fp, 
++extern int copy_sc_from_user_skas(int pid, union uml_pt_regs *regs, 
++                                void *from_ptr);
++extern int copy_sc_to_user_skas(int pid, void *to_ptr, void *fp, 
+                               union uml_pt_regs *regs, 
+                               unsigned long fault_addr, int fault_type);
+ extern void sig_handler_common_skas(int sig, void *sc_ptr);
+ extern void halt_skas(void);
+ extern void reboot_skas(void);
+ extern void kill_off_processes_skas(void);
++extern int is_skas_winch(int pid, int fd, void *data);
+ #endif
+diff -Naur a/arch/um/kernel/skas/include/skas.h b/arch/um/kernel/skas/include/skas.h
+--- a/arch/um/kernel/skas/include/skas.h       2004-01-08 22:17:37.000000000 -0500
++++ b/arch/um/kernel/skas/include/skas.h       2004-01-08 22:23:23.000000000 -0500
+@@ -8,7 +8,7 @@
+ #include "sysdep/ptrace.h"
+-extern int userspace_pid;
++extern int userspace_pid[];
+ extern void switch_threads(void *me, void *next);
+ extern void thread_wait(void *sw, void *fb);
+@@ -32,7 +32,7 @@
+ extern int new_mm(int from);
+ extern void save_registers(union uml_pt_regs *regs);
+ extern void restore_registers(union uml_pt_regs *regs);
+-extern void start_userspace(void);
++extern void start_userspace(int cpu);
+ extern void init_registers(int pid);
+ #endif
+diff -Naur a/arch/um/kernel/skas/include/uaccess.h b/arch/um/kernel/skas/include/uaccess.h
+--- a/arch/um/kernel/skas/include/uaccess.h    2004-01-08 22:20:08.000000000 -0500
++++ b/arch/um/kernel/skas/include/uaccess.h    2004-01-08 22:26:25.000000000 -0500
+@@ -6,20 +6,10 @@
+ #ifndef __SKAS_UACCESS_H
+ #define __SKAS_UACCESS_H
+-#include "linux/string.h"
+-#include "linux/sched.h"
+-#include "linux/err.h"
+-#include "asm/processor.h"
+-#include "asm/pgtable.h"
+-#include "asm/errno.h"
+-#include "asm/current.h"
+-#include "asm/a.out.h"
+-#include "kern_util.h"
+-
+ #define access_ok_skas(type, addr, size) \
+       ((segment_eq(get_fs(), KERNEL_DS)) || \
+        (((unsigned long) (addr) < TASK_SIZE) && \
+-        ((unsigned long) (addr) + (size) < TASK_SIZE)))
++        ((unsigned long) (addr) + (size) <= TASK_SIZE)))
+ static inline int verify_area_skas(int type, const void * addr, 
+                                  unsigned long size)
+@@ -27,197 +17,12 @@
+       return(access_ok_skas(type, addr, size) ? 0 : -EFAULT);
+ }
+-static inline unsigned long maybe_map(unsigned long virt, int is_write)
+-{
+-      pte_t pte;
+-
+-      void *phys = um_virt_to_phys(current, virt, &pte);
+-      int dummy_code;
+-
+-      if(IS_ERR(phys) || (is_write && !pte_write(pte))){
+-              if(handle_page_fault(virt, 0, is_write, 0, &dummy_code))
+-                      return(0);
+-              phys = um_virt_to_phys(current, virt, NULL);
+-      }
+-      return((unsigned long) __va((unsigned long) phys));
+-}
+-
+-static inline int buffer_op(unsigned long addr, int len, 
+-                          int (*op)(unsigned long addr, int len, void *arg),
+-                          void *arg)
+-{
+-      int size = min(PAGE_ALIGN(addr) - addr, (unsigned long) len);
+-      int remain = len, n;
+-
+-      n = (*op)(addr, size, arg);
+-      if(n != 0)
+-              return(n < 0 ? remain : 0);
+-
+-      addr += size;
+-      remain -= size;
+-      if(remain == 0) 
+-              return(0);
+-
+-      while(addr < ((addr + remain) & PAGE_MASK)){
+-              n = (*op)(addr, PAGE_SIZE, arg);
+-              if(n != 0)
+-                      return(n < 0 ? remain : 0);
+-
+-              addr += PAGE_SIZE;
+-              remain -= PAGE_SIZE;
+-      }
+-      if(remain == 0)
+-              return(0);
+-
+-      n = (*op)(addr, remain, arg);
+-      if(n != 0)
+-              return(n < 0 ? remain : 0);
+-      return(0);
+-}
+-
+-static inline int copy_chunk_from_user(unsigned long from, int len, void *arg)
+-{
+-      unsigned long *to_ptr = arg, to = *to_ptr;
+-
+-      from = maybe_map(from, 0);
+-      if(from == 0)
+-              return(-1);
+-
+-      memcpy((void *) to, (void *) from, len);
+-      *to_ptr += len;
+-      return(0);
+-}
+-
+-static inline int copy_from_user_skas(void *to, const void *from, int n)
+-{
+-      if(segment_eq(get_fs(), KERNEL_DS)){
+-              memcpy(to, from, n);
+-              return(0);
+-      }
+-
+-      return(access_ok_skas(VERIFY_READ, from, n) ?
+-             buffer_op((unsigned long) from, n, copy_chunk_from_user, &to) :
+-             n);
+-}
+-
+-static inline int copy_chunk_to_user(unsigned long to, int len, void *arg)
+-{
+-      unsigned long *from_ptr = arg, from = *from_ptr;
+-
+-      to = maybe_map(to, 1);
+-      if(to == 0)
+-              return(-1);
+-
+-      memcpy((void *) to, (void *) from, len);
+-      *from_ptr += len;
+-      return(0);
+-}
+-
+-static inline int copy_to_user_skas(void *to, const void *from, int n)
+-{
+-      if(segment_eq(get_fs(), KERNEL_DS)){
+-              memcpy(to, from, n);
+-              return(0);
+-      }
+-
+-      return(access_ok_skas(VERIFY_WRITE, to, n) ?
+-             buffer_op((unsigned long) to, n, copy_chunk_to_user, &from) :
+-             n);
+-}
+-
+-static inline int strncpy_chunk_from_user(unsigned long from, int len, 
+-                                        void *arg)
+-{
+-        char **to_ptr = arg, *to = *to_ptr;
+-      int n;
+-
+-      from = maybe_map(from, 0);
+-      if(from == 0)
+-              return(-1);
+-
+-      strncpy(to, (void *) from, len);
+-      n = strnlen(to, len);
+-      *to_ptr += n;
+-
+-      if(n < len) 
+-              return(1);
+-      return(0);
+-}
+-
+-static inline int strncpy_from_user_skas(char *dst, const char *src, int count)
+-{
+-      int n;
+-      char *ptr = dst;
+-
+-      if(segment_eq(get_fs(), KERNEL_DS)){
+-              strncpy(dst, src, count);
+-              return(strnlen(dst, count));
+-      }
+-
+-      if(!access_ok_skas(VERIFY_READ, src, 1))
+-              return(-EFAULT);
+-
+-      n = buffer_op((unsigned long) src, count, strncpy_chunk_from_user, 
+-                    &ptr);
+-      if(n != 0)
+-              return(-EFAULT);
+-      return(strnlen(dst, count));
+-}
+-
+-static inline int clear_chunk(unsigned long addr, int len, void *unused)
+-{
+-      addr = maybe_map(addr, 1);
+-      if(addr == 0) 
+-              return(-1);
+-
+-      memset((void *) addr, 0, len);
+-      return(0);
+-}
+-
+-static inline int __clear_user_skas(void *mem, int len)
+-{
+-      return(buffer_op((unsigned long) mem, len, clear_chunk, NULL));
+-}
+-
+-static inline int clear_user_skas(void *mem, int len)
+-{
+-      if(segment_eq(get_fs(), KERNEL_DS)){
+-              memset(mem, 0, len);
+-              return(0);
+-      }
+-
+-      return(access_ok_skas(VERIFY_WRITE, mem, len) ? 
+-             buffer_op((unsigned long) mem, len, clear_chunk, NULL) : len);
+-}
+-
+-static inline int strnlen_chunk(unsigned long str, int len, void *arg)
+-{
+-      int *len_ptr = arg, n;
+-
+-      str = maybe_map(str, 0);
+-      if(str == 0) 
+-              return(-1);
+-
+-      n = strnlen((void *) str, len);
+-      *len_ptr += n;
+-
+-      if(n < len)
+-              return(1);
+-      return(0);
+-}
+-
+-static inline int strnlen_user_skas(const void *str, int len)
+-{
+-      int count = 0, n;
+-
+-      if(segment_eq(get_fs(), KERNEL_DS))
+-              return(strnlen(str, len) + 1);
+-
+-      n = buffer_op((unsigned long) str, len, strnlen_chunk, &count);
+-      if(n == 0)
+-              return(count + 1);
+-      return(-EFAULT);
+-}
++extern int copy_from_user_skas(void *to, const void *from, int n);
++extern int copy_to_user_skas(void *to, const void *from, int n);
++extern int strncpy_from_user_skas(char *dst, const char *src, int count);
++extern int __clear_user_skas(void *mem, int len);
++extern int clear_user_skas(void *mem, int len);
++extern int strnlen_user_skas(const void *str, int len);
+ #endif
+diff -Naur a/arch/um/kernel/skas/Makefile b/arch/um/kernel/skas/Makefile
+--- a/arch/um/kernel/skas/Makefile     2004-01-08 22:17:52.000000000 -0500
++++ b/arch/um/kernel/skas/Makefile     2004-01-08 22:23:56.000000000 -0500
+@@ -5,20 +5,24 @@
+ obj-y = exec_kern.o exec_user.o mem.o mem_user.o mmu.o process.o \
+       process_kern.o syscall_kern.o syscall_user.o time.o tlb.o trap_user.o \
+-      sys-$(SUBARCH)/
++      uaccess.o sys-$(SUBARCH)/
++
++host-progs    := util/mk_ptregs
++clean-files   := include/skas_ptregs.h
+ USER_OBJS = $(filter %_user.o,$(obj-y)) process.o time.o
+ USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
+-include/skas_ptregs.h : util/mk_ptregs
+-      util/mk_ptregs > $@
+-
+-util/mk_ptregs :
+-      $(MAKE) -C util
++$(TOPDIR)/arch/um/include/skas_ptregs.h : $(src)/util/mk_ptregs
++      @echo -n '  Generating $@'
++      @$< > $@.tmp
++      @if [ -r $@ ] && cmp -s $@ $@.tmp; then \
++              echo ' (unchanged)'; \
++              rm -f $@.tmp; \
++      else \
++              echo ' (updated)'; \
++              mv -f $@.tmp $@; \
++      fi
+ $(USER_OBJS) : %.o: %.c
+       $(CC) $(CFLAGS_$(notdir $@)) $(USER_CFLAGS) -c -o $@ $<
+-
+-clean :
+-      $(MAKE) -C util clean
+-      $(RM) -f include/skas_ptregs.h
+diff -Naur a/arch/um/kernel/skas/mem_user.c b/arch/um/kernel/skas/mem_user.c
+--- a/arch/um/kernel/skas/mem_user.c   2004-01-08 22:18:42.000000000 -0500
++++ b/arch/um/kernel/skas/mem_user.c   2004-01-08 22:24:31.000000000 -0500
+@@ -7,6 +7,7 @@
+ #include <sys/mman.h>
+ #include <sys/ptrace.h>
+ #include "mem_user.h"
++#include "mem.h"
+ #include "user.h"
+ #include "os.h"
+ #include "proc_mm.h"
+@@ -15,12 +16,12 @@
+        int r, int w, int x)
+ {
+       struct proc_mm_op map;
+-      struct mem_region *region;
+-      int prot, n;
++      __u64 offset;
++      int prot, n, phys_fd;
+       prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
+               (x ? PROT_EXEC : 0);
+-      region = phys_region(phys);
++      phys_fd = phys_mapping(phys, &offset);
+       map = ((struct proc_mm_op) { .op        = MM_MMAP,
+                                    .u         = 
+@@ -30,12 +31,12 @@
+                                        .prot          = prot,
+                                        .flags         = MAP_SHARED | 
+                                                         MAP_FIXED,
+-                                       .fd            = region->fd,
+-                                       .offset        = phys_offset(phys)
++                                       .fd            = phys_fd,
++                                       .offset        = offset
+                                      } } } );
+       n = os_write_file(fd, &map, sizeof(map));
+       if(n != sizeof(map)) 
+-              printk("map : /proc/mm map failed, errno = %d\n", errno);
++              printk("map : /proc/mm map failed, err = %d\n", -n);
+ }
+ int unmap(int fd, void *addr, int len)
+@@ -49,8 +50,13 @@
+                                        { .addr        = (unsigned long) addr,
+                                          .len         = len } } } );
+       n = os_write_file(fd, &unmap, sizeof(unmap));
+-      if((n != 0) && (n != sizeof(unmap)))
+-              return(-errno);
++      if(n != sizeof(unmap)) {
++              if(n < 0) 
++                      return(n);
++              else if(n > 0) 
++                      return(-EIO);
++      }
++
+       return(0);
+ }
+@@ -71,11 +77,15 @@
+                                          .prot        = prot } } }&