Linux-2.6.12-rc2v2.6.12-rc2

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

Let it rip!

295 files changed, 35908 insertions, 0 deletions

diff --git a/arch/um/Kconfig b/arch/um/Kconfig
new file mode 100644
index 000000000000..9a23df182123
--- /dev/null
+++ b/arch/um/Kconfig
@@ -0,0 +1,320 @@
+# UML uses the generic IRQ sugsystem
+config GENERIC_HARDIRQS
+        bool
+        default y
+
+config UML
+        bool
+        default y
+
+# XXX: does UM have a mmu/swap?
+config MMU
+        bool
+        default y
+
+mainmenu "Linux/Usermode Kernel Configuration"
+
+config ISA
+        bool
+
+config SBUS
+        bool
+
+config PCI
+        bool
+
+config UID16
+        bool
+        default y
+
+config RWSEM_GENERIC_SPINLOCK
+        bool
+        default y
+
+config GENERIC_CALIBRATE_DELAY
+        bool
+        default y
+
+menu "UML-specific options"
+
+config MODE_TT
+        bool "Tracing thread support"
+        default y
+        help
+        This option controls whether tracing thread support is compiled
+        into UML.  Normally, this should be set to Y.  If you intend to
+        use only skas mode (and the host has the skas patch applied to it),
+        then it is OK to say N here.
+
+config STATIC_LINK
+        bool "Force a static link"
+        default n
+        depends on !MODE_TT
+        help
+        If CONFIG_MODE_TT is disabled, then this option gives you the ability
+        to force a static link of UML.  Normally, if only skas mode is built
+        in to UML, it will be linked as a shared binary.  This is inconvenient
+        for use in a chroot jail.  So, if you intend to run UML inside a
+        chroot, and you disable CONFIG_MODE_TT, you probably want to say Y
+        here.
+
+config MODE_SKAS
+        bool "Separate Kernel Address Space support"
+        default y
+        help
+        This option controls whether skas (separate kernel address space)
+        support is compiled in.  If you have applied the skas patch to the
+        host, then you certainly want to say Y here (and consider saying N
+        to CONFIG_MODE_TT).  Otherwise, it is safe to say Y.  Disabling this
+        option will shrink the UML binary slightly.
+
+source "arch/um/Kconfig_arch"
+
+config LD_SCRIPT_STATIC
+        bool
+        default y
+        depends on MODE_TT || STATIC_LINK
+
+config LD_SCRIPT_DYN
+        bool
+        default y
+        depends on !LD_SCRIPT_STATIC
+
+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 <file: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"
+
+config HOSTFS
+        tristate "Host filesystem"
+        help
+        While the User-Mode Linux port uses its own root file system for
+        booting and normal file access, this module lets the UML user
+        access files stored on the host.  It does not require any
+        network connection between the Host and UML.  An example use of
+        this might be:
+
+        mount none /tmp/fromhost -t hostfs -o /tmp/umlshare
+
+        where /tmp/fromhost is an empty directory inside UML and
+        /tmp/umlshare is a directory on the host with files the UML user
+        wishes to access.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/hostfs.html>.
+
+        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 (EXPERIMENTAL)"
+        depends on BROKEN
+        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.
+
+        If you are actively using it, please ask for it to be fixed. In this
+        moment, it does not work on 2.6 (it works somehow on 2.4).
+
+config MCONSOLE
+        bool "Management console"
+        default y
+        help
+        The user mode linux management console is a low-level interface to
+        the kernel, somewhat like the i386 SysRq interface.  Since there is
+        a full-blown operating system running under every user mode linux
+        instance, there is much greater flexibility possible than with the
+        SysRq mechanism.
+
+        If you answer 'Y' to this option, to use this feature, you need the
+        mconsole client (called uml_mconsole) which is present in CVS in
+        2.4.5-9um and later (path /tools/mconsole), and is also in the
+        distribution RPM package in 2.4.6 and later.
+
+        It is safe to say 'Y' here.
+
+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). A key for each of the
+        possible requests is provided.
+
+        This is the feature normally accomplished by pressing a key
+        while holding SysRq (Alt+PrintScreen).
+
+        On UML, this is accomplished by sending a "sysrq" command with
+        mconsole, followed by the letter for the requested command.
+
+        The keys are documented in <file: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"
+        default n
+        help
+        This is needed when the host on which you run has a 2G/2G memory
+        split, instead of the customary 3G/1G.
+
+        Note that to enable such a host
+        configuration, which makes sense only in some cases, you need special
+        host patches.
+
+        So, if you do not know what to do here, say 'N'.
+
+config SMP
+        bool "Symmetric multi-processing support (EXPERIMENTAL)"
+        default n
+        depends on MODE_TT && EXPERIMENTAL
+        help
+        This option enables UML SMP support.
+        It is NOT related to having a real SMP box. Not directly, at least.
+
+        UML implements virtual SMP by allowing as many processes to run
+        simultaneously on the host as there are virtual processors configured.
+
+        Obviously, if the host is a uniprocessor, those processes will
+        timeshare, but, inside UML, will appear to be running simultaneously.
+        If the host is a multiprocessor, then UML processes may run
+        simultaneously, depending on the host scheduler.
+
+        This, however, is supported only in TT mode. So, if you use the SKAS
+        patch on your host, switching to TT mode and enabling SMP usually gives
+        you worse performances.
+        Also, since the support for SMP has been under-developed, there could
+        be some bugs being exposed by enabling SMP.
+
+        If you don't know what to do, say N.
+
+config NR_CPUS
+        int "Maximum number of CPUs (2-32)"
+        range 2 32
+        depends on SMP
+        default "32"
+
+config NEST_LEVEL
+        int "Nesting level"
+        default "0"
+        help
+        This is set to the number of layers of UMLs that this UML will be run
+        in.  Normally, this is zero, meaning that it will run directly on the
+        host.  Setting it to one will build a UML that can run inside a UML
+        that is running on the host.  Generally, if you intend this UML to run
+        inside another UML, set CONFIG_NEST_LEVEL to one more than the host
+        UML.
+
+        Note that if the hosting UML has its CONFIG_KERNEL_HALF_GIGS set to
+        greater than one, then the guest UML should have its CONFIG_NEST_LEVEL
+        set to the host's CONFIG_NEST_LEVEL + CONFIG_KERNEL_HALF_GIGS.
+        Only change this if you are running nested UMLs.
+
+config KERNEL_HALF_GIGS
+        int "Kernel address space size (in .5G units)"
+        default "1"
+        help
+        This determines the amount of address space that UML will allocate for
+        its own, measured in half Gigabyte units.  The default is 1.
+        Change this only if you need to boot UML with an unusually large amount
+        of physical memory.
+
+config HIGHMEM
+        bool "Highmem support"
+
+config KERNEL_STACK_ORDER
+        int "Kernel stack size order"
+        default 2
+        help
+        This option determines the size of UML kernel stacks.  They will
+        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"
+
+source "drivers/base/Kconfig"
+
+source "arch/um/Kconfig_char"
+
+source "drivers/block/Kconfig"
+
+config NETDEVICES
+        bool
+        default NET
+
+source "arch/um/Kconfig_net"
+
+source "net/Kconfig"
+
+source "fs/Kconfig"
+
+source "security/Kconfig"
+
+source "crypto/Kconfig"
+
+source "lib/Kconfig"
+
+menu "SCSI support"
+depends on BROKEN
+
+config SCSI
+        tristate "SCSI support"
+
+# This gives us free_dma, which scsi.c wants.
+config GENERIC_ISA_DMA
+        bool
+        depends on SCSI
+        default y
+
+source "arch/um/Kconfig_scsi"
+
+endmenu
+
+source "drivers/md/Kconfig"
+
+if BROKEN
+        source "drivers/mtd/Kconfig"
+endif
+
+#This is just to shut up some Kconfig warnings, so no prompt.
+config INPUT
+        bool
+        default n
+
+source "arch/um/Kconfig.debug"
diff --git a/arch/um/Kconfig.debug b/arch/um/Kconfig.debug
new file mode 100644
index 000000000000..b89989de364d
--- /dev/null
+++ b/arch/um/Kconfig.debug
@@ -0,0 +1,53 @@
+menu "Kernel hacking"
+
+source "lib/Kconfig.debug"
+
+config FRAME_POINTER
+        bool
+        default y if DEBUG_INFO
+
+config PT_PROXY
+        bool "Enable ptrace proxy"
+        depends on XTERM_CHAN && DEBUG_INFO && MODE_TT
+        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"
+        depends on DEBUG_INFO && MODE_SKAS && !MODE_TT
+        help
+        This allows profiling of a User-Mode Linux kernel with the gprof
+        utility.
+
+        See <http://user-mode-linux.sourceforge.net/gprof.html> for more
+        details.
+
+        If you're involved in UML kernel development and want to use gprof,
+        say Y.  If you're unsure, say N.
+
+config GCOV
+        bool "Enable gcov support"
+        depends on DEBUG_INFO && MODE_SKAS
+        help
+        This option allows developers to retrieve coverage data from a UML
+        session.
+
+        See <http://user-mode-linux.sourceforge.net/gprof.html> for more
+        details.
+
+        If you're involved in UML kernel development and want to use gcov,
+        say Y.  If you're unsure, say N.
+
+config SYSCALL_DEBUG
+        bool "Enable system call debugging"
+        default N
+        depends on DEBUG_INFO
+        help
+        This adds some system debugging to UML, including keeping a ring buffer
+        with recent system calls and some global and per-task statistics.
+
+        If unsure, say N
+
+endmenu
diff --git a/arch/um/Kconfig_char b/arch/um/Kconfig_char
new file mode 100644
index 000000000000..3e50fdb67626
--- /dev/null
+++ b/arch/um/Kconfig_char
@@ -0,0 +1,208 @@
+
+menu "Character Devices"
+
+config STDERR_CONSOLE
+        bool "stderr console"
+        default y
+        help
+        console driver which dumps all printk messages to stderr.
+
+config STDIO_CONSOLE
+        bool
+        default y
+
+config SSL
+        bool "Virtual serial line"
+        help
+        The User-Mode Linux environment allows you to create virtual serial
+        lines on the UML that are usually made to show up on the host as
+        ttys or ptys.
+
+        See <http://user-mode-linux.sourceforge.net/input.html> for more
+        information and command line examples of how to use this facility.
+
+        Unless you have a specific reason for disabling this, say Y.
+
+config NULL_CHAN
+        bool "null channel support"
+        help
+        This option enables support for attaching UML consoles and serial
+        lines to a device similar to /dev/null.  Data written to it disappears
+        and there is never any data to be read.
+
+config PORT_CHAN
+        bool "port channel support"
+        help
+        This option enables support for attaching UML consoles and serial
+        lines to host portals.  They may be accessed with 'telnet <host>
+        <port number>'.  Any number of consoles and serial lines may be
+        attached to a single portal, although what UML device you get when
+        you telnet to that portal will be unpredictable.
+        It is safe to say 'Y' here.
+
+config PTY_CHAN
+        bool "pty channel support"
+        help
+        This option enables support for attaching UML consoles and serial
+        lines to host pseudo-terminals.  Access to both traditional
+        pseudo-terminals (/dev/pty*) and pts pseudo-terminals are controlled
+        with this option.  The assignment of UML devices to host devices
+        will be announced in the kernel message log.
+        It is safe to say 'Y' here.
+
+config TTY_CHAN
+        bool "tty channel support"
+        help
+        This option enables support for attaching UML consoles and serial
+        lines to host terminals.  Access to both virtual consoles
+        (/dev/tty*) and the slave side of pseudo-terminals (/dev/ttyp* and
+        /dev/pts/*) are controlled by this option.
+        It is safe to say 'Y' here.
+
+config XTERM_CHAN
+        bool "xterm channel support"
+        help
+        This option enables support for attaching UML consoles and serial
+        lines to xterms.  Each UML device so assigned will be brought up in
+        its own xterm.
+        If you disable this option, then CONFIG_PT_PROXY will be disabled as
+        well, since UML's gdb currently requires an xterm.
+        It is safe to say 'Y' here.
+
+config NOCONFIG_CHAN
+        bool
+        default !(XTERM_CHAN && TTY_CHAN && PTY_CHAN && PORT_CHAN && NULL_CHAN)
+
+config CON_ZERO_CHAN
+        string "Default main console channel initialization"
+        default "fd:0,fd:1"
+        help
+        This is the string describing the channel to which the main console
+        will be attached by default.  This value can be overridden from the
+        command line.  The default value is "fd:0,fd:1", which attaches the
+        main console to stdin and stdout.
+        It is safe to leave this unchanged.
+
+config CON_CHAN
+        string "Default console channel initialization"
+        default "xterm"
+        help
+        This is the string describing the channel to which all consoles
+        except the main console will be attached by default.  This value can
+        be overridden from the command line.  The default value is "xterm",
+        which brings them up in xterms.
+        It is safe to leave this unchanged, although you may wish to change
+        this if you expect the UML that you build to be run in environments
+        which don't have X or xterm available.
+
+config SSL_CHAN
+        string "Default serial line channel initialization"
+        default "pty"
+        help
+        This is the string describing the channel to which the serial lines
+        will be attached by default.  This value can be overridden from the
+        command line.  The default value is "pty", which attaches them to
+        traditional pseudo-terminals.
+        It is safe to leave this unchanged, although you may wish to change
+        this if you expect the UML that you build to be run in environments
+        which don't have a set of /dev/pty* devices.
+
+config UNIX98_PTYS
+        bool "Unix98 PTY support"
+        ---help---
+          A pseudo terminal (PTY) is a software device consisting of two
+          halves: a master and a slave. The slave device behaves identical to
+          a physical terminal; the master device is used by a process to
+          read data from and write data to the slave, thereby emulating a
+          terminal. Typical programs for the master side are telnet servers
+          and xterms.
+
+          Linux has traditionally used the BSD-like names /dev/ptyxx for
+          masters and /dev/ttyxx for slaves of pseudo terminals. This scheme
+          has a number of problems. The GNU C library glibc 2.1 and later,
+          however, supports the Unix98 naming standard: in order to acquire a
+          pseudo terminal, a process opens /dev/ptmx; the number of the pseudo
+          terminal is then made available to the process and the pseudo
+          terminal slave can be accessed as /dev/pts/<number>. What was
+          traditionally /dev/ttyp2 will then be /dev/pts/2, for example.
+
+          All modern Linux systems use the Unix98 ptys.  Say Y unless
+          you're on an embedded system and want to conserve memory.
+
+config LEGACY_PTYS
+        bool "Legacy (BSD) PTY support"
+        default y
+        ---help---
+          A pseudo terminal (PTY) is a software device consisting of two
+          halves: a master and a slave. The slave device behaves identical to
+          a physical terminal; the master device is used by a process to
+          read data from and write data to the slave, thereby emulating a
+          terminal. Typical programs for the master side are telnet servers
+          and xterms.
+
+          Linux has traditionally used the BSD-like names /dev/ptyxx
+          for masters and /dev/ttyxx for slaves of pseudo
+          terminals. This scheme has a number of problems, including
+          security.  This option enables these legacy devices; on most
+          systems, it is safe to say N.
+
+
+config LEGACY_PTY_COUNT
+        int "Maximum number of legacy PTY in use"
+        depends on LEGACY_PTYS
+        default "256"
+        ---help---
+          The maximum number of legacy PTYs that can be used at any one time.
+          The default is 256, and should be more than enough.  Embedded
+          systems may want to reduce this to save memory.
+
+          When not in use, each legacy PTY occupies 12 bytes on 32-bit
+          architectures and 24 bytes on 64-bit architectures.
+
+config WATCHDOG
+        bool "Watchdog Timer Support"
+
+config WATCHDOG_NOWAYOUT
+        bool "Disable watchdog shutdown on close"
+        depends on WATCHDOG
+
+config SOFT_WATCHDOG
+        tristate "Software Watchdog"
+        depends on WATCHDOG
+
+config UML_WATCHDOG
+        tristate "UML watchdog"
+        depends on WATCHDOG
+
+config UML_SOUND
+        tristate "Sound support"
+        help
+        This option enables UML sound support.  If enabled, it will pull in
+        soundcore and the UML hostaudio relay, which acts as a intermediary
+        between the host's dsp and mixer devices and the UML sound system.
+        It is safe to say 'Y' here.
+
+config SOUND
+        tristate
+        default UML_SOUND
+
+config HOSTAUDIO
+        tristate
+        default UML_SOUND
+
+config UML_RANDOM
+        tristate "Hardware random number generator"
+        help
+        This option enables UML's "hardware" random number generator.  It
+        attaches itself to the host's /dev/random, supplying as much entropy
+        as the host has, rather than the small amount the UML gets from its
+        own drivers.  It registers itself as a standard hardware random number
+        generator, major 10, minor 183, and the canonical device name is
+        /dev/hwrng.
+        The way to make use of this is to install the rng-tools package
+        (check your distro, or download from
+        http://sourceforge.net/projects/gkernel/).  rngd periodically reads
+        /dev/hwrng and injects the entropy into /dev/random.
+
+endmenu
+
diff --git a/arch/um/Kconfig_i386 b/arch/um/Kconfig_i386
new file mode 100644
index 000000000000..203c242201b6
--- /dev/null
+++ b/arch/um/Kconfig_i386
@@ -0,0 +1,24 @@
+config 64_BIT
+        bool
+        default n
+
+config TOP_ADDR
+        hex
+        default 0xc0000000 if !HOST_2G_2G
+        default 0x80000000 if HOST_2G_2G
+
+config 3_LEVEL_PGTABLES
+        bool "Three-level pagetables"
+        default n
+        help
+        Three-level pagetables will let UML have more than 4G of physical
+        memory.  All the memory that can't be mapped directly will be treated
+        as high memory.
+
+config ARCH_HAS_SC_SIGNALS
+        bool
+        default y
+
+config ARCH_REUSE_HOST_VSYSCALL_AREA
+        bool
+        default y
diff --git a/arch/um/Kconfig_net b/arch/um/Kconfig_net
new file mode 100644
index 000000000000..1c2f9a70d91d
--- /dev/null
+++ b/arch/um/Kconfig_net
@@ -0,0 +1,180 @@
+
+menu "UML Network Devices"
+        depends on NET
+
+# UML virtual driver
+config UML_NET
+        bool "Virtual network device"
+        help
+        While the User-Mode port cannot directly talk to any physical
+        hardware devices, this choice and the following transport options
+        provide one or more virtual network devices through which the UML
+        kernels can talk to each other, the host, and with the host's help,
+        machines on the outside world.
+
+        For more information, including explanations of the networking and
+        sample configurations, see
+        <http://user-mode-linux.sourceforge.net/networking.html>.
+
+        If you'd like to be able to enable networking in the User-Mode
+        linux environment, say Y; otherwise say N.  Note that you must
+        enable at least one of the following transport options to actually
+        make use of UML networking.
+
+config UML_NET_ETHERTAP
+        bool "Ethertap transport"
+        depends on UML_NET
+        help
+        The Ethertap User-Mode Linux network transport allows a single
+        running UML to exchange packets with its host over one of the
+        host's Ethertap devices, such as /dev/tap0.  Additional running
+        UMLs can use additional Ethertap devices, one per running UML.
+        While the UML believes it's on a (multi-device, broadcast) virtual
+        Ethernet network, it's in fact communicating over a point-to-point
+        link with the host.
+
+        To use this, your host kernel must have support for Ethertap
+        devices.  Also, if your host kernel is 2.4.x, it must have 
+        CONFIG_NETLINK_DEV configured as Y or M.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        has examples of the UML command line to use to enable Ethertap
+        networking.
+
+        If you'd like to set up an IP network with the host and/or the
+        outside world, say Y to this, the Daemon Transport and/or the 
+        Slip Transport.  You'll need at least one of them, but may choose
+        more than one without conflict.  If you don't need UML networking,
+        say N.
+
+config UML_NET_TUNTAP
+        bool "TUN/TAP transport"
+        depends on UML_NET
+        help
+        The UML TUN/TAP network transport allows a UML instance to exchange
+        packets with the host over a TUN/TAP device.  This option will only
+        work with a 2.4 host, unless you've applied the TUN/TAP patch to
+        your 2.2 host kernel.
+
+        To use this transport, your host kernel must have support for TUN/TAP
+        devices, either built-in or as a module.
+
+config UML_NET_SLIP
+        bool "SLIP transport"
+        depends on UML_NET
+        help
+        The slip User-Mode Linux network transport allows a running UML to
+        network with its host over a point-to-point link.  Unlike Ethertap,
+        which can carry any Ethernet frame (and hence even non-IP packets),
+        the slip transport can only carry IP packets.
+
+        To use this, your host must support slip devices.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/networking.html>.  That site
+        has examples of the UML command line to use to enable slip
+        networking, and details of a few quirks with it.
+
+        The Ethertap Transport is preferred over slip because of its
+        limitations.  If you prefer slip, however, say Y here.  Otherwise
+        choose the Multicast transport (to network multiple UMLs on 
+        multiple hosts), Ethertap (to network with the host and the
+        outside world), and/or the Daemon transport (to network multiple
+        UMLs on a single host).  You may choose more than one without
+        conflict.  If you don't need UML networking, say N.
+
+config UML_NET_DAEMON
+        bool "Daemon transport"
+        depends on UML_NET
+        help
+        This User-Mode Linux network transport allows one or more running
+        UMLs on a single host to communicate with each other, but not to
+        the host.
+
+        To use this form of networking, you'll need to run the UML
+        networking daemon on the host.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        has examples of the UML command line to use to enable Daemon
+        networking.
+
+        If you'd like to set up a network with other UMLs on a single host,
+        say Y.  If you need a network between UMLs on multiple physical
+        hosts, choose the Multicast Transport.  To set up a network with
+        the host and/or other IP machines, say Y to the Ethertap or Slip
+        transports.  You'll need at least one of them, but may choose
+        more than one without conflict.  If you don't need UML networking,
+        say N.
+
+config UML_NET_MCAST
+        bool "Multicast transport"
+        depends on UML_NET
+        help
+        This Multicast User-Mode Linux network transport allows multiple
+        UMLs (even ones running on different host machines!) to talk to
+        each other over a virtual ethernet network.  However, it requires
+        at least one UML with one of the other transports to act as a
+        bridge if any of them need to be able to talk to their hosts or any
+        other IP machines.
+
+        To use this, your host kernel(s) must support IP Multicasting.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        has examples of the UML command line to use to enable Multicast
+        networking, and notes about the security of this approach.
+
+        If you need UMLs on multiple physical hosts to communicate as if
+        they shared an Ethernet network, say Y.  If you need to communicate
+        with other IP machines, make sure you select one of the other
+        transports (possibly in addition to Multicast; they're not
+        exclusive).  If you don't need to network UMLs say N to each of
+        the transports.
+
+config UML_NET_PCAP
+        bool "pcap transport"
+        depends on UML_NET && BROKEN
+        help
+        The pcap transport makes a pcap packet stream on the host look
+        like an ethernet device inside UML.  This is useful for making 
+        UML act as a network monitor for the host.  You must have libcap
+        installed in order to build the pcap transport into UML.
+
+        For more information, see
+        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        has examples of the UML command line to use to enable this option.
+
+        If you intend to use UML as a network monitor for the host, say
+        Y here.  Otherwise, say N.
+
+config UML_NET_SLIRP
+        bool "SLiRP transport"
+        depends on UML_NET
+        help
+        The SLiRP User-Mode Linux network transport allows a running UML
+        to network by invoking a program that can handle SLIP encapsulated
+        packets.  This is commonly (but not limited to) the application
+        known as SLiRP, a program that can re-socket IP packets back onto
+        the host on which it is run.  Only IP packets are supported,
+        unlike other network transports that can handle all Ethernet
+        frames.  In general, slirp allows the UML the same IP connectivity
+        to the outside world that the host user is permitted, and unlike
+        other transports, SLiRP works without the need of root level
+        privleges, setuid binaries, or SLIP devices on the host.  This
+        also means not every type of connection is possible, but most
+        situations can be accomodated with carefully crafted slirp
+        commands that can be passed along as part of the network device's
+        setup string.  The effect of this transport on the UML is similar
+        that of a host behind a firewall that masquerades all network
+        connections passing through it (but is less secure).
+        
+        To use this you should first have slirp compiled somewhere
+        accessible on the host, and have read its documentation.  If you
+        don't need UML networking, say N.
+        
+        Startup example: "eth0=slirp,FE:FD:01:02:03:04,/usr/local/bin/slirp"
+
+endmenu
+
diff --git a/arch/um/Kconfig_scsi b/arch/um/Kconfig_scsi
new file mode 100644
index 000000000000..c291c942b1a8
--- /dev/null
+++ b/arch/um/Kconfig_scsi
@@ -0,0 +1,58 @@
+comment "SCSI support type (disk, tape, CD-ROM)"
+        depends on SCSI
+
+config BLK_DEV_SD
+        tristate "SCSI disk support"
+        depends on SCSI
+
+config SD_EXTRA_DEVS
+        int "Maximum number of SCSI disks that can be loaded as modules"
+        depends on BLK_DEV_SD
+        default "40"
+
+config CHR_DEV_ST
+        tristate "SCSI tape support"
+        depends on SCSI
+
+config BLK_DEV_SR
+        tristate "SCSI CD-ROM support"
+        depends on SCSI
+
+config BLK_DEV_SR_VENDOR
+        bool "Enable vendor-specific extensions (for SCSI CDROM)"
+        depends on BLK_DEV_SR
+
+config SR_EXTRA_DEVS
+        int "Maximum number of CDROM devices that can be loaded as modules"
+        depends on BLK_DEV_SR
+        default "2"
+
+config CHR_DEV_SG
+        tristate "SCSI generic support"
+        depends on SCSI
+
+comment "Some SCSI devices (e.g. CD jukebox) support multiple LUNs"
+        depends on SCSI
+
+#if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+config SCSI_DEBUG_QUEUES
+        bool "Enable extra checks in new queueing code"
+        depends on SCSI
+
+#fi
+config SCSI_MULTI_LUN
+        bool "Probe all LUNs on each SCSI device"
+        depends on SCSI
+
+config SCSI_CONSTANTS
+        bool "Verbose SCSI error reporting (kernel size +=12K)"
+        depends on SCSI
+
+config SCSI_LOGGING
+        bool "SCSI logging facility"
+        depends on SCSI
+
+config SCSI_DEBUG
+        tristate "SCSI debugging host simulator (EXPERIMENTAL)"
+        depends on SCSI
+
diff --git a/arch/um/Kconfig_x86_64 b/arch/um/Kconfig_x86_64
new file mode 100644
index 000000000000..768dc6626a8d
--- /dev/null
+++ b/arch/um/Kconfig_x86_64
@@ -0,0 +1,15 @@
+config 64_BIT
+        bool
+        default y
+
+config 3_LEVEL_PGTABLES
+       bool
+       default y
+
+config ARCH_HAS_SC_SIGNALS
+        bool
+        default n
+
+config ARCH_REUSE_HOST_VSYSCALL_AREA
+        bool
+        default n
diff --git a/arch/um/Makefile b/arch/um/Makefile
new file mode 100644
index 000000000000..97bca6b5ca95
--- /dev/null
+++ b/arch/um/Makefile
@@ -0,0 +1,210 @@
+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+ARCH_DIR := arch/um
+OS := $(shell uname -s)
+# We require bash because the vmlinux link and loader script cpp use bash
+# features.
+SHELL := /bin/bash
+
+filechk_gen_header = $<
+
+core-y                  += $(ARCH_DIR)/kernel/          \
+                           $(ARCH_DIR)/drivers/         \
+                           $(ARCH_DIR)/os-$(OS)/
+
+# Have to precede the include because the included Makefiles reference them.
+SYMLINK_HEADERS := archparam.h system.h sigcontext.h processor.h ptrace.h \
+        arch-signal.h module.h vm-flags.h
+SYMLINK_HEADERS := $(foreach header,$(SYMLINK_HEADERS),include/asm-um/$(header))
+
+# XXX: The "os" symlink is only used by arch/um/include/os.h, which includes
+# ../os/include/file.h
+#
+# These are cleaned up during mrproper. Please DO NOT fix it again, this is
+# the Correct Thing(tm) to do!
+ARCH_SYMLINKS = include/asm-um/arch $(ARCH_DIR)/include/sysdep $(ARCH_DIR)/os \
+        $(SYMLINK_HEADERS) $(ARCH_DIR)/include/uml-config.h
+
+GEN_HEADERS += $(ARCH_DIR)/include/task.h $(ARCH_DIR)/include/kern_constants.h
+
+um-modes-$(CONFIG_MODE_TT) += tt
+um-modes-$(CONFIG_MODE_SKAS) += skas
+
+MODE_INCLUDE    += $(foreach mode,$(um-modes-y),\
+                   -I$(srctree)/$(ARCH_DIR)/kernel/$(mode)/include)
+
+MAKEFILES-INCL  += $(foreach mode,$(um-modes-y),\
+                   $(srctree)/$(ARCH_DIR)/Makefile-$(mode))
+
+ifneq ($(MAKEFILES-INCL),)
+  include $(MAKEFILES-INCL)
+endif
+
+ARCH_INCLUDE    := -I$(ARCH_DIR)/include
+SYS_DIR         := $(ARCH_DIR)/include/sysdep-$(SUBARCH)
+
+include $(srctree)/$(ARCH_DIR)/Makefile-$(SUBARCH)
+
+core-y += $(SUBARCH_CORE)
+libs-y += $(SUBARCH_LIBS)
+
+# -Derrno=kernel_errno - This turns all kernel references to errno into
+# kernel_errno to separate them from the libc errno.  This allows -fno-common
+# in CFLAGS.  Otherwise, it would cause ld to complain about the two different
+# errnos.
+
+CFLAGS += $(CFLAGS-y) -D__arch_um__ -DSUBARCH=\"$(SUBARCH)\" \
+        $(ARCH_INCLUDE) $(MODE_INCLUDE)
+
+USER_CFLAGS := $(patsubst -I%,,$(CFLAGS))
+USER_CFLAGS := $(patsubst -D__KERNEL__,,$(USER_CFLAGS)) $(ARCH_INCLUDE) \
+        $(MODE_INCLUDE) $(ARCH_USER_CFLAGS)
+CFLAGS += -Derrno=kernel_errno -Dsigprocmask=kernel_sigprocmask
+CFLAGS += $(call cc-option,-fno-unit-at-a-time,)
+
+#This will adjust *FLAGS accordingly to the platform.
+include $(srctree)/$(ARCH_DIR)/Makefile-os-$(OS)
+
+# These are needed for clean and mrproper, since in that case .config is not
+# included; the values here are meaningless
+
+CONFIG_NEST_LEVEL ?= 0
+CONFIG_KERNEL_HALF_GIGS ?= 0
+
+SIZE = (($(CONFIG_NEST_LEVEL) + $(CONFIG_KERNEL_HALF_GIGS)) * 0x20000000)
+
+ifeq ($(CONFIG_MODE_SKAS), y)
+$(SYS_HEADERS) : $(ARCH_DIR)/include/skas_ptregs.h
+endif
+
+.PHONY: linux
+
+all: linux
+
+linux: vmlinux
+        ln -f $< $@
+
+define archhelp
+  echo '* linux         - Binary kernel image (./linux) - for backward'
+  echo '                   compatibility only, this creates a hard link to the'
+  echo '                   real kernel binary, the the "vmlinux" binary you'
+  echo '                   find in the kernel root.'
+endef
+
+$(shell cd $(ARCH_DIR) && ln -sf Kconfig_$(SUBARCH) Kconfig_arch)
+
+prepare: $(ARCH_SYMLINKS) $(SYS_HEADERS) $(GEN_HEADERS) \
+        $(ARCH_DIR)/kernel/vmlinux.lds.S
+
+LINK-$(CONFIG_LD_SCRIPT_STATIC) += -static
+LINK-$(CONFIG_LD_SCRIPT_DYN) += -Wl,-rpath,/lib
+
+LD_SCRIPT-$(CONFIG_LD_SCRIPT_STATIC) := uml.lds.S
+LD_SCRIPT-$(CONFIG_LD_SCRIPT_DYN) := dyn.lds.S
+
+CPP_MODE-$(CONFIG_MODE_TT) := -DMODE_TT
+CONFIG_KERNEL_STACK_ORDER ?= 2
+STACK_SIZE := $(shell echo $$[ 4096 * (1 << $(CONFIG_KERNEL_STACK_ORDER)) ] )
+
+ifndef START
+  START = $$(($(TOP_ADDR) - $(SIZE)))
+endif
+
+CPPFLAGS_vmlinux.lds = $(shell echo -U$(SUBARCH) \
+        -DSTART=$(START) -DELF_ARCH=$(ELF_ARCH) \
+        -DELF_FORMAT=\"$(ELF_FORMAT)\" $(CPP_MODE-y) \
+        -DKERNEL_STACK_SIZE=$(STACK_SIZE))
+
+#The wrappers will select whether using "malloc" or the kernel allocator.
+LINK_WRAPS = -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc
+
+CFLAGS_vmlinux = $(LINK-y) $(LINK_WRAPS)
+define cmd_vmlinux__
+        $(CC) $(CFLAGS_vmlinux) -o $@ \
+        -Wl,-T,$(vmlinux-lds) $(vmlinux-init) \
+        -Wl,--start-group $(vmlinux-main) -Wl,--end-group \
+        -L/usr/lib -lutil \
+        $(filter-out $(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) \
+        FORCE ,$^) ; rm -f linux
+endef
+
+#When cleaning we don't include .config, so we don't include
+#TT or skas makefiles and don't clean skas_ptregs.h.
+CLEAN_FILES += linux x.i gmon.out $(ARCH_DIR)/include/uml-config.h \
+        $(GEN_HEADERS) $(ARCH_DIR)/include/skas_ptregs.h
+
+MRPROPER_FILES += $(SYMLINK_HEADERS) $(ARCH_SYMLINKS) \
+        $(addprefix $(ARCH_DIR)/kernel/,$(KERN_SYMLINKS)) $(ARCH_DIR)/os \
+        $(ARCH_DIR)/Kconfig_arch
+
+archclean:
+        $(Q)$(MAKE) $(clean)=$(ARCH_DIR)/util
+        @find . \( -name '*.bb' -o -name '*.bbg' -o -name '*.da' \
+                -o -name '*.gcov' \) -type f -print | xargs rm -f
+
+#We need to re-preprocess this when the symlink dest changes.
+#So we touch it when needed.
+$(ARCH_DIR)/kernel/vmlinux.lds.S: FORCE
+        $(Q)if [ "$(shell readlink $@)" != "$(LD_SCRIPT-y)" ]; then \
+                echo '  SYMLINK $@'; \
+                ln -sf $(LD_SCRIPT-y) $@; \
+                touch $@; \
+        fi;
+
+$(SYMLINK_HEADERS):
+        @echo '  SYMLINK $@'
+        $(Q)cd $(TOPDIR)/$(dir $@) ; \
+        ln -sf $(basename $(notdir $@))-$(SUBARCH)$(suffix $@) $(notdir $@)
+
+include/asm-um/arch:
+        @echo '  SYMLINK $@'
+        $(Q)cd $(TOPDIR)/include/asm-um && ln -sf ../asm-$(SUBARCH) arch
+
+$(ARCH_DIR)/include/sysdep:
+        @echo '  SYMLINK $@'
+        $(Q)cd $(ARCH_DIR)/include && ln -sf sysdep-$(SUBARCH) sysdep
+
+$(ARCH_DIR)/os:
+        @echo '  SYMLINK $@'
+        $(Q)cd $(ARCH_DIR) && ln -sf os-$(OS) os
+
+# Generated files
+define filechk_umlconfig
+        sed 's/ CONFIG/ UML_CONFIG/'
+endef
+
+$(ARCH_DIR)/include/uml-config.h : include/linux/autoconf.h
+        $(call filechk,umlconfig)
+
+$(ARCH_DIR)/include/task.h: $(ARCH_DIR)/util/mk_task
+        $(call filechk,gen_header)
+
+$(ARCH_DIR)/include/user_constants.h: $(ARCH_DIR)/os/util/mk_user_constants
+        $(call filechk,gen_header)
+
+$(ARCH_DIR)/include/kern_constants.h: $(ARCH_DIR)/util/mk_constants
+        $(call filechk,gen_header)
+
+$(ARCH_DIR)/include/skas_ptregs.h: $(ARCH_DIR)/kernel/skas/util/mk_ptregs
+        $(call filechk,gen_header)
+
+$(ARCH_DIR)/os/util/mk_user_constants: $(ARCH_DIR)/os/util FORCE ;
+
+$(ARCH_DIR)/util/mk_task $(ARCH_DIR)/util/mk_constants: $(ARCH_DIR)/include/user_constants.h $(ARCH_DIR)/util \
+        FORCE ;
+
+$(ARCH_DIR)/kernel/skas/util/mk_ptregs: $(ARCH_DIR)/kernel/skas/util FORCE ;
+
+$(ARCH_DIR)/util: scripts_basic $(SYS_DIR)/sc.h FORCE
+        $(Q)$(MAKE) $(build)=$@
+
+$(ARCH_DIR)/kernel/skas/util: scripts_basic FORCE
+        $(Q)$(MAKE) $(build)=$@
+
+$(ARCH_DIR)/os/util: scripts_basic FORCE
+        $(Q)$(MAKE) $(build)=$@
+
+export SUBARCH USER_CFLAGS OS
diff --git a/arch/um/Makefile-i386 b/arch/um/Makefile-i386
new file mode 100644
index 000000000000..97b223bfa78e
--- /dev/null
+++ b/arch/um/Makefile-i386
@@ -0,0 +1,44 @@
+SUBARCH_CORE := arch/um/sys-i386/
+
+TOP_ADDR := $(CONFIG_TOP_ADDR)
+
+ifeq ($(CONFIG_MODE_SKAS),y)
+  ifneq ($(CONFIG_MODE_TT),y)
+     START := 0x8048000
+  endif
+endif
+
+CFLAGS += -U__$(SUBARCH)__ -U$(SUBARCH)
+ARCH_USER_CFLAGS :=
+
+ifneq ($(CONFIG_GPROF),y)
+ARCH_CFLAGS += -DUM_FASTCALL
+endif
+
+ELF_ARCH := $(SUBARCH)
+ELF_FORMAT := elf32-$(SUBARCH)
+
+OBJCOPYFLAGS  := -O binary -R .note -R .comment -S
+
+SYS_UTIL_DIR    := $(ARCH_DIR)/sys-i386/util
+
+SYS_HEADERS := $(SYS_DIR)/sc.h $(SYS_DIR)/thread.h
+
+prepare: $(SYS_HEADERS)
+
+$(SYS_DIR)/sc.h: $(SYS_UTIL_DIR)/mk_sc
+        $(call filechk,gen_header)
+
+$(SYS_DIR)/thread.h: $(SYS_UTIL_DIR)/mk_thread 
+        $(call filechk,gen_header)
+
+$(SYS_UTIL_DIR)/mk_sc: scripts_basic FORCE
+        $(Q)$(MAKE) $(build)=$(SYS_UTIL_DIR) $@
+
+$(SYS_UTIL_DIR)/mk_thread: scripts_basic $(ARCH_SYMLINKS) $(GEN_HEADERS) FORCE
+        $(Q)$(MAKE) $(build)=$(SYS_UTIL_DIR) $@
+
+$(SYS_UTIL_DIR): scripts_basic include/asm FORCE
+        $(Q)$(MAKE) $(build)=$(SYS_UTIL_DIR)
+
+CLEAN_FILES += $(SYS_HEADERS)
diff --git a/arch/um/Makefile-ia64 b/arch/um/Makefile-ia64
new file mode 100644
index 000000000000..f84dc23b0f6e
--- /dev/null
+++ b/arch/um/Makefile-ia64
@@ -0,0 +1 @@
+START_ADDR = 0x1000000000000000
diff --git a/arch/um/Makefile-os-Linux b/arch/um/Makefile-os-Linux
new file mode 100644
index 000000000000..0c0f9a1cbbad
--- /dev/null
+++ b/arch/um/Makefile-os-Linux
@@ -0,0 +1,8 @@
+# 
+# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+# To get a definition of F_SETSIG
+USER_CFLAGS += -D_GNU_SOURCE -D_LARGEFILE64_SOURCE
+CFLAGS += -D_LARGEFILE64_SOURCE
diff --git a/arch/um/Makefile-ppc b/arch/um/Makefile-ppc
new file mode 100644
index 000000000000..66fd2003e165
--- /dev/null
+++ b/arch/um/Makefile-ppc
@@ -0,0 +1,9 @@
+ifeq ($(CONFIG_HOST_2G_2G), y)
+START_ADDR = 0x80000000
+else
+START_ADDR = 0xc0000000
+endif
+ARCH_CFLAGS = -U__powerpc__ -D__UM_PPC__
+
+# The arch is ppc, but the elf32 name is powerpc
+ELF_SUBARCH = powerpc
diff --git a/arch/um/Makefile-skas b/arch/um/Makefile-skas
new file mode 100644
index 000000000000..fd18ec572271
--- /dev/null
+++ b/arch/um/Makefile-skas
@@ -0,0 +1,14 @@
+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+GPROF_OPT += -pg
+GCOV_OPT += -fprofile-arcs -ftest-coverage
+
+CFLAGS-$(CONFIG_GCOV) += $(GCOV_OPT)
+CFLAGS-$(CONFIG_GPROF) += $(GPROF_OPT)
+LINK-$(CONFIG_GCOV) += $(GCOV_OPT)
+LINK-$(CONFIG_GPROF) += $(GPROF_OPT)
+
+GEN_HEADERS += $(ARCH_DIR)/include/skas_ptregs.h
diff --git a/arch/um/Makefile-tt b/arch/um/Makefile-tt
new file mode 100644
index 000000000000..03f7b10cfd0b
--- /dev/null
+++ b/arch/um/Makefile-tt
@@ -0,0 +1,5 @@
+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
diff --git a/arch/um/Makefile-x86_64 b/arch/um/Makefile-x86_64
new file mode 100644
index 000000000000..a77971133e91
--- /dev/null
+++ b/arch/um/Makefile-x86_64
@@ -0,0 +1,32 @@
+# Copyright 2003 - 2004 Pathscale, Inc
+# Released under the GPL
+
+SUBARCH_LIBS := arch/um/sys-x86_64/
+START := 0x60000000
+
+CFLAGS += -U__$(SUBARCH)__ -fno-builtin
+ARCH_USER_CFLAGS := -D__x86_64__
+
+ELF_ARCH := i386:x86-64
+ELF_FORMAT := elf64-x86-64
+
+SYS_UTIL_DIR := $(ARCH_DIR)/sys-x86_64/util
+SYS_DIR := $(ARCH_DIR)/include/sysdep-x86_64
+
+SYS_HEADERS = $(SYS_DIR)/sc.h $(SYS_DIR)/thread.h
+
+prepare: $(SYS_HEADERS)
+
+$(SYS_DIR)/sc.h: $(SYS_UTIL_DIR)/mk_sc
+        $(call filechk,gen_header)
+
+$(SYS_DIR)/thread.h: $(SYS_UTIL_DIR)/mk_thread
+        $(call filechk,gen_header)
+
+$(SYS_UTIL_DIR)/mk_sc: scripts_basic FORCE
+        $(Q)$(MAKE) $(build)=$(SYS_UTIL_DIR) $@
+
+$(SYS_UTIL_DIR)/mk_thread: scripts_basic $(ARCH_SYMLINKS) $(GEN_HEADERS) FORCE
+        $(Q)$(MAKE) $(build)=$(SYS_UTIL_DIR) $@
+
+CLEAN_FILES += $(SYS_HEADERS)
diff --git a/arch/um/config.release b/arch/um/config.release
new file mode 100644
index 000000000000..fc68bcb9294e
--- /dev/null
+++ b/arch/um/config.release
@@ -0,0 +1,333 @@
+#
+# Automatically generated make config: don't edit
+#
+CONFIG_USERMODE=y
+# CONFIG_ISA is not set
+# CONFIG_SBUS is not set
+# CONFIG_PCI is not set
+CONFIG_UID16=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+
+#
+# General Setup
+#
+CONFIG_STDIO_CONSOLE=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_UNIX98_PTYS=y
+CONFIG_UNIX98_PTY_COUNT=256
+CONFIG_SSL=y
+CONFIG_HOSTFS=y
+CONFIG_MCONSOLE=y
+CONFIG_MAGIC_SYSRQ=y
+# CONFIG_HOST_2G_2G is not set
+# CONFIG_UML_SMP is not set
+# CONFIG_SMP is not set
+CONFIG_CON_ZERO_CHAN="fd:0,fd:1"
+CONFIG_CON_CHAN="xterm"
+CONFIG_SSL_CHAN="pty"
+CONFIG_NEST_LEVEL=0
+CONFIG_KERNEL_HALF_GIGS=1
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_KMOD=y
+
+#
+# Devices
+#
+CONFIG_BLK_DEV_UBD=y
+# CONFIG_BLK_DEV_UBD_SYNC is not set
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_NBD=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_SIZE=4096
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_MMAPPER is not set
+CONFIG_UML_SOUND=y
+CONFIG_SOUND=y
+CONFIG_HOSTAUDIO=y
+# CONFIG_UML_WATCHDOG is not set
+# CONFIG_TTY_LOG is not set
+CONFIG_FD_CHAN=y
+# CONFIG_NULL_CHAN is not set
+CONFIG_PORT_CHAN=y
+CONFIG_PTY_CHAN=y
+CONFIG_TTY_CHAN=y
+CONFIG_XTERM_CHAN=y
+
+#
+# Networking options
+#
+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_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_INET_ECN is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_IPV6 is not set
+# CONFIG_KHTTPD is not set
+# CONFIG_ATM is not set
+# CONFIG_VLAN_8021Q is not set
+
+#
+#  
+#
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_DECNET is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_LLC is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_NET_HW_FLOWCONTROL is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+
+#
+# Network device support
+#
+CONFIG_UML_NET=y
+CONFIG_UML_NET_ETHERTAP=y
+CONFIG_UML_NET_TUNTAP=y
+CONFIG_UML_NET_SLIP=y
+CONFIG_UML_NET_DAEMON=y
+CONFIG_UML_NET_MCAST=y
+CONFIG_NETDEVICES=y
+
+#
+# ARCnet devices
+#
+# CONFIG_ARCNET is not set
+CONFIG_DUMMY=y
+CONFIG_BONDING=m
+CONFIG_EQUALIZER=m
+CONFIG_TUN=y
+# CONFIG_ETHERTAP is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+# CONFIG_NET_ETHERNET is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+# CONFIG_MYRI_SBUS is not set
+# CONFIG_NS83820 is not set
+# CONFIG_HAMACHI is not set
+# CONFIG_YELLOWFIN is not set
+# CONFIG_SK98LIN is not set
+# CONFIG_FDDI is not set
+# CONFIG_HIPPI is not set
+CONFIG_PLIP=m
+CONFIG_PPP=m
+CONFIG_PPP_MULTILINK=y
+# CONFIG_PPP_FILTER is not set
+# CONFIG_PPP_ASYNC is not set
+CONFIG_PPP_SYNC_TTY=m
+CONFIG_PPP_DEFLATE=m
+CONFIG_PPP_BSDCOMP=m
+CONFIG_PPPOE=m
+CONFIG_SLIP=m
+CONFIG_SLIP_COMPRESSED=y
+CONFIG_SLIP_SMART=y
+# CONFIG_SLIP_MODE_SLIP6 is not set
+
+#
+# Wireless LAN (non-hamradio)
+#
+# CONFIG_NET_RADIO is not set
+
+#
+# Token Ring devices
+#
+# CONFIG_TR is not set
+# CONFIG_NET_FC is not set
+# CONFIG_RCPCI is not set
+CONFIG_SHAPER=m
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+
+#
+# File systems
+#
+CONFIG_QUOTA=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_ADFS_FS=m
+# CONFIG_ADFS_FS_RW is not set
+CONFIG_AFFS_FS=m
+CONFIG_HFS_FS=m
+CONFIG_BFS_FS=m
+CONFIG_EXT3_FS=y
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FAT_FS=y
+CONFIG_MSDOS_FS=y
+CONFIG_UMSDOS_FS=y
+CONFIG_VFAT_FS=y
+CONFIG_EFS_FS=m
+# CONFIG_JFFS_FS is not set
+# CONFIG_JFFS2_FS is not set
+CONFIG_CRAMFS=m
+CONFIG_TMPFS=y
+CONFIG_RAMFS=m
+CONFIG_ISO9660_FS=y
+# CONFIG_JOLIET is not set
+# CONFIG_ZISOFS is not set
+CONFIG_MINIX_FS=m
+CONFIG_VXFS_FS=m
+# CONFIG_NTFS_FS is not set
+# CONFIG_NTFS_RW is not set
+CONFIG_HPFS_FS=m
+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=m
+# CONFIG_QNX4FS_RW is not set
+CONFIG_ROMFS_FS=m
+CONFIG_EXT2_FS=y
+CONFIG_SYSV_FS=m
+CONFIG_UDF_FS=m
+CONFIG_UFS_FS=m
+# CONFIG_UFS_FS_WRITE is not set
+
+#
+# Network File Systems
+#
+# CONFIG_CODA_FS is not set
+# CONFIG_INTERMEZZO_FS is not set
+CONFIG_NFS_FS=y
+CONFIG_NFS_V3=y
+# CONFIG_ROOT_NFS is not set
+CONFIG_NFSD=y
+CONFIG_NFSD_V3=y
+CONFIG_SUNRPC=y
+CONFIG_LOCKD=y
+CONFIG_LOCKD_V4=y
+# CONFIG_SMB_FS is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_NCPFS_PACKET_SIGNING is not set
+# CONFIG_NCPFS_IOCTL_LOCKING is not set
+# CONFIG_NCPFS_STRONG is not set
+# CONFIG_NCPFS_NFS_NS is not set
+# CONFIG_NCPFS_OS2_NS is not set
+# CONFIG_NCPFS_SMALLDOS is not set
+# CONFIG_NCPFS_NLS is not set
+# CONFIG_NCPFS_EXTRAS is not set
+# CONFIG_ZISOFS_FS is not set
+CONFIG_ZLIB_FS_INFLATE=m
+
+#
+# Partition Types
+#
+# CONFIG_PARTITION_ADVANCED is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_SMB_NLS is not set
+CONFIG_NLS=y
+
+#
+# Native Language Support
+#
+CONFIG_NLS_DEFAULT="iso8859-1"
+# CONFIG_NLS_CODEPAGE_437 is not set
+# CONFIG_NLS_CODEPAGE_737 is not set
+# CONFIG_NLS_CODEPAGE_775 is not set
+# CONFIG_NLS_CODEPAGE_850 is not set
+# CONFIG_NLS_CODEPAGE_852 is not set
+# CONFIG_NLS_CODEPAGE_855 is not set
+# CONFIG_NLS_CODEPAGE_857 is not set
+# CONFIG_NLS_CODEPAGE_860 is not set
+# CONFIG_NLS_CODEPAGE_861 is not set
+# CONFIG_NLS_CODEPAGE_862 is not set
+# CONFIG_NLS_CODEPAGE_863 is not set
+# CONFIG_NLS_CODEPAGE_864 is not set
+# CONFIG_NLS_CODEPAGE_865 is not set
+# CONFIG_NLS_CODEPAGE_866 is not set
+# CONFIG_NLS_CODEPAGE_869 is not set
+# CONFIG_NLS_CODEPAGE_936 is not set
+# CONFIG_NLS_CODEPAGE_950 is not set
+# CONFIG_NLS_CODEPAGE_932 is not set
+# CONFIG_NLS_CODEPAGE_949 is not set
+# CONFIG_NLS_CODEPAGE_874 is not set
+# CONFIG_NLS_ISO8859_8 is not set
+# CONFIG_NLS_CODEPAGE_1250 is not set
+# CONFIG_NLS_CODEPAGE_1251 is not set
+# CONFIG_NLS_ISO8859_1 is not set
+# CONFIG_NLS_ISO8859_2 is not set
+# CONFIG_NLS_ISO8859_3 is not set
+# CONFIG_NLS_ISO8859_4 is not set
+# CONFIG_NLS_ISO8859_5 is not set
+# CONFIG_NLS_ISO8859_6 is not set
+# CONFIG_NLS_ISO8859_7 is not set
+# CONFIG_NLS_ISO8859_9 is not set
+# CONFIG_NLS_ISO8859_13 is not set
+# CONFIG_NLS_ISO8859_14 is not set
+# CONFIG_NLS_ISO8859_15 is not set
+# CONFIG_NLS_KOI8_R is not set
+# CONFIG_NLS_KOI8_U is not set
+# CONFIG_NLS_UTF8 is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+# CONFIG_MD is not set
+# CONFIG_BLK_DEV_MD is not set
+# CONFIG_MD_LINEAR is not set
+# CONFIG_MD_RAID0 is not set
+# CONFIG_MD_RAID1 is not set
+# CONFIG_MD_RAID5 is not set
+# CONFIG_MD_MULTIPATH is not set
+# CONFIG_BLK_DEV_LVM is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+# CONFIG_MTD is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_INFO is not set
+# CONFIG_PT_PROXY is not set
+# CONFIG_GPROF is not set
+# CONFIG_GCOV is not set
diff --git a/arch/um/defconfig b/arch/um/defconfig
new file mode 100644
index 000000000000..fc3075c589d8
--- /dev/null
+++ b/arch/um/defconfig
@@ -0,0 +1,417 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.12-rc1-bk1
+# Sun Mar 20 16:53:00 2005
+#
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_UML=y
+CONFIG_MMU=y
+CONFIG_UID16=y
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+
+#
+# UML-specific options
+#
+CONFIG_MODE_TT=y
+CONFIG_MODE_SKAS=y
+# CONFIG_64_BIT is not set
+CONFIG_TOP_ADDR=0xc0000000
+# CONFIG_3_LEVEL_PGTABLES is not set
+CONFIG_ARCH_HAS_SC_SIGNALS=y
+CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA=y
+CONFIG_LD_SCRIPT_STATIC=y
+CONFIG_NET=y
+CONFIG_BINFMT_ELF=y
+CONFIG_BINFMT_MISC=m
+CONFIG_HOSTFS=y
+CONFIG_MCONSOLE=y
+# CONFIG_MAGIC_SYSRQ is not set
+# CONFIG_HOST_2G_2G is not set
+# CONFIG_SMP is not set
+CONFIG_NEST_LEVEL=0
+CONFIG_KERNEL_HALF_GIGS=1
+# CONFIG_HIGHMEM is not set
+CONFIG_KERNEL_STACK_ORDER=2
+CONFIG_UML_REAL_TIME_CLOCK=y
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_CLEAN_COMPILE=y
+CONFIG_BROKEN_ON_SMP=y
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_POSIX_MQUEUE=y
+CONFIG_BSD_PROCESS_ACCT=y
+# CONFIG_BSD_PROCESS_ACCT_V3 is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+# CONFIG_HOTPLUG is not set
+CONFIG_KOBJECT_UEVENT=y
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+# CONFIG_EMBEDDED is not set
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_ALL is not set
+CONFIG_KALLSYMS_EXTRA_PASS=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SHMEM=y
+CONFIG_CC_ALIGN_FUNCTIONS=0
+CONFIG_CC_ALIGN_LABELS=0
+CONFIG_CC_ALIGN_LOOPS=0
+CONFIG_CC_ALIGN_JUMPS=0
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+CONFIG_OBSOLETE_MODPARM=y
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+CONFIG_KMOD=y
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+# CONFIG_FW_LOADER is not set
+# CONFIG_DEBUG_DRIVER is not set
+
+#
+# Character Devices
+#
+CONFIG_STDERR_CONSOLE=y
+CONFIG_STDIO_CONSOLE=y
+CONFIG_SSL=y
+CONFIG_NULL_CHAN=y
+CONFIG_PORT_CHAN=y
+CONFIG_PTY_CHAN=y
+CONFIG_TTY_CHAN=y
+CONFIG_XTERM_CHAN=y
+# CONFIG_NOCONFIG_CHAN is not set
+CONFIG_CON_ZERO_CHAN="fd:0,fd:1"
+CONFIG_CON_CHAN="xterm"
+CONFIG_SSL_CHAN="pty"
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+# CONFIG_WATCHDOG is not set
+CONFIG_UML_SOUND=m
+CONFIG_SOUND=m
+CONFIG_HOSTAUDIO=m
+CONFIG_UML_RANDOM=y
+
+#
+# Block devices
+#
+CONFIG_BLK_DEV_UBD=y
+CONFIG_BLK_DEV_UBD_SYNC=y
+CONFIG_BLK_DEV_COW_COMMON=y
+CONFIG_BLK_DEV_LOOP=m
+# CONFIG_BLK_DEV_CRYPTOLOOP is not set
+CONFIG_BLK_DEV_NBD=m
+# CONFIG_BLK_DEV_RAM is not set
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_LBD is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_ATA_OVER_ETH is not set
+CONFIG_NETDEVICES=y
+
+#
+# UML Network Devices
+#
+CONFIG_UML_NET=y
+CONFIG_UML_NET_ETHERTAP=y
+CONFIG_UML_NET_TUNTAP=y
+CONFIG_UML_NET_SLIP=y
+CONFIG_UML_NET_DAEMON=y
+CONFIG_UML_NET_MCAST=y
+CONFIG_UML_NET_SLIRP=y
+
+#
+# Networking support
+#
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+CONFIG_PACKET_MMAP=y
+# CONFIG_NETLINK_DEV is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_IP_TCPDIAG=y
+# CONFIG_IP_TCPDIAG_IPV6 is not set
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET 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
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+# CONFIG_NET_CLS_ROUTE is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+CONFIG_DUMMY=m
+# CONFIG_BONDING is not set
+# CONFIG_EQUALIZER is not set
+CONFIG_TUN=m
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+CONFIG_PPP=m
+# 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=m
+# CONFIG_SLIP_COMPRESSED is not set
+# CONFIG_SLIP_SMART is not set
+# CONFIG_SLIP_MODE_SLIP6 is not set
+# CONFIG_SHAPER is not set
+# CONFIG_NETCONSOLE is not set
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+# CONFIG_EXT2_FS_XATTR is not set
+CONFIG_EXT3_FS=y
+# CONFIG_EXT3_FS_XATTR is not set
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+CONFIG_REISERFS_FS=y
+# CONFIG_REISERFS_CHECK is not set
+# CONFIG_REISERFS_PROC_INFO is not set
+# CONFIG_REISERFS_FS_XATTR is not set
+# CONFIG_JFS_FS is not set
+
+#
+# XFS support
+#
+# CONFIG_XFS_FS is not set
+# CONFIG_MINIX_FS is not set
+# 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_DNOTIFY=y
+CONFIG_AUTOFS_FS=m
+CONFIG_AUTOFS4_FS=m
+
+#
+# CD-ROM/DVD Filesystems
+#
+CONFIG_ISO9660_FS=m
+CONFIG_JOLIET=y
+# CONFIG_ZISOFS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+# CONFIG_MSDOS_FS is not set
+# CONFIG_VFAT_FS is not set
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_KCORE=y
+CONFIG_SYSFS=y
+# CONFIG_DEVFS_FS is not set
+# CONFIG_DEVPTS_FS_XATTR is not set
+CONFIG_TMPFS=y
+# CONFIG_TMPFS_XATTR 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_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+
+#
+# Network File Systems
+#
+# CONFIG_NFS_FS is not set
+# CONFIG_NFSD 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_AFS_FS is not set
+
+#
+# Partition Types
+#
+# CONFIG_PARTITION_ADVANCED is not set
+CONFIG_MSDOS_PARTITION=y
+
+#
+# Native Language Support
+#
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="iso8859-1"
+# CONFIG_NLS_CODEPAGE_437 is not set
+# CONFIG_NLS_CODEPAGE_737 is not set
+# CONFIG_NLS_CODEPAGE_775 is not set
+# CONFIG_NLS_CODEPAGE_850 is not set
+# CONFIG_NLS_CODEPAGE_852 is not set
+# CONFIG_NLS_CODEPAGE_855 is not set
+# CONFIG_NLS_CODEPAGE_857 is not set
+# CONFIG_NLS_CODEPAGE_860 is not set
+# CONFIG_NLS_CODEPAGE_861 is not set
+# CONFIG_NLS_CODEPAGE_862 is not set
+# CONFIG_NLS_CODEPAGE_863 is not set
+# CONFIG_NLS_CODEPAGE_864 is not set
+# CONFIG_NLS_CODEPAGE_865 is not set
+# CONFIG_NLS_CODEPAGE_866 is not set
+# CONFIG_NLS_CODEPAGE_869 is not set
+# CONFIG_NLS_CODEPAGE_936 is not set
+# CONFIG_NLS_CODEPAGE_950 is not set
+# CONFIG_NLS_CODEPAGE_932 is not set
+# CONFIG_NLS_CODEPAGE_949 is not set
+# CONFIG_NLS_CODEPAGE_874 is not set
+# CONFIG_NLS_ISO8859_8 is not set
+# CONFIG_NLS_CODEPAGE_1250 is not set
+# CONFIG_NLS_CODEPAGE_1251 is not set
+# CONFIG_NLS_ASCII is not set
+# CONFIG_NLS_ISO8859_1 is not set
+# CONFIG_NLS_ISO8859_2 is not set
+# CONFIG_NLS_ISO8859_3 is not set
+# CONFIG_NLS_ISO8859_4 is not set
+# CONFIG_NLS_ISO8859_5 is not set
+# CONFIG_NLS_ISO8859_6 is not set
+# CONFIG_NLS_ISO8859_7 is not set
+# CONFIG_NLS_ISO8859_9 is not set
+# CONFIG_NLS_ISO8859_13 is not set
+# CONFIG_NLS_ISO8859_14 is not set
+# CONFIG_NLS_ISO8859_15 is not set
+# CONFIG_NLS_KOI8_R is not set
+# CONFIG_NLS_KOI8_U is not set
+# CONFIG_NLS_UTF8 is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+# CONFIG_CRYPTO is not set
+
+#
+# Hardware crypto devices
+#
+
+#
+# Library routines
+#
+# CONFIG_CRC_CCITT is not set
+CONFIG_CRC32=m
+# CONFIG_LIBCRC32C is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+# CONFIG_MD is not set
+# CONFIG_INPUT is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+CONFIG_DEBUG_KERNEL=y
+CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_KOBJECT is not set
+CONFIG_DEBUG_INFO=y
+# CONFIG_DEBUG_FS is not set
+CONFIG_FRAME_POINTER=y
+CONFIG_PT_PROXY=y
+# CONFIG_GPROF is not set
+# CONFIG_GCOV is not set
+# CONFIG_SYSCALL_DEBUG is not set
diff --git a/arch/um/drivers/Makefile b/arch/um/drivers/Makefile
new file mode 100644
index 000000000000..323f72c64cd2
--- /dev/null
+++ b/arch/um/drivers/Makefile
@@ -0,0 +1,46 @@
+# 
+# Copyright (C) 2000, 2002, 2003 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+# pcap is broken in 2.5 because kbuild doesn't allow pcap.a to be linked
+# in to pcap.o
+
+slip-objs := slip_kern.o slip_user.o
+slirp-objs := slirp_kern.o slirp_user.o
+daemon-objs := daemon_kern.o daemon_user.o
+mcast-objs := mcast_kern.o mcast_user.o
+#pcap-objs := pcap_kern.o pcap_user.o $(PCAP)
+net-objs := net_kern.o net_user.o
+mconsole-objs := mconsole_kern.o mconsole_user.o
+hostaudio-objs := hostaudio_kern.o
+ubd-objs := ubd_kern.o ubd_user.o
+port-objs := port_kern.o port_user.o
+harddog-objs := harddog_kern.o harddog_user.o
+
+obj-y := stdio_console.o fd.o chan_kern.o chan_user.o line.o
+obj-$(CONFIG_SSL) += ssl.o
+obj-$(CONFIG_STDERR_CONSOLE) += stderr_console.o
+
+obj-$(CONFIG_UML_NET_SLIP) += slip.o
+obj-$(CONFIG_UML_NET_SLIRP) += slirp.o
+obj-$(CONFIG_UML_NET_DAEMON) += daemon.o 
+obj-$(CONFIG_UML_NET_MCAST) += mcast.o 
+#obj-$(CONFIG_UML_NET_PCAP) += pcap.o $(PCAP)
+obj-$(CONFIG_UML_NET) += net.o 
+obj-$(CONFIG_MCONSOLE) += mconsole.o
+obj-$(CONFIG_MMAPPER) += mmapper_kern.o 
+obj-$(CONFIG_BLK_DEV_UBD) += ubd.o 
+obj-$(CONFIG_HOSTAUDIO) += hostaudio.o
+obj-$(CONFIG_NULL_CHAN) += null.o 
+obj-$(CONFIG_PORT_CHAN) += port.o
+obj-$(CONFIG_PTY_CHAN) += pty.o
+obj-$(CONFIG_TTY_CHAN) += tty.o 
+obj-$(CONFIG_XTERM_CHAN) += xterm.o xterm_kern.o
+obj-$(CONFIG_UML_WATCHDOG) += harddog.o
+obj-$(CONFIG_BLK_DEV_COW_COMMON) += cow_user.o
+obj-$(CONFIG_UML_RANDOM) += random.o
+
+USER_OBJS := fd.o null.o pty.o tty.o xterm.o
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
new file mode 100644
index 000000000000..1f77deb3fd23
--- /dev/null
+++ b/arch/um/drivers/chan_kern.c
@@ -0,0 +1,577 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/string.h>
+#include <linux/tty_flip.h>
+#include <asm/irq.h>
+#include "chan_kern.h"
+#include "user_util.h"
+#include "kern.h"
+#include "irq_user.h"
+#include "sigio.h"
+#include "line.h"
+#include "os.h"
+
+#ifdef CONFIG_NOCONFIG_CHAN
+static void *not_configged_init(char *str, int device, struct chan_opts *opts)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(NULL);
+}
+
+static int not_configged_open(int input, int output, int primary, void *data,
+                              char **dev_out)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-ENODEV);
+}
+
+static void not_configged_close(int fd, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+}
+
+static int not_configged_read(int fd, char *c_out, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_write(int fd, const char *buf, int len, void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_console_write(int fd, const char *buf, int len,
+                                       void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-EIO);
+}
+
+static int not_configged_window_size(int fd, void *data, unsigned short *rows,
+                                     unsigned short *cols)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+        return(-ENODEV);
+}
+
+static void not_configged_free(void *data)
+{
+        printk(KERN_ERR "Using a channel type which is configured out of "
+               "UML\n");
+}
+
+static struct chan_ops not_configged_ops = {
+        .init           = not_configged_init,
+        .open           = not_configged_open,
+        .close          = not_configged_close,
+        .read           = not_configged_read,
+        .write          = not_configged_write,
+        .console_write  = not_configged_console_write,
+        .window_size    = not_configged_window_size,
+        .free           = not_configged_free,
+        .winch          = 0,
+};
+#endif /* CONFIG_NOCONFIG_CHAN */
+
+void generic_close(int fd, void *unused)
+{
+        os_close_file(fd);
+}
+
+int generic_read(int fd, char *c_out, void *unused)
+{
+        int n;
+
+        n = os_read_file(fd, c_out, sizeof(*c_out));
+
+        if(n == -EAGAIN)
+                return(0);
+        else if(n == 0)
+                return(-EIO);
+        return(n);
+}
+
+/* XXX Trivial wrapper around os_write_file */
+
+int generic_write(int fd, const char *buf, int n, void *unused)
+{
+        return(os_write_file(fd, buf, n));
+}
+
+int generic_window_size(int fd, void *unused, unsigned short *rows_out,
+                        unsigned short *cols_out)
+{
+        int rows, cols;
+        int ret;
+
+        ret = os_window_size(fd, &rows, &cols);
+        if(ret < 0)
+                return(ret);
+
+        ret = ((*rows_out != rows) || (*cols_out != cols));
+
+        *rows_out = rows;
+        *cols_out = cols;
+
+        return(ret);
+}
+
+void generic_free(void *data)
+{
+        kfree(data);
+}
+
+static void tty_receive_char(struct tty_struct *tty, char ch)
+{
+        if(tty == NULL) return;
+
+        if(I_IXON(tty) && !I_IXOFF(tty) && !tty->raw) {
+                if(ch == STOP_CHAR(tty)){
+                        stop_tty(tty);
+                        return;
+                }
+                else if(ch == START_CHAR(tty)){
+                        start_tty(tty);
+                        return;
+                }
+        }
+
+        if((tty->flip.flag_buf_ptr == NULL) || 
+           (tty->flip.char_buf_ptr == NULL))
+                return;
+        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+}
+
+static int open_one_chan(struct chan *chan, int input, int output, int primary)
+{
+        int fd;
+
+        if(chan->opened) return(0);
+        if(chan->ops->open == NULL) fd = 0;
+        else fd = (*chan->ops->open)(input, output, primary, chan->data,
+                                     &chan->dev);
+        if(fd < 0) return(fd);
+        chan->fd = fd;
+
+        chan->opened = 1;
+        return(0);
+}
+
+int open_chan(struct list_head *chans)
+{
+        struct list_head *ele;
+        struct chan *chan;
+        int ret, err = 0;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                ret = open_one_chan(chan, chan->input, chan->output,
+                                    chan->primary);
+                if(chan->primary) err = ret;
+        }
+        return(err);
+}
+
+void chan_enable_winch(struct list_head *chans, struct tty_struct *tty)
+{
+        struct list_head *ele;
+        struct chan *chan;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(chan->primary && chan->output && chan->ops->winch){
+                        register_winch(chan->fd, tty);
+                        return;
+                }
+        }
+}
+
+void enable_chan(struct list_head *chans, struct tty_struct *tty)
+{
+        struct list_head *ele;
+        struct chan *chan;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(!chan->opened) continue;
+
+                line_setup_irq(chan->fd, chan->input, chan->output, tty);
+        }
+}
+
+void close_chan(struct list_head *chans)
+{
+        struct chan *chan;
+
+        /* Close in reverse order as open in case more than one of them
+         * refers to the same device and they save and restore that device's
+         * state.  Then, the first one opened will have the original state,
+         * so it must be the last closed.
+         */
+        list_for_each_entry_reverse(chan, chans, list) {
+                if(!chan->opened) continue;
+                if(chan->ops->close != NULL)
+                        (*chan->ops->close)(chan->fd, chan->data);
+                chan->opened = 0;
+                chan->fd = -1;
+        }
+}
+
+int write_chan(struct list_head *chans, const char *buf, int len, 
+               int write_irq)
+{
+        struct list_head *ele;
+        struct chan *chan = NULL;
+        int n, ret = 0;
+
+        list_for_each(ele, chans) {
+                chan = list_entry(ele, struct chan, list);
+                if (!chan->output || (chan->ops->write == NULL))
+                        continue;
+                n = chan->ops->write(chan->fd, buf, len, chan->data);
+                if (chan->primary) {
+                        ret = n;
+                        if ((ret == -EAGAIN) || ((ret >= 0) && (ret < len)))
+                                reactivate_fd(chan->fd, write_irq);
+                }
+        }
+        return(ret);
+}
+
+int console_write_chan(struct list_head *chans, const char *buf, int len)
+{
+        struct list_head *ele;
+        struct chan *chan;
+        int n, ret = 0;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(!chan->output || (chan->ops->console_write == NULL))
+                        continue;
+                n = chan->ops->console_write(chan->fd, buf, len, chan->data);
+                if(chan->primary) ret = n;
+        }
+        return(ret);
+}
+
+int console_open_chan(struct line *line, struct console *co, struct chan_opts *opts)
+{
+        if (!list_empty(&line->chan_list))
+                return 0;
+
+        if (0 != parse_chan_pair(line->init_str, &line->chan_list,
+                                 line->init_pri, co->index, opts))
+                return -1;
+        if (0 != open_chan(&line->chan_list))
+                return -1;
+        printk("Console initialized on /dev/%s%d\n",co->name,co->index);
+        return 0;
+}
+
+int chan_window_size(struct list_head *chans, unsigned short *rows_out,
+                      unsigned short *cols_out)
+{
+        struct list_head *ele;
+        struct chan *chan;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(chan->primary){
+                        if(chan->ops->window_size == NULL) return(0);
+                        return(chan->ops->window_size(chan->fd, chan->data,
+                                                      rows_out, cols_out));
+                }
+        }
+        return(0);
+}
+
+void free_one_chan(struct chan *chan)
+{
+        list_del(&chan->list);
+        if(chan->ops->free != NULL)
+                (*chan->ops->free)(chan->data);
+        free_irq_by_fd(chan->fd);
+        if(chan->primary && chan->output) ignore_sigio_fd(chan->fd);
+        kfree(chan);
+}
+
+void free_chan(struct list_head *chans)
+{
+        struct list_head *ele, *next;
+        struct chan *chan;
+
+        list_for_each_safe(ele, next, chans){
+                chan = list_entry(ele, struct chan, list);
+                free_one_chan(chan);
+        }
+}
+
+static int one_chan_config_string(struct chan *chan, char *str, int size,
+                                  char **error_out)
+{
+        int n = 0;
+
+        if(chan == NULL){
+                CONFIG_CHUNK(str, size, n, "none", 1);
+                return(n);
+        }
+
+        CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
+
+        if(chan->dev == NULL){
+                CONFIG_CHUNK(str, size, n, "", 1);
+                return(n);
+        }
+
+        CONFIG_CHUNK(str, size, n, ":", 0);
+        CONFIG_CHUNK(str, size, n, chan->dev, 0);
+
+        return(n);
+}
+
+static int chan_pair_config_string(struct chan *in, struct chan *out, 
+                                   char *str, int size, char **error_out)
+{
+        int n;
+
+        n = one_chan_config_string(in, str, size, error_out);
+        str += n;
+        size -= n;
+
+        if(in == out){
+                CONFIG_CHUNK(str, size, n, "", 1);
+                return(n);
+        }
+
+        CONFIG_CHUNK(str, size, n, ",", 1);
+        n = one_chan_config_string(out, str, size, error_out);
+        str += n;
+        size -= n;
+        CONFIG_CHUNK(str, size, n, "", 1);
+
+        return(n);
+}
+
+int chan_config_string(struct list_head *chans, char *str, int size, 
+                       char **error_out)
+{
+        struct list_head *ele;
+        struct chan *chan, *in = NULL, *out = NULL;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(!chan->primary)
+                        continue;
+                if(chan->input)
+                        in = chan;
+                if(chan->output)
+                        out = chan;
+        }
+
+        return(chan_pair_config_string(in, out, str, size, error_out));
+}
+
+struct chan_type {
+        char *key;
+        struct chan_ops *ops;
+};
+
+struct chan_type chan_table[] = {
+        { "fd", &fd_ops },
+
+#ifdef CONFIG_NULL_CHAN
+        { "null", &null_ops },
+#else
+        { "null", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_PORT_CHAN
+        { "port", &port_ops },
+#else
+        { "port", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_PTY_CHAN
+        { "pty", &pty_ops },
+        { "pts", &pts_ops },
+#else
+        { "pty", &not_configged_ops },
+        { "pts", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_TTY_CHAN
+        { "tty", &tty_ops },
+#else
+        { "tty", &not_configged_ops },
+#endif
+
+#ifdef CONFIG_XTERM_CHAN
+        { "xterm", &xterm_ops },
+#else
+        { "xterm", &not_configged_ops },
+#endif
+};
+
+static struct chan *parse_chan(char *str, int pri, int device, 
+                               struct chan_opts *opts)
+{
+        struct chan_type *entry;
+        struct chan_ops *ops;
+        struct chan *chan;
+        void *data;
+        int i;
+
+        ops = NULL;
+        data = NULL;
+        for(i = 0; i < sizeof(chan_table)/sizeof(chan_table[0]); i++){
+                entry = &chan_table[i];
+                if(!strncmp(str, entry->key, strlen(entry->key))){
+                        ops = entry->ops;
+                        str += strlen(entry->key);
+                        break;
+                }
+        }
+        if(ops == NULL){
+                printk(KERN_ERR "parse_chan couldn't parse \"%s\"\n", 
+                       str);
+                return(NULL);
+        }
+        if(ops->init == NULL) return(NULL); 
+        data = (*ops->init)(str, device, opts);
+        if(data == NULL) return(NULL);
+
+        chan = kmalloc(sizeof(*chan), GFP_KERNEL);
+        if(chan == NULL) return(NULL);
+        *chan = ((struct chan) { .list          = LIST_HEAD_INIT(chan->list),
+                                 .primary       = 1,
+                                 .input         = 0,
+                                 .output        = 0,
+                                 .opened        = 0,
+                                 .fd            = -1,
+                                 .pri           = pri,
+                                 .ops           = ops,
+                                 .data          = data });
+        return(chan);
+}
+
+int parse_chan_pair(char *str, struct list_head *chans, int pri, int device,
+                    struct chan_opts *opts)
+{
+        struct chan *new, *chan;
+        char *in, *out;
+
+        if(!list_empty(chans)){
+                chan = list_entry(chans->next, struct chan, list);
+                if(chan->pri >= pri) return(0);
+                free_chan(chans);
+                INIT_LIST_HEAD(chans);
+        }
+
+        out = strchr(str, ',');
+        if(out != NULL){
+                in = str;
+                *out = '\0';
+                out++;
+                new = parse_chan(in, pri, device, opts);
+                if(new == NULL) return(-1);
+                new->input = 1;
+                list_add(&new->list, chans);
+
+                new = parse_chan(out, pri, device, opts);
+                if(new == NULL) return(-1);
+                list_add(&new->list, chans);
+                new->output = 1;
+        }
+        else {
+                new = parse_chan(str, pri, device, opts);
+                if(new == NULL) return(-1);
+                list_add(&new->list, chans);
+                new->input = 1;
+                new->output = 1;
+        }
+        return(0);
+}
+
+int chan_out_fd(struct list_head *chans)
+{
+        struct list_head *ele;
+        struct chan *chan;
+
+        list_for_each(ele, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(chan->primary && chan->output)
+                        return(chan->fd);
+        }
+        return(-1);
+}
+
+void chan_interrupt(struct list_head *chans, struct work_struct *task,
+                    struct tty_struct *tty, int irq)
+{
+        struct list_head *ele, *next;
+        struct chan *chan;
+        int err;
+        char c;
+
+        list_for_each_safe(ele, next, chans){
+                chan = list_entry(ele, struct chan, list);
+                if(!chan->input || (chan->ops->read == NULL)) continue;
+                do {
+                        if((tty != NULL) && 
+                           (tty->flip.count >= TTY_FLIPBUF_SIZE)){
+                                schedule_work(task);
+                                goto out;
+                        }
+                        err = chan->ops->read(chan->fd, &c, chan->data);
+                        if(err > 0)
+                                tty_receive_char(tty, c);
+                } while(err > 0);
+
+                if(err == 0) reactivate_fd(chan->fd, irq);
+                if(err == -EIO){
+                        if(chan->primary){
+                                if(tty != NULL)
+                                        tty_hangup(tty);
+                                line_disable(tty, irq);
+                                close_chan(chans);
+                                free_chan(chans);
+                                return;
+                        }
+                        else {
+                                if(chan->ops->close != NULL)
+                                        chan->ops->close(chan->fd, chan->data);
+                                free_one_chan(chan);
+                        }
+                }
+        }
+ out:
+        if(tty) tty_flip_buffer_push(tty);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
new file mode 100644
index 000000000000..583b8e137c33
--- /dev/null
+++ b/arch/um/drivers/chan_user.c
@@ -0,0 +1,210 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <termios.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include "kern_util.h"
+#include "user_util.h"
+#include "chan_user.h"
+#include "user.h"
+#include "helper.h"
+#include "os.h"
+#include "choose-mode.h"
+#include "mode.h"
+
+int generic_console_write(int fd, const char *buf, int n, void *unused)
+{
+        struct termios save, new;
+        int err;
+
+        if(isatty(fd)){
+                CATCH_EINTR(err = tcgetattr(fd, &save));
+                if (err)
+                        goto error;
+                new = save;
+                /* The terminal becomes a bit less raw, to handle \n also as
+                 * "Carriage Return", not only as "New Line". Otherwise, the new
+                 * line won't start at the first column.*/
+                new.c_oflag |= OPOST;
+                CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &new));
+                if (err)
+                        goto error;
+        }
+        err = generic_write(fd, buf, n, NULL);
+        /* Restore raw mode, in any case; we *must* ignore any error apart
+         * EINTR, except for debug.*/
+        if(isatty(fd))
+                CATCH_EINTR(tcsetattr(fd, TCSAFLUSH, &save));
+        return(err);
+error:
+        return(-errno);
+}
+
+/*
+ * UML SIGWINCH handling
+ *
+ * The point of this is to handle SIGWINCH on consoles which have host ttys and
+ * relay them inside UML to whatever might be running on the console and cares
+ * about the window size (since SIGWINCH notifies about terminal size changes).
+ *
+ * So, we have a separate thread for each host tty attached to a UML device
+ * (side-issue - I'm annoyed that one thread can't have multiple controlling
+ * ttys for purposed of handling SIGWINCH, but I imagine there are other reasons
+ * that doesn't make any sense).
+ *
+ * SIGWINCH can't be received synchronously, so you have to set up to receive it
+ * as a signal.  That being the case, if you are going to wait for it, it is
+ * convenient to sit in a pause() and wait for the signal to bounce you out of
+ * it (see below for how we make sure to exit only on SIGWINCH).
+ */
+
+static void winch_handler(int sig)
+{
+}
+
+struct winch_data {
+        int pty_fd;
+        int pipe_fd;
+        int close_me;
+};
+
+static int winch_thread(void *arg)
+{
+        struct winch_data *data = arg;
+        sigset_t sigs;
+        int pty_fd, pipe_fd;
+        int count, err;
+        char c = 1;
+
+        os_close_file(data->close_me);
+        pty_fd = data->pty_fd;
+        pipe_fd = data->pipe_fd;
+        count = os_write_file(pipe_fd, &c, sizeof(c));
+        if(count != sizeof(c))
+                printk("winch_thread : failed to write synchronization "
+                       "byte, err = %d\n", -count);
+
+        /* We are not using SIG_IGN on purpose, so don't fix it as I thought to
+         * do! If using SIG_IGN, the pause() call below would not stop on
+         * SIGWINCH. */
+
+        signal(SIGWINCH, winch_handler);
+        sigfillset(&sigs);
+        sigdelset(&sigs, SIGWINCH);
+        /* Block anything else than SIGWINCH. */
+        if(sigprocmask(SIG_SETMASK, &sigs, NULL) < 0){
+                printk("winch_thread : sigprocmask failed, errno = %d\n", 
+                       errno);
+                exit(1);
+        }
+
+        if(setsid() < 0){
+                printk("winch_thread : setsid failed, errno = %d\n", errno);
+                exit(1);
+        }
+
+        err = os_new_tty_pgrp(pty_fd, os_getpid());
+        if(err < 0){
+                printk("winch_thread : new_tty_pgrp failed, err = %d\n", -err);
+                exit(1);
+        }
+
+        /* These are synchronization calls between various UML threads on the
+         * host - since they are not different kernel threads, we cannot use
+         * kernel semaphores. We don't use SysV semaphores because they are
+         * persistant. */
+        count = os_read_file(pipe_fd, &c, sizeof(c));
+        if(count != sizeof(c))
+                printk("winch_thread : failed to read synchronization byte, "
+                       "err = %d\n", -count);
+
+        while(1){
+                /* This will be interrupted by SIGWINCH only, since other signals
+                 * are blocked.*/
+                pause();
+
+                count = os_write_file(pipe_fd, &c, sizeof(c));
+                if(count != sizeof(c))
+                        printk("winch_thread : write failed, err = %d\n",
+                               -count);
+        }
+}
+
+static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out)
+{
+        struct winch_data data;
+        unsigned long stack;
+        int fds[2], pid, n, err;
+        char c;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("winch_tramp : os_pipe failed, err = %d\n", -err);
+                return(err);
+        }
+
+        data = ((struct winch_data) { .pty_fd           = fd,
+                                      .pipe_fd          = fds[1],
+                                      .close_me         = fds[0] } );
+        pid = run_helper_thread(winch_thread, &data, 0, &stack, 0);
+        if(pid < 0){
+                printk("fork of winch_thread failed - errno = %d\n", errno);
+                return(pid);
+        }
+
+        os_close_file(fds[1]);
+        *fd_out = fds[0];
+        n = os_read_file(fds[0], &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("winch_tramp : failed to read synchronization byte\n");
+                printk("read failed, err = %d\n", -n);
+                printk("fd %d will not support SIGWINCH\n", fd);
+                *fd_out = -1;
+        }
+        return(pid);
+}
+
+void register_winch(int fd, struct tty_struct *tty)
+{
+        int pid, thread, thread_fd;
+        int count;
+        char c = 1;
+
+        if(!isatty(fd))
+                return;
+
+        pid = tcgetpgrp(fd);
+        if(!CHOOSE_MODE_PROC(is_tracer_winch, is_skas_winch, pid, fd,
+                             tty) && (pid == -1)){
+                thread = winch_tramp(fd, tty, &thread_fd);
+                if(fd != -1){
+                        register_winch_irq(thread_fd, fd, thread, tty);
+
+                        count = os_write_file(thread_fd, &c, sizeof(c));
+                        if(count != sizeof(c))
+                                printk("register_winch : failed to write "
+                                       "synchronization byte, err = %d\n",
+                                        -count);
+                }
+        }
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/cow.h b/arch/um/drivers/cow.h
new file mode 100644
index 000000000000..4fcbe8b1b77e
--- /dev/null
+++ b/arch/um/drivers/cow.h
@@ -0,0 +1,42 @@
+#ifndef __COW_H__
+#define __COW_H__
+
+#include <asm/types.h>
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+# define ntohll(x) (x)
+# define htonll(x) (x)
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+# define ntohll(x)  bswap_64(x)
+# define htonll(x)  bswap_64(x)
+#else
+#error "__BYTE_ORDER not defined"
+#endif
+
+extern int init_cow_file(int fd, char *cow_file, char *backing_file,
+                         int sectorsize, int alignment, int *bitmap_offset_out,
+                         unsigned long *bitmap_len_out, int *data_offset_out);
+
+extern int file_reader(__u64 offset, char *buf, int len, void *arg);
+extern int read_cow_header(int (*reader)(__u64, char *, int, void *),
+                           void *arg, __u32 *version_out,
+                           char **backing_file_out, time_t *mtime_out,
+                           unsigned long long *size_out, int *sectorsize_out,
+                           __u32 *align_out, int *bitmap_offset_out);
+
+extern int write_cow_header(char *cow_file, int fd, char *backing_file,
+                            int sectorsize, int alignment,
+                            unsigned long long *size);
+
+extern void cow_sizes(int version, __u64 size, int sectorsize, int align,
+                      int bitmap_offset, unsigned long *bitmap_len_out,
+                      int *data_offset_out);
+
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/cow_sys.h b/arch/um/drivers/cow_sys.h
new file mode 100644
index 000000000000..c83fc5d68936
--- /dev/null
+++ b/arch/um/drivers/cow_sys.h
@@ -0,0 +1,48 @@
+#ifndef __COW_SYS_H__
+#define __COW_SYS_H__
+
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+#include "user.h"
+
+static inline void *cow_malloc(int size)
+{
+        return(um_kmalloc(size));
+}
+
+static inline void cow_free(void *ptr)
+{
+        kfree(ptr);
+}
+
+#define cow_printf printk
+
+static inline char *cow_strdup(char *str)
+{
+        return(uml_strdup(str));
+}
+
+static inline int cow_seek_file(int fd, unsigned long long offset)
+{
+        return(os_seek_file(fd, offset));
+}
+
+static inline int cow_file_size(char *file, unsigned long long *size_out)
+{
+        return(os_file_size(file, size_out));
+}
+
+static inline int cow_write_file(int fd, char *buf, int size)
+{
+        return(os_write_file(fd, buf, size));
+}
+
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/cow_user.c b/arch/um/drivers/cow_user.c
new file mode 100644
index 000000000000..a8ce6fc3ef26
--- /dev/null
+++ b/arch/um/drivers/cow_user.c
@@ -0,0 +1,378 @@
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+/* _XOPEN_SOURCE is needed for pread, but we define _GNU_SOURCE, which defines
+ * that.
+ */
+#include <unistd.h>
+#include <byteswap.h>
+#include <sys/time.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <netinet/in.h>
+
+#include "os.h"
+
+#include "cow.h"
+#include "cow_sys.h"
+
+#define PATH_LEN_V1 256
+
+struct cow_header_v1 {
+        int magic;
+        int version;
+        char backing_file[PATH_LEN_V1];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+#define PATH_LEN_V2 MAXPATHLEN
+
+struct cow_header_v2 {
+        __u32 magic;
+        __u32 version;
+        char backing_file[PATH_LEN_V2];
+        time_t mtime;
+        __u64 size;
+        int sectorsize;
+};
+
+/* Define PATH_LEN_V3 as the usual value of MAXPATHLEN, just hard-code it in
+ * case other systems have different values for MAXPATHLEN
+ */
+#define PATH_LEN_V3 4096
+
+/* Changes from V2 -
+ *      PATH_LEN_V3 as described above
+ *      Explicitly specify field bit lengths for systems with different
+ *              lengths for the usual C types.  Not sure whether char or
+ *              time_t should be changed, this can be changed later without
+ *              breaking compatibility
+ *      Add alignment field so that different alignments can be used for the
+ *              bitmap and data
+ *      Add cow_format field to allow for the possibility of different ways
+ *              of specifying the COW blocks.  For now, the only value is 0,
+ *              for the traditional COW bitmap.
+ *      Move the backing_file field to the end of the header.  This allows
+ *              for the possibility of expanding it into the padding required
+ *              by the bitmap alignment.
+ *      The bitmap and data portions of the file will be aligned as specified
+ *              by the alignment field.  This is to allow COW files to be
+ *              put on devices with restrictions on access alignments, such as
+ *              /dev/raw, with a 512 byte alignment restriction.  This also
+ *              allows the data to be more aligned more strictly than on
+ *              sector boundaries.  This is needed for ubd-mmap, which needs
+ *              the data to be page aligned.
+ *      Fixed (finally!) the rounding bug
+ */
+
+struct cow_header_v3 {
+        __u32 magic;
+        __u32 version;
+        __u32 mtime;
+        __u64 size;
+        __u32 sectorsize;
+        __u32 alignment;
+        __u32 cow_format;
+        char backing_file[PATH_LEN_V3];
+};
+
+/* COW format definitions - for now, we have only the usual COW bitmap */
+#define COW_BITMAP 0
+
+union cow_header {
+        struct cow_header_v1 v1;
+        struct cow_header_v2 v2;
+        struct cow_header_v3 v3;
+};
+
+#define COW_MAGIC 0x4f4f4f4d  /* MOOO */
+#define COW_VERSION 3
+
+#define DIV_ROUND(x, len) (((x) + (len) - 1) / (len))
+#define ROUND_UP(x, align) DIV_ROUND(x, align) * (align)
+
+void cow_sizes(int version, __u64 size, int sectorsize, int align,
+               int bitmap_offset, unsigned long *bitmap_len_out,
+               int *data_offset_out)
+{
+        if(version < 3){
+                *bitmap_len_out = (size + sectorsize - 1) / (8 * sectorsize);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = (*data_offset_out + sectorsize - 1) /
+                        sectorsize;
+                *data_offset_out *= sectorsize;
+        }
+        else {
+                *bitmap_len_out = DIV_ROUND(size, sectorsize);
+                *bitmap_len_out = DIV_ROUND(*bitmap_len_out, 8);
+
+                *data_offset_out = bitmap_offset + *bitmap_len_out;
+                *data_offset_out = ROUND_UP(*data_offset_out, align);
+        }
+}
+
+static int absolutize(char *to, int size, char *from)
+{
+        char save_cwd[256], *slash;
+        int remaining;
+
+        if(getcwd(save_cwd, sizeof(save_cwd)) == NULL) {
+                cow_printf("absolutize : unable to get cwd - errno = %d\n",
+                           errno);
+                return(-1);
+        }
+        slash = strrchr(from, '/');
+        if(slash != NULL){
+                *slash = '\0';
+                if(chdir(from)){
+                        *slash = '/';
+                        cow_printf("absolutize : Can't cd to '%s' - "
+                                   "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                *slash = '/';
+                if(getcwd(to, size) == NULL){
+                        cow_printf("absolutize : unable to get cwd of '%s' - "
+                               "errno = %d\n", from, errno);
+                        return(-1);
+                }
+                remaining = size - strlen(to);
+                if(strlen(slash) + 1 > remaining){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcat(to, slash);
+        }
+        else {
+                if(strlen(save_cwd) + 1 + strlen(from) + 1 > size){
+                        cow_printf("absolutize : unable to fit '%s' into %d "
+                               "chars\n", from, size);
+                        return(-1);
+                }
+                strcpy(to, save_cwd);
+                strcat(to, "/");
+                strcat(to, from);
+        }
+        chdir(save_cwd);
+        return(0);
+}
+
+int write_cow_header(char *cow_file, int fd, char *backing_file,
+                     int sectorsize, int alignment, unsigned long long *size)
+{
+        struct cow_header_v3 *header;
+        unsigned long modtime;
+        int err;
+
+        err = cow_seek_file(fd, 0);
+        if(err < 0){
+                cow_printf("write_cow_header - lseek failed, err = %d\n", -err);
+                goto out;
+        }
+
+        err = -ENOMEM;
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("Failed to allocate COW V3 header\n");
+                goto out;
+        }
+        header->magic = htonl(COW_MAGIC);
+        header->version = htonl(COW_VERSION);
+
+        err = -EINVAL;
+        if(strlen(backing_file) > sizeof(header->backing_file) - 1){
+                cow_printf("Backing file name \"%s\" is too long - names are "
+                           "limited to %d characters\n", backing_file,
+                           sizeof(header->backing_file) - 1);
+                goto out_free;
+        }
+
+        if(absolutize(header->backing_file, sizeof(header->backing_file),
+                      backing_file))
+                goto out_free;
+
+        err = os_file_modtime(header->backing_file, &modtime);
+        if(err < 0){
+                cow_printf("Backing file '%s' mtime request failed, "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        err = cow_file_size(header->backing_file, size);
+        if(err < 0){
+                cow_printf("Couldn't get size of backing file '%s', "
+                           "err = %d\n", header->backing_file, -err);
+                goto out_free;
+        }
+
+        header->mtime = htonl(modtime);
+        header->size = htonll(*size);
+        header->sectorsize = htonl(sectorsize);
+        header->alignment = htonl(alignment);
+        header->cow_format = COW_BITMAP;
+
+        err = os_write_file(fd, header, sizeof(*header));
+        if(err != sizeof(*header)){
+                cow_printf("Write of header to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                goto out_free;
+        }
+        err = 0;
+ out_free:
+        cow_free(header);
+ out:
+        return(err);
+}
+
+int file_reader(__u64 offset, char *buf, int len, void *arg)
+{
+        int fd = *((int *) arg);
+
+        return(pread(fd, buf, len, offset));
+}
+
+/* XXX Need to sanity-check the values read from the header */
+
+int read_cow_header(int (*reader)(__u64, char *, int, void *), void *arg,
+                    __u32 *version_out, char **backing_file_out,
+                    time_t *mtime_out, unsigned long long *size_out,
+                    int *sectorsize_out, __u32 *align_out,
+                    int *bitmap_offset_out)
+{
+        union cow_header *header;
+        char *file;
+        int err, n;
+        unsigned long version, magic;
+
+        header = cow_malloc(sizeof(*header));
+        if(header == NULL){
+                cow_printf("read_cow_header - Failed to allocate header\n");
+                return(-ENOMEM);
+        }
+        err = -EINVAL;
+        n = (*reader)(0, (char *) header, sizeof(*header), arg);
+        if(n < offsetof(typeof(header->v1), backing_file)){
+                cow_printf("read_cow_header - short header\n");
+                goto out;
+        }
+
+        magic = header->v1.magic;
+        if(magic == COW_MAGIC) {
+                version = header->v1.version;
+        }
+        else if(magic == ntohl(COW_MAGIC)){
+                version = ntohl(header->v1.version);
+        }
+        /* No error printed because the non-COW case comes through here */
+        else goto out;
+
+        *version_out = version;
+
+        if(version == 1){
+                if(n < sizeof(header->v1)){
+                        cow_printf("read_cow_header - failed to read V1 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = header->v1.mtime;
+                *size_out = header->v1.size;
+                *sectorsize_out = header->v1.sectorsize;
+                *bitmap_offset_out = sizeof(header->v1);
+                *align_out = *sectorsize_out;
+                file = header->v1.backing_file;
+        }
+        else if(version == 2){
+                if(n < sizeof(header->v2)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v2.mtime);
+                *size_out = ntohll(header->v2.size);
+                *sectorsize_out = ntohl(header->v2.sectorsize);
+                *bitmap_offset_out = sizeof(header->v2);
+                *align_out = *sectorsize_out;
+                file = header->v2.backing_file;
+        }
+        else if(version == 3){
+                if(n < sizeof(header->v3)){
+                        cow_printf("read_cow_header - failed to read V2 "
+                                   "header\n");
+                        goto out;
+                }
+                *mtime_out = ntohl(header->v3.mtime);
+                *size_out = ntohll(header->v3.size);
+                *sectorsize_out = ntohl(header->v3.sectorsize);
+                *align_out = ntohl(header->v3.alignment);
+                *bitmap_offset_out = ROUND_UP(sizeof(header->v3), *align_out);
+                file = header->v3.backing_file;
+        }
+        else {
+                cow_printf("read_cow_header - invalid COW version\n");
+                goto out;
+        }
+        err = -ENOMEM;
+        *backing_file_out = cow_strdup(file);
+        if(*backing_file_out == NULL){
+                cow_printf("read_cow_header - failed to allocate backing "
+                           "file\n");
+                goto out;
+        }
+        err = 0;
+ out:
+        cow_free(header);
+        return(err);
+}
+
+int init_cow_file(int fd, char *cow_file, char *backing_file, int sectorsize,
+                  int alignment, int *bitmap_offset_out,
+                  unsigned long *bitmap_len_out, int *data_offset_out)
+{
+        unsigned long long size, offset;
+        char zero = 0;
+        int err;
+
+        err = write_cow_header(cow_file, fd, backing_file, sectorsize,
+                               alignment, &size);
+        if(err)
+                goto out;
+
+        *bitmap_offset_out = ROUND_UP(sizeof(struct cow_header_v3), alignment);
+        cow_sizes(COW_VERSION, size, sectorsize, alignment, *bitmap_offset_out,
+                  bitmap_len_out, data_offset_out);
+
+        offset = *data_offset_out + size - sizeof(zero);
+        err = cow_seek_file(fd, offset);
+        if(err < 0){
+                cow_printf("cow bitmap lseek failed : err = %d\n", -err);
+                goto out;
+        }
+
+        /* does not really matter how much we write it is just to set EOF
+         * this also sets the entire COW bitmap
+         * to zero without having to allocate it
+         */
+        err = cow_write_file(fd, &zero, sizeof(zero));
+        if(err != sizeof(zero)){
+                cow_printf("Write of bitmap to new COW file '%s' failed, "
+                           "err = %d\n", cow_file, -err);
+                err = -EINVAL;
+                goto out;
+        }
+
+        return(0);
+
+ out:
+        return(err);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/daemon.h b/arch/um/drivers/daemon.h
new file mode 100644
index 000000000000..7326c42f7ef9
--- /dev/null
+++ b/arch/um/drivers/daemon.h
@@ -0,0 +1,35 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+#define SWITCH_VERSION 3
+
+struct daemon_data {
+        char *sock_type;
+        char *ctl_sock;
+        void *ctl_addr;
+        void *data_addr;
+        void *local_addr;
+        int fd;
+        int control;
+        void *dev;
+};
+
+extern struct net_user_info daemon_user_info;
+
+extern int daemon_user_write(int fd, void *buf, int len, 
+                             struct daemon_data *pri);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/daemon_kern.c b/arch/um/drivers/daemon_kern.c
new file mode 100644
index 000000000000..30d285b266af
--- /dev/null
+++ b/arch/um/drivers/daemon_kern.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include "linux/kernel.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "daemon.h"
+
+struct daemon_init {
+        char *sock_type;
+        char *ctl_sock;
+};
+
+void daemon_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct daemon_data *dpri;
+        struct daemon_init *init = data;
+
+        pri = dev->priv;
+        dpri = (struct daemon_data *) pri->user;
+        dpri->sock_type = init->sock_type;
+        dpri->ctl_sock = init->ctl_sock;
+        dpri->fd = -1;
+        dpri->control = -1;
+        dpri->dev = dev;
+
+        printk("daemon backend (uml_switch version %d) - %s:%s", 
+               SWITCH_VERSION, dpri->sock_type, dpri->ctl_sock);
+        printk("\n");
+}
+
+static int daemon_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(net_recvfrom(fd, (*skb)->mac.raw, 
+                            (*skb)->dev->mtu + ETH_HEADER_OTHER));
+}
+
+static int daemon_write(int fd, struct sk_buff **skb,
+                        struct uml_net_private *lp)
+{
+        return(daemon_user_write(fd, (*skb)->data, (*skb)->len, 
+                                 (struct daemon_data *) &lp->user));
+}
+
+static struct net_kern_info daemon_kern_info = {
+        .init                   = daemon_init,
+        .protocol               = eth_protocol,
+        .read                   = daemon_read,
+        .write                  = daemon_write,
+};
+
+int daemon_setup(char *str, char **mac_out, void *data)
+{
+        struct daemon_init *init = data;
+        char *remain;
+
+        *init = ((struct daemon_init)
+                { .sock_type            = "unix",
+                  .ctl_sock             = "/tmp/uml.ctl" });
+        
+        remain = split_if_spec(str, mac_out, &init->sock_type, &init->ctl_sock,
+                               NULL);
+        if(remain != NULL)
+                printk(KERN_WARNING "daemon_setup : Ignoring data socket "
+                       "specification\n");
+        
+        return(1);
+}
+
+static struct transport daemon_transport = {
+        .list           = LIST_HEAD_INIT(daemon_transport.list),
+        .name           = "daemon",
+        .setup          = daemon_setup,
+        .user           = &daemon_user_info,
+        .kern           = &daemon_kern_info,
+        .private_size   = sizeof(struct daemon_data),
+        .setup_size     = sizeof(struct daemon_init),
+};
+
+static int register_daemon(void)
+{
+        register_transport(&daemon_transport);
+        return(1);
+}
+
+__initcall(register_daemon);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
new file mode 100644
index 000000000000..cf15b4a8b517
--- /dev/null
+++ b/arch/um/drivers/daemon_user.c
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/time.h>
+#include "net_user.h"
+#include "daemon.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+enum request_type { REQ_NEW_CONTROL };
+
+#define SWITCH_MAGIC 0xfeedface
+
+struct request_v3 {
+        uint32_t magic;
+        uint32_t version;
+        enum request_type type;
+        struct sockaddr_un sock;
+};
+
+static struct sockaddr_un *new_addr(void *name, int len)
+{
+        struct sockaddr_un *sun;
+
+        sun = um_kmalloc(sizeof(struct sockaddr_un));
+        if(sun == NULL){
+                printk("new_addr: allocation of sockaddr_un failed\n");
+                return(NULL);
+        }
+        sun->sun_family = AF_UNIX;
+        memcpy(sun->sun_path, name, len);
+        return(sun);
+}
+
+static int connect_to_switch(struct daemon_data *pri)
+{
+        struct sockaddr_un *ctl_addr = pri->ctl_addr;
+        struct sockaddr_un *local_addr = pri->local_addr;
+        struct sockaddr_un *sun;
+        struct request_v3 req;
+        int fd, n, err;
+
+        pri->control = socket(AF_UNIX, SOCK_STREAM, 0);
+        if(pri->control < 0){
+                printk("daemon_open : control socket failed, errno = %d\n", 
+                       errno);          
+                return(-errno);
+        }
+
+        if(connect(pri->control, (struct sockaddr *) ctl_addr, 
+                   sizeof(*ctl_addr)) < 0){
+                printk("daemon_open : control connect failed, errno = %d\n",
+                       errno);
+                err = -errno;
+                goto out;
+        }
+
+        fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+        if(fd < 0){
+                printk("daemon_open : data socket failed, errno = %d\n", 
+                       errno);
+                err = -errno;
+                goto out;
+        }
+        if(bind(fd, (struct sockaddr *) local_addr, sizeof(*local_addr)) < 0){
+                printk("daemon_open : data bind failed, errno = %d\n", 
+                       errno);
+                err = -errno;
+                goto out_close;
+        }
+
+        sun = um_kmalloc(sizeof(struct sockaddr_un));
+        if(sun == NULL){
+                printk("new_addr: allocation of sockaddr_un failed\n");
+                err = -ENOMEM;
+                goto out_close;
+        }
+
+        req.magic = SWITCH_MAGIC;
+        req.version = SWITCH_VERSION;
+        req.type = REQ_NEW_CONTROL;
+        req.sock = *local_addr;
+        n = os_write_file(pri->control, &req, sizeof(req));
+        if(n != sizeof(req)){
+                printk("daemon_open : control setup request failed, err = %d\n",
+                       -n);
+                err = -ENOTCONN;
+                goto out;               
+        }
+
+        n = os_read_file(pri->control, sun, sizeof(*sun));
+        if(n != sizeof(*sun)){
+                printk("daemon_open : read of data socket failed, err = %d\n",
+                       -n);
+                err = -ENOTCONN;
+                goto out_close;         
+        }
+
+        pri->data_addr = sun;
+        return(fd);
+
+ out_close:
+        os_close_file(fd);
+ out:
+        os_close_file(pri->control);
+        return(err);
+}
+
+static void daemon_user_init(void *data, void *dev)
+{
+        struct daemon_data *pri = data;
+        struct timeval tv;
+        struct {
+                char zero;
+                int pid;
+                int usecs;
+        } name;
+
+        if(!strcmp(pri->sock_type, "unix"))
+                pri->ctl_addr = new_addr(pri->ctl_sock, 
+                                         strlen(pri->ctl_sock) + 1);
+        name.zero = 0;
+        name.pid = os_getpid();
+        gettimeofday(&tv, NULL);
+        name.usecs = tv.tv_usec;
+        pri->local_addr = new_addr(&name, sizeof(name));
+        pri->dev = dev;
+        pri->fd = connect_to_switch(pri);
+        if(pri->fd < 0){
+                kfree(pri->local_addr);
+                pri->local_addr = NULL;
+        }
+}
+
+static int daemon_open(void *data)
+{
+        struct daemon_data *pri = data;
+        return(pri->fd);
+}
+
+static void daemon_remove(void *data)
+{
+        struct daemon_data *pri = data;
+
+        os_close_file(pri->fd);
+        os_close_file(pri->control);
+        if(pri->data_addr != NULL) kfree(pri->data_addr);
+        if(pri->ctl_addr != NULL) kfree(pri->ctl_addr);
+        if(pri->local_addr != NULL) kfree(pri->local_addr);
+}
+
+int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
+{
+        struct sockaddr_un *data_addr = pri->data_addr;
+
+        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+}
+
+static int daemon_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info daemon_user_info = {
+        .init           = daemon_user_init,
+        .open           = daemon_open,
+        .close          = NULL,
+        .remove         = daemon_remove,
+        .set_mtu        = daemon_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
new file mode 100644
index 000000000000..f0b888f66e05
--- /dev/null
+++ b/arch/um/drivers/fd.c
@@ -0,0 +1,108 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <termios.h>
+#include <errno.h>
+#include "user.h"
+#include "user_util.h"
+#include "chan_user.h"
+
+struct fd_chan {
+        int fd;
+        int raw;
+        struct termios tt;
+        char str[sizeof("1234567890\0")];
+};
+
+static void *fd_init(char *str, int device, struct chan_opts *opts)
+{
+        struct fd_chan *data;
+        char *end;
+        int n;
+
+        if(*str != ':'){
+                printk("fd_init : channel type 'fd' must specify a file "
+                       "descriptor\n");
+                return(NULL);
+        }
+        str++;
+        n = strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str)){
+                printk("fd_init : couldn't parse file descriptor '%s'\n", str);
+                return(NULL);
+        }
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct fd_chan) { .fd         = n,
+                                    .raw        = opts->raw });
+        return(data);
+}
+
+static int fd_open(int input, int output, int primary, void *d, char **dev_out)
+{
+        struct fd_chan *data = d;
+        int err;
+
+        if(data->raw && isatty(data->fd)){
+                CATCH_EINTR(err = tcgetattr(data->fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(data->fd);
+                if(err)
+                        return(err);
+        }
+        sprintf(data->str, "%d", data->fd);
+        *dev_out = data->str;
+        return(data->fd);
+}
+
+static void fd_close(int fd, void *d)
+{
+        struct fd_chan *data = d;
+        int err;
+
+        if(data->raw && isatty(fd)){
+                CATCH_EINTR(err = tcsetattr(fd, TCSAFLUSH, &data->tt));
+                if(err)
+                        printk("Failed to restore terminal state - "
+                               "errno = %d\n", -err);
+                data->raw = 0;
+        }
+}
+
+static int fd_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct fd_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops fd_ops = {
+        .type           = "fd",
+        .init           = fd_init,
+        .open           = fd_open,
+        .close          = fd_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = fd_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 1,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/harddog_kern.c b/arch/um/drivers/harddog_kern.c
new file mode 100644
index 000000000000..147ec19f6bb9
--- /dev/null
+++ b/arch/um/drivers/harddog_kern.c
@@ -0,0 +1,190 @@
+/* UML hardware watchdog, shamelessly stolen from:
+ *
+ *      SoftDog 0.05:   A Software Watchdog Device
+ *
+ *      (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
+ *                              http://www.redhat.com
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ *      
+ *      Neither Alan Cox nor CymruNet Ltd. admit liability nor provide 
+ *      warranty for any of this software. This material is provided 
+ *      "AS-IS" and at no charge.       
+ *
+ *      (c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
+ *
+ *      Software only watchdog driver. Unlike its big brother the WDT501P
+ *      driver this won't always recover a failed machine.
+ *
+ *  03/96: Angelo Haritsis <ah@doc.ic.ac.uk> :
+ *      Modularised.
+ *      Added soft_margin; use upon insmod to change the timer delay.
+ *      NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
+ *          minors.
+ *
+ *  19980911 Alan Cox
+ *      Made SMP safe for 2.3.x
+ *
+ *  20011127 Joel Becker (jlbec@evilplan.org>
+ *      Added soft_noboot; Allows testing the softdog trigger without 
+ *      requiring a recompile.
+ *      Added WDIOC_GETTIMEOUT and WDIOC_SETTIMOUT.
+ */
+ 
+#include <linux/module.h>
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/reboot.h>
+#include <linux/smp_lock.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include "helper.h"
+#include "mconsole.h"
+
+MODULE_LICENSE("GPL");
+
+/* Locked by the BKL in harddog_open and harddog_release */
+static int timer_alive;
+static int harddog_in_fd = -1;
+static int harddog_out_fd = -1;
+
+/*
+ *      Allow only one person to hold it open
+ */
+ 
+extern int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock);
+
+static int harddog_open(struct inode *inode, struct file *file)
+{
+        int err;
+        char *sock = NULL;
+
+        lock_kernel();
+        if(timer_alive)
+                return -EBUSY;
+#ifdef CONFIG_HARDDOG_NOWAYOUT   
+        __module_get(THIS_MODULE);
+#endif
+
+#ifdef CONFIG_MCONSOLE
+        sock = mconsole_notify_socket();
+#endif
+        err = start_watchdog(&harddog_in_fd, &harddog_out_fd, sock);
+        if(err) return(err);
+
+        timer_alive = 1;
+        unlock_kernel();
+        return nonseekable_open(inode, file);
+}
+
+extern void stop_watchdog(int in_fd, int out_fd);
+
+static int harddog_release(struct inode *inode, struct file *file)
+{
+        /*
+         *      Shut off the timer.
+         */
+        lock_kernel();
+
+        stop_watchdog(harddog_in_fd, harddog_out_fd);
+        harddog_in_fd = -1;
+        harddog_out_fd = -1;
+
+        timer_alive=0;
+        unlock_kernel();
+        return 0;
+}
+
+extern int ping_watchdog(int fd);
+
+static ssize_t harddog_write(struct file *file, const char *data, size_t len,
+                             loff_t *ppos)
+{
+        /*
+         *      Refresh the timer.
+         */
+        if(len)
+                return(ping_watchdog(harddog_out_fd));
+        return 0;
+}
+
+static int harddog_ioctl(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg)
+{
+        static struct watchdog_info ident = {
+                WDIOC_SETTIMEOUT,
+                0,
+                "UML Hardware Watchdog"
+        };
+        switch (cmd) {
+                default:
+                        return -ENOTTY;
+                case WDIOC_GETSUPPORT:
+                        if(copy_to_user((struct harddog_info *)arg, &ident,
+                                        sizeof(ident)))
+                                return -EFAULT;
+                        return 0;
+                case WDIOC_GETSTATUS:
+                case WDIOC_GETBOOTSTATUS:
+                        return put_user(0,(int *)arg);
+                case WDIOC_KEEPALIVE:
+                        return(ping_watchdog(harddog_out_fd));
+        }
+}
+
+static struct file_operations harddog_fops = {
+        .owner          = THIS_MODULE,
+        .write          = harddog_write,
+        .ioctl          = harddog_ioctl,
+        .open           = harddog_open,
+        .release        = harddog_release,
+};
+
+static struct miscdevice harddog_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &harddog_fops,
+};
+
+static char banner[] __initdata = KERN_INFO "UML Watchdog Timer\n";
+
+static int __init harddog_init(void)
+{
+        int ret;
+
+        ret = misc_register(&harddog_miscdev);
+
+        if (ret)
+                return ret;
+
+        printk(banner);
+
+        return(0);
+}
+
+static void __exit harddog_exit(void)
+{
+        misc_deregister(&harddog_miscdev);
+}
+
+module_init(harddog_init);
+module_exit(harddog_exit);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/harddog_user.c b/arch/um/drivers/harddog_user.c
new file mode 100644
index 000000000000..d934181b8d4c
--- /dev/null
+++ b/arch/um/drivers/harddog_user.c
@@ -0,0 +1,143 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include "user_util.h"
+#include "user.h"
+#include "helper.h"
+#include "mconsole.h"
+#include "os.h"
+#include "choose-mode.h"
+#include "mode.h"
+
+struct dog_data {
+        int stdin;
+        int stdout;
+        int close_me[2];
+};
+
+static void pre_exec(void *d)
+{
+        struct dog_data *data = d;
+
+        dup2(data->stdin, 0);
+        dup2(data->stdout, 1);
+        dup2(data->stdout, 2);
+        os_close_file(data->stdin);
+        os_close_file(data->stdout);
+        os_close_file(data->close_me[0]);
+        os_close_file(data->close_me[1]);
+}
+
+int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock)
+{
+        struct dog_data data;
+        int in_fds[2], out_fds[2], pid, n, err;
+        char pid_buf[sizeof("nnnnn\0")], c;
+        char *pid_args[] = { "/usr/bin/uml_watchdog", "-pid", pid_buf, NULL };
+        char *mconsole_args[] = { "/usr/bin/uml_watchdog", "-mconsole", NULL, 
+                                  NULL };
+        char **args = NULL;
+
+        err = os_pipe(in_fds, 1, 0);
+        if(err < 0){
+                printk("harddog_open - os_pipe failed, err = %d\n", -err);
+                goto out;
+        }
+
+        err = os_pipe(out_fds, 1, 0);
+        if(err < 0){
+                printk("harddog_open - os_pipe failed, err = %d\n", -err);
+                goto out_close_in;
+        }
+
+        data.stdin = out_fds[0];
+        data.stdout = in_fds[1];
+        data.close_me[0] = out_fds[1];
+        data.close_me[1] = in_fds[0];
+
+        if(sock != NULL){
+                mconsole_args[2] = sock;
+                args = mconsole_args;
+        }
+        else {
+                /* XXX The os_getpid() is not SMP correct */
+                sprintf(pid_buf, "%d", CHOOSE_MODE(tracing_pid, os_getpid()));
+                args = pid_args;
+        }
+
+        pid = run_helper(pre_exec, &data, args, NULL);
+
+        os_close_file(out_fds[0]);
+        os_close_file(in_fds[1]);
+
+        if(pid < 0){
+                err = -pid;
+                printk("harddog_open - run_helper failed, errno = %d\n", -err);
+                goto out_close_out;
+        }
+
+        n = os_read_file(in_fds[0], &c, sizeof(c));
+        if(n == 0){
+                printk("harddog_open - EOF on watchdog pipe\n");
+                helper_wait(pid);
+                err = -EIO;
+                goto out_close_out;
+        }
+        else if(n < 0){
+                printk("harddog_open - read of watchdog pipe failed, "
+                       "err = %d\n", -n);
+                helper_wait(pid);
+                err = n;
+                goto out_close_out;
+        }
+        *in_fd_ret = in_fds[0];
+        *out_fd_ret = out_fds[1];
+        return(0);
+
+ out_close_in:
+        os_close_file(in_fds[0]);
+        os_close_file(in_fds[1]);
+ out_close_out:
+        os_close_file(out_fds[0]);
+        os_close_file(out_fds[1]);
+ out:
+        return(err);
+}
+
+void stop_watchdog(int in_fd, int out_fd)
+{
+        os_close_file(in_fd);
+        os_close_file(out_fd);
+}
+
+int ping_watchdog(int fd)
+{
+        int n;
+        char c = '\n';
+
+        n = os_write_file(fd, &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("ping_watchdog - write failed, err = %d\n", -n);
+                if(n < 0)
+                        return(n);
+                return(-EIO);
+        }
+        return 1;
+
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c
new file mode 100644
index 000000000000..d5742783e19d
--- /dev/null
+++ b/arch/um/drivers/hostaudio_kern.c
@@ -0,0 +1,352 @@
+/* 
+ * Copyright (C) 2002 Steve Schmidtke 
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/module.h"
+#include "linux/init.h"
+#include "linux/slab.h"
+#include "linux/fs.h"
+#include "linux/sound.h"
+#include "linux/soundcard.h"
+#include "asm/uaccess.h"
+#include "kern_util.h"
+#include "init.h"
+#include "os.h"
+
+struct hostaudio_state {
+  int fd;
+};
+
+struct hostmixer_state {
+  int fd;
+};
+
+#define HOSTAUDIO_DEV_DSP "/dev/sound/dsp"
+#define HOSTAUDIO_DEV_MIXER "/dev/sound/mixer"
+
+/* Only changed from linux_main at boot time */
+char *dsp = HOSTAUDIO_DEV_DSP;
+char *mixer = HOSTAUDIO_DEV_MIXER;
+
+#define DSP_HELP \
+"    This is used to specify the host dsp device to the hostaudio driver.\n" \
+"    The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n"
+
+#define MIXER_HELP \
+"    This is used to specify the host mixer device to the hostaudio driver.\n"\
+"    The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n"
+
+#ifndef MODULE
+static int set_dsp(char *name, int *add)
+{
+        dsp = name;
+        return(0);
+}
+
+__uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP);
+
+static int set_mixer(char *name, int *add)
+{
+        mixer = name;
+        return(0);
+}
+
+__uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP);
+
+#else /*MODULE*/
+
+MODULE_PARM(dsp, "s");
+MODULE_PARM_DESC(dsp, DSP_HELP);
+
+MODULE_PARM(mixer, "s");
+MODULE_PARM_DESC(mixer, MIXER_HELP);
+
+#endif
+
+/* /dev/dsp file operations */
+
+static ssize_t hostaudio_read(struct file *file, char *buffer, size_t count, 
+                              loff_t *ppos)
+{
+        struct hostaudio_state *state = file->private_data;
+        void *kbuf;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: read called, count = %d\n", count);
+#endif
+
+        kbuf = kmalloc(count, GFP_KERNEL);
+        if(kbuf == NULL)
+                return(-ENOMEM);
+
+        err = os_read_file(state->fd, kbuf, count);
+        if(err < 0)
+                goto out;
+
+        if(copy_to_user(buffer, kbuf, err))
+                err = -EFAULT;
+
+ out:
+        kfree(kbuf);
+        return(err);
+}
+
+static ssize_t hostaudio_write(struct file *file, const char *buffer, 
+                               size_t count, loff_t *ppos)
+{
+        struct hostaudio_state *state = file->private_data;
+        void *kbuf;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: write called, count = %d\n", count);
+#endif
+
+        kbuf = kmalloc(count, GFP_KERNEL);
+        if(kbuf == NULL)
+                return(-ENOMEM);
+
+        err = -EFAULT;
+        if(copy_from_user(kbuf, buffer, count))
+                goto out;
+
+        err = os_write_file(state->fd, kbuf, count);
+        if(err < 0)
+                goto out;
+        *ppos += err;
+
+ out:
+        kfree(kbuf);
+        return(err);
+}
+
+static unsigned int hostaudio_poll(struct file *file, 
+                                   struct poll_table_struct *wait)
+{
+        unsigned int mask = 0;
+
+#ifdef DEBUG
+        printk("hostaudio: poll called (unimplemented)\n");
+#endif
+
+        return(mask);
+}
+
+static int hostaudio_ioctl(struct inode *inode, struct file *file, 
+                           unsigned int cmd, unsigned long arg)
+{
+        struct hostaudio_state *state = file->private_data;
+        unsigned long data = 0;
+        int err;
+
+#ifdef DEBUG
+        printk("hostaudio: ioctl called, cmd = %u\n", cmd);
+#endif
+        switch(cmd){
+        case SNDCTL_DSP_SPEED:
+        case SNDCTL_DSP_STEREO:
+        case SNDCTL_DSP_GETBLKSIZE:
+        case SNDCTL_DSP_CHANNELS:
+        case SNDCTL_DSP_SUBDIVIDE:
+        case SNDCTL_DSP_SETFRAGMENT:
+                if(get_user(data, (int *) arg))
+                        return(-EFAULT);
+                break;
+        default:
+                break;
+        }
+
+        err = os_ioctl_generic(state->fd, cmd, (unsigned long) &data);
+
+        switch(cmd){
+        case SNDCTL_DSP_SPEED:
+        case SNDCTL_DSP_STEREO:
+        case SNDCTL_DSP_GETBLKSIZE:
+        case SNDCTL_DSP_CHANNELS:
+        case SNDCTL_DSP_SUBDIVIDE:
+        case SNDCTL_DSP_SETFRAGMENT:
+                if(put_user(data, (int *) arg))
+                        return(-EFAULT);
+                break;
+        default:
+                break;
+        }
+
+        return(err);
+}
+
+static int hostaudio_open(struct inode *inode, struct file *file)
+{
+        struct hostaudio_state *state;
+        int r = 0, w = 0;
+        int ret;
+
+#ifdef DEBUG
+        printk("hostaudio: open called (host: %s)\n", dsp);
+#endif
+
+        state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL);
+        if(state == NULL)
+                return(-ENOMEM);
+
+        if(file->f_mode & FMODE_READ) r = 1;
+        if(file->f_mode & FMODE_WRITE) w = 1;
+
+        ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
+        if(ret < 0){
+                kfree(state);
+                return(ret);
+        }
+
+        state->fd = ret;
+        file->private_data = state;
+        return(0);
+}
+
+static int hostaudio_release(struct inode *inode, struct file *file)
+{
+        struct hostaudio_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostaudio: release called\n");
+#endif
+
+                os_close_file(state->fd);
+        kfree(state);
+
+        return(0);
+}
+
+/* /dev/mixer file operations */
+
+static int hostmixer_ioctl_mixdev(struct inode *inode, struct file *file, 
+                                  unsigned int cmd, unsigned long arg)
+{
+        struct hostmixer_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostmixer: ioctl called\n");
+#endif
+
+        return(os_ioctl_generic(state->fd, cmd, arg));
+}
+
+static int hostmixer_open_mixdev(struct inode *inode, struct file *file)
+{
+        struct hostmixer_state *state;
+        int r = 0, w = 0;
+        int ret;
+
+#ifdef DEBUG
+        printk("hostmixer: open called (host: %s)\n", mixer);
+#endif
+
+        state = kmalloc(sizeof(struct hostmixer_state), GFP_KERNEL);
+        if(state == NULL) return(-ENOMEM);
+
+        if(file->f_mode & FMODE_READ) r = 1;
+        if(file->f_mode & FMODE_WRITE) w = 1;
+
+        ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
+        
+        if(ret < 0){
+                printk("hostaudio_open_mixdev failed to open '%s', err = %d\n",
+                       dsp, -ret);
+                kfree(state);
+                return(ret);
+        }
+
+        file->private_data = state;
+        return(0);
+}
+
+static int hostmixer_release(struct inode *inode, struct file *file)
+{
+        struct hostmixer_state *state = file->private_data;
+
+#ifdef DEBUG
+        printk("hostmixer: release called\n");
+#endif
+
+                os_close_file(state->fd);
+        kfree(state);
+
+        return(0);
+}
+
+
+/* kernel module operations */
+
+static struct file_operations hostaudio_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .read           = hostaudio_read,
+        .write          = hostaudio_write,
+        .poll           = hostaudio_poll,
+        .ioctl          = hostaudio_ioctl,
+        .mmap           = NULL,
+        .open           = hostaudio_open,
+        .release        = hostaudio_release,
+};
+
+static struct file_operations hostmixer_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .ioctl          = hostmixer_ioctl_mixdev,
+        .open           = hostmixer_open_mixdev,
+        .release        = hostmixer_release,
+};
+
+struct {
+        int dev_audio;
+        int dev_mixer;
+} module_data;
+
+MODULE_AUTHOR("Steve Schmidtke");
+MODULE_DESCRIPTION("UML Audio Relay");
+MODULE_LICENSE("GPL");
+
+static int __init hostaudio_init_module(void)
+{
+        printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
+               dsp, mixer);
+
+        module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
+        if(module_data.dev_audio < 0){
+                printk(KERN_ERR "hostaudio: couldn't register DSP device!\n");
+                return -ENODEV;
+        }
+
+        module_data.dev_mixer = register_sound_mixer(&hostmixer_fops, -1);
+        if(module_data.dev_mixer < 0){
+                printk(KERN_ERR "hostmixer: couldn't register mixer "
+                       "device!\n");
+                unregister_sound_dsp(module_data.dev_audio);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void __exit hostaudio_cleanup_module (void)
+{
+       unregister_sound_mixer(module_data.dev_mixer);
+       unregister_sound_dsp(module_data.dev_audio);
+}
+
+module_init(hostaudio_init_module);
+module_exit(hostaudio_cleanup_module);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
new file mode 100644
index 000000000000..6924f273ced9
--- /dev/null
+++ b/arch/um/drivers/line.c
@@ -0,0 +1,681 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "linux/list.h"
+#include "linux/kd.h"
+#include "linux/interrupt.h"
+#include "linux/devfs_fs_kernel.h"
+#include "asm/uaccess.h"
+#include "chan_kern.h"
+#include "irq_user.h"
+#include "line.h"
+#include "kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "os.h"
+#include "irq_kern.h"
+
+#define LINE_BUFSIZE 4096
+
+static irqreturn_t line_interrupt(int irq, void *data, struct pt_regs *unused)
+{
+        struct tty_struct *tty = data;
+        struct line *line = tty->driver_data;
+
+        if (line)
+                chan_interrupt(&line->chan_list, &line->task, tty, irq);
+        return IRQ_HANDLED;
+}
+
+static void line_timer_cb(void *arg)
+{
+        struct tty_struct *tty = arg;
+        struct line *line = tty->driver_data;
+
+        line_interrupt(line->driver->read_irq, arg, NULL);
+}
+
+static int write_room(struct line *dev)
+{
+        int n;
+
+        if (dev->buffer == NULL)
+                return (LINE_BUFSIZE - 1);
+
+        n = dev->head - dev->tail;
+        if (n <= 0)
+                n = LINE_BUFSIZE + n;
+        return (n - 1);
+}
+
+static int buffer_data(struct line *line, const char *buf, int len)
+{
+        int end, room;
+
+        if(line->buffer == NULL){
+                line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC);
+                if (line->buffer == NULL) {
+                        printk("buffer_data - atomic allocation failed\n");
+                        return(0);
+                }
+                line->head = line->buffer;
+                line->tail = line->buffer;
+        }
+
+        room = write_room(line);
+        len = (len > room) ? room : len;
+
+        end = line->buffer + LINE_BUFSIZE - line->tail;
+        if(len < end){
+                memcpy(line->tail, buf, len);
+                line->tail += len;
+        }
+        else {
+                memcpy(line->tail, buf, end);
+                buf += end;
+                memcpy(line->buffer, buf, len - end);
+                line->tail = line->buffer + len - end;
+        }
+
+        return(len);
+}
+
+static int flush_buffer(struct line *line)
+{
+        int n, count;
+
+        if ((line->buffer == NULL) || (line->head == line->tail))
+                return(1);
+
+        if (line->tail < line->head) {
+                count = line->buffer + LINE_BUFSIZE - line->head;
+                n = write_chan(&line->chan_list, line->head, count,
+                               line->driver->write_irq);
+                if (n < 0)
+                        return(n);
+                if (n == count)
+                        line->head = line->buffer;
+                else {
+                        line->head += n;
+                        return(0);
+                }
+        }
+
+        count = line->tail - line->head;
+        n = write_chan(&line->chan_list, line->head, count, 
+                       line->driver->write_irq);
+        if(n < 0) return(n);
+
+        line->head += n;
+        return(line->head == line->tail);
+}
+
+int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
+{
+        struct line *line = tty->driver_data;
+        unsigned long flags;
+        int n, err, ret = 0;
+
+        if(tty->stopped) return 0;
+
+        down(&line->sem);
+        if(line->head != line->tail){
+                local_irq_save(flags);
+                ret = buffer_data(line, buf, len);
+                err = flush_buffer(line);
+                local_irq_restore(flags);
+                if(err <= 0 && (err != -EAGAIN || !ret))
+                        ret = err;
+        }
+        else {
+                n = write_chan(&line->chan_list, buf, len, 
+                               line->driver->write_irq);
+                if(n < 0){
+                        ret = n;
+                        goto out_up;
+                }
+
+                len -= n;
+                ret += n;
+                if(len > 0)
+                        ret += buffer_data(line, buf + n, len);
+        }
+ out_up:
+        up(&line->sem);
+        return(ret);
+}
+
+void line_put_char(struct tty_struct *tty, unsigned char ch)
+{
+        line_write(tty, &ch, sizeof(ch));
+}
+
+void line_set_termios(struct tty_struct *tty, struct termios * old)
+{
+        /* nothing */
+}
+
+int line_chars_in_buffer(struct tty_struct *tty)
+{
+        return 0;
+}
+
+static struct {
+        int  cmd;
+        char *level;
+        char *name;
+} tty_ioctls[] = {
+        /* don't print these, they flood the log ... */
+        { TCGETS,      NULL,       "TCGETS"      },
+        { TCSETS,      NULL,       "TCSETS"      },
+        { TCSETSW,     NULL,       "TCSETSW"     },
+        { TCFLSH,      NULL,       "TCFLSH"      },
+        { TCSBRK,      NULL,       "TCSBRK"      },
+
+        /* general tty stuff */
+        { TCSETSF,     KERN_DEBUG, "TCSETSF"     },
+        { TCGETA,      KERN_DEBUG, "TCGETA"      },
+        { TIOCMGET,    KERN_DEBUG, "TIOCMGET"    },
+        { TCSBRKP,     KERN_DEBUG, "TCSBRKP"     },
+        { TIOCMSET,    KERN_DEBUG, "TIOCMSET"    },
+
+        /* linux-specific ones */
+        { TIOCLINUX,   KERN_INFO,  "TIOCLINUX"   },
+        { KDGKBMODE,   KERN_INFO,  "KDGKBMODE"   },
+        { KDGKBTYPE,   KERN_INFO,  "KDGKBTYPE"   },
+        { KDSIGACCEPT, KERN_INFO,  "KDSIGACCEPT" },
+};
+
+int line_ioctl(struct tty_struct *tty, struct file * file,
+               unsigned int cmd, unsigned long arg)
+{
+        int ret;
+        int i;
+
+        ret = 0;
+        switch(cmd) {
+#ifdef TIOCGETP
+        case TIOCGETP:
+        case TIOCSETP:
+        case TIOCSETN:
+#endif
+#ifdef TIOCGETC
+        case TIOCGETC:
+        case TIOCSETC:
+#endif
+#ifdef TIOCGLTC
+        case TIOCGLTC:
+        case TIOCSLTC:
+#endif
+        case TCGETS:
+        case TCSETSF:
+        case TCSETSW:
+        case TCSETS:
+        case TCGETA:
+        case TCSETAF:
+        case TCSETAW:
+        case TCSETA:
+        case TCXONC:
+        case TCFLSH:
+        case TIOCOUTQ:
+        case TIOCINQ:
+        case TIOCGLCKTRMIOS:
+        case TIOCSLCKTRMIOS:
+        case TIOCPKT:
+        case TIOCGSOFTCAR:
+        case TIOCSSOFTCAR:
+                return -ENOIOCTLCMD;
+#if 0
+        case TCwhatever:
+                /* do something */
+                break;
+#endif
+        default:
+                for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++)
+                        if (cmd == tty_ioctls[i].cmd)
+                                break;
+                if (i < ARRAY_SIZE(tty_ioctls)) {
+                        if (NULL != tty_ioctls[i].level)
+                                printk("%s%s: %s: ioctl %s called\n",
+                                       tty_ioctls[i].level, __FUNCTION__,
+                                       tty->name, tty_ioctls[i].name);
+                } else {
+                        printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n",
+                               __FUNCTION__, tty->name, cmd);
+                }
+                ret = -ENOIOCTLCMD;
+                break;
+        }
+        return(ret);
+}
+
+static irqreturn_t line_write_interrupt(int irq, void *data,
+                                        struct pt_regs *unused)
+{
+        struct tty_struct *tty = data;
+        struct line *line = tty->driver_data;
+        int err;
+
+        err = flush_buffer(line);
+        if(err == 0)
+                return(IRQ_NONE);
+        else if(err < 0){
+                line->head = line->buffer;
+                line->tail = line->buffer;
+        }
+
+        if(tty == NULL)
+                return(IRQ_NONE);
+
+        if(test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
+           (tty->ldisc.write_wakeup != NULL))
+                (tty->ldisc.write_wakeup)(tty);
+        
+        /* BLOCKING mode
+         * In blocking mode, everything sleeps on tty->write_wait.
+         * Sleeping in the console driver would break non-blocking
+         * writes.
+         */
+
+        if(waitqueue_active(&tty->write_wait))
+                wake_up_interruptible(&tty->write_wait);
+        return(IRQ_HANDLED);
+}
+
+int line_setup_irq(int fd, int input, int output, struct tty_struct *tty)
+{
+        struct line *line = tty->driver_data;
+        struct line_driver *driver = line->driver;
+        int err = 0, flags = SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM;
+
+        if(input) err = um_request_irq(driver->read_irq, fd, IRQ_READ, 
+                                       line_interrupt, flags, 
+                                       driver->read_irq_name, tty);
+        if(err) return(err);
+        if(output) err = um_request_irq(driver->write_irq, fd, IRQ_WRITE, 
+                                        line_write_interrupt, flags, 
+                                        driver->write_irq_name, tty);
+        line->have_irq = 1;
+        return(err);
+}
+
+void line_disable(struct tty_struct *tty, int current_irq)
+{
+        struct line *line = tty->driver_data;
+
+        if(!line->have_irq)
+                return;
+
+        if(line->driver->read_irq == current_irq)
+                free_irq_later(line->driver->read_irq, tty);
+        else {
+                free_irq_by_irq_and_dev(line->driver->read_irq, tty);
+                free_irq(line->driver->read_irq, tty);
+        }
+
+        if(line->driver->write_irq == current_irq)
+                free_irq_later(line->driver->write_irq, tty);
+        else {
+                free_irq_by_irq_and_dev(line->driver->write_irq, tty);
+                free_irq(line->driver->write_irq, tty);
+        }
+
+        line->have_irq = 0;
+}
+
+int line_open(struct line *lines, struct tty_struct *tty,
+              struct chan_opts *opts)
+{
+        struct line *line;
+        int err = 0;
+
+        line = &lines[tty->index];
+        tty->driver_data = line;
+
+        down(&line->sem);
+        if (tty->count == 1) {
+                if (!line->valid) {
+                        err = -ENODEV;
+                        goto out;
+                }
+                if (list_empty(&line->chan_list)) {
+                        err = parse_chan_pair(line->init_str, &line->chan_list,
+                                              line->init_pri, tty->index, opts);
+                        if(err) goto out;
+                        err = open_chan(&line->chan_list);
+                        if(err) goto out;
+                }
+                enable_chan(&line->chan_list, tty);
+                INIT_WORK(&line->task, line_timer_cb, tty);
+        }
+
+        if(!line->sigio){
+                chan_enable_winch(&line->chan_list, tty);
+                line->sigio = 1;
+        }
+        chan_window_size(&line->chan_list, &tty->winsize.ws_row,
+                         &tty->winsize.ws_col);
+        line->count++;
+
+out:
+        up(&line->sem);
+        return(err);
+}
+
+void line_close(struct tty_struct *tty, struct file * filp)
+{
+        struct line *line = tty->driver_data;
+
+        down(&line->sem);
+        line->count--;
+        if (tty->count == 1) {
+                line_disable(tty, -1);
+                tty->driver_data = NULL;
+        }
+        up(&line->sem);
+}
+
+void close_lines(struct line *lines, int nlines)
+{
+        int i;
+
+        for(i = 0; i < nlines; i++)
+                close_chan(&lines[i].chan_list);
+}
+
+int line_setup(struct line *lines, int num, char *init, int all_allowed)
+{
+        int i, n;
+        char *end;
+
+        if(*init == '=') n = -1;
+        else {
+                n = simple_strtoul(init, &end, 0);
+                if(*end != '='){
+                        printk(KERN_ERR "line_setup failed to parse \"%s\"\n", 
+                               init);
+                        return(0);
+                }
+                init = end;
+        }
+        init++;
+        if((n >= 0) && (n >= num)){
+                printk("line_setup - %d out of range ((0 ... %d) allowed)\n",
+                       n, num - 1);
+                return(0);
+        }
+        else if (n >= 0){
+                if (lines[n].count > 0) {
+                        printk("line_setup - device %d is open\n", n);
+                        return(0);
+                }
+                if (lines[n].init_pri <= INIT_ONE){
+                        lines[n].init_pri = INIT_ONE;
+                        if (!strcmp(init, "none"))
+                                lines[n].valid = 0;
+                        else {
+                                lines[n].init_str = init;
+                                lines[n].valid = 1;
+                        }       
+                }
+        }
+        else if(!all_allowed){
+                printk("line_setup - can't configure all devices from "
+                       "mconsole\n");
+                return(0);
+        }
+        else {
+                for(i = 0; i < num; i++){
+                        if(lines[i].init_pri <= INIT_ALL){
+                                lines[i].init_pri = INIT_ALL;
+                                if(!strcmp(init, "none")) lines[i].valid = 0;
+                                else {
+                                        lines[i].init_str = init;
+                                        lines[i].valid = 1;
+                                }
+                        }
+                }
+        }
+        return(1);
+}
+
+int line_config(struct line *lines, int num, char *str)
+{
+        char *new = uml_strdup(str);
+
+        if(new == NULL){
+                printk("line_config - uml_strdup failed\n");
+                return(-ENOMEM);
+        }
+        return(!line_setup(lines, num, new, 0));
+}
+
+int line_get_config(char *name, struct line *lines, int num, char *str, 
+                    int size, char **error_out)
+{
+        struct line *line;
+        char *end;
+        int dev, n = 0;
+
+        dev = simple_strtoul(name, &end, 0);
+        if((*end != '\0') || (end == name)){
+                *error_out = "line_get_config failed to parse device number";
+                return(0);
+        }
+
+        if((dev < 0) || (dev >= num)){
+                *error_out = "device number of of range";
+                return(0);
+        }
+
+        line = &lines[dev];
+
+        down(&line->sem);
+        if(!line->valid)
+                CONFIG_CHUNK(str, size, n, "none", 1);
+        else if(line->count == 0)
+                CONFIG_CHUNK(str, size, n, line->init_str, 1);
+        else n = chan_config_string(&line->chan_list, str, size, error_out);
+        up(&line->sem);
+
+        return(n);
+}
+
+int line_remove(struct line *lines, int num, char *str)
+{
+        char config[sizeof("conxxxx=none\0")];
+
+        sprintf(config, "%s=none", str);
+        return(!line_setup(lines, num, config, 0));
+}
+
+int line_write_room(struct tty_struct *tty)
+{
+        struct line *dev = tty->driver_data;
+        int room;
+
+        if (tty->stopped)
+                return 0;
+        room = write_room(dev);
+        if (0 == room)
+                printk(KERN_DEBUG "%s: %s: no room left in buffer\n",
+                       __FUNCTION__,tty->name);
+        return room;
+}
+
+struct tty_driver *line_register_devfs(struct lines *set,
+                         struct line_driver *line_driver, 
+                         struct tty_operations *ops, struct line *lines,
+                         int nlines)
+{
+        int i;
+        struct tty_driver *driver = alloc_tty_driver(nlines);
+
+        if (!driver)
+                return NULL;
+
+        driver->driver_name = line_driver->name;
+        driver->name = line_driver->device_name;
+        driver->devfs_name = line_driver->devfs_name;
+        driver->major = line_driver->major;
+        driver->minor_start = line_driver->minor_start;
+        driver->type = line_driver->type;
+        driver->subtype = line_driver->subtype;
+        driver->flags = TTY_DRIVER_REAL_RAW;
+        driver->init_termios = tty_std_termios;
+        tty_set_operations(driver, ops);
+
+        if (tty_register_driver(driver)) {
+                printk("%s: can't register %s driver\n",
+                       __FUNCTION__,line_driver->name);
+                put_tty_driver(driver);
+                return NULL;
+        }
+
+        for(i = 0; i < nlines; i++){
+                if(!lines[i].valid) 
+                        tty_unregister_device(driver, i);
+        }
+
+        mconsole_register_dev(&line_driver->mc);
+        return driver;
+}
+
+void lines_init(struct line *lines, int nlines)
+{
+        struct line *line;
+        int i;
+
+        for(i = 0; i < nlines; i++){
+                line = &lines[i];
+                INIT_LIST_HEAD(&line->chan_list);
+                sema_init(&line->sem, 1);
+                if(line->init_str != NULL){
+                        line->init_str = uml_strdup(line->init_str);
+                        if(line->init_str == NULL)
+                                printk("lines_init - uml_strdup returned "
+                                       "NULL\n");
+                }
+        }
+}
+
+struct winch {
+        struct list_head list;
+        int fd;
+        int tty_fd;
+        int pid;
+        struct tty_struct *tty;
+};
+
+irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
+{
+        struct winch *winch = data;
+        struct tty_struct *tty;
+        struct line *line;
+        int err;
+        char c;
+
+        if(winch->fd != -1){
+                err = generic_read(winch->fd, &c, NULL);
+                if(err < 0){
+                        if(err != -EAGAIN){
+                                printk("winch_interrupt : read failed, "
+                                       "errno = %d\n", -err);
+                                printk("fd %d is losing SIGWINCH support\n",
+                                       winch->tty_fd);
+                                return(IRQ_HANDLED);
+                        }
+                        goto out;
+                }
+        }
+        tty  = winch->tty;
+        if (tty != NULL) {
+                line = tty->driver_data;
+                chan_window_size(&line->chan_list,
+                                 &tty->winsize.ws_row, 
+                                 &tty->winsize.ws_col);
+                kill_pg(tty->pgrp, SIGWINCH, 1);
+        }
+ out:
+        if(winch->fd != -1)
+                reactivate_fd(winch->fd, WINCH_IRQ);
+        return(IRQ_HANDLED);
+}
+
+DECLARE_MUTEX(winch_handler_sem);
+LIST_HEAD(winch_handlers);
+
+void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty)
+{
+        struct winch *winch;
+
+        down(&winch_handler_sem);
+        winch = kmalloc(sizeof(*winch), GFP_KERNEL);
+        if (winch == NULL) {
+                printk("register_winch_irq - kmalloc failed\n");
+                goto out;
+        }
+        *winch = ((struct winch) { .list        = LIST_HEAD_INIT(winch->list),
+                                   .fd          = fd,
+                                   .tty_fd      = tty_fd,
+                                   .pid         = pid,
+                                   .tty         = tty });
+        list_add(&winch->list, &winch_handlers);
+        if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                          "winch", winch) < 0)
+                printk("register_winch_irq - failed to register IRQ\n");
+ out:
+        up(&winch_handler_sem);
+}
+
+static void winch_cleanup(void)
+{
+        struct list_head *ele;
+        struct winch *winch;
+
+        list_for_each(ele, &winch_handlers){
+                winch = list_entry(ele, struct winch, list);
+                if(winch->fd != -1){
+                        deactivate_fd(winch->fd, WINCH_IRQ);
+                        os_close_file(winch->fd);
+                }
+                if(winch->pid != -1) 
+                        os_kill_process(winch->pid, 1);
+        }
+}
+__uml_exitcall(winch_cleanup);
+
+char *add_xterm_umid(char *base)
+{
+        char *umid, *title;
+        int len;
+
+        umid = get_umid(1);
+        if(umid == NULL) return(base);
+        
+        len = strlen(base) + strlen(" ()") + strlen(umid) + 1;
+        title = kmalloc(len, GFP_KERNEL);
+        if(title == NULL){
+                printk("Failed to allocate buffer for xterm title\n");
+                return(base);
+        }
+
+        snprintf(title, len, "%s (%s)", base, umid);
+        return(title);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mcast.h b/arch/um/drivers/mcast.h
new file mode 100644
index 000000000000..a2c6db243458
--- /dev/null
+++ b/arch/um/drivers/mcast.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+struct mcast_data {
+        char *addr;
+        unsigned short port;
+        void *mcast_addr;
+        int ttl;
+        void *dev;
+};
+
+extern struct net_user_info mcast_user_info;
+
+extern int mcast_user_write(int fd, void *buf, int len, 
+                            struct mcast_data *pri);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mcast_kern.c b/arch/um/drivers/mcast_kern.c
new file mode 100644
index 000000000000..faf714e87b5b
--- /dev/null
+++ b/arch/um/drivers/mcast_kern.c
@@ -0,0 +1,143 @@
+/*
+ * user-mode-linux networking multicast transport
+ * Copyright (C) 2001 by Harald Welte <laforge@gnumonks.org>
+ *
+ * based on the existing uml-networking code, which is
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ *
+ * Licensed under the GPL.
+ */
+
+#include "linux/kernel.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "linux/in.h"
+#include "linux/inet.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "mcast.h"
+
+struct mcast_init {
+        char *addr;
+        int port;
+        int ttl;
+};
+
+void mcast_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct mcast_data *dpri;
+        struct mcast_init *init = data;
+
+        pri = dev->priv;
+        dpri = (struct mcast_data *) pri->user;
+        dpri->addr = init->addr;
+        dpri->port = init->port;
+        dpri->ttl = init->ttl;
+        dpri->dev = dev;
+
+        printk("mcast backend ");
+        printk("multicast adddress: %s:%u, TTL:%u ",
+               dpri->addr, dpri->port, dpri->ttl);
+
+        printk("\n");
+}
+
+static int mcast_read(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(net_recvfrom(fd, (*skb)->mac.raw, 
+                            (*skb)->dev->mtu + ETH_HEADER_OTHER));
+}
+
+static int mcast_write(int fd, struct sk_buff **skb,
+                        struct uml_net_private *lp)
+{
+        return mcast_user_write(fd, (*skb)->data, (*skb)->len, 
+                                 (struct mcast_data *) &lp->user);
+}
+
+static struct net_kern_info mcast_kern_info = {
+        .init                   = mcast_init,
+        .protocol               = eth_protocol,
+        .read                   = mcast_read,
+        .write                  = mcast_write,
+};
+
+int mcast_setup(char *str, char **mac_out, void *data)
+{
+        struct mcast_init *init = data;
+        char *port_str = NULL, *ttl_str = NULL, *remain;
+        char *last;
+        int n;
+
+        *init = ((struct mcast_init)
+                { .addr         = "239.192.168.1",
+                  .port         = 1102,
+                  .ttl          = 1 });
+
+        remain = split_if_spec(str, mac_out, &init->addr, &port_str, &ttl_str,
+                               NULL);
+        if(remain != NULL){
+                printk(KERN_ERR "mcast_setup - Extra garbage on "
+                       "specification : '%s'\n", remain);
+                return(0);
+        }
+        
+        if(port_str != NULL){
+                n = simple_strtoul(port_str, &last, 10);
+                if((*last != '\0') || (last == port_str)){
+                        printk(KERN_ERR "mcast_setup - Bad port : '%s'\n", 
+                               port_str);
+                        return(0);
+                }
+                init->port = htons(n);
+        }
+
+        if(ttl_str != NULL){
+                init->ttl = simple_strtoul(ttl_str, &last, 10);
+                if((*last != '\0') || (last == ttl_str)){
+                        printk(KERN_ERR "mcast_setup - Bad ttl : '%s'\n", 
+                               ttl_str);
+                        return(0);
+                }
+        }
+
+        printk(KERN_INFO "Configured mcast device: %s:%u-%u\n", init->addr,
+               init->port, init->ttl);
+
+        return(1);
+}
+
+static struct transport mcast_transport = {
+        .list           = LIST_HEAD_INIT(mcast_transport.list),
+        .name           = "mcast",
+        .setup          = mcast_setup,
+        .user           = &mcast_user_info,
+        .kern           = &mcast_kern_info,
+        .private_size   = sizeof(struct mcast_data),
+        .setup_size     = sizeof(struct mcast_init),
+};
+
+static int register_mcast(void)
+{
+        register_transport(&mcast_transport);
+        return(1);
+}
+
+__initcall(register_mcast);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mcast_user.c b/arch/um/drivers/mcast_user.c
new file mode 100644
index 000000000000..0fe1d9fa9139
--- /dev/null
+++ b/arch/um/drivers/mcast_user.c
@@ -0,0 +1,177 @@
+/*
+ * user-mode-linux networking multicast transport
+ * Copyright (C) 2001 by Harald Welte <laforge@gnumonks.org>
+ *
+ * based on the existing uml-networking code, which is
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ *
+ * Licensed under the GPL.
+ *
+ */
+
+#include <errno.h>
+#include <unistd.h>
+#include <linux/inet.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include "net_user.h"
+#include "mcast.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+static struct sockaddr_in *new_addr(char *addr, unsigned short port)
+{
+        struct sockaddr_in *sin;
+
+        sin = um_kmalloc(sizeof(struct sockaddr_in));
+        if(sin == NULL){
+                printk("new_addr: allocation of sockaddr_in failed\n");
+                return(NULL);
+        }
+        sin->sin_family = AF_INET;
+        sin->sin_addr.s_addr = in_aton(addr);
+        sin->sin_port = port;
+        return(sin);
+}
+
+static void mcast_user_init(void *data, void *dev)
+{
+        struct mcast_data *pri = data;
+
+        pri->mcast_addr = new_addr(pri->addr, pri->port);
+        pri->dev = dev;
+}
+
+static int mcast_open(void *data)
+{
+        struct mcast_data *pri = data;
+        struct sockaddr_in *sin = pri->mcast_addr;
+        struct ip_mreq mreq;
+        int fd, yes = 1;
+
+
+        if ((sin->sin_addr.s_addr == 0) || (sin->sin_port == 0)) {
+                fd = -EINVAL;
+                goto out;
+        }
+
+        fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if (fd < 0){
+                printk("mcast_open : data socket failed, errno = %d\n", 
+                       errno);
+                fd = -ENOMEM;
+                goto out;
+        }
+
+        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
+                printk("mcast_open: SO_REUSEADDR failed, errno = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* set ttl according to config */
+        if (setsockopt(fd, SOL_IP, IP_MULTICAST_TTL, &pri->ttl,
+                       sizeof(pri->ttl)) < 0) {
+                printk("mcast_open: IP_MULTICAST_TTL failed, error = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* set LOOP, so data does get fed back to local sockets */
+        if (setsockopt(fd, SOL_IP, IP_MULTICAST_LOOP, &yes, sizeof(yes)) < 0) {
+                printk("mcast_open: IP_MULTICAST_LOOP failed, error = %d\n",
+                        errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }
+
+        /* bind socket to mcast address */
+        if (bind(fd, (struct sockaddr *) sin, sizeof(*sin)) < 0) {
+                printk("mcast_open : data bind failed, errno = %d\n", errno);
+                os_close_file(fd);
+                fd = -EINVAL;
+                goto out;
+        }               
+        
+        /* subscribe to the multicast group */
+        mreq.imr_multiaddr.s_addr = sin->sin_addr.s_addr;
+        mreq.imr_interface.s_addr = 0;
+        if (setsockopt(fd, SOL_IP, IP_ADD_MEMBERSHIP, 
+                       &mreq, sizeof(mreq)) < 0) {
+                printk("mcast_open: IP_ADD_MEMBERSHIP failed, error = %d\n",
+                        errno);
+                printk("There appears not to be a multicast-capable network "
+                       "interface on the host.\n");
+                printk("eth0 should be configured in order to use the "
+                       "multicast transport.\n");
+                os_close_file(fd);
+                fd = -EINVAL;
+        }
+
+ out:
+        return(fd);
+}
+
+static void mcast_close(int fd, void *data)
+{
+        struct ip_mreq mreq;
+        struct mcast_data *pri = data;
+        struct sockaddr_in *sin = pri->mcast_addr;
+
+        mreq.imr_multiaddr.s_addr = sin->sin_addr.s_addr;
+        mreq.imr_interface.s_addr = 0;
+        if (setsockopt(fd, SOL_IP, IP_DROP_MEMBERSHIP,
+                       &mreq, sizeof(mreq)) < 0) {
+                printk("mcast_open: IP_DROP_MEMBERSHIP failed, error = %d\n",
+                        errno);
+        }
+
+        os_close_file(fd);
+}
+
+int mcast_user_write(int fd, void *buf, int len, struct mcast_data *pri)
+{
+        struct sockaddr_in *data_addr = pri->mcast_addr;
+
+        return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
+}
+
+static int mcast_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info mcast_user_info = {
+        .init           = mcast_user_init,
+        .open           = mcast_open,
+        .close          = mcast_close,
+        .remove         = NULL,
+        .set_mtu        = mcast_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
new file mode 100644
index 000000000000..d7c7adcc0a67
--- /dev/null
+++ b/arch/um/drivers/mconsole_kern.c
@@ -0,0 +1,619 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/slab.h"
+#include "linux/init.h"
+#include "linux/notifier.h"
+#include "linux/reboot.h"
+#include "linux/utsname.h"
+#include "linux/ctype.h"
+#include "linux/interrupt.h"
+#include "linux/sysrq.h"
+#include "linux/workqueue.h"
+#include "linux/module.h"
+#include "linux/file.h"
+#include "linux/fs.h"
+#include "linux/namei.h"
+#include "linux/proc_fs.h"
+#include "linux/syscalls.h"
+#include "asm/irq.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mconsole.h"
+#include "mconsole_kern.h"
+#include "irq_user.h"
+#include "init.h"
+#include "os.h"
+#include "umid.h"
+#include "irq_kern.h"
+
+static int do_unlink_socket(struct notifier_block *notifier, 
+                            unsigned long what, void *data)
+{
+        return(mconsole_unlink_socket());
+}
+
+
+static struct notifier_block reboot_notifier = {
+        .notifier_call          = do_unlink_socket,
+        .priority               = 0,
+};
+
+/* Safe without explicit locking for now.  Tasklets provide their own 
+ * locking, and the interrupt handler is safe because it can't interrupt
+ * itself and it can only happen on CPU 0.
+ */
+
+LIST_HEAD(mc_requests);
+
+static void mc_work_proc(void *unused)
+{
+        struct mconsole_entry *req;
+        unsigned long flags;
+
+        while(!list_empty(&mc_requests)){
+                local_save_flags(flags);
+                req = list_entry(mc_requests.next, struct mconsole_entry, 
+                                 list);
+                list_del(&req->list);
+                local_irq_restore(flags);
+                req->request.cmd->handler(&req->request);
+                kfree(req);
+        }
+}
+
+DECLARE_WORK(mconsole_work, mc_work_proc, NULL);
+
+static irqreturn_t mconsole_interrupt(int irq, void *dev_id,
+                                      struct pt_regs *regs)
+{
+        /* long to avoid size mismatch warnings from gcc */
+        long fd;
+        struct mconsole_entry *new;
+        struct mc_request req;
+
+        fd = (long) dev_id;
+        while (mconsole_get_request(fd, &req)){
+                if(req.cmd->context == MCONSOLE_INTR)
+                        (*req.cmd->handler)(&req);
+                else {
+                        new = kmalloc(sizeof(*new), GFP_ATOMIC);
+                        if(new == NULL)
+                                mconsole_reply(&req, "Out of memory", 1, 0);
+                        else {
+                                new->request = req;
+                                list_add(&new->list, &mc_requests);
+                        }
+                }
+        }
+        if(!list_empty(&mc_requests))
+                schedule_work(&mconsole_work);
+        reactivate_fd(fd, MCONSOLE_IRQ);
+        return(IRQ_HANDLED);
+}
+
+void mconsole_version(struct mc_request *req)
+{
+        char version[256];
+
+        sprintf(version, "%s %s %s %s %s", system_utsname.sysname, 
+                system_utsname.nodename, system_utsname.release, 
+                system_utsname.version, system_utsname.machine);
+        mconsole_reply(req, version, 0, 0);
+}
+
+void mconsole_log(struct mc_request *req)
+{
+        int len;
+        char *ptr = req->request.data;
+
+        ptr += strlen("log ");
+
+        len = req->len - (ptr - req->request.data);
+        printk("%.*s", len, ptr);
+        mconsole_reply(req, "", 0, 0);
+}
+
+/* This is a more convoluted version of mconsole_proc, which has some stability
+ * problems; however, we need it fixed, because it is expected that UML users
+ * mount HPPFS instead of procfs on /proc. And we want mconsole_proc to still
+ * show the real procfs content, not the ones from hppfs.*/
+#if 0
+void mconsole_proc(struct mc_request *req)
+{
+        struct nameidata nd;
+        struct file_system_type *proc;
+        struct super_block *super;
+        struct file *file;
+        int n, err;
+        char *ptr = req->request.data, *buf;
+
+        ptr += strlen("proc");
+        while(isspace(*ptr)) ptr++;
+
+        proc = get_fs_type("proc");
+        if(proc == NULL){
+                mconsole_reply(req, "procfs not registered", 1, 0);
+                goto out;
+        }
+
+        super = (*proc->get_sb)(proc, 0, NULL, NULL);
+        put_filesystem(proc);
+        if(super == NULL){
+                mconsole_reply(req, "Failed to get procfs superblock", 1, 0);
+                goto out;
+        }
+        up_write(&super->s_umount);
+
+        nd.dentry = super->s_root;
+        nd.mnt = NULL;
+        nd.flags = O_RDONLY + 1;
+        nd.last_type = LAST_ROOT;
+
+        /* START: it was experienced that the stability problems are closed
+         * if commenting out these two calls + the below read cycle. To
+         * make UML crash again, it was enough to readd either one.*/
+        err = link_path_walk(ptr, &nd);
+        if(err){
+                mconsole_reply(req, "Failed to look up file", 1, 0);
+                goto out_kill;
+        }
+
+        file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
+        if(IS_ERR(file)){
+                mconsole_reply(req, "Failed to open file", 1, 0);
+                goto out_kill;
+        }
+        /*END*/
+
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if(buf == NULL){
+                mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                goto out_fput;
+        }
+
+        if((file->f_op != NULL) && (file->f_op->read != NULL)){
+                do {
+                        n = (*file->f_op->read)(file, buf, PAGE_SIZE - 1,
+                                                &file->f_pos);
+                        if(n >= 0){
+                                buf[n] = '\0';
+                                mconsole_reply(req, buf, 0, (n > 0));
+                        }
+                        else {
+                                mconsole_reply(req, "Read of file failed",
+                                               1, 0);
+                                goto out_free;
+                        }
+                } while(n > 0);
+        }
+        else mconsole_reply(req, "", 0, 0);
+
+ out_free:
+        kfree(buf);
+ out_fput:
+        fput(file);
+ out_kill:
+        deactivate_super(super);
+ out: ;
+}
+#endif
+
+void mconsole_proc(struct mc_request *req)
+{
+        char path[64];
+        char *buf;
+        int len;
+        int fd;
+        int first_chunk = 1;
+        char *ptr = req->request.data;
+
+        ptr += strlen("proc");
+        while(isspace(*ptr)) ptr++;
+        snprintf(path, sizeof(path), "/proc/%s", ptr);
+
+        fd = sys_open(path, 0, 0);
+        if (fd < 0) {
+                mconsole_reply(req, "Failed to open file", 1, 0);
+                printk("open %s: %d\n",path,fd);
+                goto out;
+        }
+
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if(buf == NULL){
+                mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                goto out_close;
+        }
+
+        for (;;) {
+                len = sys_read(fd, buf, PAGE_SIZE-1);
+                if (len < 0) {
+                        mconsole_reply(req, "Read of file failed", 1, 0);
+                        goto out_free;
+                }
+                /*Begin the file content on his own line.*/
+                if (first_chunk) {
+                        mconsole_reply(req, "\n", 0, 1);
+                        first_chunk = 0;
+                }
+                if (len == PAGE_SIZE-1) {
+                        buf[len] = '\0';
+                        mconsole_reply(req, buf, 0, 1);
+                } else {
+                        buf[len] = '\0';
+                        mconsole_reply(req, buf, 0, 0);
+                        break;
+                }
+        }
+
+ out_free:
+        kfree(buf);
+ out_close:
+        sys_close(fd);
+ out:
+        /* nothing */;
+}
+
+#define UML_MCONSOLE_HELPTEXT \
+"Commands: \n\
+    version - Get kernel version \n\
+    help - Print this message \n\
+    halt - Halt UML \n\
+    reboot - Reboot UML \n\
+    config <dev>=<config> - Add a new device to UML;  \n\
+        same syntax as command line \n\
+    config <dev> - Query the configuration of a device \n\
+    remove <dev> - Remove a device from UML \n\
+    sysrq <letter> - Performs the SysRq action controlled by the letter \n\
+    cad - invoke the Ctl-Alt-Del handler \n\
+    stop - pause the UML; it will do nothing until it receives a 'go' \n\
+    go - continue the UML after a 'stop' \n\
+    log <string> - make UML enter <string> into the kernel log\n\
+    proc <file> - returns the contents of the UML's /proc/<file>\n\
+"
+
+void mconsole_help(struct mc_request *req)
+{
+        mconsole_reply(req, UML_MCONSOLE_HELPTEXT, 0, 0);
+}
+
+void mconsole_halt(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        machine_halt();
+}
+
+void mconsole_reboot(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        machine_restart(NULL);
+}
+
+extern void ctrl_alt_del(void);
+
+void mconsole_cad(struct mc_request *req)
+{
+        mconsole_reply(req, "", 0, 0);
+        ctrl_alt_del();
+}
+
+void mconsole_go(struct mc_request *req)
+{
+        mconsole_reply(req, "Not stopped", 1, 0);
+}
+
+void mconsole_stop(struct mc_request *req)
+{
+        deactivate_fd(req->originating_fd, MCONSOLE_IRQ);
+        os_set_fd_block(req->originating_fd, 1);
+        mconsole_reply(req, "", 0, 0);
+        while(mconsole_get_request(req->originating_fd, req)){
+                if(req->cmd->handler == mconsole_go) break;
+                (*req->cmd->handler)(req);
+        }
+        os_set_fd_block(req->originating_fd, 0);
+        reactivate_fd(req->originating_fd, MCONSOLE_IRQ);
+        mconsole_reply(req, "", 0, 0);
+}
+
+/* This list is populated by __initcall routines. */
+
+LIST_HEAD(mconsole_devices);
+
+void mconsole_register_dev(struct mc_device *new)
+{
+        list_add(&new->list, &mconsole_devices);
+}
+
+static struct mc_device *mconsole_find_dev(char *name)
+{
+        struct list_head *ele;
+        struct mc_device *dev;
+
+        list_for_each(ele, &mconsole_devices){
+                dev = list_entry(ele, struct mc_device, list);
+                if(!strncmp(name, dev->name, strlen(dev->name)))
+                        return(dev);
+        }
+        return(NULL);
+}
+
+#define CONFIG_BUF_SIZE 64
+
+static void mconsole_get_config(int (*get_config)(char *, char *, int, 
+                                                  char **),
+                                struct mc_request *req, char *name)
+{
+        char default_buf[CONFIG_BUF_SIZE], *error, *buf;
+        int n, size;
+
+        if(get_config == NULL){
+                mconsole_reply(req, "No get_config routine defined", 1, 0);
+                return;
+        }
+
+        error = NULL;
+        size = sizeof(default_buf)/sizeof(default_buf[0]);
+        buf = default_buf;
+
+        while(1){
+                n = (*get_config)(name, buf, size, &error);
+                if(error != NULL){
+                        mconsole_reply(req, error, 1, 0);
+                        goto out;
+                }
+
+                if(n <= size){
+                        mconsole_reply(req, buf, 0, 0);
+                        goto out;
+                }
+
+                if(buf != default_buf)
+                        kfree(buf);
+
+                size = n;
+                buf = kmalloc(size, GFP_KERNEL);
+                if(buf == NULL){
+                        mconsole_reply(req, "Failed to allocate buffer", 1, 0);
+                        return;
+                }
+        }
+ out:
+        if(buf != default_buf)
+                kfree(buf);
+        
+}
+
+void mconsole_config(struct mc_request *req)
+{
+        struct mc_device *dev;
+        char *ptr = req->request.data, *name;
+        int err;
+
+        ptr += strlen("config");
+        while(isspace(*ptr)) ptr++;
+        dev = mconsole_find_dev(ptr);
+        if(dev == NULL){
+                mconsole_reply(req, "Bad configuration option", 1, 0);
+                return;
+        }
+
+        name = &ptr[strlen(dev->name)];
+        ptr = name;
+        while((*ptr != '=') && (*ptr != '\0'))
+                ptr++;
+
+        if(*ptr == '='){
+                err = (*dev->config)(name);
+                mconsole_reply(req, "", err, 0);
+        }
+        else mconsole_get_config(dev->get_config, req, name);
+}
+
+void mconsole_remove(struct mc_request *req)
+{
+        struct mc_device *dev;  
+        char *ptr = req->request.data;
+        int err;
+
+        ptr += strlen("remove");
+        while(isspace(*ptr)) ptr++;
+        dev = mconsole_find_dev(ptr);
+        if(dev == NULL){
+                mconsole_reply(req, "Bad remove option", 1, 0);
+                return;
+        }
+        err = (*dev->remove)(&ptr[strlen(dev->name)]);
+        mconsole_reply(req, "", err, 0);
+}
+
+#ifdef CONFIG_MAGIC_SYSRQ
+void mconsole_sysrq(struct mc_request *req)
+{
+        char *ptr = req->request.data;
+
+        ptr += strlen("sysrq");
+        while(isspace(*ptr)) ptr++;
+
+        mconsole_reply(req, "", 0, 0);
+        handle_sysrq(*ptr, &current->thread.regs, NULL);
+}
+#else
+void mconsole_sysrq(struct mc_request *req)
+{
+        mconsole_reply(req, "Sysrq not compiled in", 1, 0);
+}
+#endif
+
+/* Changed by mconsole_setup, which is __setup, and called before SMP is
+ * active.
+ */
+static char *notify_socket = NULL; 
+
+int mconsole_init(void)
+{
+        /* long to avoid size mismatch warnings from gcc */
+        long sock;
+        int err;
+        char file[256];
+
+        if(umid_file_name("mconsole", file, sizeof(file))) return(-1);
+        snprintf(mconsole_socket_name, sizeof(file), "%s", file);
+
+        sock = os_create_unix_socket(file, sizeof(file), 1);
+        if (sock < 0){
+                printk("Failed to initialize management console\n");
+                return(1);
+        }
+
+        register_reboot_notifier(&reboot_notifier);
+
+        err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
+                             SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
+                             "mconsole", (void *)sock);
+        if (err){
+                printk("Failed to get IRQ for management console\n");
+                return(1);
+        }
+
+        if(notify_socket != NULL){
+                notify_socket = uml_strdup(notify_socket);
+                if(notify_socket != NULL)
+                        mconsole_notify(notify_socket, MCONSOLE_SOCKET,
+                                        mconsole_socket_name, 
+                                        strlen(mconsole_socket_name) + 1);
+                else printk(KERN_ERR "mconsole_setup failed to strdup "
+                            "string\n");
+        }
+
+        printk("mconsole (version %d) initialized on %s\n", 
+               MCONSOLE_VERSION, mconsole_socket_name);
+        return(0);
+}
+
+__initcall(mconsole_init);
+
+static int write_proc_mconsole(struct file *file, const char __user *buffer,
+                               unsigned long count, void *data)
+{
+        char *buf;
+
+        buf = kmalloc(count + 1, GFP_KERNEL);
+        if(buf == NULL) 
+                return(-ENOMEM);
+
+        if(copy_from_user(buf, buffer, count)){
+                count = -EFAULT;
+                goto out;
+        }
+
+        buf[count] = '\0';
+
+        mconsole_notify(notify_socket, MCONSOLE_USER_NOTIFY, buf, count);
+ out:
+        kfree(buf);
+        return(count);
+}
+
+static int create_proc_mconsole(void)
+{
+        struct proc_dir_entry *ent;
+
+        if(notify_socket == NULL) return(0);
+
+        ent = create_proc_entry("mconsole", S_IFREG | 0200, NULL);
+        if(ent == NULL){
+                printk("create_proc_mconsole : create_proc_entry failed\n");
+                return(0);
+        }
+
+        ent->read_proc = NULL;
+        ent->write_proc = write_proc_mconsole;
+        return(0);
+}
+
+static DEFINE_SPINLOCK(notify_spinlock);
+
+void lock_notify(void)
+{
+        spin_lock(&notify_spinlock);
+}
+
+void unlock_notify(void)
+{
+        spin_unlock(&notify_spinlock);
+}
+
+__initcall(create_proc_mconsole);
+
+#define NOTIFY "=notify:"
+
+static int mconsole_setup(char *str)
+{
+        if(!strncmp(str, NOTIFY, strlen(NOTIFY))){
+                str += strlen(NOTIFY);
+                notify_socket = str;
+        }
+        else printk(KERN_ERR "mconsole_setup : Unknown option - '%s'\n", str);
+        return(1);
+}
+
+__setup("mconsole", mconsole_setup);
+
+__uml_help(mconsole_setup,
+"mconsole=notify:<socket>\n"
+"    Requests that the mconsole driver send a message to the named Unix\n"
+"    socket containing the name of the mconsole socket.  This also serves\n"
+"    to notify outside processes when UML has booted far enough to respond\n"
+"    to mconsole requests.\n\n"
+);
+
+static int notify_panic(struct notifier_block *self, unsigned long unused1,
+                        void *ptr)
+{
+        char *message = ptr;
+
+        if(notify_socket == NULL) return(0);
+
+        mconsole_notify(notify_socket, MCONSOLE_PANIC, message, 
+                        strlen(message) + 1);
+        return(0);
+}
+
+static struct notifier_block panic_exit_notifier = {
+        .notifier_call          = notify_panic,
+        .next                   = NULL,
+        .priority               = 1
+};
+
+static int add_notifier(void)
+{
+        notifier_chain_register(&panic_notifier_list, &panic_exit_notifier);
+        return(0);
+}
+
+__initcall(add_notifier);
+
+char *mconsole_notify_socket(void)
+{
+        return(notify_socket);
+}
+
+EXPORT_SYMBOL(mconsole_notify_socket);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
new file mode 100644
index 000000000000..fe5afb13252c
--- /dev/null
+++ b/arch/um/drivers/mconsole_user.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include "user.h"
+#include "mconsole.h"
+#include "umid.h"
+
+static struct mconsole_command commands[] = {
+        { "version", mconsole_version, MCONSOLE_INTR },
+        { "halt", mconsole_halt, MCONSOLE_PROC },
+        { "reboot", mconsole_reboot, MCONSOLE_PROC },
+        { "config", mconsole_config, MCONSOLE_PROC },
+        { "remove", mconsole_remove, MCONSOLE_PROC },
+        { "sysrq", mconsole_sysrq, MCONSOLE_INTR },
+        { "help", mconsole_help, MCONSOLE_INTR },
+        { "cad", mconsole_cad, MCONSOLE_INTR },
+        { "stop", mconsole_stop, MCONSOLE_PROC },
+        { "go", mconsole_go, MCONSOLE_INTR },
+        { "log", mconsole_log, MCONSOLE_INTR },
+        { "proc", mconsole_proc, MCONSOLE_PROC },
+};
+
+/* Initialized in mconsole_init, which is an initcall */
+char mconsole_socket_name[256];
+
+int mconsole_reply_v0(struct mc_request *req, char *reply)
+{
+        struct iovec iov;
+        struct msghdr msg;
+
+        iov.iov_base = reply;
+        iov.iov_len = strlen(reply);
+
+        msg.msg_name = &(req->origin);
+        msg.msg_namelen = req->originlen;
+        msg.msg_iov = &iov;
+        msg.msg_iovlen = 1;
+        msg.msg_control = NULL;
+        msg.msg_controllen = 0;
+        msg.msg_flags = 0;
+
+        return sendmsg(req->originating_fd, &msg, 0);
+}
+
+static struct mconsole_command *mconsole_parse(struct mc_request *req)
+{
+        struct mconsole_command *cmd;
+        int i;
+
+        for(i=0;i<sizeof(commands)/sizeof(commands[0]);i++){
+                cmd = &commands[i];
+                if(!strncmp(req->request.data, cmd->command, 
+                            strlen(cmd->command))){
+                        return(cmd);
+                }
+        }
+        return(NULL);
+}
+
+#define MIN(a,b) ((a)<(b) ? (a):(b))
+
+#define STRINGX(x) #x
+#define STRING(x) STRINGX(x)
+
+int mconsole_get_request(int fd, struct mc_request *req)
+{
+        int len;
+
+        req->originlen = sizeof(req->origin);
+        req->len = recvfrom(fd, &req->request, sizeof(req->request), 0,
+                            (struct sockaddr *) req->origin, &req->originlen);
+        if (req->len < 0)
+                return 0;
+
+        req->originating_fd = fd;
+
+        if(req->request.magic != MCONSOLE_MAGIC){
+                /* Unversioned request */
+                len = MIN(sizeof(req->request.data) - 1, 
+                          strlen((char *) &req->request));
+                memmove(req->request.data, &req->request, len);
+                req->request.data[len] = '\0';
+
+                req->request.magic = MCONSOLE_MAGIC;
+                req->request.version = 0;
+                req->request.len = len;
+
+                mconsole_reply_v0(req, "ERR Version 0 mconsole clients are "
+                                  "not supported by this driver");
+                return(0);
+        }
+
+        if(req->request.len >= MCONSOLE_MAX_DATA){
+                mconsole_reply(req, "Request too large", 1, 0);
+                return(0);
+        }
+        if(req->request.version != MCONSOLE_VERSION){
+                mconsole_reply(req, "This driver only supports version " 
+                               STRING(MCONSOLE_VERSION) " clients", 1, 0);
+        }
+        
+        req->request.data[req->request.len] = '\0';
+        req->cmd = mconsole_parse(req);
+        if(req->cmd == NULL){
+                mconsole_reply(req, "Unknown command", 1, 0);
+                return(0);
+        }
+
+        return(1);
+}
+
+int mconsole_reply(struct mc_request *req, char *str, int err, int more)
+{
+        struct mconsole_reply reply;
+        int total, len, n;
+
+        total = strlen(str);
+        do {
+                reply.err = err;
+
+                /* err can only be true on the first packet */
+                err = 0;
+
+                len = MIN(total, MCONSOLE_MAX_DATA - 1);
+
+                if(len == total) reply.more = more;
+                else reply.more = 1;
+
+                memcpy(reply.data, str, len);
+                reply.data[len] = '\0';
+                total -= len;
+                str += len;
+                reply.len = len + 1;
+
+                len = sizeof(reply) + reply.len - sizeof(reply.data);
+
+                n = sendto(req->originating_fd, &reply, len, 0,
+                           (struct sockaddr *) req->origin, req->originlen);
+
+                if(n < 0) return(-errno);
+        } while(total > 0);
+        return(0);
+}
+
+int mconsole_unlink_socket(void)
+{
+        unlink(mconsole_socket_name);
+        return 0;
+}
+
+static int notify_sock = -1;
+
+int mconsole_notify(char *sock_name, int type, const void *data, int len)
+{
+        struct sockaddr_un target;
+        struct mconsole_notify packet;
+        int n, err = 0;
+
+        lock_notify();
+        if(notify_sock < 0){
+                notify_sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+                if(notify_sock < 0){
+                        printk("mconsole_notify - socket failed, errno = %d\n",
+                               errno);
+                        err = -errno;
+                }
+        }
+        unlock_notify();
+        
+        if(err)
+                return(err);
+
+        target.sun_family = AF_UNIX;
+        strcpy(target.sun_path, sock_name);
+
+        packet.magic = MCONSOLE_MAGIC;
+        packet.version = MCONSOLE_VERSION;
+        packet.type = type;
+        len = (len > sizeof(packet.data)) ? sizeof(packet.data) : len;
+        packet.len = len;
+        memcpy(packet.data, data, len);
+
+        err = 0;
+        len = sizeof(packet) + packet.len - sizeof(packet.data);
+        n = sendto(notify_sock, &packet, len, 0, (struct sockaddr *) &target, 
+                   sizeof(target));
+        if(n < 0){
+                printk("mconsole_notify - sendto failed, errno = %d\n", errno);
+                err = -errno;
+        }
+        return(err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
new file mode 100644
index 000000000000..a63231dffe05
--- /dev/null
+++ b/arch/um/drivers/mmapper_kern.c
@@ -0,0 +1,150 @@
+/*
+ * arch/um/drivers/mmapper_kern.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * Copyright (C) 2000 RidgeRun, Inc.
+ * Author: RidgeRun, Inc.
+ *         Greg Lonnon glonnon@ridgerun.com or info@ridgerun.com
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kdev_t.h>
+#include <linux/time.h>
+#include <linux/devfs_fs_kernel.h>
+#include <linux/module.h>
+#include <linux/mm.h> 
+#include <linux/slab.h>
+#include <linux/init.h> 
+#include <linux/smp_lock.h>
+#include <asm/uaccess.h>
+#include <asm/irq.h>
+#include <asm/pgtable.h>
+#include "mem_user.h"
+#include "user_util.h"
+ 
+/* These are set in mmapper_init, which is called at boot time */
+static unsigned long mmapper_size;
+static unsigned long p_buf = 0;
+static char *v_buf = NULL;
+
+static ssize_t
+mmapper_read(struct file *file, char *buf, size_t count, loff_t *ppos)
+{
+        if(*ppos > mmapper_size)
+                return -EINVAL;
+
+        if(count + *ppos > mmapper_size)
+                count = count + *ppos - mmapper_size;
+
+        if(count < 0)
+                return -EINVAL;
+ 
+        copy_to_user(buf,&v_buf[*ppos],count);
+        
+        return count;
+}
+
+static ssize_t
+mmapper_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
+{
+        if(*ppos > mmapper_size)
+                return -EINVAL;
+
+        if(count + *ppos > mmapper_size)
+                count = count + *ppos - mmapper_size;
+
+        if(count < 0)
+                return -EINVAL;
+
+        copy_from_user(&v_buf[*ppos],buf,count);
+        
+        return count;
+}
+
+static int 
+mmapper_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+         unsigned long arg)
+{
+        return(-ENOIOCTLCMD);
+}
+
+static int 
+mmapper_mmap(struct file *file, struct vm_area_struct * vma)
+{
+        int ret = -EINVAL;
+        int size;
+
+        lock_kernel();
+        if (vma->vm_pgoff != 0)
+                goto out;
+        
+        size = vma->vm_end - vma->vm_start;
+        if(size > mmapper_size) return(-EFAULT);
+
+        /* XXX A comment above remap_pfn_range says it should only be
+         * called when the mm semaphore is held
+         */
+        if (remap_pfn_range(vma, vma->vm_start, p_buf >> PAGE_SHIFT, size,
+                             vma->vm_page_prot))
+                goto out;
+        ret = 0;
+out:
+        unlock_kernel();
+        return ret;
+}
+
+static int
+mmapper_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static int 
+mmapper_release(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static struct file_operations mmapper_fops = {
+        .owner          = THIS_MODULE,
+        .read           = mmapper_read,
+        .write          = mmapper_write,
+        .ioctl          = mmapper_ioctl,
+        .mmap           = mmapper_mmap,
+        .open           = mmapper_open,
+        .release        = mmapper_release,
+};
+
+static int __init mmapper_init(void)
+{
+        printk(KERN_INFO "Mapper v0.1\n");
+
+        v_buf = (char *) find_iomem("mmapper", &mmapper_size);
+        if(mmapper_size == 0){
+                printk(KERN_ERR "mmapper_init - find_iomem failed\n");
+                return(0);
+        }
+
+        p_buf = __pa(v_buf);
+
+        devfs_mk_cdev(MKDEV(30, 0), S_IFCHR|S_IRUGO|S_IWUGO, "mmapper");
+        return(0);
+}
+
+static void mmapper_exit(void)
+{
+}
+
+module_init(mmapper_init);
+module_exit(mmapper_exit);
+
+MODULE_AUTHOR("Greg Lonnon <glonnon@ridgerun.com>");
+MODULE_DESCRIPTION("DSPLinux simulator mmapper driver");
+/*
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
new file mode 100644
index 000000000000..4eeaf88c1e97
--- /dev/null
+++ b/arch/um/drivers/net_kern.c
@@ -0,0 +1,896 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/netdevice.h"
+#include "linux/rtnetlink.h"
+#include "linux/skbuff.h"
+#include "linux/socket.h"
+#include "linux/spinlock.h"
+#include "linux/module.h"
+#include "linux/init.h"
+#include "linux/etherdevice.h"
+#include "linux/list.h"
+#include "linux/inetdevice.h"
+#include "linux/ctype.h"
+#include "linux/bootmem.h"
+#include "linux/ethtool.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+
+#define DRIVER_NAME "uml-netdev"
+
+static DEFINE_SPINLOCK(opened_lock);
+LIST_HEAD(opened);
+
+static int uml_net_rx(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        int pkt_len;
+        struct sk_buff *skb;
+
+        /* If we can't allocate memory, try again next round. */
+        skb = dev_alloc_skb(dev->mtu);
+        if (skb == NULL) {
+                lp->stats.rx_dropped++;
+                return 0;
+        }
+
+        skb->dev = dev;
+        skb_put(skb, dev->mtu);
+        skb->mac.raw = skb->data;
+        pkt_len = (*lp->read)(lp->fd, &skb, lp);
+
+        if (pkt_len > 0) {
+                skb_trim(skb, pkt_len);
+                skb->protocol = (*lp->protocol)(skb);
+                netif_rx(skb);
+
+                lp->stats.rx_bytes += skb->len;
+                lp->stats.rx_packets++;
+                return pkt_len;
+        }
+
+        kfree_skb(skb);
+        return pkt_len;
+}
+
+irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct uml_net_private *lp = dev->priv;
+        int err;
+
+        if(!netif_running(dev))
+                return(IRQ_NONE);
+
+        spin_lock(&lp->lock);
+        while((err = uml_net_rx(dev)) > 0) ;
+        if(err < 0) {
+                printk(KERN_ERR 
+                       "Device '%s' read returned %d, shutting it down\n", 
+                       dev->name, err);
+                dev_close(dev);
+                goto out;
+        }
+        reactivate_fd(lp->fd, UM_ETH_IRQ);
+
+ out:
+        spin_unlock(&lp->lock);
+        return(IRQ_HANDLED);
+}
+
+static int uml_net_open(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        char addr[sizeof("255.255.255.255\0")];
+        int err;
+
+        spin_lock(&lp->lock);
+
+        if(lp->fd >= 0){
+                err = -ENXIO;
+                goto out;
+        }
+
+        if(!lp->have_mac){
+                dev_ip_addr(dev, addr, &lp->mac[2]);
+                set_ether_mac(dev, lp->mac);
+        }
+
+        lp->fd = (*lp->open)(&lp->user);
+        if(lp->fd < 0){
+                err = lp->fd;
+                goto out;
+        }
+
+        err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
+                             SA_INTERRUPT | SA_SHIRQ, dev->name, dev);
+        if(err != 0){
+                printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
+                if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
+                lp->fd = -1;
+                err = -ENETUNREACH;
+        }
+
+        lp->tl.data = (unsigned long) &lp->user;
+        netif_start_queue(dev);
+
+        /* clear buffer - it can happen that the host side of the interface
+         * is full when we get here.  In this case, new data is never queued,
+         * SIGIOs never arrive, and the net never works.
+         */
+        while((err = uml_net_rx(dev)) > 0) ;
+
+ out:
+        spin_unlock(&lp->lock);
+        return(err);
+}
+
+static int uml_net_close(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        
+        netif_stop_queue(dev);
+        spin_lock(&lp->lock);
+
+        free_irq_by_irq_and_dev(dev->irq, dev);
+        free_irq(dev->irq, dev);
+        if(lp->close != NULL)
+                (*lp->close)(lp->fd, &lp->user);
+        lp->fd = -1;
+
+        spin_unlock(&lp->lock);
+        return 0;
+}
+
+static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        unsigned long flags;
+        int len;
+
+        netif_stop_queue(dev);
+
+        spin_lock_irqsave(&lp->lock, flags);
+
+        len = (*lp->write)(lp->fd, &skb, lp);
+
+        if(len == skb->len) {
+                lp->stats.tx_packets++;
+                lp->stats.tx_bytes += skb->len;
+                dev->trans_start = jiffies;
+                netif_start_queue(dev);
+
+                /* this is normally done in the interrupt when tx finishes */
+                netif_wake_queue(dev);
+        } 
+        else if(len == 0){
+                netif_start_queue(dev);
+                lp->stats.tx_dropped++;
+        }
+        else {
+                netif_start_queue(dev);
+                printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
+        }
+
+        spin_unlock_irqrestore(&lp->lock, flags);
+
+        dev_kfree_skb(skb);
+
+        return 0;
+}
+
+static struct net_device_stats *uml_net_get_stats(struct net_device *dev)
+{
+        struct uml_net_private *lp = dev->priv;
+        return &lp->stats;
+}
+
+static void uml_net_set_multicast_list(struct net_device *dev)
+{
+        if (dev->flags & IFF_PROMISC) return;
+        else if (dev->mc_count) dev->flags |= IFF_ALLMULTI;
+        else dev->flags &= ~IFF_ALLMULTI;
+}
+
+static void uml_net_tx_timeout(struct net_device *dev)
+{
+        dev->trans_start = jiffies;
+        netif_wake_queue(dev);
+}
+
+static int uml_net_set_mac(struct net_device *dev, void *addr)
+{
+        struct uml_net_private *lp = dev->priv;
+        struct sockaddr *hwaddr = addr;
+
+        spin_lock(&lp->lock);
+        memcpy(dev->dev_addr, hwaddr->sa_data, ETH_ALEN);
+        spin_unlock(&lp->lock);
+
+        return(0);
+}
+
+static int uml_net_change_mtu(struct net_device *dev, int new_mtu)
+{
+        struct uml_net_private *lp = dev->priv;
+        int err = 0;
+
+        spin_lock(&lp->lock);
+
+        new_mtu = (*lp->set_mtu)(new_mtu, &lp->user);
+        if(new_mtu < 0){
+                err = new_mtu;
+                goto out;
+        }
+
+        dev->mtu = new_mtu;
+
+ out:
+        spin_unlock(&lp->lock);
+        return err;
+}
+
+static int uml_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+{
+        static const struct ethtool_drvinfo info = {
+                .cmd     = ETHTOOL_GDRVINFO,
+                .driver  = DRIVER_NAME,
+                .version = "42",
+        };
+        void *useraddr;
+        u32 ethcmd;
+
+        switch (cmd) {
+        case SIOCETHTOOL:
+                useraddr = ifr->ifr_data;
+                if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
+                        return -EFAULT;
+                switch (ethcmd) {
+                case ETHTOOL_GDRVINFO:
+                        if (copy_to_user(useraddr, &info, sizeof(info)))
+                                return -EFAULT;
+                        return 0;
+                default:
+                        return -EOPNOTSUPP;
+                }
+        default:
+                return -EINVAL;
+        }
+}
+
+void uml_net_user_timer_expire(unsigned long _conn)
+{
+#ifdef undef
+        struct connection *conn = (struct connection *)_conn;
+
+        dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
+        do_connect(conn);
+#endif
+}
+
+static DEFINE_SPINLOCK(devices_lock);
+static struct list_head devices = LIST_HEAD_INIT(devices);
+
+static struct device_driver uml_net_driver = {
+        .name  = DRIVER_NAME,
+        .bus   = &platform_bus_type,
+};
+static int driver_registered;
+
+static int eth_configure(int n, void *init, char *mac,
+                         struct transport *transport)
+{
+        struct uml_net *device;
+        struct net_device *dev;
+        struct uml_net_private *lp;
+        int save, err, size;
+
+        size = transport->private_size + sizeof(struct uml_net_private) + 
+                sizeof(((struct uml_net_private *) 0)->user);
+
+        device = kmalloc(sizeof(*device), GFP_KERNEL);
+        if (device == NULL) {
+                printk(KERN_ERR "eth_configure failed to allocate uml_net\n");
+                return(1);
+        }
+
+        memset(device, 0, sizeof(*device));
+        INIT_LIST_HEAD(&device->list);
+        device->index = n;
+
+        spin_lock(&devices_lock);
+        list_add(&device->list, &devices);
+        spin_unlock(&devices_lock);
+
+        if (setup_etheraddr(mac, device->mac))
+                device->have_mac = 1;
+
+        printk(KERN_INFO "Netdevice %d ", n);
+        if (device->have_mac)
+                printk("(%02x:%02x:%02x:%02x:%02x:%02x) ",
+                       device->mac[0], device->mac[1],
+                       device->mac[2], device->mac[3],
+                       device->mac[4], device->mac[5]);
+        printk(": ");
+        dev = alloc_etherdev(size);
+        if (dev == NULL) {
+                printk(KERN_ERR "eth_configure: failed to allocate device\n");
+                return 1;
+        }
+
+        /* sysfs register */
+        if (!driver_registered) {
+                driver_register(&uml_net_driver);
+                driver_registered = 1;
+        }
+        device->pdev.id = n;
+        device->pdev.name = DRIVER_NAME;
+        platform_device_register(&device->pdev);
+        SET_NETDEV_DEV(dev,&device->pdev.dev);
+
+        /* If this name ends up conflicting with an existing registered
+         * netdevice, that is OK, register_netdev{,ice}() will notice this
+         * and fail.
+         */
+        snprintf(dev->name, sizeof(dev->name), "eth%d", n);
+        device->dev = dev;
+
+        (*transport->kern->init)(dev, init);
+
+        dev->mtu = transport->user->max_packet;
+        dev->open = uml_net_open;
+        dev->hard_start_xmit = uml_net_start_xmit;
+        dev->stop = uml_net_close;
+        dev->get_stats = uml_net_get_stats;
+        dev->set_multicast_list = uml_net_set_multicast_list;
+        dev->tx_timeout = uml_net_tx_timeout;
+        dev->set_mac_address = uml_net_set_mac;
+        dev->change_mtu = uml_net_change_mtu;
+        dev->do_ioctl = uml_net_ioctl;
+        dev->watchdog_timeo = (HZ >> 1);
+        dev->irq = UM_ETH_IRQ;
+
+        rtnl_lock();
+        err = register_netdevice(dev);
+        rtnl_unlock();
+        if (err) {
+                device->dev = NULL;
+                /* XXX: should we call ->remove() here? */
+                free_netdev(dev);
+                return 1;
+        }
+        lp = dev->priv;
+
+        /* lp.user is the first four bytes of the transport data, which
+         * has already been initialized.  This structure assignment will
+         * overwrite that, so we make sure that .user gets overwritten with
+         * what it already has.
+         */
+        save = lp->user[0];
+        *lp = ((struct uml_net_private)
+                { .list                 = LIST_HEAD_INIT(lp->list),
+                  .dev                  = dev,
+                  .fd                   = -1,
+                  .mac                  = { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
+                  .have_mac             = device->have_mac,
+                  .protocol             = transport->kern->protocol,
+                  .open                 = transport->user->open,
+                  .close                = transport->user->close,
+                  .remove               = transport->user->remove,
+                  .read                 = transport->kern->read,
+                  .write                = transport->kern->write,
+                  .add_address          = transport->user->add_address,
+                  .delete_address       = transport->user->delete_address,
+                  .set_mtu              = transport->user->set_mtu,
+                  .user                 = { save } });
+
+        init_timer(&lp->tl);
+        spin_lock_init(&lp->lock);
+        lp->tl.function = uml_net_user_timer_expire;
+        if (lp->have_mac)
+                memcpy(lp->mac, device->mac, sizeof(lp->mac));
+
+        if (transport->user->init) 
+                (*transport->user->init)(&lp->user, dev);
+
+        if (device->have_mac)
+                set_ether_mac(dev, device->mac);
+
+        spin_lock(&opened_lock);
+        list_add(&lp->list, &opened);
+        spin_unlock(&opened_lock);
+
+        return(0);
+}
+
+static struct uml_net *find_device(int n)
+{
+        struct uml_net *device;
+        struct list_head *ele;
+
+        spin_lock(&devices_lock);
+        list_for_each(ele, &devices){
+                device = list_entry(ele, struct uml_net, list);
+                if(device->index == n)
+                        goto out;
+        }
+        device = NULL;
+ out:
+        spin_unlock(&devices_lock);
+        return(device);
+}
+
+static int eth_parse(char *str, int *index_out, char **str_out)
+{
+        char *end;
+        int n;
+
+        n = simple_strtoul(str, &end, 0);
+        if(end == str){
+                printk(KERN_ERR "eth_setup: Failed to parse '%s'\n", str);
+                return(1);
+        }
+        if(n < 0){
+                printk(KERN_ERR "eth_setup: device %d is negative\n", n);
+                return(1);
+        }
+        str = end;
+        if(*str != '='){
+                printk(KERN_ERR 
+                       "eth_setup: expected '=' after device number\n");
+                return(1);
+        }
+        str++;
+        if(find_device(n)){
+                printk(KERN_ERR "eth_setup: Device %d already configured\n",
+                       n);
+                return(1);
+        }
+        if(index_out) *index_out = n;
+        *str_out = str;
+        return(0);
+}
+
+struct eth_init {
+        struct list_head list;
+        char *init;
+        int index;
+};
+
+/* Filled in at boot time.  Will need locking if the transports become
+ * modular.
+ */
+struct list_head transports = LIST_HEAD_INIT(transports);
+
+/* Filled in during early boot */
+struct list_head eth_cmd_line = LIST_HEAD_INIT(eth_cmd_line);
+
+static int check_transport(struct transport *transport, char *eth, int n,
+                           void **init_out, char **mac_out)
+{
+        int len;
+
+        len = strlen(transport->name);
+        if(strncmp(eth, transport->name, len))
+                return(0);
+
+        eth += len;
+        if(*eth == ',')
+                eth++;
+        else if(*eth != '\0')
+                return(0);
+
+        *init_out = kmalloc(transport->setup_size, GFP_KERNEL);
+        if(*init_out == NULL)
+                return(1);
+
+        if(!transport->setup(eth, mac_out, *init_out)){
+                kfree(*init_out);
+                *init_out = NULL;
+        }
+        return(1);
+}
+
+void register_transport(struct transport *new)
+{
+        struct list_head *ele, *next;
+        struct eth_init *eth;
+        void *init;
+        char *mac = NULL;
+        int match;
+
+        list_add(&new->list, &transports);
+
+        list_for_each_safe(ele, next, &eth_cmd_line){
+                eth = list_entry(ele, struct eth_init, list);
+                match = check_transport(new, eth->init, eth->index, &init,
+                                        &mac);
+                if(!match)
+                        continue;
+                else if(init != NULL){
+                        eth_configure(eth->index, init, mac, new);
+                        kfree(init);
+                }
+                list_del(&eth->list);
+        }
+}
+
+static int eth_setup_common(char *str, int index)
+{
+        struct list_head *ele;
+        struct transport *transport;
+        void *init;
+        char *mac = NULL;
+
+        list_for_each(ele, &transports){
+                transport = list_entry(ele, struct transport, list);
+                if(!check_transport(transport, str, index, &init, &mac))
+                        continue;
+                if(init != NULL){
+                        eth_configure(index, init, mac, transport);
+                        kfree(init);
+                }
+                return(1);
+        }
+        return(0);
+}
+
+static int eth_setup(char *str)
+{
+        struct eth_init *new;
+        int n, err;
+
+        err = eth_parse(str, &n, &str);
+        if(err) return(1);
+
+        new = alloc_bootmem(sizeof(new));
+        if (new == NULL){
+                printk("eth_init : alloc_bootmem failed\n");
+                return(1);
+        }
+
+        INIT_LIST_HEAD(&new->list);
+        new->index = n;
+        new->init = str;
+
+        list_add_tail(&new->list, &eth_cmd_line);
+        return(1);
+}
+
+__setup("eth", eth_setup);
+__uml_help(eth_setup,
+"eth[0-9]+=<transport>,<options>\n"
+"    Configure a network device.\n\n"
+);
+
+#if 0
+static int eth_init(void)
+{
+        struct list_head *ele, *next;
+        struct eth_init *eth;
+
+        list_for_each_safe(ele, next, &eth_cmd_line){
+                eth = list_entry(ele, struct eth_init, list);
+
+                if(eth_setup_common(eth->init, eth->index))
+                        list_del(&eth->list);
+        }
+        
+        return(1);
+}
+__initcall(eth_init);
+#endif
+
+static int net_config(char *str)
+{
+        int n, err;
+
+        err = eth_parse(str, &n, &str);
+        if(err) return(err);
+
+        str = uml_strdup(str);
+        if(str == NULL){
+                printk(KERN_ERR "net_config failed to strdup string\n");
+                return(-1);
+        }
+        err = !eth_setup_common(str, n);
+        if(err) 
+                kfree(str);
+        return(err);
+}
+
+static int net_remove(char *str)
+{
+        struct uml_net *device;
+        struct net_device *dev;
+        struct uml_net_private *lp;
+        char *end;
+        int n;
+
+        n = simple_strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str))
+                return(-1);
+
+        device = find_device(n);
+        if(device == NULL)
+                return(0);
+
+        dev = device->dev;
+        lp = dev->priv;
+        if(lp->fd > 0) return(-1);
+        if(lp->remove != NULL) (*lp->remove)(&lp->user);
+        unregister_netdev(dev);
+        platform_device_unregister(&device->pdev);
+
+        list_del(&device->list);
+        kfree(device);
+        free_netdev(dev);
+        return(0);
+}
+
+static struct mc_device net_mc = {
+        .name           = "eth",
+        .config         = net_config,
+        .get_config     = NULL,
+        .remove         = net_remove,
+};
+
+static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
+                              void *ptr)
+{
+        struct in_ifaddr *ifa = ptr;
+        u32 addr = ifa->ifa_address;
+        u32 netmask = ifa->ifa_mask;
+        struct net_device *dev = ifa->ifa_dev->dev;
+        struct uml_net_private *lp;
+        void (*proc)(unsigned char *, unsigned char *, void *);
+        unsigned char addr_buf[4], netmask_buf[4];
+
+        if(dev->open != uml_net_open) return(NOTIFY_DONE);
+
+        lp = dev->priv;
+
+        proc = NULL;
+        switch (event){
+        case NETDEV_UP:
+                proc = lp->add_address;
+                break;
+        case NETDEV_DOWN:
+                proc = lp->delete_address;
+                break;
+        }
+        if(proc != NULL){
+                addr_buf[0] = addr & 0xff;
+                addr_buf[1] = (addr >> 8) & 0xff;
+                addr_buf[2] = (addr >> 16) & 0xff;
+                addr_buf[3] = addr >> 24;
+                netmask_buf[0] = netmask & 0xff;
+                netmask_buf[1] = (netmask >> 8) & 0xff;
+                netmask_buf[2] = (netmask >> 16) & 0xff;
+                netmask_buf[3] = netmask >> 24;
+                (*proc)(addr_buf, netmask_buf, &lp->user);
+        }
+        return(NOTIFY_DONE);
+}
+
+struct notifier_block uml_inetaddr_notifier = {
+        .notifier_call          = uml_inetaddr_event,
+};
+
+static int uml_net_init(void)
+{
+        struct list_head *ele;
+        struct uml_net_private *lp;     
+        struct in_device *ip;
+        struct in_ifaddr *in;
+
+        mconsole_register_dev(&net_mc);
+        register_inetaddr_notifier(&uml_inetaddr_notifier);
+
+        /* Devices may have been opened already, so the uml_inetaddr_notifier
+         * didn't get a chance to run for them.  This fakes it so that
+         * addresses which have already been set up get handled properly.
+         */
+        list_for_each(ele, &opened){
+                lp = list_entry(ele, struct uml_net_private, list);
+                ip = lp->dev->ip_ptr;
+                if(ip == NULL) continue;
+                in = ip->ifa_list;
+                while(in != NULL){
+                        uml_inetaddr_event(NULL, NETDEV_UP, in);
+                        in = in->ifa_next;
+                }
+        }       
+
+        return(0);
+}
+
+__initcall(uml_net_init);
+
+static void close_devices(void)
+{
+        struct list_head *ele;
+        struct uml_net_private *lp;
+
+        list_for_each(ele, &opened){
+                lp = list_entry(ele, struct uml_net_private, list);
+                if((lp->close != NULL) && (lp->fd >= 0))
+                        (*lp->close)(lp->fd, &lp->user);
+                if(lp->remove != NULL) (*lp->remove)(&lp->user);
+        }
+}
+
+__uml_exitcall(close_devices);
+
+int setup_etheraddr(char *str, unsigned char *addr)
+{
+        char *end;
+        int i;
+
+        if(str == NULL)
+                return(0);
+        for(i=0;i<6;i++){
+                addr[i] = simple_strtoul(str, &end, 16);
+                if((end == str) ||
+                   ((*end != ':') && (*end != ',') && (*end != '\0'))){
+                        printk(KERN_ERR 
+                               "setup_etheraddr: failed to parse '%s' "
+                               "as an ethernet address\n", str);
+                        return(0);
+                }
+                str = end + 1;
+        }
+        if(addr[0] & 1){
+                printk(KERN_ERR 
+                       "Attempt to assign a broadcast ethernet address to a "
+                       "device disallowed\n");
+                return(0);
+        }
+        return(1);
+}
+
+void dev_ip_addr(void *d, char *buf, char *bin_buf)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        u32 addr;
+
+        if((ip == NULL) || ((in = ip->ifa_list) == NULL)){
+                printk(KERN_WARNING "dev_ip_addr - device not assigned an "
+                       "IP address\n");
+                return;
+        }
+        addr = in->ifa_address;
+        sprintf(buf, "%d.%d.%d.%d", addr & 0xff, (addr >> 8) & 0xff, 
+                (addr >> 16) & 0xff, addr >> 24);
+        if(bin_buf){
+                bin_buf[0] = addr & 0xff;
+                bin_buf[1] = (addr >> 8) & 0xff;
+                bin_buf[2] = (addr >> 16) & 0xff;
+                bin_buf[3] = addr >> 24;
+        }
+}
+
+void set_ether_mac(void *d, unsigned char *addr)
+{
+        struct net_device *dev = d;
+
+        memcpy(dev->dev_addr, addr, ETH_ALEN);  
+}
+
+struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra)
+{
+        if((skb != NULL) && (skb_tailroom(skb) < extra)){
+                struct sk_buff *skb2;
+
+                skb2 = skb_copy_expand(skb, 0, extra, GFP_ATOMIC);
+                dev_kfree_skb(skb);
+                skb = skb2;
+        }
+        if(skb != NULL) skb_put(skb, extra);
+        return(skb);
+}
+
+void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *, 
+                                        void *), 
+                    void *arg)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        unsigned char address[4], netmask[4];
+
+        if(ip == NULL) return;
+        in = ip->ifa_list;
+        while(in != NULL){
+                address[0] = in->ifa_address & 0xff;
+                address[1] = (in->ifa_address >> 8) & 0xff;
+                address[2] = (in->ifa_address >> 16) & 0xff;
+                address[3] = in->ifa_address >> 24;
+                netmask[0] = in->ifa_mask & 0xff;
+                netmask[1] = (in->ifa_mask >> 8) & 0xff;
+                netmask[2] = (in->ifa_mask >> 16) & 0xff;
+                netmask[3] = in->ifa_mask >> 24;
+                (*cb)(address, netmask, arg);
+                in = in->ifa_next;
+        }
+}
+
+int dev_netmask(void *d, void *m)
+{
+        struct net_device *dev = d;
+        struct in_device *ip = dev->ip_ptr;
+        struct in_ifaddr *in;
+        __u32 *mask_out = m;
+
+        if(ip == NULL) 
+                return(1);
+
+        in = ip->ifa_list;
+        if(in == NULL) 
+                return(1);
+
+        *mask_out = in->ifa_mask;
+        return(0);
+}
+
+void *get_output_buffer(int *len_out)
+{
+        void *ret;
+
+        ret = (void *) __get_free_pages(GFP_KERNEL, 0);
+        if(ret) *len_out = PAGE_SIZE;
+        else *len_out = 0;
+        return(ret);
+}
+
+void free_output_buffer(void *buffer)
+{
+        free_pages((unsigned long) buffer, 0);
+}
+
+int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out, 
+                     char **gate_addr)
+{
+        char *remain;
+
+        remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
+        if(remain != NULL){
+                printk("tap_setup_common - Extra garbage on specification : "
+                       "'%s'\n", remain);
+                return(1);
+        }
+
+        return(0);
+}
+
+unsigned short eth_protocol(struct sk_buff *skb)
+{
+        return(eth_type_trans(skb, skb->dev));
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
new file mode 100644
index 000000000000..47229fe4a813
--- /dev/null
+++ b/arch/um/drivers/net_user.c
@@ -0,0 +1,255 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include "user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "net_user.h"
+#include "helper.h"
+#include "os.h"
+
+int tap_open_common(void *dev, char *gate_addr)
+{
+        int tap_addr[4];
+
+        if(gate_addr == NULL) return(0);
+        if(sscanf(gate_addr, "%d.%d.%d.%d", &tap_addr[0], 
+                  &tap_addr[1], &tap_addr[2], &tap_addr[3]) != 4){
+                printk("Invalid tap IP address - '%s'\n", gate_addr);
+                return(-EINVAL);
+        }
+        return(0);
+}
+
+void tap_check_ips(char *gate_addr, char *eth_addr)
+{
+        int tap_addr[4];
+
+        if((gate_addr != NULL) && 
+           (sscanf(gate_addr, "%d.%d.%d.%d", &tap_addr[0], 
+                   &tap_addr[1], &tap_addr[2], &tap_addr[3]) == 4) &&
+           (eth_addr[0] == tap_addr[0]) && 
+           (eth_addr[1] == tap_addr[1]) && 
+           (eth_addr[2] == tap_addr[2]) && 
+           (eth_addr[3] == tap_addr[3])){
+                printk("The tap IP address and the UML eth IP address"
+                       " must be different\n");
+        }
+}
+
+void read_output(int fd, char *output, int len)
+{
+        int remain, n, actual;
+        char c;
+
+        if(output == NULL){
+                output = &c;
+                len = sizeof(c);
+        }
+                
+        *output = '\0';
+        n = os_read_file(fd, &remain, sizeof(remain));
+        if(n != sizeof(remain)){
+                printk("read_output - read of length failed, err = %d\n", -n);
+                return;
+        }
+
+        while(remain != 0){
+                n = (remain < len) ? remain : len;
+                actual = os_read_file(fd, output, n);
+                if(actual != n){
+                        printk("read_output - read of data failed, "
+                               "err = %d\n", -actual);
+                        return;
+                }
+                remain -= actual;
+        }
+        return;
+}
+
+int net_read(int fd, void *buf, int len)
+{
+        int n;
+
+        n = os_read_file(fd,  buf,  len);
+
+        if(n == -EAGAIN)
+                return(0);
+        else if(n == 0)
+                return(-ENOTCONN);
+        return(n);
+}
+
+int net_recvfrom(int fd, void *buf, int len)
+{
+        int n;
+
+        while(((n = recvfrom(fd,  buf,  len, 0, NULL, NULL)) < 0) && 
+              (errno == EINTR)) ;
+
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);
+}
+
+int net_write(int fd, void *buf, int len)
+{
+        int n;
+
+        n = os_write_file(fd, buf, len);
+
+        if(n == -EAGAIN)
+                return(0);
+        else if(n == 0)
+                return(-ENOTCONN);
+        return(n);
+}
+
+int net_send(int fd, void *buf, int len)
+{
+        int n;
+
+        while(((n = send(fd, buf, len, 0)) < 0) && (errno == EINTR)) ;
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);      
+}
+
+int net_sendto(int fd, void *buf, int len, void *to, int sock_len)
+{
+        int n;
+
+        while(((n = sendto(fd, buf, len, 0, (struct sockaddr *) to,
+                           sock_len)) < 0) && (errno == EINTR)) ;
+        if(n < 0){
+                if(errno == EAGAIN) return(0);
+                return(-errno);
+        }
+        else if(n == 0) return(-ENOTCONN);
+        return(n);      
+}
+
+struct change_pre_exec_data {
+        int close_me;
+        int stdout;
+};
+
+static void change_pre_exec(void *arg)
+{
+        struct change_pre_exec_data *data = arg;
+
+        os_close_file(data->close_me);
+        dup2(data->stdout, 1);
+}
+
+static int change_tramp(char **argv, char *output, int output_len)
+{
+        int pid, fds[2], err;
+        struct change_pre_exec_data pe_data;
+
+        err = os_pipe(fds, 1, 0);
+        if(err < 0){
+                printk("change_tramp - pipe failed, err = %d\n", -err);
+                return(err);
+        }
+        pe_data.close_me = fds[0];
+        pe_data.stdout = fds[1];
+        pid = run_helper(change_pre_exec, &pe_data, argv, NULL);
+
+        read_output(fds[0], output, output_len);
+        os_close_file(fds[0]);
+        os_close_file(fds[1]);
+
+        if (pid > 0)
+                CATCH_EINTR(err = waitpid(pid, NULL, 0));
+        return(pid);
+}
+
+static void change(char *dev, char *what, unsigned char *addr,
+                   unsigned char *netmask)
+{
+        char addr_buf[sizeof("255.255.255.255\0")];
+        char netmask_buf[sizeof("255.255.255.255\0")];
+        char version[sizeof("nnnnn\0")];
+        char *argv[] = { "uml_net", version, what, dev, addr_buf, 
+                         netmask_buf, NULL };
+        char *output;
+        int output_len, pid;
+
+        sprintf(version, "%d", UML_NET_VERSION);
+        sprintf(addr_buf, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
+        sprintf(netmask_buf, "%d.%d.%d.%d", netmask[0], netmask[1], 
+                netmask[2], netmask[3]);
+
+        output_len = page_size();
+        output = um_kmalloc(output_len);
+        if(output == NULL)
+                printk("change : failed to allocate output buffer\n");
+
+        pid = change_tramp(argv, output, output_len);
+        if(pid < 0) return;
+
+        if(output != NULL){
+                printk("%s", output);
+                kfree(output);
+        }
+}
+
+void open_addr(unsigned char *addr, unsigned char *netmask, void *arg)
+{
+        change(arg, "add", addr, netmask);
+}
+
+void close_addr(unsigned char *addr, unsigned char *netmask, void *arg)
+{
+        change(arg, "del", addr, netmask);
+}
+
+char *split_if_spec(char *str, ...)
+{
+        char **arg, *end;
+        va_list ap;
+
+        va_start(ap, str);
+        while((arg = va_arg(ap, char **)) != NULL){
+                if(*str == '\0')
+                        return(NULL);
+                end = strchr(str, ',');
+                if(end != str)
+                        *arg = str;
+                if(end == NULL)
+                        return(NULL);
+                *end++ = '\0';
+                str = end;
+        }
+        va_end(ap);
+        return(str);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/null.c b/arch/um/drivers/null.c
new file mode 100644
index 000000000000..14cc5f78398a
--- /dev/null
+++ b/arch/um/drivers/null.c
@@ -0,0 +1,56 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include "chan_user.h"
+#include "os.h"
+
+static int null_chan;
+
+static void *null_init(char *str, int device, struct chan_opts *opts)
+{
+        return(&null_chan);
+}
+
+static int null_open(int input, int output, int primary, void *d,
+                     char **dev_out)
+{
+        *dev_out = NULL;
+        return(os_open_file(DEV_NULL, of_rdwr(OPENFLAGS()), 0));
+}
+
+static int null_read(int fd, char *c_out, void *unused)
+{
+        return(-ENODEV);
+}
+
+static void null_free(void *data)
+{
+}
+
+struct chan_ops null_ops = {
+        .type           = "null",
+        .init           = null_init,
+        .open           = null_open,
+        .close          = generic_close,
+        .read           = null_read,
+        .write          = generic_write,
+        .console_write  = generic_console_write,
+        .window_size    = generic_window_size,
+        .free           = null_free,
+        .winch          = 0,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/pcap_kern.c b/arch/um/drivers/pcap_kern.c
new file mode 100644
index 000000000000..07c80f2156ef
--- /dev/null
+++ b/arch/um/drivers/pcap_kern.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2002 Jeff Dike <jdike@karaya.com>
+ * Licensed under the GPL.
+ */
+
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "pcap_user.h"
+
+struct pcap_init {
+        char *host_if;
+        int promisc;
+        int optimize;
+        char *filter;
+};
+
+void pcap_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct pcap_data *ppri;
+        struct pcap_init *init = data;
+
+        pri = dev->priv;
+        ppri = (struct pcap_data *) pri->user;
+        ppri->host_if = init->host_if;
+        ppri->promisc = init->promisc;
+        ppri->optimize = init->optimize;
+        ppri->filter = init->filter;
+}
+
+static int pcap_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(pcap_user_read(fd, (*skb)->mac.raw, 
+                              (*skb)->dev->mtu + ETH_HEADER_OTHER,
+                              (struct pcap_data *) &lp->user));
+}
+
+static int pcap_write(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        return(-EPERM);
+}
+
+static struct net_kern_info pcap_kern_info = {
+        .init                   = pcap_init,
+        .protocol               = eth_protocol,
+        .read                   = pcap_read,
+        .write                  = pcap_write,
+};
+
+int pcap_setup(char *str, char **mac_out, void *data)
+{
+        struct pcap_init *init = data;
+        char *remain, *host_if = NULL, *options[2] = { NULL, NULL };
+        int i;
+
+        *init = ((struct pcap_init)
+                { .host_if      = "eth0",
+                  .promisc      = 1,
+                  .optimize     = 0,
+                  .filter       = NULL });
+
+        remain = split_if_spec(str, &host_if, &init->filter, 
+                               &options[0], &options[1], NULL);
+        if(remain != NULL){
+                printk(KERN_ERR "pcap_setup - Extra garbage on "
+                       "specification : '%s'\n", remain);
+                return(0);
+        }
+
+        if(host_if != NULL)
+                init->host_if = host_if;
+
+        for(i = 0; i < sizeof(options)/sizeof(options[0]); i++){
+                if(options[i] == NULL)
+                        continue;
+                if(!strcmp(options[i], "promisc"))
+                        init->promisc = 1;
+                else if(!strcmp(options[i], "nopromisc"))
+                        init->promisc = 0;
+                else if(!strcmp(options[i], "optimize"))
+                        init->optimize = 1;
+                else if(!strcmp(options[i], "nooptimize"))
+                        init->optimize = 0;
+                else printk("pcap_setup : bad option - '%s'\n", options[i]);
+        }
+
+        return(1);
+}
+
+static struct transport pcap_transport = {
+        .list           = LIST_HEAD_INIT(pcap_transport.list),
+        .name           = "pcap",
+        .setup          = pcap_setup,
+        .user           = &pcap_user_info,
+        .kern           = &pcap_kern_info,
+        .private_size   = sizeof(struct pcap_data),
+        .setup_size     = sizeof(struct pcap_init),
+};
+
+static int register_pcap(void)
+{
+        register_transport(&pcap_transport);
+        return(1);
+}
+
+__initcall(register_pcap);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/pcap_user.c b/arch/um/drivers/pcap_user.c
new file mode 100644
index 000000000000..edfcb29273e1
--- /dev/null
+++ b/arch/um/drivers/pcap_user.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2002 Jeff Dike <jdike@karaya.com>
+ * Licensed under the GPL.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <pcap.h>
+#include <asm/types.h>
+#include "net_user.h"
+#include "pcap_user.h"
+#include "user.h"
+
+#define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
+
+#define PCAP_FD(p) (*(int *)(p))
+
+static void pcap_user_init(void *data, void *dev)
+{
+        struct pcap_data *pri = data;
+        pcap_t *p;
+        char errors[PCAP_ERRBUF_SIZE];
+
+        p = pcap_open_live(pri->host_if, MAX_PACKET, pri->promisc, 0, errors);
+        if(p == NULL){
+                printk("pcap_user_init : pcap_open_live failed - '%s'\n", 
+                       errors);
+                return;
+        }
+
+        pri->dev = dev;
+        pri->pcap = p;
+}
+
+static int pcap_open(void *data)
+{
+        struct pcap_data *pri = data;
+        __u32 netmask;
+        int err;
+
+        if(pri->pcap == NULL)
+                return(-ENODEV);
+
+        if(pri->filter != NULL){
+                err = dev_netmask(pri->dev, &netmask);
+                if(err < 0){
+                        printk("pcap_open : dev_netmask failed\n");
+                        return(-EIO);
+                }
+
+                pri->compiled = um_kmalloc(sizeof(struct bpf_program));
+                if(pri->compiled == NULL){
+                        printk("pcap_open : kmalloc failed\n");
+                        return(-ENOMEM);
+                }
+                
+                err = pcap_compile(pri->pcap, 
+                                   (struct bpf_program *) pri->compiled, 
+                                   pri->filter, pri->optimize, netmask);
+                if(err < 0){
+                        printk("pcap_open : pcap_compile failed - '%s'\n", 
+                               pcap_geterr(pri->pcap));
+                        return(-EIO);
+                }
+
+                err = pcap_setfilter(pri->pcap, pri->compiled);
+                if(err < 0){
+                        printk("pcap_open : pcap_setfilter failed - '%s'\n", 
+                               pcap_geterr(pri->pcap));
+                        return(-EIO);
+                }
+        }
+        
+        return(PCAP_FD(pri->pcap));
+}
+
+static void pcap_remove(void *data)
+{
+        struct pcap_data *pri = data;
+
+        if(pri->compiled != NULL)
+                pcap_freecode(pri->compiled);
+
+        pcap_close(pri->pcap);
+}
+
+struct pcap_handler_data {
+        char *buffer;
+        int len;
+};
+
+static void handler(u_char *data, const struct pcap_pkthdr *header, 
+                    const u_char *packet)
+{
+        int len;
+
+        struct pcap_handler_data *hdata = (struct pcap_handler_data *) data;
+
+        len = hdata->len < header->caplen ? hdata->len : header->caplen;
+        memcpy(hdata->buffer, packet, len);
+        hdata->len = len;
+}
+
+int pcap_user_read(int fd, void *buffer, int len, struct pcap_data *pri)
+{
+        struct pcap_handler_data hdata = ((struct pcap_handler_data)
+                                          { .buffer     = buffer,
+                                            .len        = len });
+        int n;
+
+        n = pcap_dispatch(pri->pcap, 1, handler, (u_char *) &hdata);
+        if(n < 0){
+                printk("pcap_dispatch failed - %s\n", pcap_geterr(pri->pcap));
+                return(-EIO);
+        }
+        else if(n == 0) 
+                return(0);
+        return(hdata.len);
+}
+
+struct net_user_info pcap_user_info = {
+        .init           = pcap_user_init,
+        .open           = pcap_open,
+        .close          = NULL,
+        .remove         = pcap_remove,
+        .set_mtu        = NULL,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/pcap_user.h b/arch/um/drivers/pcap_user.h
new file mode 100644
index 000000000000..58f9f6a1420f
--- /dev/null
+++ b/arch/um/drivers/pcap_user.h
@@ -0,0 +1,31 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+struct pcap_data {
+        char *host_if;
+        int promisc;
+        int optimize;
+        char *filter;
+        void *compiled;
+        void *pcap;
+        void *dev;
+};
+
+extern struct net_user_info pcap_user_info;
+
+extern int pcap_user_read(int fd, void *buf, int len, struct pcap_data *pri);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/port.h b/arch/um/drivers/port.h
new file mode 100644
index 000000000000..9117609a575d
--- /dev/null
+++ b/arch/um/drivers/port.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __PORT_H__
+#define __PORT_H__
+
+extern void *port_data(int port);
+extern int port_wait(void *data);
+extern void port_kern_close(void *d);
+extern int port_connection(int fd, int *socket_out, int *pid_out);
+extern int port_listen_fd(int port);
+extern void port_read(int fd, void *data);
+extern void port_kern_free(void *d);
+extern int port_rcv_fd(int fd);
+extern void port_remove_dev(void *d);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/port_kern.c b/arch/um/drivers/port_kern.c
new file mode 100644
index 000000000000..b5ee07472f79
--- /dev/null
+++ b/arch/um/drivers/port_kern.c
@@ -0,0 +1,309 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/list.h"
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "linux/interrupt.h"
+#include "linux/irq.h"
+#include "linux/spinlock.h"
+#include "linux/errno.h"
+#include "asm/atomic.h"
+#include "asm/semaphore.h"
+#include "asm/errno.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "port.h"
+#include "init.h"
+#include "os.h"
+
+struct port_list {
+        struct list_head list;
+        atomic_t wait_count;
+        int has_connection;
+        struct completion done;
+        int port;
+        int fd;
+        spinlock_t lock;
+        struct list_head pending;
+        struct list_head connections;
+};
+
+struct port_dev {
+        struct port_list *port;
+        int helper_pid;
+        int telnetd_pid;
+};
+
+struct connection {
+        struct list_head list;
+        int fd;
+        int helper_pid;
+        int socket[2];
+        int telnetd_pid;
+        struct port_list *port;
+};
+
+static irqreturn_t pipe_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct connection *conn = data;
+        int fd;
+
+        fd = os_rcv_fd(conn->socket[0], &conn->helper_pid);
+        if(fd < 0){
+                if(fd == -EAGAIN)
+                        return(IRQ_NONE);
+
+                printk(KERN_ERR "pipe_interrupt : os_rcv_fd returned %d\n", 
+                       -fd);
+                os_close_file(conn->fd);
+        }
+
+        list_del(&conn->list);
+
+        conn->fd = fd;
+        list_add(&conn->list, &conn->port->connections);
+
+        complete(&conn->port->done);
+        return(IRQ_HANDLED);
+}
+
+#define NO_WAITER_MSG \
+    "****\n" \
+    "There are currently no UML consoles waiting for port connections.\n" \
+    "Either disconnect from one to make it available or activate some more\n" \
+    "by enabling more consoles in the UML /etc/inittab.\n" \
+    "****\n"
+
+static int port_accept(struct port_list *port)
+{
+        struct connection *conn;
+        int fd, socket[2], pid, ret = 0;
+
+        fd = port_connection(port->fd, socket, &pid);
+        if(fd < 0){
+                if(fd != -EAGAIN)
+                        printk(KERN_ERR "port_accept : port_connection "
+                               "returned %d\n", -fd);
+                goto out;
+        }
+
+        conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
+        if(conn == NULL){
+                printk(KERN_ERR "port_accept : failed to allocate "
+                       "connection\n");
+                goto out_close;
+        }
+        *conn = ((struct connection) 
+                { .list         = LIST_HEAD_INIT(conn->list),
+                  .fd           = fd,
+                  .socket       = { socket[0], socket[1] },
+                  .telnetd_pid  = pid,
+                  .port         = port });
+
+        if(um_request_irq(TELNETD_IRQ, socket[0], IRQ_READ, pipe_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                          "telnetd", conn)){
+                printk(KERN_ERR "port_accept : failed to get IRQ for "
+                       "telnetd\n");
+                goto out_free;
+        }
+
+        if(atomic_read(&port->wait_count) == 0){
+                os_write_file(fd, NO_WAITER_MSG, sizeof(NO_WAITER_MSG));
+                printk("No one waiting for port\n");
+        }
+        list_add(&conn->list, &port->pending);
+        return(1);
+
+ out_free:
+        kfree(conn);
+ out_close:
+        os_close_file(fd);
+        if(pid != -1) 
+                os_kill_process(pid, 1);
+ out:
+        return(ret);
+} 
+
+DECLARE_MUTEX(ports_sem);
+struct list_head ports = LIST_HEAD_INIT(ports);
+
+void port_work_proc(void *unused)
+{
+        struct port_list *port;
+        struct list_head *ele;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                if(!port->has_connection)
+                        continue;
+                reactivate_fd(port->fd, ACCEPT_IRQ);
+                while(port_accept(port)) ;
+                port->has_connection = 0;
+        }
+        local_irq_restore(flags);
+}
+
+DECLARE_WORK(port_work, port_work_proc, NULL);
+
+static irqreturn_t port_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct port_list *port = data;
+
+        port->has_connection = 1;
+        schedule_work(&port_work);
+        return(IRQ_HANDLED);
+} 
+
+void *port_data(int port_num)
+{
+        struct list_head *ele;
+        struct port_list *port;
+        struct port_dev *dev = NULL;
+        int fd;
+
+        down(&ports_sem);
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                if(port->port == port_num) goto found;
+        }
+        port = kmalloc(sizeof(struct port_list), GFP_KERNEL);
+        if(port == NULL){
+                printk(KERN_ERR "Allocation of port list failed\n");
+                goto out;
+        }
+
+        fd = port_listen_fd(port_num);
+        if(fd < 0){
+                printk(KERN_ERR "binding to port %d failed, errno = %d\n",
+                       port_num, -fd);
+                goto out_free;
+        }
+        if(um_request_irq(ACCEPT_IRQ, fd, IRQ_READ, port_interrupt, 
+                          SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, "port",
+                          port)){
+                printk(KERN_ERR "Failed to get IRQ for port %d\n", port_num);
+                goto out_close;
+        }
+
+        *port = ((struct port_list) 
+                { .list                 = LIST_HEAD_INIT(port->list),
+                  .wait_count           = ATOMIC_INIT(0),
+                  .has_connection       = 0,
+                  .port                 = port_num,
+                  .fd                   = fd,
+                  .pending              = LIST_HEAD_INIT(port->pending),
+                  .connections          = LIST_HEAD_INIT(port->connections) });
+        spin_lock_init(&port->lock);
+        init_completion(&port->done);
+        list_add(&port->list, &ports);
+
+ found:
+        dev = kmalloc(sizeof(struct port_dev), GFP_KERNEL);
+        if(dev == NULL){
+                printk(KERN_ERR "Allocation of port device entry failed\n");
+                goto out;
+        }
+
+        *dev = ((struct port_dev) { .port               = port,
+                                    .helper_pid         = -1,
+                                    .telnetd_pid        = -1 });
+        goto out;
+
+ out_free:
+        kfree(port);
+ out_close:
+        os_close_file(fd);
+ out:
+        up(&ports_sem);
+        return(dev);
+}
+
+int port_wait(void *data)
+{
+        struct port_dev *dev = data;
+        struct connection *conn;
+        struct port_list *port = dev->port;
+        int fd;
+
+        atomic_inc(&port->wait_count);
+        while(1){
+                fd = -ERESTARTSYS;
+                if(wait_for_completion_interruptible(&port->done))
+                        goto out;
+
+                spin_lock(&port->lock);
+
+                conn = list_entry(port->connections.next, struct connection, 
+                                  list);
+                list_del(&conn->list);
+                spin_unlock(&port->lock);
+
+                os_shutdown_socket(conn->socket[0], 1, 1);
+                os_close_file(conn->socket[0]);
+                os_shutdown_socket(conn->socket[1], 1, 1);
+                os_close_file(conn->socket[1]); 
+
+                /* This is done here because freeing an IRQ can't be done
+                 * within the IRQ handler.  So, pipe_interrupt always ups
+                 * the semaphore regardless of whether it got a successful
+                 * connection.  Then we loop here throwing out failed 
+                 * connections until a good one is found.
+                 */
+                free_irq_by_irq_and_dev(TELNETD_IRQ, conn);
+                free_irq(TELNETD_IRQ, conn);
+
+                if(conn->fd >= 0) break;
+                os_close_file(conn->fd);
+                kfree(conn);
+        }
+
+        fd = conn->fd;
+        dev->helper_pid = conn->helper_pid;
+        dev->telnetd_pid = conn->telnetd_pid;
+        kfree(conn);
+ out:
+        atomic_dec(&port->wait_count);
+        return fd;
+}
+
+void port_remove_dev(void *d)
+{
+        struct port_dev *dev = d;
+
+        if(dev->helper_pid != -1)
+                os_kill_process(dev->helper_pid, 0);
+        if(dev->telnetd_pid != -1)
+                os_kill_process(dev->telnetd_pid, 1);
+        dev->helper_pid = -1;
+        dev->telnetd_pid = -1;
+}
+
+void port_kern_free(void *d)
+{
+        struct port_dev *dev = d;
+
+        port_remove_dev(dev);
+        kfree(dev);
+}
+
+static void free_port(void)
+{
+        struct list_head *ele;
+        struct port_list *port;
+
+        list_for_each(ele, &ports){
+                port = list_entry(ele, struct port_list, list);
+                free_irq_by_fd(port->fd);
+                os_close_file(port->fd);
+        }
+}
+
+__uml_exitcall(free_port);
diff --git a/arch/um/drivers/port_user.c b/arch/um/drivers/port_user.c
new file mode 100644
index 000000000000..14dd2002d2da
--- /dev/null
+++ b/arch/um/drivers/port_user.c
@@ -0,0 +1,225 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <termios.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "chan_user.h"
+#include "port.h"
+#include "helper.h"
+#include "os.h"
+
+struct port_chan {
+        int raw;
+        struct termios tt;
+        void *kernel_data;
+        char dev[sizeof("32768\0")];
+};
+
+static void *port_init(char *str, int device, struct chan_opts *opts)
+{
+        struct port_chan *data;
+        void *kern_data;
+        char *end;
+        int port;
+
+        if(*str != ':'){
+                printk("port_init : channel type 'port' must specify a "
+                       "port number\n");
+                return(NULL);
+        }
+        str++;
+        port = strtoul(str, &end, 0);
+        if((*end != '\0') || (end == str)){
+                printk("port_init : couldn't parse port '%s'\n", str);
+                return(NULL);
+        }
+
+        kern_data = port_data(port);
+        if(kern_data == NULL)
+                return(NULL);
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL)
+                goto err;
+
+        *data = ((struct port_chan) { .raw              = opts->raw,
+                                      .kernel_data      = kern_data });
+        sprintf(data->dev, "%d", port);
+
+        return(data);
+ err:
+        port_kern_free(kern_data);
+        return(NULL);
+}
+
+static void port_free(void *d)
+{
+        struct port_chan *data = d;
+
+        port_kern_free(data->kernel_data);
+        kfree(data);
+}
+
+static int port_open(int input, int output, int primary, void *d,
+                     char **dev_out)
+{
+        struct port_chan *data = d;
+        int fd, err;
+
+        fd = port_wait(data->kernel_data);
+        if((fd >= 0) && data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+        *dev_out = data->dev;
+        return(fd);
+}
+
+static void port_close(int fd, void *d)
+{
+        struct port_chan *data = d;
+
+        port_remove_dev(data->kernel_data);
+        os_close_file(fd);
+}
+
+static int port_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct port_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops port_ops = {
+        .type           = "port",
+        .init           = port_init,
+        .open           = port_open,
+        .close          = port_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = port_console_write,
+        .window_size    = generic_window_size,
+        .free           = port_free,
+        .winch          = 1,
+};
+
+int port_listen_fd(int port)
+{
+        struct sockaddr_in addr;
+        int fd, err, arg;
+
+        fd = socket(PF_INET, SOCK_STREAM, 0);
+        if(fd == -1) 
+                return(-errno);
+
+        arg = 1;
+        if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &arg, sizeof(arg)) < 0){
+                err = -errno;
+                goto out;
+        }
+
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons(port);
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        if(bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0){
+                err = -errno;
+                goto out;
+        }
+  
+        if(listen(fd, 1) < 0){
+                err = -errno;
+                goto out;
+        }
+
+        err = os_set_fd_block(fd, 0);
+        if(err < 0)
+                goto out;
+
+        return(fd);
+ out:
+        os_close_file(fd);
+        return(err);
+}
+
+struct port_pre_exec_data {
+        int sock_fd;
+        int pipe_fd;
+};
+
+void port_pre_exec(void *arg)
+{
+        struct port_pre_exec_data *data = arg;
+
+        dup2(data->sock_fd, 0);
+        dup2(data->sock_fd, 1);
+        dup2(data->sock_fd, 2);
+        os_close_file(data->sock_fd);
+        dup2(data->pipe_fd, 3);
+        os_shutdown_socket(3, 1, 0);
+        os_close_file(data->pipe_fd);
+}
+
+int port_connection(int fd, int *socket, int *pid_out)
+{
+        int new, err;
+        char *argv[] = { "/usr/sbin/in.telnetd", "-L", 
+                         "/usr/lib/uml/port-helper", NULL };
+        struct port_pre_exec_data data;
+
+        new = os_accept_connection(fd);
+        if(new < 0)
+                return(new);
+
+        err = os_pipe(socket, 0, 0);
+        if(err < 0)
+                goto out_close;
+
+        data = ((struct port_pre_exec_data)
+                { .sock_fd              = new,
+                  .pipe_fd              = socket[1] });
+
+        err = run_helper(port_pre_exec, &data, argv, NULL);
+        if(err < 0) 
+                goto out_shutdown;
+
+        *pid_out = err;
+        return(new);
+
+ out_shutdown:
+        os_shutdown_socket(socket[0], 1, 1);
+        os_close_file(socket[0]);
+        os_shutdown_socket(socket[1], 1, 1);    
+        os_close_file(socket[1]);
+ out_close:
+        os_close_file(new);
+        return(err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/pty.c b/arch/um/drivers/pty.c
new file mode 100644
index 000000000000..ed84d01df6cc
--- /dev/null
+++ b/arch/um/drivers/pty.c
@@ -0,0 +1,162 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include "chan_user.h"
+#include "user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "os.h"
+
+struct pty_chan {
+        void (*announce)(char *dev_name, int dev);
+        int dev;
+        int raw;
+        struct termios tt;
+        char dev_name[sizeof("/dev/pts/0123456\0")];
+};
+
+static void *pty_chan_init(char *str, int device, struct chan_opts *opts)
+{
+        struct pty_chan *data;
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct pty_chan) { .announce          = opts->announce, 
+                                     .dev               = device,
+                                     .raw               = opts->raw });
+        return(data);
+}
+
+static int pts_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct pty_chan *data = d;
+        char *dev;
+        int fd, err;
+
+        fd = get_pty();
+        if(fd < 0){
+                printk("open_pts : Failed to open pts\n");
+                return(-errno);
+        }
+        if(data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+
+        dev = ptsname(fd);
+        sprintf(data->dev_name, "%s", dev);
+        *dev_out = data->dev_name;
+        if (data->announce)
+                (*data->announce)(dev, data->dev);
+        return(fd);
+}
+
+static int getmaster(char *line)
+{
+        char *pty, *bank, *cp;
+        int master, err;
+
+        pty = &line[strlen("/dev/ptyp")];
+        for (bank = "pqrs"; *bank; bank++) {
+                line[strlen("/dev/pty")] = *bank;
+                *pty = '0';
+                if (os_stat_file(line, NULL) < 0)
+                        break;
+                for (cp = "0123456789abcdef"; *cp; cp++) {
+                        *pty = *cp;
+                        master = os_open_file(line, of_rdwr(OPENFLAGS()), 0);
+                        if (master >= 0) {
+                                char *tp = &line[strlen("/dev/")];
+
+                                /* verify slave side is usable */
+                                *tp = 't';
+                                err = os_access(line, OS_ACC_RW_OK);
+                                *tp = 'p';
+                                if(err == 0) return(master);
+                                (void) os_close_file(master);
+                        }
+                }
+        }
+        return(-1);
+}
+
+static int pty_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct pty_chan *data = d;
+        int fd, err;
+        char dev[sizeof("/dev/ptyxx\0")] = "/dev/ptyxx";
+
+        fd = getmaster(dev);
+        if(fd < 0)
+                return(-errno);
+
+        if(data->raw){
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+        
+        if(data->announce) (*data->announce)(dev, data->dev);
+
+        sprintf(data->dev_name, "%s", dev);
+        *dev_out = data->dev_name;
+        return(fd);
+}
+
+static int pty_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct pty_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops pty_ops = {
+        .type           = "pty",
+        .init           = pty_chan_init,
+        .open           = pty_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = pty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+struct chan_ops pts_ops = {
+        .type           = "pts",
+        .init           = pty_chan_init,
+        .open           = pts_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = pty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/random.c b/arch/um/drivers/random.c
new file mode 100644
index 000000000000..d43e9fab05a7
--- /dev/null
+++ b/arch/um/drivers/random.c
@@ -0,0 +1,122 @@
+/* Much of this ripped from hw_random.c */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/delay.h>
+#include <asm/uaccess.h>
+#include "os.h"
+
+/*
+ * core module and version information
+ */
+#define RNG_VERSION "1.0.0"
+#define RNG_MODULE_NAME "random"
+#define RNG_DRIVER_NAME   RNG_MODULE_NAME " virtual driver " RNG_VERSION
+#define PFX RNG_MODULE_NAME ": "
+
+#define RNG_MISCDEV_MINOR               183 /* official */
+
+static int random_fd = -1;
+
+static int rng_dev_open (struct inode *inode, struct file *filp)
+{
+        /* enforce read-only access to this chrdev */
+        if ((filp->f_mode & FMODE_READ) == 0)
+                return -EINVAL;
+        if (filp->f_mode & FMODE_WRITE)
+                return -EINVAL;
+
+        return 0;
+}
+
+static ssize_t rng_dev_read (struct file *filp, char __user *buf, size_t size,
+                             loff_t * offp)
+{
+        u32 data;
+        int n, ret = 0, have_data;
+
+        while(size){
+                n = os_read_file(random_fd, &data, sizeof(data));
+                if(n > 0){
+                        have_data = n;
+                        while (have_data && size) {
+                                if (put_user((u8)data, buf++)) {
+                                        ret = ret ? : -EFAULT;
+                                        break;
+                                }
+                                size--;
+                                ret++;
+                                have_data--;
+                                data>>=8;
+                        }
+                }
+                else if(n == -EAGAIN){
+                        if (filp->f_flags & O_NONBLOCK)
+                                return ret ? : -EAGAIN;
+
+                        if(need_resched()){
+                                current->state = TASK_INTERRUPTIBLE;
+                                schedule_timeout(1);
+                        }
+                }
+                else return n;
+                if (signal_pending (current))
+                        return ret ? : -ERESTARTSYS;
+        }
+        return ret;
+}
+
+static struct file_operations rng_chrdev_ops = {
+        .owner          = THIS_MODULE,
+        .open           = rng_dev_open,
+        .read           = rng_dev_read,
+};
+
+static struct miscdevice rng_miscdev = {
+        RNG_MISCDEV_MINOR,
+        RNG_MODULE_NAME,
+        &rng_chrdev_ops,
+};
+
+/*
+ * rng_init - initialize RNG module
+ */
+static int __init rng_init (void)
+{
+        int err;
+
+        err = os_open_file("/dev/random", of_read(OPENFLAGS()), 0);
+        if(err < 0)
+                goto out;
+
+        random_fd = err;
+
+        err = os_set_fd_block(random_fd, 0);
+        if(err)
+                goto err_out_cleanup_hw;
+
+        err = misc_register (&rng_miscdev);
+        if (err) {
+                printk (KERN_ERR PFX "misc device register failed\n");
+                goto err_out_cleanup_hw;
+        }
+
+ out:
+        return err;
+
+ err_out_cleanup_hw:
+        random_fd = -1;
+        goto out;
+}
+
+/*
+ * rng_cleanup - shutdown RNG module
+ */
+static void __exit rng_cleanup (void)
+{
+        misc_deregister (&rng_miscdev);
+}
+
+module_init (rng_init);
+module_exit (rng_cleanup);
diff --git a/arch/um/drivers/slip.h b/arch/um/drivers/slip.h
new file mode 100644
index 000000000000..495f2f1b1420
--- /dev/null
+++ b/arch/um/drivers/slip.h
@@ -0,0 +1,39 @@
+#ifndef __UM_SLIP_H
+#define __UM_SLIP_H
+
+#define BUF_SIZE 1500
+ /* two bytes each for a (pathological) max packet of escaped chars +  * 
+  * terminating END char + initial END char                            */
+#define ENC_BUF_SIZE (2 * BUF_SIZE + 2)
+
+struct slip_data {
+        void *dev;
+        char name[sizeof("slnnnnn\0")];
+        char *addr;
+        char *gate_addr;
+        int slave;
+        char ibuf[ENC_BUF_SIZE];
+        char obuf[ENC_BUF_SIZE];
+        int more; /* more data: do not read fd until ibuf has been drained */
+        int pos;
+        int esc;
+};
+
+extern struct net_user_info slip_user_info;
+
+extern int set_umn_addr(int fd, char *addr, char *ptp_addr);
+extern int slip_user_read(int fd, void *buf, int len, struct slip_data *pri);
+extern int slip_user_write(int fd, void *buf, int len, struct slip_data *pri);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slip_kern.c b/arch/um/drivers/slip_kern.c
new file mode 100644
index 000000000000..0886eedba213
--- /dev/null
+++ b/arch/um/drivers/slip_kern.c
@@ -0,0 +1,109 @@
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/stddef.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/if_arp.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "kern.h"
+#include "slip.h"
+
+struct slip_init {
+        char *gate_addr;
+};
+
+void slip_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *private;
+        struct slip_data *spri;
+        struct slip_init *init = data;
+
+        private = dev->priv;
+        spri = (struct slip_data *) private->user;
+        *spri = ((struct slip_data)
+                { .name         = { '\0' },
+                  .addr         = NULL,
+                  .gate_addr    = init->gate_addr,
+                  .slave        = -1,
+                  .ibuf         = { '\0' },
+                  .obuf         = { '\0' },
+                  .pos          = 0,
+                  .esc          = 0,
+                  .dev          = dev });
+
+        dev->init = NULL;
+        dev->hard_header_len = 0;
+        dev->addr_len = 4;
+        dev->type = ARPHRD_ETHER;
+        dev->tx_queue_len = 256;
+        dev->flags = IFF_NOARP;
+        printk("SLIP backend - SLIP IP = %s\n", spri->gate_addr);
+}
+
+static unsigned short slip_protocol(struct sk_buff *skbuff)
+{
+        return(htons(ETH_P_IP));
+}
+
+static int slip_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        return(slip_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 
+                              (struct slip_data *) &lp->user));
+}
+
+static int slip_write(int fd, struct sk_buff **skb,
+                      struct uml_net_private *lp)
+{
+        return(slip_user_write(fd, (*skb)->data, (*skb)->len, 
+                               (struct slip_data *) &lp->user));
+}
+
+struct net_kern_info slip_kern_info = {
+        .init                   = slip_init,
+        .protocol               = slip_protocol,
+        .read                   = slip_read,
+        .write                  = slip_write,
+};
+
+static int slip_setup(char *str, char **mac_out, void *data)
+{
+        struct slip_init *init = data;
+
+        *init = ((struct slip_init)
+                { .gate_addr            = NULL });
+
+        if(str[0] != '\0') 
+                init->gate_addr = str;
+        return(1);
+}
+
+static struct transport slip_transport = {
+        .list           = LIST_HEAD_INIT(slip_transport.list),
+        .name           = "slip",
+        .setup          = slip_setup,
+        .user           = &slip_user_info,
+        .kern           = &slip_kern_info,
+        .private_size   = sizeof(struct slip_data),
+        .setup_size     = sizeof(struct slip_init),
+};
+
+static int register_slip(void)
+{
+        register_transport(&slip_transport);
+        return(1);
+}
+
+__initcall(register_slip);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slip_proto.h b/arch/um/drivers/slip_proto.h
new file mode 100644
index 000000000000..7206361ace45
--- /dev/null
+++ b/arch/um/drivers/slip_proto.h
@@ -0,0 +1,93 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_SLIP_PROTO_H__
+#define __UM_SLIP_PROTO_H__
+
+/* SLIP protocol characters. */
+#define SLIP_END             0300       /* indicates end of frame       */
+#define SLIP_ESC             0333       /* indicates byte stuffing      */
+#define SLIP_ESC_END         0334       /* ESC ESC_END means END 'data' */
+#define SLIP_ESC_ESC         0335       /* ESC ESC_ESC means ESC 'data' */
+
+static inline int slip_unesc(unsigned char c,char *buf,int *pos, int *esc)
+{
+        int ret;
+
+        switch(c){
+        case SLIP_END:
+                *esc = 0;
+                ret=*pos;
+                *pos=0;
+                return(ret);
+        case SLIP_ESC:
+                *esc = 1;
+                return(0);
+        case SLIP_ESC_ESC:
+                if(*esc){
+                        *esc = 0;
+                        c = SLIP_ESC;
+                }
+                break;
+        case SLIP_ESC_END:
+                if(*esc){
+                        *esc = 0;
+                        c = SLIP_END;
+                }
+                break;
+        }
+        buf[(*pos)++] = c;
+        return(0);
+}
+
+static inline int slip_esc(unsigned char *s, unsigned char *d, int len)
+{
+        unsigned char *ptr = d;
+        unsigned char c;
+
+        /*
+         * Send an initial END character to flush out any
+         * data that may have accumulated in the receiver
+         * due to line noise.
+         */
+
+        *ptr++ = SLIP_END;
+
+        /*
+         * For each byte in the packet, send the appropriate
+         * character sequence, according to the SLIP protocol.
+         */
+
+        while (len-- > 0) {
+                switch(c = *s++) {
+                case SLIP_END:
+                        *ptr++ = SLIP_ESC;
+                        *ptr++ = SLIP_ESC_END;
+                        break;
+                case SLIP_ESC:
+                        *ptr++ = SLIP_ESC;
+                        *ptr++ = SLIP_ESC_ESC;
+                        break;
+                default:
+                        *ptr++ = c;
+                        break;
+                }
+        }
+        *ptr++ = SLIP_END;
+        return (ptr - d);
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
new file mode 100644
index 000000000000..d94846b1b4cf
--- /dev/null
+++ b/arch/um/drivers/slip_user.c
@@ -0,0 +1,280 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/termios.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "net_user.h"
+#include "slip.h"
+#include "slip_proto.h"
+#include "helper.h"
+#include "os.h"
+
+void slip_user_init(void *data, void *dev)
+{
+        struct slip_data *pri = data;
+
+        pri->dev = dev;
+}
+
+static int set_up_tty(int fd)
+{
+        int i;
+        struct termios tios;
+
+        if (tcgetattr(fd, &tios) < 0) {
+                printk("could not get initial terminal attributes\n");
+                return(-1);
+        }
+
+        tios.c_cflag = CS8 | CREAD | HUPCL | CLOCAL;
+        tios.c_iflag = IGNBRK | IGNPAR;
+        tios.c_oflag = 0;
+        tios.c_lflag = 0;
+        for (i = 0; i < NCCS; i++)
+                tios.c_cc[i] = 0;
+        tios.c_cc[VMIN] = 1;
+        tios.c_cc[VTIME] = 0;
+
+        cfsetospeed(&tios, B38400);
+        cfsetispeed(&tios, B38400);
+
+        if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
+                printk("failed to set terminal attributes\n");
+                return(-1);
+        }
+        return(0);
+}
+
+struct slip_pre_exec_data {
+        int stdin;
+        int stdout;
+        int close_me;
+};
+
+static void slip_pre_exec(void *arg)
+{
+        struct slip_pre_exec_data *data = arg;
+
+        if(data->stdin >= 0) dup2(data->stdin, 0);
+        dup2(data->stdout, 1);
+        if(data->close_me >= 0) os_close_file(data->close_me);
+}
+
+static int slip_tramp(char **argv, int fd)
+{
+        struct slip_pre_exec_data pe_data;
+        char *output;
+        int status, pid, fds[2], err, output_len;
+
+        err = os_pipe(fds, 1, 0);
+        if(err < 0){
+                printk("slip_tramp : pipe failed, err = %d\n", -err);
+                return(err);
+        }
+
+        err = 0;
+        pe_data.stdin = fd;
+        pe_data.stdout = fds[1];
+        pe_data.close_me = fds[0];
+        pid = run_helper(slip_pre_exec, &pe_data, argv, NULL);
+
+        if(pid < 0) err = pid;
+        else {
+                output_len = page_size();
+                output = um_kmalloc(output_len);
+                if(output == NULL)
+                        printk("slip_tramp : failed to allocate output "
+                               "buffer\n");
+
+                os_close_file(fds[1]);
+                read_output(fds[0], output, output_len);
+                if(output != NULL){
+                        printk("%s", output);
+                        kfree(output);
+                }
+                CATCH_EINTR(err = waitpid(pid, &status, 0));
+                if(err < 0)
+                        err = errno;
+                else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
+                        printk("'%s' didn't exit with status 0\n", argv[0]);
+                        err = -EINVAL;
+                }
+        }
+
+        os_close_file(fds[0]);
+
+        return(err);
+}
+
+static int slip_open(void *data)
+{
+        struct slip_data *pri = data;
+        char version_buf[sizeof("nnnnn\0")];
+        char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
+        char *argv[] = { "uml_net", version_buf, "slip", "up", gate_buf, 
+                         NULL };
+        int sfd, mfd, err;
+
+        mfd = get_pty();
+        if(mfd < 0){
+                printk("umn : Failed to open pty, err = %d\n", -mfd);
+                return(mfd);
+        }
+        sfd = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0);
+        if(sfd < 0){
+                printk("Couldn't open tty for slip line, err = %d\n", -sfd);
+                os_close_file(mfd);
+                return(sfd);
+        }
+        if(set_up_tty(sfd)) return(-1);
+        pri->slave = sfd;
+        pri->pos = 0;
+        pri->esc = 0;
+        if(pri->gate_addr != NULL){
+                sprintf(version_buf, "%d", UML_NET_VERSION);
+                strcpy(gate_buf, pri->gate_addr);
+
+                err = slip_tramp(argv, sfd);
+
+                if(err < 0){
+                        printk("slip_tramp failed - err = %d\n", -err);
+                        return(err);
+                }
+                err = os_get_ifname(pri->slave, pri->name);
+                if(err < 0){
+                        printk("get_ifname failed, err = %d\n", -err);
+                        return(err);
+                }
+                iter_addresses(pri->dev, open_addr, pri->name);
+        }
+        else {
+                err = os_set_slip(sfd);
+                if(err < 0){
+                        printk("Failed to set slip discipline encapsulation - "
+                               "err = %d\n", -err);
+                        return(err);
+                }
+        }
+        return(mfd);
+}
+
+static void slip_close(int fd, void *data)
+{
+        struct slip_data *pri = data;
+        char version_buf[sizeof("nnnnn\0")];
+        char *argv[] = { "uml_net", version_buf, "slip", "down", pri->name, 
+                         NULL };
+        int err;
+
+        if(pri->gate_addr != NULL)
+                iter_addresses(pri->dev, close_addr, pri->name);
+
+        sprintf(version_buf, "%d", UML_NET_VERSION);
+
+        err = slip_tramp(argv, pri->slave);
+
+        if(err != 0)
+                printk("slip_tramp failed - errno = %d\n", -err);
+        os_close_file(fd);
+        os_close_file(pri->slave);
+        pri->slave = -1;
+}
+
+int slip_user_read(int fd, void *buf, int len, struct slip_data *pri)
+{
+        int i, n, size, start;
+
+        if(pri->more>0) {
+                i = 0;
+                while(i < pri->more) {
+                        size = slip_unesc(pri->ibuf[i++],
+                                        pri->ibuf, &pri->pos, &pri->esc);
+                        if(size){
+                                memcpy(buf, pri->ibuf, size);
+                                memmove(pri->ibuf, &pri->ibuf[i], pri->more-i);
+                                pri->more=pri->more-i; 
+                                return(size);
+                        }
+                }
+                pri->more=0;
+        }
+
+        n = net_read(fd, &pri->ibuf[pri->pos], sizeof(pri->ibuf) - pri->pos);
+        if(n <= 0) return(n);
+
+        start = pri->pos;
+        for(i = 0; i < n; i++){
+                size = slip_unesc(pri->ibuf[start + i],
+                                pri->ibuf, &pri->pos, &pri->esc);
+                if(size){
+                        memcpy(buf, pri->ibuf, size);
+                        memmove(pri->ibuf, &pri->ibuf[start+i+1], n-(i+1));
+                        pri->more=n-(i+1); 
+                        return(size);
+                }
+        }
+        return(0);
+}
+
+int slip_user_write(int fd, void *buf, int len, struct slip_data *pri)
+{
+        int actual, n;
+
+        actual = slip_esc(buf, pri->obuf, len);
+        n = net_write(fd, pri->obuf, actual);
+        if(n < 0) return(n);
+        else return(len);
+}
+
+static int slip_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+static void slip_add_addr(unsigned char *addr, unsigned char *netmask,
+                          void *data)
+{
+        struct slip_data *pri = data;
+
+        if(pri->slave < 0) return;
+        open_addr(addr, netmask, pri->name);
+}
+
+static void slip_del_addr(unsigned char *addr, unsigned char *netmask,
+                            void *data)
+{
+        struct slip_data *pri = data;
+
+        if(pri->slave < 0) return;
+        close_addr(addr, netmask, pri->name);
+}
+
+struct net_user_info slip_user_info = {
+        .init           = slip_user_init,
+        .open           = slip_open,
+        .close          = slip_close,
+        .remove         = NULL,
+        .set_mtu        = slip_set_mtu,
+        .add_address    = slip_add_addr,
+        .delete_address = slip_del_addr,
+        .max_packet     = BUF_SIZE
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slirp.h b/arch/um/drivers/slirp.h
new file mode 100644
index 000000000000..04e407d1e44a
--- /dev/null
+++ b/arch/um/drivers/slirp.h
@@ -0,0 +1,51 @@
+#ifndef __UM_SLIRP_H
+#define __UM_SLIRP_H
+
+#define BUF_SIZE 1500
+ /* two bytes each for a (pathological) max packet of escaped chars +  * 
+  * terminating END char + initial END char                            */
+#define ENC_BUF_SIZE (2 * BUF_SIZE + 2)
+
+#define SLIRP_MAX_ARGS 100
+/*
+ * XXX this next definition is here because I don't understand why this
+ * initializer doesn't work in slirp_kern.c:
+ *
+ *   argv :  { init->argv[ 0 ... SLIRP_MAX_ARGS-1 ] },
+ *
+ * or why I can't typecast like this:
+ *
+ *   argv :  (char* [SLIRP_MAX_ARGS])(init->argv), 
+ */
+struct arg_list_dummy_wrapper { char *argv[SLIRP_MAX_ARGS]; };
+
+struct slirp_data {
+        void *dev;
+        struct arg_list_dummy_wrapper argw;
+        int pid;
+        int slave;
+        char ibuf[ENC_BUF_SIZE];
+        char obuf[ENC_BUF_SIZE];
+        int more; /* more data: do not read fd until ibuf has been drained */
+        int pos;
+        int esc;
+};
+
+extern struct net_user_info slirp_user_info;
+
+extern int set_umn_addr(int fd, char *addr, char *ptp_addr);
+extern int slirp_user_read(int fd, void *buf, int len, struct slirp_data *pri);
+extern int slirp_user_write(int fd, void *buf, int len, struct slirp_data *pri);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slirp_kern.c b/arch/um/drivers/slirp_kern.c
new file mode 100644
index 000000000000..c9d6b52a831d
--- /dev/null
+++ b/arch/um/drivers/slirp_kern.c
@@ -0,0 +1,135 @@
+#include "linux/kernel.h"
+#include "linux/stddef.h"
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/if_arp.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "kern.h"
+#include "slirp.h"
+
+struct slirp_init {
+        struct arg_list_dummy_wrapper argw;  /* XXX should be simpler... */
+};
+
+void slirp_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *private;
+        struct slirp_data *spri;
+        struct slirp_init *init = data;
+        int i;
+
+        private = dev->priv;
+        spri = (struct slirp_data *) private->user;
+        *spri = ((struct slirp_data)
+                { .argw         = init->argw,
+                  .pid          = -1,
+                  .slave        = -1,
+                  .ibuf         = { '\0' },
+                  .obuf         = { '\0' },
+                  .pos          = 0,
+                  .esc          = 0,
+                  .dev          = dev });
+
+        dev->init = NULL;
+        dev->hard_header_len = 0;
+        dev->header_cache_update = NULL;
+        dev->hard_header_cache = NULL;
+        dev->hard_header = NULL;
+        dev->addr_len = 0;
+        dev->type = ARPHRD_SLIP;
+        dev->tx_queue_len = 256;
+        dev->flags = IFF_NOARP;
+        printk("SLIRP backend - command line:");
+        for(i=0;spri->argw.argv[i]!=NULL;i++) {
+                printk(" '%s'",spri->argw.argv[i]);
+        }
+        printk("\n");
+}
+
+static unsigned short slirp_protocol(struct sk_buff *skbuff)
+{
+        return(htons(ETH_P_IP));
+}
+
+static int slirp_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        return(slirp_user_read(fd, (*skb)->mac.raw, (*skb)->dev->mtu, 
+                              (struct slirp_data *) &lp->user));
+}
+
+static int slirp_write(int fd, struct sk_buff **skb,
+                      struct uml_net_private *lp)
+{
+        return(slirp_user_write(fd, (*skb)->data, (*skb)->len, 
+                               (struct slirp_data *) &lp->user));
+}
+
+struct net_kern_info slirp_kern_info = {
+        .init                   = slirp_init,
+        .protocol               = slirp_protocol,
+        .read                   = slirp_read,
+        .write                  = slirp_write,
+};
+
+static int slirp_setup(char *str, char **mac_out, void *data)
+{
+        struct slirp_init *init = data;
+        int i=0;
+
+        *init = ((struct slirp_init)
+                { argw :                { { "slirp", NULL  } } });
+
+        str = split_if_spec(str, mac_out, NULL);
+
+        if(str == NULL) { /* no command line given after MAC addr */
+                return(1);
+        }
+
+        do {
+                if(i>=SLIRP_MAX_ARGS-1) {
+                        printk("slirp_setup: truncating slirp arguments\n");
+                        break;
+                }
+                init->argw.argv[i++] = str;
+                while(*str && *str!=',') {
+                        if(*str=='_') *str=' ';
+                        str++;
+                }
+                if(*str!=',')
+                        break;
+                *str++='\0';
+        } while(1);
+        init->argw.argv[i]=NULL;
+        return(1);
+}
+
+static struct transport slirp_transport = {
+        .list           = LIST_HEAD_INIT(slirp_transport.list),
+        .name           = "slirp",
+        .setup          = slirp_setup,
+        .user           = &slirp_user_info,
+        .kern           = &slirp_kern_info,
+        .private_size   = sizeof(struct slirp_data),
+        .setup_size     = sizeof(struct slirp_init),
+};
+
+static int register_slirp(void)
+{
+        register_transport(&slirp_transport);
+        return(1);
+}
+
+__initcall(register_slirp);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
new file mode 100644
index 000000000000..c322515c71cc
--- /dev/null
+++ b/arch/um/drivers/slirp_user.c
@@ -0,0 +1,201 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "net_user.h"
+#include "slirp.h"
+#include "slip_proto.h"
+#include "helper.h"
+#include "os.h"
+
+void slirp_user_init(void *data, void *dev)
+{
+        struct slirp_data *pri = data;
+
+        pri->dev = dev;
+}
+
+struct slirp_pre_exec_data {
+        int stdin;
+        int stdout;
+};
+
+static void slirp_pre_exec(void *arg)
+{
+        struct slirp_pre_exec_data *data = arg;
+
+        if(data->stdin != -1) dup2(data->stdin, 0);
+        if(data->stdout != -1) dup2(data->stdout, 1);
+}
+
+static int slirp_tramp(char **argv, int fd)
+{
+        struct slirp_pre_exec_data pe_data;
+        int pid;
+
+        pe_data.stdin = fd;
+        pe_data.stdout = fd;
+        pid = run_helper(slirp_pre_exec, &pe_data, argv, NULL);
+
+        return(pid);
+}
+
+/* XXX This is just a trivial wrapper around os_pipe */
+static int slirp_datachan(int *mfd, int *sfd)
+{
+        int fds[2], err;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("slirp_datachan: Failed to open pipe, err = %d\n", -err);
+                return(err);
+        }
+
+        *mfd = fds[0];
+        *sfd = fds[1];
+        return(0);
+}
+
+static int slirp_open(void *data)
+{
+        struct slirp_data *pri = data;
+        int sfd, mfd, pid, err;
+
+        err = slirp_datachan(&mfd, &sfd);
+        if(err)
+                return(err);
+
+        pid = slirp_tramp(pri->argw.argv, sfd);
+
+        if(pid < 0){
+                printk("slirp_tramp failed - errno = %d\n", -pid);
+                os_close_file(sfd);     
+                os_close_file(mfd);     
+                return(pid);
+        }
+
+        pri->slave = sfd;
+        pri->pos = 0;
+        pri->esc = 0;
+
+        pri->pid = pid;
+
+        return(mfd);
+}
+
+static void slirp_close(int fd, void *data)
+{
+        struct slirp_data *pri = data;
+        int status,err;
+
+        os_close_file(fd);
+        os_close_file(pri->slave);
+
+        pri->slave = -1;
+
+        if(pri->pid<1) {
+                printk("slirp_close: no child process to shut down\n");
+                return;
+        }
+
+#if 0
+        if(kill(pri->pid, SIGHUP)<0) {
+                printk("slirp_close: sending hangup to %d failed (%d)\n",
+                        pri->pid, errno);
+        }
+#endif
+
+        CATCH_EINTR(err = waitpid(pri->pid, &status, WNOHANG));
+        if(err < 0) {
+                printk("slirp_close: waitpid returned %d\n", errno);
+                return;
+        }
+
+        if(err == 0) {
+                printk("slirp_close: process %d has not exited\n");
+                return;
+        }
+
+        pri->pid = -1;
+}
+
+int slirp_user_read(int fd, void *buf, int len, struct slirp_data *pri)
+{
+        int i, n, size, start;
+
+        if(pri->more>0) {
+                i = 0;
+                while(i < pri->more) {
+                        size = slip_unesc(pri->ibuf[i++],
+                                        pri->ibuf,&pri->pos,&pri->esc);
+                        if(size){
+                                memcpy(buf, pri->ibuf, size);
+                                memmove(pri->ibuf, &pri->ibuf[i], pri->more-i);
+                                pri->more=pri->more-i; 
+                                return(size);
+                        }
+                }
+                pri->more=0;
+        }
+
+        n = net_read(fd, &pri->ibuf[pri->pos], sizeof(pri->ibuf) - pri->pos);
+        if(n <= 0) return(n);
+
+        start = pri->pos;
+        for(i = 0; i < n; i++){
+                size = slip_unesc(pri->ibuf[start + i],
+                                pri->ibuf,&pri->pos,&pri->esc);
+                if(size){
+                        memcpy(buf, pri->ibuf, size);
+                        memmove(pri->ibuf, &pri->ibuf[start+i+1], n-(i+1));
+                        pri->more=n-(i+1); 
+                        return(size);
+                }
+        }
+        return(0);
+}
+
+int slirp_user_write(int fd, void *buf, int len, struct slirp_data *pri)
+{
+        int actual, n;
+
+        actual = slip_esc(buf, pri->obuf, len);
+        n = net_write(fd, pri->obuf, actual);
+        if(n < 0) return(n);
+        else return(len);
+}
+
+static int slirp_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info slirp_user_info = {
+        .init           = slirp_user_init,
+        .open           = slirp_open,
+        .close          = slirp_close,
+        .remove         = NULL,
+        .set_mtu        = slirp_set_mtu,
+        .add_address    = NULL,
+        .delete_address = NULL,
+        .max_packet     = BUF_SIZE
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
new file mode 100644
index 000000000000..c5839c3141f8
--- /dev/null
+++ b/arch/um/drivers/ssl.c
@@ -0,0 +1,251 @@
+/* 
+ * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/fs.h"
+#include "linux/tty.h"
+#include "linux/tty_driver.h"
+#include "linux/major.h"
+#include "linux/mm.h"
+#include "linux/init.h"
+#include "linux/console.h"
+#include "asm/termbits.h"
+#include "asm/irq.h"
+#include "line.h"
+#include "ssl.h"
+#include "chan_kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "mconsole_kern.h"
+#include "2_5compat.h"
+
+static int ssl_version = 1;
+
+/* Referenced only by tty_driver below - presumably it's locked correctly
+ * by the tty driver.
+ */
+
+static struct tty_driver *ssl_driver;
+
+#define NR_PORTS 64
+
+void ssl_announce(char *dev_name, int dev)
+{
+        printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
+               dev_name);
+}
+
+static struct chan_opts opts = {
+        .announce       = ssl_announce,
+        .xterm_title    = "Serial Line #%d",
+        .raw            = 1,
+        .tramp_stack    = 0,
+        .in_kernel      = 1,
+};
+
+static int ssl_config(char *str);
+static int ssl_get_config(char *dev, char *str, int size, char **error_out);
+static int ssl_remove(char *str);
+
+static struct line_driver driver = {
+        .name                   = "UML serial line",
+        .device_name            = "ttyS",
+        .devfs_name             = "tts/",
+        .major                  = TTY_MAJOR,
+        .minor_start            = 64,
+        .type                   = TTY_DRIVER_TYPE_SERIAL,
+        .subtype                = 0,
+        .read_irq               = SSL_IRQ,
+        .read_irq_name          = "ssl",
+        .write_irq              = SSL_WRITE_IRQ,
+        .write_irq_name         = "ssl-write",
+        .symlink_from           = "serial",
+        .symlink_to             = "tts",
+        .mc  = {
+                .name           = "ssl",
+                .config         = ssl_config,
+                .get_config     = ssl_get_config,
+                .remove         = ssl_remove,
+        },
+};
+
+/* The array is initialized by line_init, which is an initcall.  The 
+ * individual elements are protected by individual semaphores.
+ */
+static struct line serial_lines[NR_PORTS] =
+        { [0 ... NR_PORTS - 1] = LINE_INIT(CONFIG_SSL_CHAN, &driver) };
+
+static struct lines lines = LINES_INIT(NR_PORTS);
+
+static int ssl_config(char *str)
+{
+        return(line_config(serial_lines, 
+                           sizeof(serial_lines)/sizeof(serial_lines[0]), str));
+}
+
+static int ssl_get_config(char *dev, char *str, int size, char **error_out)
+{
+        return(line_get_config(dev, serial_lines, 
+                               sizeof(serial_lines)/sizeof(serial_lines[0]), 
+                               str, size, error_out));
+}
+
+static int ssl_remove(char *str)
+{
+        return(line_remove(serial_lines, 
+                           sizeof(serial_lines)/sizeof(serial_lines[0]), str));
+}
+
+int ssl_open(struct tty_struct *tty, struct file *filp)
+{
+        return line_open(serial_lines, tty, &opts);
+}
+
+#if 0
+static int ssl_chars_in_buffer(struct tty_struct *tty)
+{
+        return(0);
+}
+
+static void ssl_flush_buffer(struct tty_struct *tty)
+{
+        return;
+}
+
+static void ssl_throttle(struct tty_struct * tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_throttle\n");
+}
+
+static void ssl_unthrottle(struct tty_struct * tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_unthrottle\n");
+}
+
+static void ssl_stop(struct tty_struct *tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_stop\n");
+}
+
+static void ssl_start(struct tty_struct *tty)
+{
+        printk(KERN_ERR "Someone should implement ssl_start\n");
+}
+
+void ssl_hangup(struct tty_struct *tty)
+{
+}
+#endif
+
+static struct tty_operations ssl_ops = {
+        .open                   = ssl_open,
+        .close                  = line_close,
+        .write                  = line_write,
+        .put_char               = line_put_char,
+        .write_room             = line_write_room,
+        .chars_in_buffer        = line_chars_in_buffer,
+        .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
+#if 0
+        .flush_chars            = ssl_flush_chars,
+        .flush_buffer           = ssl_flush_buffer,
+        .throttle               = ssl_throttle,
+        .unthrottle             = ssl_unthrottle,
+        .stop                   = ssl_stop,
+        .start                  = ssl_start,
+        .hangup                 = ssl_hangup,
+#endif
+};
+
+/* Changed by ssl_init and referenced by ssl_exit, which are both serialized
+ * by being an initcall and exitcall, respectively.
+ */
+static int ssl_init_done = 0;
+
+static void ssl_console_write(struct console *c, const char *string,
+                              unsigned len)
+{
+        struct line *line = &serial_lines[c->index];
+
+        down(&line->sem);
+        console_write_chan(&line->chan_list, string, len);
+        up(&line->sem);
+}
+
+static struct tty_driver *ssl_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return ssl_driver;
+}
+
+static int ssl_console_setup(struct console *co, char *options)
+{
+        struct line *line = &serial_lines[co->index];
+
+        return console_open_chan(line,co,&opts);
+}
+
+static struct console ssl_cons = {
+        .name           = "ttyS",
+        .write          = ssl_console_write,
+        .device         = ssl_console_device,
+        .setup          = ssl_console_setup,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+};
+
+int ssl_init(void)
+{
+        char *new_title;
+
+        printk(KERN_INFO "Initializing software serial port version %d\n", 
+               ssl_version);
+        ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops,
+                                         serial_lines, ARRAY_SIZE(serial_lines));
+
+        lines_init(serial_lines, sizeof(serial_lines)/sizeof(serial_lines[0]));
+
+        new_title = add_xterm_umid(opts.xterm_title);
+        if (new_title != NULL)
+                opts.xterm_title = new_title;
+
+        ssl_init_done = 1;
+        register_console(&ssl_cons);
+        return(0);
+}
+late_initcall(ssl_init);
+
+static void ssl_exit(void)
+{
+        if (!ssl_init_done)
+                return;
+        close_lines(serial_lines,
+                    sizeof(serial_lines)/sizeof(serial_lines[0]));
+}
+__uml_exitcall(ssl_exit);
+
+static int ssl_chan_setup(char *str)
+{
+        return(line_setup(serial_lines,
+                          sizeof(serial_lines)/sizeof(serial_lines[0]),
+                          str, 1));
+}
+
+__setup("ssl", ssl_chan_setup);
+__channel_help(ssl_chan_setup, "ssl");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/ssl.h b/arch/um/drivers/ssl.h
new file mode 100644
index 000000000000..98412aa66607
--- /dev/null
+++ b/arch/um/drivers/ssl.h
@@ -0,0 +1,23 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SSL_H__
+#define __SSL_H__
+
+extern int ssl_read(int fd, int line);
+extern void ssl_receive_char(int line, char ch);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/stderr_console.c b/arch/um/drivers/stderr_console.c
new file mode 100644
index 000000000000..98565b53d170
--- /dev/null
+++ b/arch/um/drivers/stderr_console.c
@@ -0,0 +1,45 @@
+#include <linux/init.h>
+#include <linux/console.h>
+
+#include "chan_user.h"
+
+/* ----------------------------------------------------------------------------- */
+/* trivial console driver -- simply dump everything to stderr                    */
+
+/*
+ * Don't register by default -- as this registeres very early in the
+ * boot process it becomes the default console.  And as this isn't a
+ * real tty driver init isn't able to open /dev/console then.
+ *
+ * In most cases this isn't what you want ...
+ */
+static int use_stderr_console = 0;
+
+static void stderr_console_write(struct console *console, const char *string,
+                                 unsigned len)
+{
+        generic_write(2 /* stderr */, string, len, NULL);
+}
+
+static struct console stderr_console = {
+        .name           "stderr",
+        .write          stderr_console_write,
+        .flags          CON_PRINTBUFFER,
+};
+
+static int __init stderr_console_init(void)
+{
+        if (use_stderr_console)
+                register_console(&stderr_console);
+        return 0;
+}
+console_initcall(stderr_console_init);
+
+static int stderr_setup(char *str)
+{
+        if (!str)
+                return 0;
+        use_stderr_console = simple_strtoul(str,&str,0);
+        return 1;
+}
+__setup("stderr=", stderr_setup);
diff --git a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
new file mode 100644
index 000000000000..e604d7c87695
--- /dev/null
+++ b/arch/um/drivers/stdio_console.c
@@ -0,0 +1,205 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/posix_types.h"
+#include "linux/tty.h"
+#include "linux/tty_flip.h"
+#include "linux/types.h"
+#include "linux/major.h"
+#include "linux/kdev_t.h"
+#include "linux/console.h"
+#include "linux/string.h"
+#include "linux/sched.h"
+#include "linux/list.h"
+#include "linux/init.h"
+#include "linux/interrupt.h"
+#include "linux/slab.h"
+#include "linux/hardirq.h"
+#include "asm/current.h"
+#include "asm/irq.h"
+#include "stdio_console.h"
+#include "line.h"
+#include "chan_kern.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "irq_user.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "2_5compat.h"
+
+#define MAX_TTYS (16)
+
+/* ----------------------------------------------------------------------------- */
+
+/* Referenced only by tty_driver below - presumably it's locked correctly
+ * by the tty driver.
+ */
+
+static struct tty_driver *console_driver;
+
+void stdio_announce(char *dev_name, int dev)
+{
+        printk(KERN_INFO "Virtual console %d assigned device '%s'\n", dev,
+               dev_name);
+}
+
+static struct chan_opts opts = {
+        .announce       = stdio_announce,
+        .xterm_title    = "Virtual Console #%d",
+        .raw            = 1,
+        .tramp_stack    = 0,
+        .in_kernel      = 1,
+};
+
+static int con_config(char *str);
+static int con_get_config(char *dev, char *str, int size, char **error_out);
+static int con_remove(char *str);
+
+static struct line_driver driver = {
+        .name                   = "UML console",
+        .device_name            = "tty",
+        .devfs_name             = "vc/",
+        .major                  = TTY_MAJOR,
+        .minor_start            = 0,
+        .type                   = TTY_DRIVER_TYPE_CONSOLE,
+        .subtype                = SYSTEM_TYPE_CONSOLE,
+        .read_irq               = CONSOLE_IRQ,
+        .read_irq_name          = "console",
+        .write_irq              = CONSOLE_WRITE_IRQ,
+        .write_irq_name         = "console-write",
+        .symlink_from           = "ttys",
+        .symlink_to             = "vc",
+        .mc  = {
+                .name           = "con",
+                .config         = con_config,
+                .get_config     = con_get_config,
+                .remove         = con_remove,
+        },
+};
+
+static struct lines console_lines = LINES_INIT(MAX_TTYS);
+
+/* The array is initialized by line_init, which is an initcall.  The 
+ * individual elements are protected by individual semaphores.
+ */
+struct line vts[MAX_TTYS] = { LINE_INIT(CONFIG_CON_ZERO_CHAN, &driver),
+                              [ 1 ... MAX_TTYS - 1 ] = 
+                              LINE_INIT(CONFIG_CON_CHAN, &driver) };
+
+static int con_config(char *str)
+{
+        return(line_config(vts, sizeof(vts)/sizeof(vts[0]), str));
+}
+
+static int con_get_config(char *dev, char *str, int size, char **error_out)
+{
+        return(line_get_config(dev, vts, sizeof(vts)/sizeof(vts[0]), str, 
+                               size, error_out));
+}
+
+static int con_remove(char *str)
+{
+        return(line_remove(vts, sizeof(vts)/sizeof(vts[0]), str));
+}
+
+static int con_open(struct tty_struct *tty, struct file *filp)
+{
+        return line_open(vts, tty, &opts);
+}
+
+static int con_init_done = 0;
+
+static struct tty_operations console_ops = {
+        .open                   = con_open,
+        .close                  = line_close,
+        .write                  = line_write,
+        .write_room             = line_write_room,
+        .chars_in_buffer        = line_chars_in_buffer,
+        .set_termios            = line_set_termios,
+        .ioctl                  = line_ioctl,
+};
+
+static void uml_console_write(struct console *console, const char *string,
+                          unsigned len)
+{
+        struct line *line = &vts[console->index];
+
+        down(&line->sem);
+        console_write_chan(&line->chan_list, string, len);
+        up(&line->sem);
+}
+
+static struct tty_driver *uml_console_device(struct console *c, int *index)
+{
+        *index = c->index;
+        return console_driver;
+}
+
+static int uml_console_setup(struct console *co, char *options)
+{
+        struct line *line = &vts[co->index];
+
+        return console_open_chan(line,co,&opts);
+}
+
+static struct console stdiocons = {
+        .name           = "tty",
+        .write          = uml_console_write,
+        .device         = uml_console_device,
+        .setup          = uml_console_setup,
+        .flags          = CON_PRINTBUFFER,
+        .index          = -1,
+        .data           = &vts,
+};
+
+int stdio_init(void)
+{
+        char *new_title;
+
+        console_driver = line_register_devfs(&console_lines, &driver,
+                                             &console_ops, vts,
+                                             ARRAY_SIZE(vts));
+        if (NULL == console_driver)
+                return -1;
+        printk(KERN_INFO "Initialized stdio console driver\n");
+
+        lines_init(vts, sizeof(vts)/sizeof(vts[0]));
+
+        new_title = add_xterm_umid(opts.xterm_title);
+        if(new_title != NULL)
+                opts.xterm_title = new_title;
+
+        con_init_done = 1;
+        register_console(&stdiocons);
+        return(0);
+}
+late_initcall(stdio_init);
+
+static void console_exit(void)
+{
+        if (!con_init_done)
+                return;
+        close_lines(vts, sizeof(vts)/sizeof(vts[0]));
+}
+__uml_exitcall(console_exit);
+
+static int console_chan_setup(char *str)
+{
+        return(line_setup(vts, sizeof(vts)/sizeof(vts[0]), str, 1));
+}
+__setup("con", console_chan_setup);
+__channel_help(console_chan_setup, "con");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/stdio_console.h b/arch/um/drivers/stdio_console.h
new file mode 100644
index 000000000000..505a3d5bea5e
--- /dev/null
+++ b/arch/um/drivers/stdio_console.h
@@ -0,0 +1,21 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __STDIO_CONSOLE_H
+#define __STDIO_CONSOLE_H
+
+extern void save_console_flags(void);
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/tty.c b/arch/um/drivers/tty.c
new file mode 100644
index 000000000000..6fbb670ee274
--- /dev/null
+++ b/arch/um/drivers/tty.c
@@ -0,0 +1,92 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <termios.h>
+#include <errno.h>
+#include <unistd.h>
+#include "chan_user.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+struct tty_chan {
+        char *dev;
+        int raw;
+        struct termios tt;
+};
+
+static void *tty_chan_init(char *str, int device, struct chan_opts *opts)
+{
+        struct tty_chan *data;
+
+        if(*str != ':'){
+                printk("tty_init : channel type 'tty' must specify "
+                       "a device\n");
+                return(NULL);
+        }
+        str++;
+
+        data = um_kmalloc(sizeof(*data));
+        if(data == NULL)
+                return(NULL);
+        *data = ((struct tty_chan) { .dev       = str,
+                                     .raw       = opts->raw });
+                                     
+        return(data);
+}
+
+static int tty_open(int input, int output, int primary, void *d,
+                    char **dev_out)
+{
+        struct tty_chan *data = d;
+        int fd, err;
+
+        fd = os_open_file(data->dev, of_set_rw(OPENFLAGS(), input, output), 0);
+        if(fd < 0) return(fd);
+        if(data->raw){
+                CATCH_EINTR(err = tcgetattr(fd, &data->tt));
+                if(err)
+                        return(err);
+
+                err = raw(fd);
+                if(err)
+                        return(err);
+        }
+
+        *dev_out = data->dev;
+        return(fd);
+}
+
+static int tty_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct tty_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops tty_ops = {
+        .type           = "tty",
+        .init           = tty_chan_init,
+        .open           = tty_open,
+        .close          = generic_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = tty_console_write,
+        .window_size    = generic_window_size,
+        .free           = generic_free,
+        .winch          = 0,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
new file mode 100644
index 000000000000..4d8b165bfa48
--- /dev/null
+++ b/arch/um/drivers/ubd_kern.c
@@ -0,0 +1,1669 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+/* 2001-09-28...2002-04-17
+ * Partition stuff by James_McMechan@hotmail.com
+ * old style ubd by setting UBD_SHIFT to 0
+ * 2002-09-27...2002-10-18 massive tinkering for 2.5
+ * partitions have changed in 2.5
+ * 2003-01-29 more tinkering for 2.5.59-1
+ * This should now address the sysfs problems and has
+ * the symlink for devfs to allow for booting with
+ * the common /dev/ubd/discX/... names rather than
+ * only /dev/ubdN/discN this version also has lots of
+ * clean ups preparing for ubd-many.
+ * James McMechan
+ */
+
+#define MAJOR_NR UBD_MAJOR
+#define UBD_SHIFT 4
+
+#include "linux/config.h"
+#include "linux/module.h"
+#include "linux/blkdev.h"
+#include "linux/hdreg.h"
+#include "linux/init.h"
+#include "linux/devfs_fs_kernel.h"
+#include "linux/cdrom.h"
+#include "linux/proc_fs.h"
+#include "linux/ctype.h"
+#include "linux/capability.h"
+#include "linux/mm.h"
+#include "linux/vmalloc.h"
+#include "linux/blkpg.h"
+#include "linux/genhd.h"
+#include "linux/spinlock.h"
+#include "asm/segment.h"
+#include "asm/uaccess.h"
+#include "asm/irq.h"
+#include "asm/types.h"
+#include "asm/tlbflush.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mconsole_kern.h"
+#include "init.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "ubd_user.h"
+#include "2_5compat.h"
+#include "os.h"
+#include "mem.h"
+#include "mem_kern.h"
+#include "cow.h"
+
+enum ubd_req { UBD_READ, UBD_WRITE, UBD_MMAP };
+
+struct io_thread_req {
+        enum ubd_req op;
+        int fds[2];
+        unsigned long offsets[2];
+        unsigned long long offset;
+        unsigned long length;
+        char *buffer;
+        int sectorsize;
+        unsigned long sector_mask;
+        unsigned long long cow_offset;
+        unsigned long bitmap_words[2];
+        int map_fd;
+        unsigned long long map_offset;
+        int error;
+};
+
+extern int open_ubd_file(char *file, struct openflags *openflags,
+                         char **backing_file_out, int *bitmap_offset_out,
+                         unsigned long *bitmap_len_out, int *data_offset_out,
+                         int *create_cow_out);
+extern int create_cow_file(char *cow_file, char *backing_file,
+                           struct openflags flags, int sectorsize,
+                           int alignment, int *bitmap_offset_out,
+                           unsigned long *bitmap_len_out,
+                           int *data_offset_out);
+extern int read_cow_bitmap(int fd, void *buf, int offset, int len);
+extern void do_io(struct io_thread_req *req);
+
+static inline int ubd_test_bit(__u64 bit, unsigned char *data)
+{
+        __u64 n;
+        int bits, off;
+
+        bits = sizeof(data[0]) * 8;
+        n = bit / bits;
+        off = bit % bits;
+        return((data[n] & (1 << off)) != 0);
+}
+
+static inline void ubd_set_bit(__u64 bit, unsigned char *data)
+{
+        __u64 n;
+        int bits, off;
+
+        bits = sizeof(data[0]) * 8;
+        n = bit / bits;
+        off = bit % bits;
+        data[n] |= (1 << off);
+}
+/*End stuff from ubd_user.h*/
+
+#define DRIVER_NAME "uml-blkdev"
+
+static DEFINE_SPINLOCK(ubd_io_lock);
+static DEFINE_SPINLOCK(ubd_lock);
+
+static void (*do_ubd)(void);
+
+static int ubd_open(struct inode * inode, struct file * filp);
+static int ubd_release(struct inode * inode, struct file * file);
+static int ubd_ioctl(struct inode * inode, struct file * file,
+                     unsigned int cmd, unsigned long arg);
+
+#define MAX_DEV (8)
+
+/* Changed in early boot */
+static int ubd_do_mmap = 0;
+#define UBD_MMAP_BLOCK_SIZE PAGE_SIZE
+
+static struct block_device_operations ubd_blops = {
+        .owner          = THIS_MODULE,
+        .open           = ubd_open,
+        .release        = ubd_release,
+        .ioctl          = ubd_ioctl,
+};
+
+/* Protected by the queue_lock */
+static request_queue_t *ubd_queue;
+
+/* Protected by ubd_lock */
+static int fake_major = MAJOR_NR;
+
+static struct gendisk *ubd_gendisk[MAX_DEV];
+static struct gendisk *fake_gendisk[MAX_DEV];
+ 
+#ifdef CONFIG_BLK_DEV_UBD_SYNC
+#define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 1, .c = 0, \
+                                         .cl = 1 })
+#else
+#define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 0, .c = 0, \
+                                         .cl = 1 })
+#endif
+
+/* Not protected - changed only in ubd_setup_common and then only to
+ * to enable O_SYNC.
+ */
+static struct openflags global_openflags = OPEN_FLAGS;
+
+struct cow {
+        char *file;
+        int fd;
+        unsigned long *bitmap;
+        unsigned long bitmap_len;
+        int bitmap_offset;
+        int data_offset;
+};
+
+struct ubd {
+        char *file;
+        int count;
+        int fd;
+        __u64 size;
+        struct openflags boot_openflags;
+        struct openflags openflags;
+        int no_cow;
+        struct cow cow;
+        struct platform_device pdev;
+
+        int map_writes;
+        int map_reads;
+        int nomap_writes;
+        int nomap_reads;
+        int write_maps;
+};
+
+#define DEFAULT_COW { \
+        .file =                 NULL, \
+        .fd =                   -1, \
+        .bitmap =               NULL, \
+        .bitmap_offset =        0, \
+        .data_offset =          0, \
+}
+
+#define DEFAULT_UBD { \
+        .file =                 NULL, \
+        .count =                0, \
+        .fd =                   -1, \
+        .size =                 -1, \
+        .boot_openflags =       OPEN_FLAGS, \
+        .openflags =            OPEN_FLAGS, \
+        .no_cow =               0, \
+        .cow =                  DEFAULT_COW, \
+        .map_writes             = 0, \
+        .map_reads              = 0, \
+        .nomap_writes           = 0, \
+        .nomap_reads            = 0, \
+        .write_maps             = 0, \
+}
+
+struct ubd ubd_dev[MAX_DEV] = { [ 0 ... MAX_DEV - 1 ] = DEFAULT_UBD };
+
+static int ubd0_init(void)
+{
+        struct ubd *dev = &ubd_dev[0];
+
+        if(dev->file == NULL)
+                dev->file = "root_fs";
+        return(0);
+}
+
+__initcall(ubd0_init);
+
+/* Only changed by fake_ide_setup which is a setup */
+static int fake_ide = 0;
+static struct proc_dir_entry *proc_ide_root = NULL;
+static struct proc_dir_entry *proc_ide = NULL;
+
+static void make_proc_ide(void)
+{
+        proc_ide_root = proc_mkdir("ide", NULL);
+        proc_ide = proc_mkdir("ide0", proc_ide_root);
+}
+
+static int proc_ide_read_media(char *page, char **start, off_t off, int count,
+                               int *eof, void *data)
+{
+        int len;
+
+        strcpy(page, "disk\n");
+        len = strlen("disk\n");
+        len -= off;
+        if (len < count){
+                *eof = 1;
+                if (len <= 0) return 0;
+        }
+        else len = count;
+        *start = page + off;
+        return len;
+}
+
+static void make_ide_entries(char *dev_name)
+{
+        struct proc_dir_entry *dir, *ent;
+        char name[64];
+
+        if(proc_ide_root == NULL) make_proc_ide();
+
+        dir = proc_mkdir(dev_name, proc_ide);
+        if(!dir) return;
+
+        ent = create_proc_entry("media", S_IFREG|S_IRUGO, dir);
+        if(!ent) return;
+        ent->nlink = 1;
+        ent->data = NULL;
+        ent->read_proc = proc_ide_read_media;
+        ent->write_proc = NULL;
+        sprintf(name,"ide0/%s", dev_name);
+        proc_symlink(dev_name, proc_ide_root, name);
+}
+
+static int fake_ide_setup(char *str)
+{
+        fake_ide = 1;
+        return(1);
+}
+
+__setup("fake_ide", fake_ide_setup);
+
+__uml_help(fake_ide_setup,
+"fake_ide\n"
+"    Create ide0 entries that map onto ubd devices.\n\n"
+);
+
+static int parse_unit(char **ptr)
+{
+        char *str = *ptr, *end;
+        int n = -1;
+
+        if(isdigit(*str)) {
+                n = simple_strtoul(str, &end, 0);
+                if(end == str)
+                        return(-1);
+                *ptr = end;
+        }
+        else if (('a' <= *str) && (*str <= 'h')) {
+                n = *str - 'a';
+                str++;
+                *ptr = str;
+        }
+        return(n);
+}
+
+static int ubd_setup_common(char *str, int *index_out)
+{
+        struct ubd *dev;
+        struct openflags flags = global_openflags;
+        char *backing_file;
+        int n, err, i;
+
+        if(index_out) *index_out = -1;
+        n = *str;
+        if(n == '='){
+                char *end;
+                int major;
+
+                str++;
+                if(!strcmp(str, "mmap")){
+                        CHOOSE_MODE(printk("mmap not supported by the ubd "
+                                           "driver in tt mode\n"),
+                                    ubd_do_mmap = 1);
+                        return(0);
+                }
+
+                if(!strcmp(str, "sync")){
+                        global_openflags = of_sync(global_openflags);
+                        return(0);
+                }
+                major = simple_strtoul(str, &end, 0);
+                if((*end != '\0') || (end == str)){
+                        printk(KERN_ERR 
+                               "ubd_setup : didn't parse major number\n");
+                        return(1);
+                }
+
+                err = 1;
+                spin_lock(&ubd_lock);
+                if(fake_major != MAJOR_NR){
+                        printk(KERN_ERR "Can't assign a fake major twice\n");
+                        goto out1;
+                }
+ 
+                fake_major = major;
+
+                printk(KERN_INFO "Setting extra ubd major number to %d\n",
+                       major);
+                err = 0;
+        out1:
+                spin_unlock(&ubd_lock);
+                return(err);
+        }
+
+        n = parse_unit(&str);
+        if(n < 0){
+                printk(KERN_ERR "ubd_setup : couldn't parse unit number "
+                       "'%s'\n", str);
+                return(1);
+        }
+        if(n >= MAX_DEV){
+                printk(KERN_ERR "ubd_setup : index %d out of range "
+                       "(%d devices, from 0 to %d)\n", n, MAX_DEV, MAX_DEV - 1);
+                return(1);
+        }
+
+        err = 1;
+        spin_lock(&ubd_lock);
+
+        dev = &ubd_dev[n];
+        if(dev->file != NULL){
+                printk(KERN_ERR "ubd_setup : device already configured\n");
+                goto out;
+        }
+
+        if (index_out)
+                *index_out = n;
+
+        for (i = 0; i < 4; i++) {
+                switch (*str) {
+                case 'r':
+                        flags.w = 0;
+                        break;
+                case 's':
+                        flags.s = 1;
+                        break;
+                case 'd':
+                        dev->no_cow = 1;
+                        break;
+                case '=':
+                        str++;
+                        goto break_loop;
+                default:
+                        printk(KERN_ERR "ubd_setup : Expected '=' or flag letter (r,s or d)\n");
+                        goto out;
+                }
+                str++;
+        }
+
+        if (*str == '=')
+                printk(KERN_ERR "ubd_setup : Too many flags specified\n");
+        else
+                printk(KERN_ERR "ubd_setup : Expected '='\n");
+        goto out;
+
+break_loop:
+        err = 0;
+        backing_file = strchr(str, ',');
+
+        if (!backing_file) {
+                backing_file = strchr(str, ':');
+        }
+
+        if(backing_file){
+                if(dev->no_cow)
+                        printk(KERN_ERR "Can't specify both 'd' and a "
+                               "cow file\n");
+                else {
+                        *backing_file = '\0';
+                        backing_file++;
+                }
+        }
+        dev->file = str;
+        dev->cow.file = backing_file;
+        dev->boot_openflags = flags;
+out:
+        spin_unlock(&ubd_lock);
+        return(err);
+}
+
+static int ubd_setup(char *str)
+{
+        ubd_setup_common(str, NULL);
+        return(1);
+}
+
+__setup("ubd", ubd_setup);
+__uml_help(ubd_setup,
+"ubd<n><flags>=<filename>[(:|,)<filename2>]\n"
+"    This is used to associate a device with a file in the underlying\n"
+"    filesystem. When specifying two filenames, the first one is the\n"
+"    COW name and the second is the backing file name. As separator you can\n"
+"    use either a ':' or a ',': the first one allows writing things like;\n"
+"       ubd0=~/Uml/root_cow:~/Uml/root_backing_file\n"
+"    while with a ',' the shell would not expand the 2nd '~'.\n"
+"    When using only one filename, UML will detect whether to thread it like\n"
+"    a COW file or a backing file. To override this detection, add the 'd'\n"
+"    flag:\n"
+"       ubd0d=BackingFile\n"
+"    Usually, there is a filesystem in the file, but \n"
+"    that's not required. Swap devices containing swap files can be\n"
+"    specified like this. Also, a file which doesn't contain a\n"
+"    filesystem can have its contents read in the virtual \n"
+"    machine by running 'dd' on the device. <n> must be in the range\n"
+"    0 to 7. Appending an 'r' to the number will cause that device\n"
+"    to be mounted read-only. For example ubd1r=./ext_fs. Appending\n"
+"    an 's' will cause data to be written to disk on the host immediately.\n\n"
+);
+
+static int udb_setup(char *str)
+{
+        printk("udb%s specified on command line is almost certainly a ubd -> "
+               "udb TYPO\n", str);
+        return(1);
+}
+
+__setup("udb", udb_setup);
+__uml_help(udb_setup,
+"udb\n"
+"    This option is here solely to catch ubd -> udb typos, which can be\n\n"
+"    to impossible to catch visually unless you specifically look for\n\n"
+"    them.  The only result of any option starting with 'udb' is an error\n\n"
+"    in the boot output.\n\n"
+);
+
+static int fakehd_set = 0;
+static int fakehd(char *str)
+{
+        printk(KERN_INFO "fakehd : Changing ubd name to \"hd\".\n");
+        fakehd_set = 1;
+        return 1;
+}
+
+__setup("fakehd", fakehd);
+__uml_help(fakehd,
+"fakehd\n"
+"    Change the ubd device name to \"hd\".\n\n"
+);
+
+static void do_ubd_request(request_queue_t * q);
+
+/* Only changed by ubd_init, which is an initcall. */
+int thread_fd = -1;
+
+/* Changed by ubd_handler, which is serialized because interrupts only
+ * happen on CPU 0.
+ */
+int intr_count = 0;
+
+/* call ubd_finish if you need to serialize */
+static void __ubd_finish(struct request *req, int error)
+{
+        int nsect;
+
+        if(error){
+                end_request(req, 0);
+                return;
+        }
+        nsect = req->current_nr_sectors;
+        req->sector += nsect;
+        req->buffer += nsect << 9;
+        req->errors = 0;
+        req->nr_sectors -= nsect;
+        req->current_nr_sectors = 0;
+        end_request(req, 1);
+}
+
+static inline void ubd_finish(struct request *req, int error)
+{
+        spin_lock(&ubd_io_lock);
+        __ubd_finish(req, error);
+        spin_unlock(&ubd_io_lock);
+}
+
+/* Called without ubd_io_lock held */
+static void ubd_handler(void)
+{
+        struct io_thread_req req;
+        struct request *rq = elv_next_request(ubd_queue);
+        int n, err;
+
+        do_ubd = NULL;
+        intr_count++;
+        n = os_read_file(thread_fd, &req, sizeof(req));
+        if(n != sizeof(req)){
+                printk(KERN_ERR "Pid %d - spurious interrupt in ubd_handler, "
+                       "err = %d\n", os_getpid(), -n);
+                spin_lock(&ubd_io_lock);
+                end_request(rq, 0);
+                spin_unlock(&ubd_io_lock);
+                return;
+        }
+        
+        if((req.op != UBD_MMAP) &&
+           ((req.offset != ((__u64) (rq->sector)) << 9) ||
+            (req.length != (rq->current_nr_sectors) << 9)))
+                panic("I/O op mismatch");
+        
+        if(req.map_fd != -1){
+                err = physmem_subst_mapping(req.buffer, req.map_fd,
+                                            req.map_offset, 1);
+                if(err)
+                        printk("ubd_handler - physmem_subst_mapping failed, "
+                               "err = %d\n", -err);
+        }
+
+        ubd_finish(rq, req.error);
+        reactivate_fd(thread_fd, UBD_IRQ);      
+        do_ubd_request(ubd_queue);
+}
+
+static irqreturn_t ubd_intr(int irq, void *dev, struct pt_regs *unused)
+{
+        ubd_handler();
+        return(IRQ_HANDLED);
+}
+
+/* Only changed by ubd_init, which is an initcall. */
+static int io_pid = -1;
+
+void kill_io_thread(void)
+{
+        if(io_pid != -1) 
+                os_kill_process(io_pid, 1);
+}
+
+__uml_exitcall(kill_io_thread);
+
+static int ubd_file_size(struct ubd *dev, __u64 *size_out)
+{
+        char *file;
+
+        file = dev->cow.file ? dev->cow.file : dev->file;
+        return(os_file_size(file, size_out));
+}
+
+static void ubd_close(struct ubd *dev)
+{
+        if(ubd_do_mmap)
+                physmem_forget_descriptor(dev->fd);
+        os_close_file(dev->fd);
+        if(dev->cow.file == NULL)
+                return;
+
+        if(ubd_do_mmap)
+                physmem_forget_descriptor(dev->cow.fd);
+        os_close_file(dev->cow.fd);
+        vfree(dev->cow.bitmap);
+        dev->cow.bitmap = NULL;
+}
+
+static int ubd_open_dev(struct ubd *dev)
+{
+        struct openflags flags;
+        char **back_ptr;
+        int err, create_cow, *create_ptr;
+
+        dev->openflags = dev->boot_openflags;
+        create_cow = 0;
+        create_ptr = (dev->cow.file != NULL) ? &create_cow : NULL;
+        back_ptr = dev->no_cow ? NULL : &dev->cow.file;
+        dev->fd = open_ubd_file(dev->file, &dev->openflags, back_ptr,
+                                &dev->cow.bitmap_offset, &dev->cow.bitmap_len, 
+                                &dev->cow.data_offset, create_ptr);
+
+        if((dev->fd == -ENOENT) && create_cow){
+                dev->fd = create_cow_file(dev->file, dev->cow.file, 
+                                          dev->openflags, 1 << 9, PAGE_SIZE,
+                                          &dev->cow.bitmap_offset, 
+                                          &dev->cow.bitmap_len,
+                                          &dev->cow.data_offset);
+                if(dev->fd >= 0){
+                        printk(KERN_INFO "Creating \"%s\" as COW file for "
+                               "\"%s\"\n", dev->file, dev->cow.file);
+                }
+        }
+
+        if(dev->fd < 0){
+                printk("Failed to open '%s', errno = %d\n", dev->file,
+                       -dev->fd);
+                return(dev->fd);
+        }
+
+        if(dev->cow.file != NULL){
+                err = -ENOMEM;
+                dev->cow.bitmap = (void *) vmalloc(dev->cow.bitmap_len);
+                if(dev->cow.bitmap == NULL){
+                        printk(KERN_ERR "Failed to vmalloc COW bitmap\n");
+                        goto error;
+                }
+                flush_tlb_kernel_vm();
+
+                err = read_cow_bitmap(dev->fd, dev->cow.bitmap, 
+                                      dev->cow.bitmap_offset, 
+                                      dev->cow.bitmap_len);
+                if(err < 0)
+                        goto error;
+
+                flags = dev->openflags;
+                flags.w = 0;
+                err = open_ubd_file(dev->cow.file, &flags, NULL, NULL, NULL, 
+                                    NULL, NULL);
+                if(err < 0) goto error;
+                dev->cow.fd = err;
+        }
+        return(0);
+ error:
+        os_close_file(dev->fd);
+        return(err);
+}
+
+static int ubd_new_disk(int major, u64 size, int unit,
+                        struct gendisk **disk_out)
+                        
+{
+        struct gendisk *disk;
+        char from[sizeof("ubd/nnnnn\0")], to[sizeof("discnnnnn/disc\0")];
+        int err;
+
+        disk = alloc_disk(1 << UBD_SHIFT);
+        if(disk == NULL)
+                return(-ENOMEM);
+
+        disk->major = major;
+        disk->first_minor = unit << UBD_SHIFT;
+        disk->fops = &ubd_blops;
+        set_capacity(disk, size / 512);
+        if(major == MAJOR_NR){
+                sprintf(disk->disk_name, "ubd%c", 'a' + unit);
+                sprintf(disk->devfs_name, "ubd/disc%d", unit);
+                sprintf(from, "ubd/%d", unit);
+                sprintf(to, "disc%d/disc", unit);
+                err = devfs_mk_symlink(from, to);
+                if(err)
+                        printk("ubd_new_disk failed to make link from %s to "
+                               "%s, error = %d\n", from, to, err);
+        }
+        else {
+                sprintf(disk->disk_name, "ubd_fake%d", unit);
+                sprintf(disk->devfs_name, "ubd_fake/disc%d", unit);
+        }
+
+        /* sysfs register (not for ide fake devices) */
+        if (major == MAJOR_NR) {
+                ubd_dev[unit].pdev.id   = unit;
+                ubd_dev[unit].pdev.name = DRIVER_NAME;
+                platform_device_register(&ubd_dev[unit].pdev);
+                disk->driverfs_dev = &ubd_dev[unit].pdev.dev;
+        }
+
+        disk->private_data = &ubd_dev[unit];
+        disk->queue = ubd_queue;
+        add_disk(disk);
+
+        *disk_out = disk;
+        return 0;
+}
+
+#define ROUND_BLOCK(n) ((n + ((1 << 9) - 1)) & (-1 << 9))
+
+static int ubd_add(int n)
+{
+        struct ubd *dev = &ubd_dev[n];
+        int err;
+
+        if(dev->file == NULL)
+                return(-ENODEV);
+
+        if (ubd_open_dev(dev))
+                return(-ENODEV);
+
+        err = ubd_file_size(dev, &dev->size);
+        if(err < 0)
+                return(err);
+
+        dev->size = ROUND_BLOCK(dev->size);
+
+        err = ubd_new_disk(MAJOR_NR, dev->size, n, &ubd_gendisk[n]);
+        if(err) 
+                return(err);
+ 
+        if(fake_major != MAJOR_NR)
+                ubd_new_disk(fake_major, dev->size, n, 
+                             &fake_gendisk[n]);
+
+        /* perhaps this should also be under the "if (fake_major)" above */
+        /* using the fake_disk->disk_name and also the fakehd_set name */
+        if (fake_ide)
+                make_ide_entries(ubd_gendisk[n]->disk_name);
+
+        ubd_close(dev);
+        return 0;
+}
+
+static int ubd_config(char *str)
+{
+        int n, err;
+
+        str = uml_strdup(str);
+        if(str == NULL){
+                printk(KERN_ERR "ubd_config failed to strdup string\n");
+                return(1);
+        }
+        err = ubd_setup_common(str, &n);
+        if(err){
+                kfree(str);
+                return(-1);
+        }
+        if(n == -1) return(0);
+
+        spin_lock(&ubd_lock);
+        err = ubd_add(n);
+        if(err)
+                ubd_dev[n].file = NULL;
+        spin_unlock(&ubd_lock);
+
+        return(err);
+}
+
+static int ubd_get_config(char *name, char *str, int size, char **error_out)
+{
+        struct ubd *dev;
+        int n, len = 0;
+
+        n = parse_unit(&name);
+        if((n >= MAX_DEV) || (n < 0)){
+                *error_out = "ubd_get_config : device number out of range";
+                return(-1);
+        }
+
+        dev = &ubd_dev[n];
+        spin_lock(&ubd_lock);
+
+        if(dev->file == NULL){
+                CONFIG_CHUNK(str, size, len, "", 1);
+                goto out;
+        }
+
+        CONFIG_CHUNK(str, size, len, dev->file, 0);
+
+        if(dev->cow.file != NULL){
+                CONFIG_CHUNK(str, size, len, ",", 0);
+                CONFIG_CHUNK(str, size, len, dev->cow.file, 1);
+        }
+        else CONFIG_CHUNK(str, size, len, "", 1);
+
+ out:
+        spin_unlock(&ubd_lock);
+        return(len);
+}
+
+static int ubd_remove(char *str)
+{
+        struct ubd *dev;
+        int n, err = -ENODEV;
+
+        n = parse_unit(&str);
+
+        if((n < 0) || (n >= MAX_DEV))
+                return(err);
+
+        dev = &ubd_dev[n];
+        if(dev->count > 0)
+                return(-EBUSY); /* you cannot remove a open disk */
+
+        err = 0;
+        spin_lock(&ubd_lock);
+
+        if(ubd_gendisk[n] == NULL)
+                goto out;
+
+        del_gendisk(ubd_gendisk[n]);
+        put_disk(ubd_gendisk[n]);
+        ubd_gendisk[n] = NULL;
+
+        if(fake_gendisk[n] != NULL){
+                del_gendisk(fake_gendisk[n]);
+                put_disk(fake_gendisk[n]);
+                fake_gendisk[n] = NULL;
+        }
+
+        platform_device_unregister(&dev->pdev);
+        *dev = ((struct ubd) DEFAULT_UBD);
+        err = 0;
+ out:
+        spin_unlock(&ubd_lock);
+        return(err);
+}
+
+static struct mc_device ubd_mc = {
+        .name           = "ubd",
+        .config         = ubd_config,
+        .get_config     = ubd_get_config,
+        .remove         = ubd_remove,
+};
+
+static int ubd_mc_init(void)
+{
+        mconsole_register_dev(&ubd_mc);
+        return 0;
+}
+
+__initcall(ubd_mc_init);
+
+static struct device_driver ubd_driver = {
+        .name  = DRIVER_NAME,
+        .bus   = &platform_bus_type,
+};
+
+int ubd_init(void)
+{
+        int i;
+
+        devfs_mk_dir("ubd");
+        if (register_blkdev(MAJOR_NR, "ubd"))
+                return -1;
+
+        ubd_queue = blk_init_queue(do_ubd_request, &ubd_io_lock);
+        if (!ubd_queue) {
+                unregister_blkdev(MAJOR_NR, "ubd");
+                return -1;
+        }
+                
+        if (fake_major != MAJOR_NR) {
+                char name[sizeof("ubd_nnn\0")];
+
+                snprintf(name, sizeof(name), "ubd_%d", fake_major);
+                devfs_mk_dir(name);
+                if (register_blkdev(fake_major, "ubd"))
+                        return -1;
+        }
+        driver_register(&ubd_driver);
+        for (i = 0; i < MAX_DEV; i++) 
+                ubd_add(i);
+        return 0;
+}
+
+late_initcall(ubd_init);
+
+int ubd_driver_init(void){
+        unsigned long stack;
+        int err;
+
+        /* Set by CONFIG_BLK_DEV_UBD_SYNC or ubd=sync.*/
+        if(global_openflags.s){
+                printk(KERN_INFO "ubd: Synchronous mode\n");
+                /* Letting ubd=sync be like using ubd#s= instead of ubd#= is
+                 * enough. So use anyway the io thread. */
+        }
+        stack = alloc_stack(0, 0);
+        io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), 
+                                 &thread_fd);
+        if(io_pid < 0){
+                printk(KERN_ERR 
+                       "ubd : Failed to start I/O thread (errno = %d) - "
+                       "falling back to synchronous I/O\n", -io_pid);
+                io_pid = -1;
+                return(0);
+        }
+        err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr, 
+                             SA_INTERRUPT, "ubd", ubd_dev);
+        if(err != 0)
+                printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err);
+        return(err);
+}
+
+device_initcall(ubd_driver_init);
+
+static int ubd_open(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ubd *dev = disk->private_data;
+        int err = 0;
+
+        if(dev->count == 0){
+                err = ubd_open_dev(dev);
+                if(err){
+                        printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n",
+                               disk->disk_name, dev->file, -err);
+                        goto out;
+                }
+        }
+        dev->count++;
+        if((filp->f_mode & FMODE_WRITE) && !dev->openflags.w){
+                if(--dev->count == 0) ubd_close(dev);
+                err = -EROFS;
+        }
+ out:
+        return(err);
+}
+
+static int ubd_release(struct inode * inode, struct file * file)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ubd *dev = disk->private_data;
+
+        if(--dev->count == 0)
+                ubd_close(dev);
+        return(0);
+}
+
+static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask,
+                          __u64 *cow_offset, unsigned long *bitmap,
+                          __u64 bitmap_offset, unsigned long *bitmap_words,
+                          __u64 bitmap_len)
+{
+        __u64 sector = io_offset >> 9;
+        int i, update_bitmap = 0;
+
+        for(i = 0; i < length >> 9; i++){
+                if(cow_mask != NULL)
+                        ubd_set_bit(i, (unsigned char *) cow_mask);
+                if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
+                        continue;
+
+                update_bitmap = 1;
+                ubd_set_bit(sector + i, (unsigned char *) bitmap);
+        }
+
+        if(!update_bitmap)
+                return;
+
+        *cow_offset = sector / (sizeof(unsigned long) * 8);
+
+        /* This takes care of the case where we're exactly at the end of the
+         * device, and *cow_offset + 1 is off the end.  So, just back it up
+         * by one word.  Thanks to Lynn Kerby for the fix and James McMechan
+         * for the original diagnosis.
+         */
+        if(*cow_offset == ((bitmap_len + sizeof(unsigned long) - 1) /
+                           sizeof(unsigned long) - 1))
+                (*cow_offset)--;
+
+        bitmap_words[0] = bitmap[*cow_offset];
+        bitmap_words[1] = bitmap[*cow_offset + 1];
+
+        *cow_offset *= sizeof(unsigned long);
+        *cow_offset += bitmap_offset;
+}
+
+static void cowify_req(struct io_thread_req *req, unsigned long *bitmap,
+                       __u64 bitmap_offset, __u64 bitmap_len)
+{
+        __u64 sector = req->offset >> 9;
+        int i;
+
+        if(req->length > (sizeof(req->sector_mask) * 8) << 9)
+                panic("Operation too long");
+
+        if(req->op == UBD_READ) {
+                for(i = 0; i < req->length >> 9; i++){
+                        if(ubd_test_bit(sector + i, (unsigned char *) bitmap))
+                                ubd_set_bit(i, (unsigned char *) 
+                                            &req->sector_mask);
+                }
+        }
+        else cowify_bitmap(req->offset, req->length, &req->sector_mask,
+                           &req->cow_offset, bitmap, bitmap_offset,
+                           req->bitmap_words, bitmap_len);
+}
+
+static int mmap_fd(struct request *req, struct ubd *dev, __u64 offset)
+{
+        __u64 sector;
+        unsigned char *bitmap;
+        int bit, i;
+
+        /* mmap must have been requested on the command line */
+        if(!ubd_do_mmap)
+                return(-1);
+
+        /* The buffer must be page aligned */
+        if(((unsigned long) req->buffer % UBD_MMAP_BLOCK_SIZE) != 0)
+                return(-1);
+
+        /* The request must be a page long */
+        if((req->current_nr_sectors << 9) != PAGE_SIZE)
+                return(-1);
+
+        if(dev->cow.file == NULL)
+                return(dev->fd);
+
+        sector = offset >> 9;
+        bitmap = (unsigned char *) dev->cow.bitmap;
+        bit = ubd_test_bit(sector, bitmap);
+
+        for(i = 1; i < req->current_nr_sectors; i++){
+                if(ubd_test_bit(sector + i, bitmap) != bit)
+                        return(-1);
+        }
+
+        if(bit || (rq_data_dir(req) == WRITE))
+                offset += dev->cow.data_offset;
+
+        /* The data on disk must be page aligned */
+        if((offset % UBD_MMAP_BLOCK_SIZE) != 0)
+                return(-1);
+
+        return(bit ? dev->fd : dev->cow.fd);
+}
+
+static int prepare_mmap_request(struct ubd *dev, int fd, __u64 offset,
+                                struct request *req,
+                                struct io_thread_req *io_req)
+{
+        int err;
+
+        if(rq_data_dir(req) == WRITE){
+                /* Writes are almost no-ops since the new data is already in the
+                 * host page cache
+                 */
+                dev->map_writes++;
+                if(dev->cow.file != NULL)
+                        cowify_bitmap(io_req->offset, io_req->length,
+                                      &io_req->sector_mask, &io_req->cow_offset,
+                                      dev->cow.bitmap, dev->cow.bitmap_offset,
+                                      io_req->bitmap_words,
+                                      dev->cow.bitmap_len);
+        }
+        else {
+                int w;
+
+                if((dev->cow.file != NULL) && (fd == dev->cow.fd))
+                        w = 0;
+                else w = dev->openflags.w;
+
+                if((dev->cow.file != NULL) && (fd == dev->fd))
+                        offset += dev->cow.data_offset;
+
+                err = physmem_subst_mapping(req->buffer, fd, offset, w);
+                if(err){
+                        printk("physmem_subst_mapping failed, err = %d\n",
+                               -err);
+                        return(1);
+                }
+                dev->map_reads++;
+        }
+        io_req->op = UBD_MMAP;
+        io_req->buffer = req->buffer;
+        return(0);
+}
+
+/* Called with ubd_io_lock held */
+static int prepare_request(struct request *req, struct io_thread_req *io_req)
+{
+        struct gendisk *disk = req->rq_disk;
+        struct ubd *dev = disk->private_data;
+        __u64 offset;
+        int len, fd;
+
+        if(req->rq_status == RQ_INACTIVE) return(1);
+
+        if((rq_data_dir(req) == WRITE) && !dev->openflags.w){
+                printk("Write attempted on readonly ubd device %s\n", 
+                       disk->disk_name);
+                end_request(req, 0);
+                return(1);
+        }
+
+        offset = ((__u64) req->sector) << 9;
+        len = req->current_nr_sectors << 9;
+
+        io_req->fds[0] = (dev->cow.file != NULL) ? dev->cow.fd : dev->fd;
+        io_req->fds[1] = dev->fd;
+        io_req->map_fd = -1;
+        io_req->cow_offset = -1;
+        io_req->offset = offset;
+        io_req->length = len;
+        io_req->error = 0;
+        io_req->sector_mask = 0;
+
+        fd = mmap_fd(req, dev, io_req->offset);
+        if(fd > 0){
+                /* If mmapping is otherwise OK, but the first access to the
+                 * page is a write, then it's not mapped in yet.  So we have
+                 * to write the data to disk first, then we can map the disk
+                 * page in and continue normally from there.
+                 */
+                if((rq_data_dir(req) == WRITE) && !is_remapped(req->buffer)){
+                        io_req->map_fd = dev->fd;
+                        io_req->map_offset = io_req->offset +
+                                dev->cow.data_offset;
+                        dev->write_maps++;
+                }
+                else return(prepare_mmap_request(dev, fd, io_req->offset, req,
+                                                 io_req));
+        }
+
+        if(rq_data_dir(req) == READ)
+                dev->nomap_reads++;
+        else dev->nomap_writes++;
+
+        io_req->op = (rq_data_dir(req) == READ) ? UBD_READ : UBD_WRITE;
+        io_req->offsets[0] = 0;
+        io_req->offsets[1] = dev->cow.data_offset;
+        io_req->buffer = req->buffer;
+        io_req->sectorsize = 1 << 9;
+
+        if(dev->cow.file != NULL)
+                cowify_req(io_req, dev->cow.bitmap, dev->cow.bitmap_offset,
+                           dev->cow.bitmap_len);
+
+        return(0);
+}
+
+/* Called with ubd_io_lock held */
+static void do_ubd_request(request_queue_t *q)
+{
+        struct io_thread_req io_req;
+        struct request *req;
+        int err, n;
+
+        if(thread_fd == -1){
+                while((req = elv_next_request(q)) != NULL){
+                        err = prepare_request(req, &io_req);
+                        if(!err){
+                                do_io(&io_req);
+                                __ubd_finish(req, io_req.error);
+                        }
+                }
+        }
+        else {
+                if(do_ubd || (req = elv_next_request(q)) == NULL)
+                        return;
+                err = prepare_request(req, &io_req);
+                if(!err){
+                        do_ubd = ubd_handler;
+                        n = os_write_file(thread_fd, (char *) &io_req,
+                                         sizeof(io_req));
+                        if(n != sizeof(io_req))
+                                printk("write to io thread failed, "
+                                       "errno = %d\n", -n);
+                }
+        }
+}
+
+static int ubd_ioctl(struct inode * inode, struct file * file,
+                     unsigned int cmd, unsigned long arg)
+{
+        struct hd_geometry __user *loc = (struct hd_geometry __user *) arg;
+        struct ubd *dev = inode->i_bdev->bd_disk->private_data;
+        struct hd_driveid ubd_id = {
+                .cyls           = 0,
+                .heads          = 128,
+                .sectors        = 32,
+        };
+
+        switch (cmd) {
+                struct hd_geometry g;
+                struct cdrom_volctrl volume;
+        case HDIO_GETGEO:
+                if(!loc) return(-EINVAL);
+                g.heads = 128;
+                g.sectors = 32;
+                g.cylinders = dev->size / (128 * 32 * 512);
+                g.start = get_start_sect(inode->i_bdev);
+                return(copy_to_user(loc, &g, sizeof(g)) ? -EFAULT : 0);
+
+        case HDIO_GET_IDENTITY:
+                ubd_id.cyls = dev->size / (128 * 32 * 512);
+                if(copy_to_user((char __user *) arg, (char *) &ubd_id,
+                                 sizeof(ubd_id)))
+                        return(-EFAULT);
+                return(0);
+                
+        case CDROMVOLREAD:
+                if(copy_from_user(&volume, (char __user *) arg, sizeof(volume)))
+                        return(-EFAULT);
+                volume.channel0 = 255;
+                volume.channel1 = 255;
+                volume.channel2 = 255;
+                volume.channel3 = 255;
+                if(copy_to_user((char __user *) arg, &volume, sizeof(volume)))
+                        return(-EFAULT);
+                return(0);
+        }
+        return(-EINVAL);
+}
+
+static int ubd_check_remapped(int fd, unsigned long address, int is_write,
+                              __u64 offset)
+{
+        __u64 bitmap_offset;
+        unsigned long new_bitmap[2];
+        int i, err, n;
+
+        /* If it's not a write access, we can't do anything about it */
+        if(!is_write)
+                return(0);
+
+        /* We have a write */
+        for(i = 0; i < sizeof(ubd_dev) / sizeof(ubd_dev[0]); i++){
+                struct ubd *dev = &ubd_dev[i];
+
+                if((dev->fd != fd) && (dev->cow.fd != fd))
+                        continue;
+
+                /* It's a write to a ubd device */
+
+                if(!dev->openflags.w){
+                        /* It's a write access on a read-only device - probably
+                         * shouldn't happen.  If the kernel is trying to change
+                         * something with no intention of writing it back out,
+                         * then this message will clue us in that this needs
+                         * fixing
+                         */
+                        printk("Write access to mapped page from readonly ubd "
+                               "device %d\n", i);
+                        return(0);
+                }
+
+                /* It's a write to a writeable ubd device - it must be COWed
+                 * because, otherwise, the page would have been mapped in
+                 * writeable
+                 */
+
+                if(!dev->cow.file)
+                        panic("Write fault on writeable non-COW ubd device %d",
+                              i);
+
+                /* It should also be an access to the backing file since the
+                 * COW pages should be mapped in read-write
+                 */
+
+                if(fd == dev->fd)
+                        panic("Write fault on a backing page of ubd "
+                              "device %d\n", i);
+
+                /* So, we do the write, copying the backing data to the COW
+                 * file...
+                 */
+
+                err = os_seek_file(dev->fd, offset + dev->cow.data_offset);
+                if(err < 0)
+                        panic("Couldn't seek to %lld in COW file of ubd "
+                              "device %d, err = %d",
+                              offset + dev->cow.data_offset, i, -err);
+
+                n = os_write_file(dev->fd, (void *) address, PAGE_SIZE);
+                if(n != PAGE_SIZE)
+                        panic("Couldn't copy data to COW file of ubd "
+                              "device %d, err = %d", i, -n);
+
+                /* ... updating the COW bitmap... */
+
+                cowify_bitmap(offset, PAGE_SIZE, NULL, &bitmap_offset,
+                              dev->cow.bitmap, dev->cow.bitmap_offset,
+                              new_bitmap, dev->cow.bitmap_len);
+
+                err = os_seek_file(dev->fd, bitmap_offset);
+                if(err < 0)
+                        panic("Couldn't seek to %lld in COW file of ubd "
+                              "device %d, err = %d", bitmap_offset, i, -err);
+
+                n = os_write_file(dev->fd, new_bitmap, sizeof(new_bitmap));
+                if(n != sizeof(new_bitmap))
+                        panic("Couldn't update bitmap  of ubd device %d, "
+                              "err = %d", i, -n);
+
+                /* Maybe we can map the COW page in, and maybe we can't.  If
+                 * it is a pre-V3 COW file, we can't, since the alignment will
+                 * be wrong.  If it is a V3 or later COW file which has been
+                 * moved to a system with a larger page size, then maybe we
+                 * can't, depending on the exact location of the page.
+                 */
+
+                offset += dev->cow.data_offset;
+
+                /* Remove the remapping, putting the original anonymous page
+                 * back.  If the COW file can be mapped in, that is done.
+                 * Otherwise, the COW page is read in.
+                 */
+
+                if(!physmem_remove_mapping((void *) address))
+                        panic("Address 0x%lx not remapped by ubd device %d",
+                              address, i);
+                if((offset % UBD_MMAP_BLOCK_SIZE) == 0)
+                        physmem_subst_mapping((void *) address, dev->fd,
+                                              offset, 1);
+                else {
+                        err = os_seek_file(dev->fd, offset);
+                        if(err < 0)
+                                panic("Couldn't seek to %lld in COW file of "
+                                      "ubd device %d, err = %d", offset, i,
+                                      -err);
+
+                        n = os_read_file(dev->fd, (void *) address, PAGE_SIZE);
+                        if(n != PAGE_SIZE)
+                                panic("Failed to read page from offset %llx of "
+                                      "COW file of ubd device %d, err = %d",
+                                      offset, i, -n);
+                }
+
+                return(1);
+        }
+
+        /* It's not a write on a ubd device */
+        return(0);
+}
+
+static struct remapper ubd_remapper = {
+        .list   = LIST_HEAD_INIT(ubd_remapper.list),
+        .proc   = ubd_check_remapped,
+};
+
+static int ubd_remapper_setup(void)
+{
+        if(ubd_do_mmap)
+                register_remapper(&ubd_remapper);
+
+        return(0);
+}
+
+__initcall(ubd_remapper_setup);
+
+static int same_backing_files(char *from_cmdline, char *from_cow, char *cow)
+{
+        struct uml_stat buf1, buf2;
+        int err;
+
+        if(from_cmdline == NULL) return(1);
+        if(!strcmp(from_cmdline, from_cow)) return(1);
+
+        err = os_stat_file(from_cmdline, &buf1);
+        if(err < 0){
+                printk("Couldn't stat '%s', err = %d\n", from_cmdline, -err);
+                return(1);
+        }
+        err = os_stat_file(from_cow, &buf2);
+        if(err < 0){
+                printk("Couldn't stat '%s', err = %d\n", from_cow, -err);
+                return(1);
+        }
+        if((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino))
+                return(1);
+
+        printk("Backing file mismatch - \"%s\" requested,\n"
+               "\"%s\" specified in COW header of \"%s\"\n",
+               from_cmdline, from_cow, cow);
+        return(0);
+}
+
+static int backing_file_mismatch(char *file, __u64 size, time_t mtime)
+{
+        unsigned long modtime;
+        long long actual;
+        int err;
+
+        err = os_file_modtime(file, &modtime);
+        if(err < 0){
+                printk("Failed to get modification time of backing file "
+                       "\"%s\", err = %d\n", file, -err);
+                return(err);
+        }
+
+        err = os_file_size(file, &actual);
+        if(err < 0){
+                printk("Failed to get size of backing file \"%s\", "
+                       "err = %d\n", file, -err);
+                return(err);
+        }
+
+        if(actual != size){
+                /*__u64 can be a long on AMD64 and with %lu GCC complains; so
+                 * the typecast.*/
+                printk("Size mismatch (%llu vs %llu) of COW header vs backing "
+                       "file\n", (unsigned long long) size, actual);
+                return(-EINVAL);
+        }
+        if(modtime != mtime){
+                printk("mtime mismatch (%ld vs %ld) of COW header vs backing "
+                       "file\n", mtime, modtime);
+                return(-EINVAL);
+        }
+        return(0);
+}
+
+int read_cow_bitmap(int fd, void *buf, int offset, int len)
+{
+        int err;
+
+        err = os_seek_file(fd, offset);
+        if(err < 0)
+                return(err);
+
+        err = os_read_file(fd, buf, len);
+        if(err < 0)
+                return(err);
+
+        return(0);
+}
+
+int open_ubd_file(char *file, struct openflags *openflags,
+                  char **backing_file_out, int *bitmap_offset_out,
+                  unsigned long *bitmap_len_out, int *data_offset_out,
+                  int *create_cow_out)
+{
+        time_t mtime;
+        unsigned long long size;
+        __u32 version, align;
+        char *backing_file;
+        int fd, err, sectorsize, same, mode = 0644;
+
+        fd = os_open_file(file, *openflags, mode);
+        if(fd < 0){
+                if((fd == -ENOENT) && (create_cow_out != NULL))
+                        *create_cow_out = 1;
+                if(!openflags->w ||
+                   ((fd != -EROFS) && (fd != -EACCES))) return(fd);
+                openflags->w = 0;
+                fd = os_open_file(file, *openflags, mode);
+                if(fd < 0)
+                        return(fd);
+        }
+
+        err = os_lock_file(fd, openflags->w);
+        if(err < 0){
+                printk("Failed to lock '%s', err = %d\n", file, -err);
+                goto out_close;
+        }
+
+        if(backing_file_out == NULL) return(fd);
+
+        err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
+                              &size, &sectorsize, &align, bitmap_offset_out);
+        if(err && (*backing_file_out != NULL)){
+                printk("Failed to read COW header from COW file \"%s\", "
+                       "errno = %d\n", file, -err);
+                goto out_close;
+        }
+        if(err) return(fd);
+
+        if(backing_file_out == NULL) return(fd);
+
+        same = same_backing_files(*backing_file_out, backing_file, file);
+
+        if(!same && !backing_file_mismatch(*backing_file_out, size, mtime)){
+                printk("Switching backing file to '%s'\n", *backing_file_out);
+                err = write_cow_header(file, fd, *backing_file_out,
+                                       sectorsize, align, &size);
+                if(err){
+                        printk("Switch failed, errno = %d\n", -err);
+                        return(err);
+                }
+        }
+        else {
+                *backing_file_out = backing_file;
+                err = backing_file_mismatch(*backing_file_out, size, mtime);
+                if(err) goto out_close;
+        }
+
+        cow_sizes(version, size, sectorsize, align, *bitmap_offset_out,
+                  bitmap_len_out, data_offset_out);
+
+        return(fd);
+ out_close:
+        os_close_file(fd);
+        return(err);
+}
+
+int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
+                    int sectorsize, int alignment, int *bitmap_offset_out,
+                    unsigned long *bitmap_len_out, int *data_offset_out)
+{
+        int err, fd;
+
+        flags.c = 1;
+        fd = open_ubd_file(cow_file, &flags, NULL, NULL, NULL, NULL, NULL);
+        if(fd < 0){
+                err = fd;
+                printk("Open of COW file '%s' failed, errno = %d\n", cow_file,
+                       -err);
+                goto out;
+        }
+
+        err = init_cow_file(fd, cow_file, backing_file, sectorsize, alignment,
+                            bitmap_offset_out, bitmap_len_out,
+                            data_offset_out);
+        if(!err)
+                return(fd);
+        os_close_file(fd);
+ out:
+        return(err);
+}
+
+static int update_bitmap(struct io_thread_req *req)
+{
+        int n;
+
+        if(req->cow_offset == -1)
+                return(0);
+
+        n = os_seek_file(req->fds[1], req->cow_offset);
+        if(n < 0){
+                printk("do_io - bitmap lseek failed : err = %d\n", -n);
+                return(1);
+        }
+
+        n = os_write_file(req->fds[1], &req->bitmap_words,
+                          sizeof(req->bitmap_words));
+        if(n != sizeof(req->bitmap_words)){
+                printk("do_io - bitmap update failed, err = %d fd = %d\n", -n,
+                       req->fds[1]);
+                return(1);
+        }
+
+        return(0);
+}
+
+void do_io(struct io_thread_req *req)
+{
+        char *buf;
+        unsigned long len;
+        int n, nsectors, start, end, bit;
+        int err;
+        __u64 off;
+
+        if(req->op == UBD_MMAP){
+                /* Touch the page to force the host to do any necessary IO to
+                 * get it into memory
+                 */
+                n = *((volatile int *) req->buffer);
+                req->error = update_bitmap(req);
+                return;
+        }
+
+        nsectors = req->length / req->sectorsize;
+        start = 0;
+        do {
+                bit = ubd_test_bit(start, (unsigned char *) &req->sector_mask);
+                end = start;
+                while((end < nsectors) &&
+                      (ubd_test_bit(end, (unsigned char *)
+                                    &req->sector_mask) == bit))
+                        end++;
+
+                off = req->offset + req->offsets[bit] +
+                        start * req->sectorsize;
+                len = (end - start) * req->sectorsize;
+                buf = &req->buffer[start * req->sectorsize];
+
+                err = os_seek_file(req->fds[bit], off);
+                if(err < 0){
+                        printk("do_io - lseek failed : err = %d\n", -err);
+                        req->error = 1;
+                        return;
+                }
+                if(req->op == UBD_READ){
+                        n = 0;
+                        do {
+                                buf = &buf[n];
+                                len -= n;
+                                n = os_read_file(req->fds[bit], buf, len);
+                                if (n < 0) {
+                                        printk("do_io - read failed, err = %d "
+                                               "fd = %d\n", -n, req->fds[bit]);
+                                        req->error = 1;
+                                        return;
+                                }
+                        } while((n < len) && (n != 0));
+                        if (n < len) memset(&buf[n], 0, len - n);
+                }
+                else {
+                        n = os_write_file(req->fds[bit], buf, len);
+                        if(n != len){
+                                printk("do_io - write failed err = %d "
+                                       "fd = %d\n", -n, req->fds[bit]);
+                                req->error = 1;
+                                return;
+                        }
+                }
+
+                start = end;
+        } while(start < nsectors);
+
+        req->error = update_bitmap(req);
+}
+
+/* Changed in start_io_thread, which is serialized by being called only
+ * from ubd_init, which is an initcall.
+ */
+int kernel_fd = -1;
+
+/* Only changed by the io thread */
+int io_count = 0;
+
+int io_thread(void *arg)
+{
+        struct io_thread_req req;
+        int n;
+
+        ignore_sigwinch_sig();
+        while(1){
+                n = os_read_file(kernel_fd, &req, sizeof(req));
+                if(n != sizeof(req)){
+                        if(n < 0)
+                                printk("io_thread - read failed, fd = %d, "
+                                       "err = %d\n", kernel_fd, -n);
+                        else {
+                                printk("io_thread - short read, fd = %d, "
+                                       "length = %d\n", kernel_fd, n);
+                        }
+                        continue;
+                }
+                io_count++;
+                do_io(&req);
+                n = os_write_file(kernel_fd, &req, sizeof(req));
+                if(n != sizeof(req))
+                        printk("io_thread - write failed, fd = %d, err = %d\n",
+                               kernel_fd, -n);
+        }
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
new file mode 100644
index 000000000000..b94d2bc4fe06
--- /dev/null
+++ b/arch/um/drivers/ubd_user.c
@@ -0,0 +1,75 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001 Ridgerun,Inc (glonnon@ridgerun.com)
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+#include <signal.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include "asm/types.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "ubd_user.h"
+#include "os.h"
+#include "cow.h"
+
+#include <endian.h>
+#include <byteswap.h>
+
+void ignore_sigwinch_sig(void)
+{
+        signal(SIGWINCH, SIG_IGN);
+}
+
+int start_io_thread(unsigned long sp, int *fd_out)
+{
+        int pid, fds[2], err;
+
+        err = os_pipe(fds, 1, 1);
+        if(err < 0){
+                printk("start_io_thread - os_pipe failed, err = %d\n", -err);
+                goto out;
+        }
+
+        kernel_fd = fds[0];
+        *fd_out = fds[1];
+
+        pid = clone(io_thread, (void *) sp, CLONE_FILES | CLONE_VM | SIGCHLD,
+                    NULL);
+        if(pid < 0){
+                printk("start_io_thread - clone failed : errno = %d\n", errno);
+                err = -errno;
+                goto out_close;
+        }
+
+        return(pid);
+
+ out_close:
+        os_close_file(fds[0]);
+        os_close_file(fds[1]);
+        kernel_fd = -1;
+        *fd_out = -1;
+ out:
+        return(err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/xterm.c b/arch/um/drivers/xterm.c
new file mode 100644
index 000000000000..93dc1911363f
--- /dev/null
+++ b/arch/um/drivers/xterm.c
@@ -0,0 +1,225 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <termios.h>
+#include <signal.h>
+#include <sched.h>
+#include <sys/socket.h>
+#include "kern_util.h"
+#include "chan_user.h"
+#include "helper.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+#include "xterm.h"
+
+struct xterm_chan {
+        int pid;
+        int helper_pid;
+        char *title;
+        int device;
+        int raw;
+        struct termios tt;
+        unsigned long stack;
+        int direct_rcv;
+};
+
+/* Not static because it's called directly by the tt mode gdb code */
+void *xterm_init(char *str, int device, struct chan_opts *opts)
+{
+        struct xterm_chan *data;
+
+        data = malloc(sizeof(*data));
+        if(data == NULL) return(NULL);
+        *data = ((struct xterm_chan) { .pid             = -1, 
+                                       .helper_pid      = -1,
+                                       .device          = device, 
+                                       .title           = opts->xterm_title,
+                                       .raw             = opts->raw,
+                                       .stack           = opts->tramp_stack,
+                                       .direct_rcv      = !opts->in_kernel } );
+        return(data);
+}
+
+/* Only changed by xterm_setup, which is a setup */
+static char *terminal_emulator = "xterm";
+static char *title_switch = "-T";
+static char *exec_switch = "-e";
+
+static int __init xterm_setup(char *line, int *add)
+{
+        *add = 0;
+        terminal_emulator = line;
+
+        line = strchr(line, ',');
+        if(line == NULL) return(0);
+        *line++ = '\0';
+        if(*line) title_switch = line;
+
+        line = strchr(line, ',');
+        if(line == NULL) return(0);
+        *line++ = '\0';
+        if(*line) exec_switch = line;
+
+        return(0);
+}
+
+__uml_setup("xterm=", xterm_setup,
+"xterm=<terminal emulator>,<title switch>,<exec switch>\n"
+"    Specifies an alternate terminal emulator to use for the debugger,\n"
+"    consoles, and serial lines when they are attached to the xterm channel.\n"
+"    The values are the terminal emulator binary, the switch it uses to set\n"
+"    its title, and the switch it uses to execute a subprocess,\n"
+"    respectively.  The title switch must have the form '<switch> title',\n"
+"    not '<switch>=title'.  Similarly, the exec switch must have the form\n"
+"    '<switch> command arg1 arg2 ...'.\n"
+"    The default values are 'xterm=xterm,-T,-e'.  Values for gnome-terminal\n"
+"    are 'xterm=gnome-terminal,-t,-x'.\n\n"
+);
+
+/* XXX This badly needs some cleaning up in the error paths
+ * Not static because it's called directly by the tt mode gdb code
+ */
+int xterm_open(int input, int output, int primary, void *d,
+                      char **dev_out)
+{
+        struct xterm_chan *data = d;
+        unsigned long stack;
+        int pid, fd, new, err;
+        char title[256], file[] = "/tmp/xterm-pipeXXXXXX";
+        char *argv[] = { terminal_emulator, title_switch, title, exec_switch, 
+                         "/usr/lib/uml/port-helper", "-uml-socket",
+                         file, NULL };
+
+        if(os_access(argv[4], OS_ACC_X_OK) < 0)
+                argv[4] = "port-helper";
+
+        /* Check that DISPLAY is set, this doesn't guarantee the xterm
+         * will work but w/o it we can be pretty sure it won't. */
+        if (!getenv("DISPLAY")) {
+                printk("xterm_open: $DISPLAY not set.\n");
+                return -ENODEV;
+        }
+
+        fd = mkstemp(file);
+        if(fd < 0){
+                printk("xterm_open : mkstemp failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        if(unlink(file)){
+                printk("xterm_open : unlink failed, errno = %d\n", errno);
+                return(-errno);
+        }
+        os_close_file(fd);
+
+        fd = os_create_unix_socket(file, sizeof(file), 1);
+        if(fd < 0){
+                printk("xterm_open : create_unix_socket failed, errno = %d\n", 
+                       -fd);
+                return(fd);
+        }
+
+        sprintf(title, data->title, data->device);
+        stack = data->stack;
+        pid = run_helper(NULL, NULL, argv, &stack);
+        if(pid < 0){
+                printk("xterm_open : run_helper failed, errno = %d\n", -pid);
+                return(pid);
+        }
+
+        if(data->stack == 0) free_stack(stack, 0);
+
+        if (data->direct_rcv) {
+                new = os_rcv_fd(fd, &data->helper_pid);
+        } else {
+                err = os_set_fd_block(fd, 0);
+                if(err < 0){
+                        printk("xterm_open : failed to set descriptor "
+                               "non-blocking, err = %d\n", -err);
+                        return(err);
+                }
+                new = xterm_fd(fd, &data->helper_pid);
+        }
+        if(new < 0){
+                printk("xterm_open : os_rcv_fd failed, err = %d\n", -new);
+                goto out;
+        }
+
+        CATCH_EINTR(err = tcgetattr(new, &data->tt));
+        if(err){
+                new = err;
+                goto out;
+        }
+
+        if(data->raw){
+                err = raw(new);
+                if(err){
+                        new = err;
+                        goto out;
+                }
+        }
+
+        data->pid = pid;
+        *dev_out = NULL;
+ out:
+        unlink(file);
+        return(new);
+}
+
+/* Not static because it's called directly by the tt mode gdb code */
+void xterm_close(int fd, void *d)
+{
+        struct xterm_chan *data = d;
+        
+        if(data->pid != -1) 
+                os_kill_process(data->pid, 1);
+        data->pid = -1;
+        if(data->helper_pid != -1) 
+                os_kill_process(data->helper_pid, 0);
+        data->helper_pid = -1;
+        os_close_file(fd);
+}
+
+static void xterm_free(void *d)
+{
+        free(d);
+}
+
+static int xterm_console_write(int fd, const char *buf, int n, void *d)
+{
+        struct xterm_chan *data = d;
+
+        return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops xterm_ops = {
+        .type           = "xterm",
+        .init           = xterm_init,
+        .open           = xterm_open,
+        .close          = xterm_close,
+        .read           = generic_read,
+        .write          = generic_write,
+        .console_write  = xterm_console_write,
+        .window_size    = generic_window_size,
+        .free           = xterm_free,
+        .winch          = 1,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/xterm.h b/arch/um/drivers/xterm.h
new file mode 100644
index 000000000000..f33a6e77b186
--- /dev/null
+++ b/arch/um/drivers/xterm.h
@@ -0,0 +1,22 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __XTERM_H__
+#define __XTERM_H__
+
+extern int xterm_fd(int socket, int *pid_out);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/drivers/xterm_kern.c b/arch/um/drivers/xterm_kern.c
new file mode 100644
index 000000000000..7917b9d1cec8
--- /dev/null
+++ b/arch/um/drivers/xterm_kern.c
@@ -0,0 +1,93 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/errno.h"
+#include "linux/slab.h"
+#include "linux/signal.h"
+#include "linux/interrupt.h"
+#include "asm/semaphore.h"
+#include "asm/irq.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+#include "kern_util.h"
+#include "os.h"
+#include "xterm.h"
+
+struct xterm_wait {
+        struct completion ready;
+        int fd;
+        int pid;
+        int new_fd;
+};
+
+static irqreturn_t xterm_interrupt(int irq, void *data, struct pt_regs *regs)
+{
+        struct xterm_wait *xterm = data;
+        int fd;
+
+        fd = os_rcv_fd(xterm->fd, &xterm->pid);
+        if(fd == -EAGAIN)
+                return(IRQ_NONE);
+
+        xterm->new_fd = fd;
+        complete(&xterm->ready);
+        return(IRQ_HANDLED);
+}
+
+int xterm_fd(int socket, int *pid_out)
+{
+        struct xterm_wait *data;
+        int err, ret;
+
+        data = kmalloc(sizeof(*data), GFP_KERNEL);
+        if(data == NULL){
+                printk(KERN_ERR "xterm_fd : failed to allocate xterm_wait\n");
+                return(-ENOMEM);
+        }
+
+        /* This is a locked semaphore... */
+        *data = ((struct xterm_wait) 
+                { .fd           = socket,
+                  .pid          = -1,
+                  .new_fd       = -1 });
+        init_completion(&data->ready);
+
+        err = um_request_irq(XTERM_IRQ, socket, IRQ_READ, xterm_interrupt, 
+                             SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
+                             "xterm", data);
+        if (err){
+                printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, "
+                       "err = %d\n",  err);
+                ret = err;
+                goto out;
+        }
+
+        /* ... so here we wait for an xterm interrupt.
+         *
+         * XXX Note, if the xterm doesn't work for some reason (eg. DISPLAY
+         * isn't set) this will hang... */
+        wait_for_completion(&data->ready);
+
+        free_irq_by_irq_and_dev(XTERM_IRQ, data);
+        free_irq(XTERM_IRQ, data);
+
+        ret = data->new_fd;
+        *pid_out = data->pid;
+ out:
+        kfree(data);
+
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/2_5compat.h b/arch/um/include/2_5compat.h
new file mode 100644
index 000000000000..abdb015a4d71
--- /dev/null
+++ b/arch/um/include/2_5compat.h
@@ -0,0 +1,24 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __2_5_COMPAT_H__
+#define __2_5_COMPAT_H__
+
+#define INIT_HARDSECT(arr, maj, sizes)
+
+#define SET_PRI(task) do ; while(0)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/chan_kern.h b/arch/um/include/chan_kern.h
new file mode 100644
index 000000000000..da9a6717e7a4
--- /dev/null
+++ b/arch/um/include/chan_kern.h
@@ -0,0 +1,60 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __CHAN_KERN_H__
+#define __CHAN_KERN_H__
+
+#include "linux/tty.h"
+#include "linux/list.h"
+#include "linux/console.h"
+#include "chan_user.h"
+#include "line.h"
+
+struct chan {
+        struct list_head list;
+        char *dev;
+        unsigned int primary:1;
+        unsigned int input:1;
+        unsigned int output:1;
+        unsigned int opened:1;
+        int fd;
+        enum chan_init_pri pri;
+        struct chan_ops *ops;
+        void *data;
+};
+
+extern void chan_interrupt(struct list_head *chans, struct work_struct *task,
+                           struct tty_struct *tty, int irq);
+extern int parse_chan_pair(char *str, struct list_head *chans, int pri, 
+                           int device, struct chan_opts *opts);
+extern int open_chan(struct list_head *chans);
+extern int write_chan(struct list_head *chans, const char *buf, int len,
+                             int write_irq);
+extern int console_write_chan(struct list_head *chans, const char *buf, 
+                              int len);
+extern int console_open_chan(struct line *line, struct console *co,
+                             struct chan_opts *opts);
+extern void close_chan(struct list_head *chans);
+extern void chan_enable_winch(struct list_head *chans, struct tty_struct *tty);
+extern void enable_chan(struct list_head *chans, struct tty_struct *tty);
+extern int chan_window_size(struct list_head *chans, 
+                             unsigned short *rows_out, 
+                             unsigned short *cols_out);
+extern int chan_out_fd(struct list_head *chans);
+extern int chan_config_string(struct list_head *chans, char *str, int size,
+                              char **error_out);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/chan_user.h b/arch/um/include/chan_user.h
new file mode 100644
index 000000000000..f77d9aa4c164
--- /dev/null
+++ b/arch/um/include/chan_user.h
@@ -0,0 +1,67 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __CHAN_USER_H__
+#define __CHAN_USER_H__
+
+#include "init.h"
+
+struct chan_opts {
+        void (*announce)(char *dev_name, int dev);
+        char *xterm_title;
+        int raw;
+        unsigned long tramp_stack;
+        int in_kernel;
+};
+
+enum chan_init_pri { INIT_STATIC, INIT_ALL, INIT_ONE };
+
+struct chan_ops {
+        char *type;
+        void *(*init)(char *, int, struct chan_opts *);
+        int (*open)(int, int, int, void *, char **);
+        void (*close)(int, void *);
+        int (*read)(int, char *, void *);
+        int (*write)(int, const char *, int, void *);
+        int (*console_write)(int, const char *, int, void *);
+        int (*window_size)(int, void *, unsigned short *, unsigned short *);
+        void (*free)(void *);
+        int winch;
+};
+
+extern struct chan_ops fd_ops, null_ops, port_ops, pts_ops, pty_ops, tty_ops,
+        xterm_ops;
+
+extern void generic_close(int fd, void *unused);
+extern int generic_read(int fd, char *c_out, void *unused);
+extern int generic_write(int fd, const char *buf, int n, void *unused);
+extern int generic_console_write(int fd, const char *buf, int n, void *state);
+extern int generic_window_size(int fd, void *unused, unsigned short *rows_out,
+                               unsigned short *cols_out);
+extern void generic_free(void *data);
+
+struct tty_struct;
+extern void register_winch(int fd,  struct tty_struct *tty);
+extern void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty);
+
+#define __channel_help(fn, prefix) \
+__uml_help(fn, prefix "[0-9]*=<channel description>\n" \
+"    Attach a console or serial line to a host channel.  See\n" \
+"    http://user-mode-linux.sourceforge.net/input.html for a complete\n" \
+"    description of this switch.\n\n" \
+);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/choose-mode.h b/arch/um/include/choose-mode.h
new file mode 100644
index 000000000000..8e6b62f5e9ac
--- /dev/null
+++ b/arch/um/include/choose-mode.h
@@ -0,0 +1,42 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __CHOOSE_MODE_H__
+#define __CHOOSE_MODE_H__
+
+#include "uml-config.h"
+
+#if defined(UML_CONFIG_MODE_TT) && defined(UML_CONFIG_MODE_SKAS)
+#define CHOOSE_MODE(tt, skas) (mode_tt ? (tt) : (skas))
+
+#elif defined(UML_CONFIG_MODE_SKAS)
+#define CHOOSE_MODE(tt, skas) (skas)
+
+#elif defined(UML_CONFIG_MODE_TT)
+#define CHOOSE_MODE(tt, skas) (tt)
+#endif
+
+#define CHOOSE_MODE_PROC(tt, skas, args...) \
+        CHOOSE_MODE(tt(args), skas(args))
+
+extern int mode_tt;
+static inline void *__choose_mode(void *tt, void *skas) {
+        return mode_tt ? tt : skas;
+}
+
+#define __CHOOSE_MODE(tt, skas) (*( (typeof(tt) *) __choose_mode(&(tt), &(skas))))
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/elf_user.h b/arch/um/include/elf_user.h
new file mode 100644
index 000000000000..53516b637272
--- /dev/null
+++ b/arch/um/include/elf_user.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2004 Fujitsu Siemens Computers GmbH
+ * Author: Bodo Stroesser <bstroesser@fujitsu-siemens.com>
+ * Licensed under the GPL
+ */
+
+#ifndef __ELF_USER_H__
+#define __ELF_USER_H__
+
+/* For compilation on a host that doesn't support AT_SYSINFO (Linux 2.4)  */
+
+#ifndef AT_SYSINFO
+#define AT_SYSINFO 32
+#endif
+#ifndef AT_SYSINFO_EHDR
+#define AT_SYSINFO_EHDR 33
+#endif
+
+#endif
diff --git a/arch/um/include/frame_kern.h b/arch/um/include/frame_kern.h
new file mode 100644
index 000000000000..ce9514f57211
--- /dev/null
+++ b/arch/um/include/frame_kern.h
@@ -0,0 +1,32 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __FRAME_KERN_H_
+#define __FRAME_KERN_H_
+
+#define _S(nr) (1<<((nr)-1))
+#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
+
+extern int setup_signal_stack_sc(unsigned long stack_top, int sig, 
+                                 struct k_sigaction *ka,
+                                 struct pt_regs *regs, 
+                                 sigset_t *mask);
+extern int setup_signal_stack_si(unsigned long stack_top, int sig, 
+                                 struct k_sigaction *ka,
+                                 struct pt_regs *regs, siginfo_t *info, 
+                                 sigset_t *mask);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/helper.h b/arch/um/include/helper.h
new file mode 100644
index 000000000000..162ac31192fd
--- /dev/null
+++ b/arch/um/include/helper.h
@@ -0,0 +1,27 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __HELPER_H__
+#define __HELPER_H__
+
+extern int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
+                      unsigned long *stack_out);
+extern int run_helper_thread(int (*proc)(void *), void *arg, 
+                             unsigned int flags, unsigned long *stack_out,
+                             int stack_order);
+extern int helper_wait(int pid);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/init.h b/arch/um/include/init.h
new file mode 100644
index 000000000000..55c2693f8778
--- /dev/null
+++ b/arch/um/include/init.h
@@ -0,0 +1,132 @@
+#ifndef _LINUX_UML_INIT_H
+#define _LINUX_UML_INIT_H
+
+/* These macros are used to mark some functions or
+ * initialized data (doesn't apply to uninitialized data)
+ * as `initialization' functions. The kernel can take this
+ * as hint that the function is used only during the initialization
+ * phase and free up used memory resources after
+ *
+ * Usage:
+ * For functions:
+ *
+ * You should add __init immediately before the function name, like:
+ *
+ * static void __init initme(int x, int y)
+ * {
+ *    extern int z; z = x * y;
+ * }
+ *
+ * If the function has a prototype somewhere, you can also add
+ * __init between closing brace of the prototype and semicolon:
+ *
+ * extern int initialize_foobar_device(int, int, int) __init;
+ *
+ * For initialized data:
+ * You should insert __initdata between the variable name and equal
+ * sign followed by value, e.g.:
+ *
+ * static int init_variable __initdata = 0;
+ * static char linux_logo[] __initdata = { 0x32, 0x36, ... };
+ *
+ * Don't forget to initialize data not at file scope, i.e. within a function,
+ * as gcc otherwise puts the data into the bss section and not into the init
+ * section.
+ *
+ * Also note, that this data cannot be "const".
+ */
+
+#ifndef _LINUX_INIT_H
+typedef int (*initcall_t)(void);
+typedef void (*exitcall_t)(void);
+
+/* These are for everybody (although not all archs will actually
+   discard it in modules) */
+#define __init          __attribute__ ((__section__ (".init.text")))
+#define __initdata      __attribute__ ((__section__ (".init.data")))
+#define __exitdata      __attribute__ ((__section__(".exit.data")))
+#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
+
+#ifdef MODULE
+#define __exit          __attribute__ ((__section__(".exit.text")))
+#else
+#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text")))
+#endif
+
+#endif
+
+#ifndef MODULE
+struct uml_param {
+        const char *str;
+        int (*setup_func)(char *, int *);
+};
+
+extern initcall_t __uml_initcall_start, __uml_initcall_end;
+extern initcall_t __uml_postsetup_start, __uml_postsetup_end;
+extern const char *__uml_help_start, *__uml_help_end;
+#endif
+
+#define __uml_initcall(fn)                                              \
+        static initcall_t __uml_initcall_##fn __uml_init_call = fn
+
+#define __uml_exitcall(fn)                                              \
+        static exitcall_t __uml_exitcall_##fn __uml_exit_call = fn
+
+extern struct uml_param __uml_setup_start, __uml_setup_end;
+
+#define __uml_postsetup(fn)                                             \
+        static initcall_t __uml_postsetup_##fn __uml_postsetup_call = fn
+
+#define __non_empty_string(dummyname,string)                            \
+        struct __uml_non_empty_string_struct_##dummyname                \
+        {                                                               \
+                char _string[sizeof(string)-2];                         \
+        }
+
+#ifndef MODULE
+#define __uml_setup(str, fn, help...)                                   \
+        __non_empty_string(fn ##_setup, str);                           \
+        __uml_help(fn, help);                                           \
+        static char __uml_setup_str_##fn[] __initdata = str;            \
+        static struct uml_param __uml_setup_##fn __uml_init_setup = { __uml_setup_str_##fn, fn }
+#else
+#define __uml_setup(str, fn, help...)                                   \
+
+#endif
+
+#define __uml_help(fn, help...)                                         \
+        __non_empty_string(fn ##__help, help);                          \
+        static char __uml_help_str_##fn[] __initdata = help;            \
+        static const char *__uml_help_##fn __uml_setup_help = __uml_help_str_##fn
+
+/*
+ * Mark functions and data as being only used at initialization
+ * or exit time.
+ */
+#define __uml_init_setup        __attribute_used__ __attribute__ ((__section__ (".uml.setup.init")))
+#define __uml_setup_help        __attribute_used__ __attribute__ ((__section__ (".uml.help.init")))
+#define __uml_init_call         __attribute_used__ __attribute__ ((__section__ (".uml.initcall.init")))
+#define __uml_postsetup_call    __attribute_used__ __attribute__ ((__section__ (".uml.postsetup.init")))
+#define __uml_exit_call         __attribute_used__ __attribute__ ((__section__ (".uml.exitcall.exit")))
+
+#ifndef __KERNEL__
+
+#define __initcall(fn) static initcall_t __initcall_##fn __init_call = fn
+#define __exitcall(fn) static exitcall_t __exitcall_##fn __exit_call = fn
+
+#define __init_call __attribute__ ((unused,__section__ (".initcall.init")))
+
+#endif
+
+#endif /* _LINUX_UML_INIT_H */
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/initrd.h b/arch/um/include/initrd.h
new file mode 100644
index 000000000000..439b9a814985
--- /dev/null
+++ b/arch/um/include/initrd.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __INITRD_USER_H__
+#define __INITRD_USER_H__
+
+extern int load_initrd(char *filename, void *buf, int size);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/irq_kern.h b/arch/um/include/irq_kern.h
new file mode 100644
index 000000000000..3af52a634c4c
--- /dev/null
+++ b/arch/um/include/irq_kern.h
@@ -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 --git a/arch/um/include/irq_user.h b/arch/um/include/irq_user.h
new file mode 100644
index 000000000000..f724b717213f
--- /dev/null
+++ b/arch/um/include/irq_user.h
@@ -0,0 +1,36 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __IRQ_USER_H__
+#define __IRQ_USER_H__
+
+enum { IRQ_READ, IRQ_WRITE };
+
+extern void sigio_handler(int sig, union uml_pt_regs *regs);
+extern int activate_fd(int irq, int fd, int type, void *dev_id);
+extern void free_irq_by_irq_and_dev(unsigned int irq, void *dev_id);
+extern void free_irq_by_fd(int fd);
+extern void reactivate_fd(int fd, int irqnum);
+extern void deactivate_fd(int fd, int irqnum);
+extern int deactivate_all_fds(void);
+extern void forward_interrupts(int pid);
+extern void init_irq_signals(int on_sigstack);
+extern void forward_ipi(int fd, int pid);
+extern void free_irq_later(int irq, void *dev_id);
+extern int activate_ipi(int fd, int pid);
+extern unsigned long irq_lock(void);
+extern void irq_unlock(unsigned long flags);
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/kern.h b/arch/um/include/kern.h
new file mode 100644
index 000000000000..1e3170768b5c
--- /dev/null
+++ b/arch/um/include/kern.h
@@ -0,0 +1,49 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __KERN_H__
+#define __KERN_H__
+
+/* These are all user-mode things which are convenient to call directly
+ * from kernel code and for which writing a wrapper is too much of a pain.
+ * The regular include files can't be included because this file is included
+ * only into kernel code, and user-space includes conflict with kernel
+ * includes.
+ */
+
+extern int errno;
+
+extern int clone(int (*proc)(void *), void *sp, int flags, void *data);
+extern int sleep(int);
+extern int printf(char *fmt, ...);
+extern char *strerror(int errnum);
+extern char *ptsname(int __fd);
+extern int munmap(void *, int);
+extern void *sbrk(int increment);
+extern void *malloc(int size);
+extern void perror(char *err);
+extern int kill(int pid, int sig);
+extern int getuid(void);
+extern int getgid(void);
+extern int pause(void);
+extern int write(int, const void *, int);
+extern int exit(int);
+extern int close(int);
+extern int read(unsigned int, char *, int);
+extern int pipe(int *);
+extern int sched_yield(void);
+extern int ptrace(int op, int pid, long addr, long data);
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/kern_util.h b/arch/um/include/kern_util.h
new file mode 100644
index 000000000000..15389c886b41
--- /dev/null
+++ b/arch/um/include/kern_util.h
@@ -0,0 +1,125 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __KERN_UTIL_H__
+#define __KERN_UTIL_H__
+
+#include "linux/threads.h"
+#include "sysdep/ptrace.h"
+
+extern int ncpus;
+extern char *linux_prog;
+extern char *gdb_init;
+extern int kmalloc_ok;
+extern int timer_irq_inited;
+extern int jail;
+extern int nsyscalls;
+
+extern struct task_struct *idle_threads[NR_CPUS];
+
+#define UML_ROUND_DOWN(addr) ((void *)(((unsigned long) addr) & PAGE_MASK))
+#define UML_ROUND_UP(addr) \
+        UML_ROUND_DOWN(((unsigned long) addr) + PAGE_SIZE - 1)
+
+extern int kernel_fork(unsigned long flags, int (*fn)(void *), void * arg);
+extern unsigned long stack_sp(unsigned long page);
+extern int kernel_thread_proc(void *data);
+extern void syscall_segv(int sig);
+extern int current_pid(void);
+extern unsigned long alloc_stack(int order, int atomic);
+extern int do_signal(void);
+extern int is_stack_fault(unsigned long sp);
+extern unsigned long segv(unsigned long address, unsigned long ip, 
+                          int is_write, int is_user, void *sc);
+extern int handle_page_fault(unsigned long address, unsigned long ip,
+                             int is_write, int is_user, int *code_out);
+extern void syscall_ready(void);
+extern void set_tracing(void *t, int tracing);
+extern int is_tracing(void *task);
+extern int segv_syscall(void);
+extern void kern_finish_exec(void *task, int new_pid, unsigned long stack);
+extern int page_size(void);
+extern unsigned long page_mask(void);
+extern int need_finish_fork(void);
+extern void free_stack(unsigned long stack, int order);
+extern void add_input_request(int op, void (*proc)(int), void *arg);
+extern char *current_cmd(void);
+extern void timer_handler(int sig, union uml_pt_regs *regs);
+extern int set_signals(int enable);
+extern void force_sigbus(void);
+extern int pid_to_processor_id(int pid);
+extern void block_signals(void);
+extern void unblock_signals(void);
+extern void deliver_signals(void *t);
+extern int next_syscall_index(int max);
+extern int next_trap_index(int max);
+extern void default_idle(void);
+extern void finish_fork(void);
+extern void paging_init(void);
+extern void init_flush_vm(void);
+extern void *syscall_sp(void *t);
+extern void syscall_trace(union uml_pt_regs *regs, int entryexit);
+extern int hz(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 void boot_timer_handler(int sig);
+extern void interrupt_end(void);
+extern void initial_thread_cb(void (*proc)(void *), void *arg);
+extern int debugger_signal(int status, int pid);
+extern void debugger_parent_signal(int status, int pid);
+extern void child_signal(int pid, int status);
+extern int init_ptrace_proxy(int idle_pid, int startup, int stop);
+extern int init_parent_proxy(int pid);
+extern int singlestepping(void *t);
+extern void check_stack_overflow(void *ptr);
+extern void relay_signal(int sig, union uml_pt_regs *regs);
+extern void not_implemented(void);
+extern int user_context(unsigned long sp);
+extern void timer_irq(union uml_pt_regs *regs);
+extern void unprotect_stack(unsigned long stack);
+extern void do_uml_exitcalls(void);
+extern int attach_debugger(int idle_pid, int pid, int stop);
+extern void bad_segv(unsigned long address, unsigned long ip, int is_write);
+extern int config_gdb(char *str);
+extern int remove_gdb(void);
+extern char *uml_strdup(char *string);
+extern void unprotect_kernel_mem(void);
+extern void protect_kernel_mem(void);
+extern void uml_cleanup(void);
+extern void set_current(void *t);
+extern void lock_signalled_task(void *t);
+extern void IPI_handler(int cpu);
+extern int jail_setup(char *line, int *add);
+extern void *get_init_task(void);
+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);
+extern struct task_struct *get_task(int pid, int require);
+extern void machine_halt(void);
+extern int is_syscall(unsigned long addr);
+extern void arch_switch(void);
+extern void free_irq(unsigned int, void *);
+extern int um_in_interrupt(void);
+extern int cpu(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/line.h b/arch/um/include/line.h
new file mode 100644
index 000000000000..6d81ecc17be5
--- /dev/null
+++ b/arch/um/include/line.h
@@ -0,0 +1,108 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __LINE_H__
+#define __LINE_H__
+
+#include "linux/list.h"
+#include "linux/workqueue.h"
+#include "linux/tty.h"
+#include "linux/interrupt.h"
+#include "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;
+        short type;
+        short subtype;
+        int read_irq;
+        char *read_irq_name;
+        int write_irq;
+        char *write_irq_name;
+        char *symlink_from;
+        char *symlink_to;
+        struct mc_device mc;
+};
+
+struct line {
+        char *init_str;
+        int init_pri;
+        struct list_head chan_list;
+        int valid;
+        int count;
+        struct semaphore sem;
+        char *buffer;
+        char *head;
+        char *tail;
+        int sigio;
+        struct work_struct task;
+        struct line_driver *driver;
+        int have_irq;
+};
+
+#define LINE_INIT(str, d) \
+        { init_str :    str, \
+          init_pri :    INIT_STATIC, \
+          chan_list :   { }, \
+          valid :       1, \
+          sem :         { }, \
+          buffer :      NULL, \
+          head :        NULL, \
+          tail :        NULL, \
+          sigio :       0, \
+          driver :      d, \
+          have_irq :    0 }
+
+struct lines {
+        int num;
+};
+
+#define LINES_INIT(n) {  num :          n }
+
+extern void line_close(struct tty_struct *tty, struct file * filp);
+extern int line_open(struct line *lines, struct tty_struct *tty, 
+                     struct chan_opts *opts);
+extern int line_setup(struct line *lines, int num, char *init, 
+                      int all_allowed);
+extern int line_write(struct tty_struct *tty, const unsigned char *buf, int len);
+extern void line_put_char(struct tty_struct *tty, unsigned char ch);
+extern void line_set_termios(struct tty_struct *tty, struct termios * old);
+extern int line_chars_in_buffer(struct tty_struct *tty);
+extern int line_write_room(struct tty_struct *tty);
+extern int line_ioctl(struct tty_struct *tty, struct file * file,
+                      unsigned int cmd, unsigned long arg);
+extern char *add_xterm_umid(char *base);
+extern int line_setup_irq(int fd, int input, int output, struct tty_struct *tty);
+extern void line_close_chan(struct line *line);
+extern void line_disable(struct tty_struct *tty, int current_irq);
+extern struct tty_driver * line_register_devfs(struct lines *set, 
+                                struct line_driver *line_driver, 
+                                struct tty_operations *driver,
+                                struct line *lines,
+                                int nlines);
+extern void lines_init(struct line *lines, int nlines);
+extern void close_lines(struct line *lines, int nlines);
+extern int line_config(struct line *lines, int num, char *str);
+extern int line_remove(struct line *lines, int num, char *str);
+extern int line_get_config(char *dev, struct line *lines, int num, char *str, 
+                           int size, char **error_out);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mconsole.h b/arch/um/include/mconsole.h
new file mode 100644
index 000000000000..9fbe3083fdd8
--- /dev/null
+++ b/arch/um/include/mconsole.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MCONSOLE_H__
+#define __MCONSOLE_H__
+
+#ifndef __KERNEL__
+#include <stdint.h>
+#define u32 uint32_t
+#endif
+
+#define MCONSOLE_MAGIC (0xcafebabe)
+#define MCONSOLE_MAX_DATA (512)
+#define MCONSOLE_VERSION 2
+
+struct mconsole_request {
+        u32 magic;
+        u32 version;
+        u32 len;
+        char data[MCONSOLE_MAX_DATA];
+};
+
+struct mconsole_reply {
+        u32 err;
+        u32 more;
+        u32 len;
+        char data[MCONSOLE_MAX_DATA];
+};
+
+struct mconsole_notify {
+        u32 magic;
+        u32 version;    
+        enum { MCONSOLE_SOCKET, MCONSOLE_PANIC, MCONSOLE_HANG,
+               MCONSOLE_USER_NOTIFY } type;
+        u32 len;
+        char data[MCONSOLE_MAX_DATA];
+};
+
+struct mc_request;
+
+enum mc_context { MCONSOLE_INTR, MCONSOLE_PROC };
+
+struct mconsole_command
+{
+        char *command;
+        void (*handler)(struct mc_request *req);
+        enum mc_context context;
+};
+
+struct mc_request
+{
+        int len;
+        int as_interrupt;
+
+        int originating_fd;
+        int originlen;
+        unsigned char origin[128];                      /* sockaddr_un */
+
+        struct mconsole_request request;
+        struct mconsole_command *cmd;
+};
+
+extern char mconsole_socket_name[];
+
+extern int mconsole_unlink_socket(void);
+extern int mconsole_reply(struct mc_request *req, char *reply, int err,
+                          int more);
+
+extern void mconsole_version(struct mc_request *req);
+extern void mconsole_help(struct mc_request *req);
+extern void mconsole_halt(struct mc_request *req);
+extern void mconsole_reboot(struct mc_request *req);
+extern void mconsole_config(struct mc_request *req);
+extern void mconsole_remove(struct mc_request *req);
+extern void mconsole_sysrq(struct mc_request *req);
+extern void mconsole_cad(struct mc_request *req);
+extern void mconsole_stop(struct mc_request *req);
+extern void mconsole_go(struct mc_request *req);
+extern void mconsole_log(struct mc_request *req);
+extern void mconsole_proc(struct mc_request *req);
+
+extern int mconsole_get_request(int fd, struct mc_request *req);
+extern int mconsole_notify(char *sock_name, int type, const void *data, 
+                           int len);
+extern char *mconsole_notify_socket(void);
+extern void lock_notify(void);
+extern void unlock_notify(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mconsole_kern.h b/arch/um/include/mconsole_kern.h
new file mode 100644
index 000000000000..61c274fcee5d
--- /dev/null
+++ b/arch/um/include/mconsole_kern.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MCONSOLE_KERN_H__
+#define __MCONSOLE_KERN_H__
+
+#include "linux/config.h"
+#include "linux/list.h"
+#include "mconsole.h"
+
+struct mconsole_entry {
+        struct list_head list;
+        struct mc_request request;
+};
+
+struct mc_device {
+        struct list_head list;
+        char *name;
+        int (*config)(char *);
+        int (*get_config)(char *, char *, int, char **);
+        int (*remove)(char *);
+};
+
+#define CONFIG_CHUNK(str, size, current, chunk, end) \
+do { \
+        current += strlen(chunk); \
+        if(current >= size) \
+                str = NULL; \
+        if(str != NULL){ \
+                strcpy(str, chunk); \
+                str += strlen(chunk); \
+        } \
+        if(end) \
+                current++; \
+} while(0)
+
+#ifdef CONFIG_MCONSOLE
+
+extern void mconsole_register_dev(struct mc_device *new);
+
+#else
+
+static inline void mconsole_register_dev(struct mc_device *new)
+{
+}
+
+#endif
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mem.h b/arch/um/include/mem.h
new file mode 100644
index 000000000000..10c46c38949a
--- /dev/null
+++ b/arch/um/include/mem.h
@@ -0,0 +1,28 @@
+/* 
+ * Copyright (C) 2002, 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MEM_H__
+#define __MEM_H__
+
+#include "linux/types.h"
+
+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);
+extern void physmem_forget_descriptor(int fd);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mem_kern.h b/arch/um/include/mem_kern.h
new file mode 100644
index 000000000000..cb7e196d366b
--- /dev/null
+++ b/arch/um/include/mem_kern.h
@@ -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 --git a/arch/um/include/mem_user.h b/arch/um/include/mem_user.h
new file mode 100644
index 000000000000..d6404bb64662
--- /dev/null
+++ b/arch/um/include/mem_user.h
@@ -0,0 +1,83 @@
+/*
+ * arch/um/include/mem_user.h
+ *
+ * BRIEF MODULE DESCRIPTION
+ * user side memory interface for support IO memory inside user mode linux
+ *
+ * Copyright (C) 2001 RidgeRun, Inc.
+ * Author: RidgeRun, Inc.
+ *         Greg Lonnon glonnon@ridgerun.com or info@ridgerun.com
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _MEM_USER_H
+#define _MEM_USER_H
+
+struct iomem_region {
+        struct iomem_region *next;
+        char *driver;
+        int fd;
+        int size;
+        unsigned long phys;
+        unsigned long virt;
+};
+
+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_memory(void *entry);
+extern unsigned long find_iomem(char *driver, unsigned long *len_out);
+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, unsigned long highmem);
+extern void add_iomem(char *name, int fd, unsigned long size);
+extern unsigned long phys_offset(unsigned long phys);
+extern void unmap_physmem(void);
+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);
+extern void check_tmpexec(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mode.h b/arch/um/include/mode.h
new file mode 100644
index 000000000000..786cf563eb05
--- /dev/null
+++ b/arch/um/include/mode.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_H__
+#define __MODE_H__
+
+#include "uml-config.h"
+
+#ifdef UML_CONFIG_MODE_TT
+#include "mode-tt.h"
+#endif
+
+#ifdef UML_CONFIG_MODE_SKAS
+#include "mode-skas.h"
+#endif
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/mode_kern.h b/arch/um/include/mode_kern.h
new file mode 100644
index 000000000000..2d88afd0cf16
--- /dev/null
+++ b/arch/um/include/mode_kern.h
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_KERN_H__
+#define __MODE_KERN_H__
+
+#include "linux/config.h"
+
+#ifdef CONFIG_MODE_TT
+#include "mode_kern-tt.h"
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+#include "mode_kern-skas.h"
+#endif
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/net_kern.h b/arch/um/include/net_kern.h
new file mode 100644
index 000000000000..1c07949a13d6
--- /dev/null
+++ b/arch/um/include/net_kern.h
@@ -0,0 +1,82 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_NET_KERN_H
+#define __UM_NET_KERN_H
+
+#include "linux/netdevice.h"
+#include "linux/skbuff.h"
+#include "linux/socket.h"
+#include "linux/list.h"
+
+struct uml_net {
+        struct list_head list;
+        struct net_device *dev;
+        struct platform_device pdev;
+        int index;
+        unsigned char mac[ETH_ALEN];
+        int have_mac;
+};
+
+struct uml_net_private {
+        struct list_head list;
+        spinlock_t lock;
+        struct net_device *dev;
+        struct timer_list tl;
+        struct net_device_stats stats;
+        int fd;
+        unsigned char mac[ETH_ALEN];
+        int have_mac;
+        unsigned short (*protocol)(struct sk_buff *);
+        int (*open)(void *);
+        void (*close)(int, void *);
+        void (*remove)(void *);
+        int (*read)(int, struct sk_buff **skb, struct uml_net_private *);
+        int (*write)(int, struct sk_buff **skb, struct uml_net_private *);
+        
+        void (*add_address)(unsigned char *, unsigned char *, void *);
+        void (*delete_address)(unsigned char *, unsigned char *, void *);
+        int (*set_mtu)(int mtu, void *);
+        int user[1];
+};
+
+struct net_kern_info {
+        void (*init)(struct net_device *, void *);
+        unsigned short (*protocol)(struct sk_buff *);
+        int (*read)(int, struct sk_buff **skb, struct uml_net_private *);
+        int (*write)(int, struct sk_buff **skb, struct uml_net_private *);
+};
+
+struct transport {
+        struct list_head list;
+        char *name;
+        int (*setup)(char *, char **, void *);
+        struct net_user_info *user;
+        struct net_kern_info *kern;
+        int private_size;
+        int setup_size;
+};
+
+extern struct net_device *ether_init(int);
+extern unsigned short ether_protocol(struct sk_buff *);
+extern int setup_etheraddr(char *str, unsigned char *addr);
+extern struct sk_buff *ether_adjust_skb(struct sk_buff *skb, int extra);
+extern int tap_setup_common(char *str, char *type, char **dev_name, 
+                            char **mac_out, char **gate_addr);
+extern void register_transport(struct transport *new);
+extern unsigned short eth_protocol(struct sk_buff *skb);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/net_user.h b/arch/um/include/net_user.h
new file mode 100644
index 000000000000..36807b796e9f
--- /dev/null
+++ b/arch/um/include/net_user.h
@@ -0,0 +1,66 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_NET_USER_H__
+#define __UM_NET_USER_H__
+
+#define ETH_ADDR_LEN (6)
+#define ETH_HEADER_ETHERTAP (16)
+#define ETH_HEADER_OTHER (14)
+#define ETH_MAX_PACKET (1500)
+
+#define UML_NET_VERSION (4)
+
+struct net_user_info {
+        void (*init)(void *, void *);
+        int (*open)(void *);
+        void (*close)(int, void *);
+        void (*remove)(void *);
+        int (*set_mtu)(int mtu, void *);
+        void (*add_address)(unsigned char *, unsigned char *, void *);
+        void (*delete_address)(unsigned char *, unsigned char *, void *);
+        int max_packet;
+};
+
+extern void ether_user_init(void *data, void *dev);
+extern void dev_ip_addr(void *d, char *buf, char *bin_buf);
+extern void set_ether_mac(void *d, unsigned char *addr);
+extern void iter_addresses(void *d, void (*cb)(unsigned char *, 
+                                               unsigned char *, void *), 
+                           void *arg);
+
+extern void *get_output_buffer(int *len_out);
+extern void free_output_buffer(void *buffer);
+
+extern int tap_open_common(void *dev, char *gate_addr);
+extern void tap_check_ips(char *gate_addr, char *eth_addr);
+
+extern void read_output(int fd, char *output_out, int len);
+
+extern int net_read(int fd, void *buf, int len);
+extern int net_recvfrom(int fd, void *buf, int len);
+extern int net_write(int fd, void *buf, int len);
+extern int net_send(int fd, void *buf, int len);
+extern int net_sendto(int fd, void *buf, int len, void *to, int sock_len);
+
+extern void open_addr(unsigned char *addr, unsigned char *netmask, void *arg);
+extern void close_addr(unsigned char *addr, unsigned char *netmask, void *arg);
+
+extern char *split_if_spec(char *str, ...);
+
+extern int dev_netmask(void *d, void *m);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/os.h b/arch/um/include/os.h
new file mode 100644
index 000000000000..07340c8cf203
--- /dev/null
+++ b/arch/um/include/os.h
@@ -0,0 +1,183 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __OS_H__
+#define __OS_H__
+
+#include "asm/types.h"
+#include "../os/include/file.h"
+
+#define OS_TYPE_FILE 1 
+#define OS_TYPE_DIR 2 
+#define OS_TYPE_SYMLINK 3 
+#define OS_TYPE_CHARDEV 4
+#define OS_TYPE_BLOCKDEV 5
+#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;
+        unsigned int s : 1;     /* O_SYNC */
+        unsigned int c : 1;     /* O_CREAT */
+        unsigned int t : 1;     /* O_TRUNC */
+        unsigned int a : 1;     /* O_APPEND */
+        unsigned int e : 1;     /* O_EXCL */
+        unsigned int cl : 1;    /* FD_CLOEXEC */
+};
+
+#define OPENFLAGS() ((struct openflags) { .r = 0, .w = 0, .s = 0, .c = 0, \
+                                          .t = 0, .a = 0, .e = 0, .cl = 0 })
+
+static inline struct openflags of_read(struct openflags flags)
+{
+        flags.r = 1; 
+        return(flags);
+}
+
+static inline struct openflags of_write(struct openflags flags)
+{
+        flags.w = 1; 
+        return(flags); 
+}
+
+static inline struct openflags of_rdwr(struct openflags flags)
+{
+        return(of_read(of_write(flags)));
+}
+
+static inline struct openflags of_set_rw(struct openflags flags, int r, int w)
+{
+        flags.r = r;
+        flags.w = w;
+        return(flags);
+}
+
+static inline struct openflags of_sync(struct openflags flags)
+{ 
+        flags.s = 1; 
+        return(flags); 
+}
+
+static inline struct openflags of_create(struct openflags flags)
+{ 
+        flags.c = 1; 
+        return(flags); 
+}
+ 
+static inline struct openflags of_trunc(struct openflags flags)
+{ 
+        flags.t = 1; 
+        return(flags); 
+}
+ 
+static inline struct openflags of_append(struct openflags flags)
+{ 
+        flags.a = 1; 
+        return(flags); 
+}
+ 
+static inline struct openflags of_excl(struct openflags flags)
+{ 
+        flags.e = 1; 
+        return(flags); 
+}
+
+static inline struct openflags of_cloexec(struct openflags flags)
+{ 
+        flags.cl = 1; 
+        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, 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_clear_fd_async(int fd);
+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, 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);
+extern void os_stop_process(int pid);
+extern void os_kill_process(int pid, int reap_child);
+extern void os_kill_ptraced_process(int pid, int reap_child);
+extern void os_usr1_process(int pid);
+extern int os_getpid(void);
+
+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);
+extern unsigned long long os_usecs(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/process.h b/arch/um/include/process.h
new file mode 100644
index 000000000000..5af9157ff54f
--- /dev/null
+++ b/arch/um/include/process.h
@@ -0,0 +1,25 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __PROCESS_H__
+#define __PROCESS_H__
+
+#include <signal.h>
+
+extern void sig_handler(int sig, struct sigcontext sc);
+extern void alarm_handler(int sig, struct sigcontext sc);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/ptrace_user.h b/arch/um/include/ptrace_user.h
new file mode 100644
index 000000000000..f3450e6bc18d
--- /dev/null
+++ b/arch/um/include/ptrace_user.h
@@ -0,0 +1,60 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __PTRACE_USER_H__
+#define __PTRACE_USER_H__
+
+#include "sysdep/ptrace_user.h"
+
+extern int ptrace_getregs(long pid, unsigned long *regs_out);
+extern int ptrace_setregs(long pid, unsigned long *regs_in);
+extern int ptrace_getfpregs(long pid, unsigned long *regs_out);
+extern int ptrace_setfpregs(long pid, unsigned long *regs);
+extern void arch_enter_kernel(void *task, int pid);
+extern void arch_leave_kernel(void *task, int pid);
+extern void ptrace_pokeuser(unsigned long addr, unsigned long data);
+
+
+/* syscall emulation path in ptrace */
+
+#ifndef PTRACE_SYSEMU
+#define PTRACE_SYSEMU 31
+#endif
+#ifndef PTRACE_SYSEMU_SINGLESTEP
+#define PTRACE_SYSEMU_SINGLESTEP 32
+#endif
+
+/* On architectures, that started to support PTRACE_O_TRACESYSGOOD
+ * in linux 2.4, there are two different definitions of
+ * PTRACE_SETOPTIONS: linux 2.4 uses 21 while linux 2.6 uses 0x4200.
+ * For binary compatibility, 2.6 also supports the old "21", named
+ * PTRACE_OLDSETOPTION. On these architectures, UML always must use
+ * "21", to ensure the kernel runs on 2.4 and 2.6 host without
+ * recompilation. So, we use PTRACE_OLDSETOPTIONS in UML.
+ * We also want to be able to build the kernel on 2.4, which doesn't
+ * have PTRACE_OLDSETOPTIONS. So, if it is missing, we declare
+ * PTRACE_OLDSETOPTIONS to to be the same as PTRACE_SETOPTIONS.
+ *
+ * On architectures, that start to support PTRACE_O_TRACESYSGOOD on
+ * linux 2.6, PTRACE_OLDSETOPTIONS never is defined, and also isn't
+ * supported by the host kernel. In that case, our trick lets us use
+ * the new 0x4200 with the name PTRACE_OLDSETOPTIONS.
+ */
+#ifndef PTRACE_OLDSETOPTIONS
+#define PTRACE_OLDSETOPTIONS PTRACE_SETOPTIONS
+#endif
+
+void set_using_sysemu(int value);
+int get_using_sysemu(void);
+extern int sysemu_supported;
+
+#define SELECT_PTRACE_OPERATION(sysemu_mode, singlestep_mode) \
+        (((int[3][3] ) { \
+                { PTRACE_SYSCALL, PTRACE_SYSCALL, PTRACE_SINGLESTEP }, \
+                { PTRACE_SYSEMU, PTRACE_SYSEMU, PTRACE_SINGLESTEP }, \
+                { PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP, PTRACE_SYSEMU_SINGLESTEP }}) \
+                [sysemu_mode][singlestep_mode])
+
+#endif
diff --git a/arch/um/include/registers.h b/arch/um/include/registers.h
new file mode 100644
index 000000000000..8744abb5224f
--- /dev/null
+++ b/arch/um/include/registers.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#ifndef __REGISTERS_H
+#define __REGISTERS_H
+
+#include "sysdep/ptrace.h"
+
+extern void init_thread_registers(union uml_pt_regs *to);
+extern int save_fp_registers(int pid, unsigned long *fp_regs);
+extern int restore_fp_registers(int pid, unsigned long *fp_regs);
+extern void save_registers(int pid, union uml_pt_regs *regs);
+extern void restore_registers(int pid, union uml_pt_regs *regs);
+extern void init_registers(int pid);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sigcontext.h b/arch/um/include/sigcontext.h
new file mode 100644
index 000000000000..59816ca7a8df
--- /dev/null
+++ b/arch/um/include/sigcontext.h
@@ -0,0 +1,25 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UML_SIGCONTEXT_H__
+#define __UML_SIGCONTEXT_H__
+
+#include "sysdep/sigcontext.h"
+
+extern int sc_size(void *data);
+extern void sc_to_sc(void *to_ptr, void *from_ptr);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sigio.h b/arch/um/include/sigio.h
new file mode 100644
index 000000000000..37d76e29a147
--- /dev/null
+++ b/arch/um/include/sigio.h
@@ -0,0 +1,28 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SIGIO_H__
+#define __SIGIO_H__
+
+extern int write_sigio_irq(int fd);
+extern int register_sigio_fd(int fd);
+extern int read_sigio_fd(int fd);
+extern int add_sigio_fd(int fd, int read);
+extern int ignore_sigio_fd(int fd);
+extern void sigio_lock(void);
+extern void sigio_unlock(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/signal_kern.h b/arch/um/include/signal_kern.h
new file mode 100644
index 000000000000..aeb5d5ab1dfd
--- /dev/null
+++ b/arch/um/include/signal_kern.h
@@ -0,0 +1,22 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SIGNAL_KERN_H__
+#define __SIGNAL_KERN_H__
+
+extern int have_signals(void *t);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/signal_user.h b/arch/um/include/signal_user.h
new file mode 100644
index 000000000000..b075e543d864
--- /dev/null
+++ b/arch/um/include/signal_user.h
@@ -0,0 +1,28 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SIGNAL_USER_H__
+#define __SIGNAL_USER_H__
+
+extern int signal_stack_size;
+
+extern int change_sig(int signal, int on);
+extern void set_sigstack(void *stack, int size);
+extern void set_handler(int sig, void (*handler)(int), int flags, ...);
+extern int set_signals(int enable);
+extern int get_signals(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/skas_ptrace.h b/arch/um/include/skas_ptrace.h
new file mode 100644
index 000000000000..cfb5fb4f5b91
--- /dev/null
+++ b/arch/um/include/skas_ptrace.h
@@ -0,0 +1,36 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_PTRACE_H
+#define __SKAS_PTRACE_H
+
+struct ptrace_faultinfo {
+        int is_write;
+        unsigned long addr;
+};
+
+struct ptrace_ldt {
+        int func;
+        void *ptr;
+        unsigned long bytecount;
+};
+
+#define PTRACE_FAULTINFO 52
+#define PTRACE_SIGPENDING 53
+#define PTRACE_LDT 54
+#define PTRACE_SWITCH_MM 55
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/syscall_user.h b/arch/um/include/syscall_user.h
new file mode 100644
index 000000000000..811d0ec2445e
--- /dev/null
+++ b/arch/um/include/syscall_user.h
@@ -0,0 +1,23 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSCALL_USER_H
+#define __SYSCALL_USER_H
+
+extern int record_syscall_start(int syscall);
+extern void record_syscall_end(int index, long result);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-i386/checksum.h b/arch/um/include/sysdep-i386/checksum.h
new file mode 100644
index 000000000000..3a2a45811aa3
--- /dev/null
+++ b/arch/um/include/sysdep-i386/checksum.h
@@ -0,0 +1,219 @@
+/* 
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_SYSDEP_CHECKSUM_H
+#define __UM_SYSDEP_CHECKSUM_H
+
+#include "linux/in6.h"
+#include "linux/string.h"
+
+/*
+ * computes the checksum of a memory block at buff, length len,
+ * and adds in "sum" (32-bit)
+ *
+ * returns a 32-bit number suitable for feeding into itself
+ * or csum_tcpudp_magic
+ *
+ * this function must be called with even lengths, except
+ * for the last fragment, which may be odd
+ *
+ * it's best to have buff aligned on a 32-bit boundary
+ */
+unsigned int csum_partial(const unsigned char * buff, int len, 
+                          unsigned int sum);
+
+/*
+ * the same as csum_partial, but copies from src while it
+ * checksums, and handles user-space pointer exceptions correctly, when needed.
+ *
+ * here even more important to align src and dst on a 32-bit (or even
+ * better 64-bit) boundary
+ */
+
+unsigned int csum_partial_copy_to(const unsigned char *src, unsigned char *dst,
+                                  int len, int sum, int *err_ptr);
+unsigned int csum_partial_copy_from(const unsigned char *src, unsigned char *dst,
+                                    int len, int sum, int *err_ptr);
+
+/*
+ *      Note: when you get a NULL pointer exception here this means someone
+ *      passed in an incorrect kernel address to one of these functions.
+ *
+ *      If you use these functions directly please don't forget the
+ *      access_ok().
+ */
+
+static __inline__
+unsigned int csum_partial_copy_nocheck(const unsigned char *src, unsigned char *dst,
+                                       int len, int sum)
+{
+        memcpy(dst, src, len);
+        return(csum_partial(dst, len, sum));
+}
+
+static __inline__
+unsigned int csum_partial_copy_from_user(const unsigned char *src, unsigned char *dst,
+                                         int len, int sum, int *err_ptr)
+{
+        return csum_partial_copy_from(src, dst, len, sum, err_ptr);
+}
+
+/*
+ * These are the old (and unsafe) way of doing checksums, a warning message 
+ * will be printed if they are used and an exception occurs.
+ *
+ * these functions should go away after some time.
+ */
+
+#define csum_partial_copy_fromuser csum_partial_copy_from_user
+unsigned int csum_partial_copy(const unsigned char *src, unsigned char *dst, int len, int sum);
+
+/*
+ *      This is a version of ip_compute_csum() optimized for IP headers,
+ *      which always checksum on 4 octet boundaries.
+ *
+ *      By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
+ *      Arnt Gulbrandsen.
+ */
+static inline unsigned short ip_fast_csum(unsigned char * iph,
+                                          unsigned int ihl)
+{
+        unsigned int sum;
+
+        __asm__ __volatile__(
+            "movl (%1), %0      ;\n"
+            "subl $4, %2        ;\n"
+            "jbe 2f             ;\n"
+            "addl 4(%1), %0     ;\n"
+            "adcl 8(%1), %0     ;\n"
+            "adcl 12(%1), %0    ;\n"
+"1:         adcl 16(%1), %0     ;\n"
+            "lea 4(%1), %1      ;\n"
+            "decl %2            ;\n"
+            "jne 1b             ;\n"
+            "adcl $0, %0        ;\n"
+            "movl %0, %2        ;\n"
+            "shrl $16, %0       ;\n"
+            "addw %w2, %w0      ;\n"
+            "adcl $0, %0        ;\n"
+            "notl %0            ;\n"
+"2:                             ;\n"
+        /* Since the input registers which are loaded with iph and ipl
+           are modified, we must also specify them as outputs, or gcc
+           will assume they contain their original values. */
+        : "=r" (sum), "=r" (iph), "=r" (ihl)
+        : "1" (iph), "2" (ihl)
+        : "memory");
+        return(sum);
+}
+
+/*
+ *      Fold a partial checksum
+ */
+
+static inline unsigned int csum_fold(unsigned int sum)
+{
+        __asm__(
+                "addl %1, %0            ;\n"
+                "adcl $0xffff, %0       ;\n"
+                : "=r" (sum)
+                : "r" (sum << 16), "0" (sum & 0xffff0000)
+        );
+        return (~sum) >> 16;
+}
+
+static inline unsigned long csum_tcpudp_nofold(unsigned long saddr,
+                                                   unsigned long daddr,
+                                                   unsigned short len,
+                                                   unsigned short proto,
+                                                   unsigned int sum)
+{
+    __asm__(
+        "addl %1, %0    ;\n"
+        "adcl %2, %0    ;\n"
+        "adcl %3, %0    ;\n"
+        "adcl $0, %0    ;\n"
+        : "=r" (sum)
+        : "g" (daddr), "g"(saddr), "g"((ntohs(len)<<16)+proto*256), "0"(sum));
+    return sum;
+}
+
+/*
+ * computes the checksum of the TCP/UDP pseudo-header
+ * returns a 16-bit checksum, already complemented
+ */
+static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
+                                                   unsigned long daddr,
+                                                   unsigned short len,
+                                                   unsigned short proto,
+                                                   unsigned int sum)
+{
+        return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
+}
+
+/*
+ * this routine is used for miscellaneous IP-like checksums, mainly
+ * in icmp.c
+ */
+
+static inline unsigned short ip_compute_csum(unsigned char * buff, int len)
+{
+    return csum_fold (csum_partial(buff, len, 0));
+}
+
+#define _HAVE_ARCH_IPV6_CSUM
+static __inline__ unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
+                                                     struct in6_addr *daddr,
+                                                     __u32 len,
+                                                     unsigned short proto,
+                                                     unsigned int sum)
+{
+        __asm__(
+                "addl 0(%1), %0         ;\n"
+                "adcl 4(%1), %0         ;\n"
+                "adcl 8(%1), %0         ;\n"
+                "adcl 12(%1), %0        ;\n"
+                "adcl 0(%2), %0         ;\n"
+                "adcl 4(%2), %0         ;\n"
+                "adcl 8(%2), %0         ;\n"
+                "adcl 12(%2), %0        ;\n"
+                "adcl %3, %0            ;\n"
+                "adcl %4, %0            ;\n"
+                "adcl $0, %0            ;\n"
+                : "=&r" (sum)
+                : "r" (saddr), "r" (daddr),
+                  "r"(htonl(len)), "r"(htonl(proto)), "0"(sum));
+
+        return csum_fold(sum);
+}
+
+/*
+ *      Copy and checksum to user
+ */
+#define HAVE_CSUM_COPY_USER
+static __inline__ unsigned int csum_and_copy_to_user(const unsigned char *src,
+                                                     unsigned char *dst,
+                                                     int len, int sum, int *err_ptr)
+{
+        if (access_ok(VERIFY_WRITE, dst, len))
+                return(csum_partial_copy_to(src, dst, len, sum, err_ptr));
+
+        if (len)
+                *err_ptr = -EFAULT;
+
+        return -1; /* invalid checksum */
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-i386/ptrace.h b/arch/um/include/sysdep-i386/ptrace.h
new file mode 100644
index 000000000000..661d495e2044
--- /dev/null
+++ b/arch/um/include/sysdep-i386/ptrace.h
@@ -0,0 +1,241 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_I386_PTRACE_H
+#define __SYSDEP_I386_PTRACE_H
+
+#include "uml-config.h"
+#include "user_constants.h"
+
+#define MAX_REG_NR (UM_FRAME_SIZE / sizeof(unsigned long))
+#define MAX_REG_OFFSET (UM_FRAME_SIZE)
+
+extern void update_debugregs(int seq);
+
+/* syscall emulation path in ptrace */
+
+#ifndef PTRACE_SYSEMU
+#define PTRACE_SYSEMU 31
+#endif
+
+void set_using_sysemu(int value);
+int get_using_sysemu(void);
+extern int sysemu_supported;
+
+#ifdef UML_CONFIG_MODE_TT
+#include "sysdep/sc.h"
+#endif
+
+#ifdef UML_CONFIG_MODE_SKAS
+
+#include "skas_ptregs.h"
+
+#define REGS_IP(r) ((r)[HOST_IP])
+#define REGS_SP(r) ((r)[HOST_SP])
+#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
+#define REGS_EAX(r) ((r)[HOST_EAX])
+#define REGS_EBX(r) ((r)[HOST_EBX])
+#define REGS_ECX(r) ((r)[HOST_ECX])
+#define REGS_EDX(r) ((r)[HOST_EDX])
+#define REGS_ESI(r) ((r)[HOST_ESI])
+#define REGS_EDI(r) ((r)[HOST_EDI])
+#define REGS_EBP(r) ((r)[HOST_EBP])
+#define REGS_CS(r) ((r)[HOST_CS])
+#define REGS_SS(r) ((r)[HOST_SS])
+#define REGS_DS(r) ((r)[HOST_DS])
+#define REGS_ES(r) ((r)[HOST_ES])
+#define REGS_FS(r) ((r)[HOST_FS])
+#define REGS_GS(r) ((r)[HOST_GS])
+
+#define REGS_SET_SYSCALL_RETURN(r, res) REGS_EAX(r) = (res)
+
+#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
+
+#define REGS_SEGV_IS_FIXABLE(r) SEGV_IS_FIXABLE((r)->trap_type)
+
+#define REGS_FAULT_ADDR(r) ((r)->fault_addr)
+
+#define REGS_FAULT_WRITE(r) FAULT_WRITE((r)->fault_type)
+
+#endif
+#ifndef PTRACE_SYSEMU_SINGLESTEP
+#define PTRACE_SYSEMU_SINGLESTEP 32
+#endif
+
+#include "choose-mode.h"
+
+union uml_pt_regs {
+#ifdef UML_CONFIG_MODE_TT
+        struct tt_regs {
+                long syscall;
+                void *sc;
+        } tt;
+#endif
+#ifdef UML_CONFIG_MODE_SKAS
+        struct skas_regs {
+                unsigned long regs[HOST_FRAME_SIZE];
+                unsigned long fp[HOST_FP_SIZE];
+                unsigned long xfp[HOST_XFP_SIZE];
+                unsigned long fault_addr;
+                unsigned long fault_type;
+                unsigned long trap_type;
+                long syscall;
+                int is_user;
+        } skas;
+#endif
+};
+
+#define EMPTY_UML_PT_REGS { }
+
+extern int mode_tt;
+
+#define UPT_SC(r) ((r)->tt.sc)
+#define UPT_IP(r) \
+        __CHOOSE_MODE(SC_IP(UPT_SC(r)), REGS_IP((r)->skas.regs))
+#define UPT_SP(r) \
+        __CHOOSE_MODE(SC_SP(UPT_SC(r)), REGS_SP((r)->skas.regs))
+#define UPT_EFLAGS(r) \
+        __CHOOSE_MODE(SC_EFLAGS(UPT_SC(r)), REGS_EFLAGS((r)->skas.regs))
+#define UPT_EAX(r) \
+        __CHOOSE_MODE(SC_EAX(UPT_SC(r)), REGS_EAX((r)->skas.regs))
+#define UPT_EBX(r) \
+        __CHOOSE_MODE(SC_EBX(UPT_SC(r)), REGS_EBX((r)->skas.regs))
+#define UPT_ECX(r) \
+        __CHOOSE_MODE(SC_ECX(UPT_SC(r)), REGS_ECX((r)->skas.regs))
+#define UPT_EDX(r) \
+        __CHOOSE_MODE(SC_EDX(UPT_SC(r)), REGS_EDX((r)->skas.regs))
+#define UPT_ESI(r) \
+        __CHOOSE_MODE(SC_ESI(UPT_SC(r)), REGS_ESI((r)->skas.regs))
+#define UPT_EDI(r) \
+        __CHOOSE_MODE(SC_EDI(UPT_SC(r)), REGS_EDI((r)->skas.regs))
+#define UPT_EBP(r) \
+        __CHOOSE_MODE(SC_EBP(UPT_SC(r)), REGS_EBP((r)->skas.regs))
+#define UPT_ORIG_EAX(r) \
+        __CHOOSE_MODE((r)->tt.syscall, (r)->skas.syscall)
+#define UPT_CS(r) \
+        __CHOOSE_MODE(SC_CS(UPT_SC(r)), REGS_CS((r)->skas.regs))
+#define UPT_SS(r) \
+        __CHOOSE_MODE(SC_SS(UPT_SC(r)), REGS_SS((r)->skas.regs))
+#define UPT_DS(r) \
+        __CHOOSE_MODE(SC_DS(UPT_SC(r)), REGS_DS((r)->skas.regs))
+#define UPT_ES(r) \
+        __CHOOSE_MODE(SC_ES(UPT_SC(r)), REGS_ES((r)->skas.regs))
+#define UPT_FS(r) \
+        __CHOOSE_MODE(SC_FS(UPT_SC(r)), REGS_FS((r)->skas.regs))
+#define UPT_GS(r) \
+        __CHOOSE_MODE(SC_GS(UPT_SC(r)), REGS_GS((r)->skas.regs))
+
+#define UPT_SYSCALL_ARG1(r) UPT_EBX(r)
+#define UPT_SYSCALL_ARG2(r) UPT_ECX(r)
+#define UPT_SYSCALL_ARG3(r) UPT_EDX(r)
+#define UPT_SYSCALL_ARG4(r) UPT_ESI(r)
+#define UPT_SYSCALL_ARG5(r) UPT_EDI(r)
+#define UPT_SYSCALL_ARG6(r) UPT_EBP(r)
+
+extern int user_context(unsigned long sp);
+
+#define UPT_IS_USER(r) \
+        CHOOSE_MODE(user_context(UPT_SP(r)), (r)->skas.is_user)
+
+struct syscall_args {
+        unsigned long args[6];
+};
+
+#define SYSCALL_ARGS(r) ((struct syscall_args) \
+                        { .args = { UPT_SYSCALL_ARG1(r), \
+                                    UPT_SYSCALL_ARG2(r), \
+                                    UPT_SYSCALL_ARG3(r), \
+                                    UPT_SYSCALL_ARG4(r), \
+                                    UPT_SYSCALL_ARG5(r), \
+                                    UPT_SYSCALL_ARG6(r) } } )
+
+#define UPT_REG(regs, reg) \
+        ({      unsigned long val; \
+                switch(reg){ \
+                case EIP: val = UPT_IP(regs); break; \
+                case UESP: val = UPT_SP(regs); break; \
+                case EAX: val = UPT_EAX(regs); break; \
+                case EBX: val = UPT_EBX(regs); break; \
+                case ECX: val = UPT_ECX(regs); break; \
+                case EDX: val = UPT_EDX(regs); break; \
+                case ESI: val = UPT_ESI(regs); break; \
+                case EDI: val = UPT_EDI(regs); break; \
+                case EBP: val = UPT_EBP(regs); break; \
+                case ORIG_EAX: val = UPT_ORIG_EAX(regs); break; \
+                case CS: val = UPT_CS(regs); break; \
+                case SS: val = UPT_SS(regs); break; \
+                case DS: val = UPT_DS(regs); break; \
+                case ES: val = UPT_ES(regs); break; \
+                case FS: val = UPT_FS(regs); break; \
+                case GS: val = UPT_GS(regs); break; \
+                case EFL: val = UPT_EFLAGS(regs); break; \
+                default :  \
+                        panic("Bad register in UPT_REG : %d\n", reg);  \
+                        val = -1; \
+                } \
+                val; \
+        })
+        
+
+#define UPT_SET(regs, reg, val) \
+        do { \
+                switch(reg){ \
+                case EIP: UPT_IP(regs) = val; break; \
+                case UESP: UPT_SP(regs) = val; break; \
+                case EAX: UPT_EAX(regs) = val; break; \
+                case EBX: UPT_EBX(regs) = val; break; \
+                case ECX: UPT_ECX(regs) = val; break; \
+                case EDX: UPT_EDX(regs) = val; break; \
+                case ESI: UPT_ESI(regs) = val; break; \
+                case EDI: UPT_EDI(regs) = val; break; \
+                case EBP: UPT_EBP(regs) = val; break; \
+                case ORIG_EAX: UPT_ORIG_EAX(regs) = val; break; \
+                case CS: UPT_CS(regs) = val; break; \
+                case SS: UPT_SS(regs) = val; break; \
+                case DS: UPT_DS(regs) = val; break; \
+                case ES: UPT_ES(regs) = val; break; \
+                case FS: UPT_FS(regs) = val; break; \
+                case GS: UPT_GS(regs) = val; break; \
+                case EFL: UPT_EFLAGS(regs) = val; break; \
+                default :  \
+                        panic("Bad register in UPT_SET : %d\n", reg);  \
+                        break; \
+                } \
+        } while (0)
+
+#define UPT_SET_SYSCALL_RETURN(r, res) \
+        CHOOSE_MODE(SC_SET_SYSCALL_RETURN(UPT_SC(r), (res)), \
+                    REGS_SET_SYSCALL_RETURN((r)->skas.regs, (res)))
+
+#define UPT_RESTART_SYSCALL(r) \
+        CHOOSE_MODE(SC_RESTART_SYSCALL(UPT_SC(r)), \
+                    REGS_RESTART_SYSCALL((r)->skas.regs))
+
+#define UPT_ORIG_SYSCALL(r) UPT_EAX(r)
+#define UPT_SYSCALL_NR(r) UPT_ORIG_EAX(r)
+#define UPT_SYSCALL_RET(r) UPT_EAX(r)
+
+#define UPT_SEGV_IS_FIXABLE(r) \
+        CHOOSE_MODE(SC_SEGV_IS_FIXABLE(UPT_SC(r)), \
+                    REGS_SEGV_IS_FIXABLE(&r->skas))
+
+#define UPT_FAULT_ADDR(r) \
+        __CHOOSE_MODE(SC_FAULT_ADDR(UPT_SC(r)), REGS_FAULT_ADDR(&r->skas))
+
+#define UPT_FAULT_WRITE(r) \
+        CHOOSE_MODE(SC_FAULT_WRITE(UPT_SC(r)), REGS_FAULT_WRITE(&r->skas))
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-i386/ptrace_user.h b/arch/um/include/sysdep-i386/ptrace_user.h
new file mode 100644
index 000000000000..eca8066e7a43
--- /dev/null
+++ b/arch/um/include/sysdep-i386/ptrace_user.h
@@ -0,0 +1,62 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_I386_PTRACE_USER_H__
+#define __SYSDEP_I386_PTRACE_USER_H__
+
+#include <sys/ptrace.h>
+#include <linux/ptrace.h>
+#include <asm/ptrace.h>
+
+#define PT_OFFSET(r) ((r) * sizeof(long))
+
+#define PT_SYSCALL_NR(regs) ((regs)[ORIG_EAX])
+#define PT_SYSCALL_NR_OFFSET PT_OFFSET(ORIG_EAX)
+
+#define PT_SYSCALL_ARG1_OFFSET PT_OFFSET(EBX)
+#define PT_SYSCALL_ARG2_OFFSET PT_OFFSET(ECX)
+#define PT_SYSCALL_ARG3_OFFSET PT_OFFSET(EDX)
+#define PT_SYSCALL_ARG4_OFFSET PT_OFFSET(ESI)
+#define PT_SYSCALL_ARG5_OFFSET PT_OFFSET(EDI)
+
+#define PT_SYSCALL_RET_OFFSET PT_OFFSET(EAX)
+
+#define PT_IP_OFFSET PT_OFFSET(EIP)
+#define PT_IP(regs) ((regs)[EIP])
+#define PT_SP(regs) ((regs)[UESP])
+
+#ifndef FRAME_SIZE
+#define FRAME_SIZE (17)
+#endif
+#define FRAME_SIZE_OFFSET (FRAME_SIZE * sizeof(unsigned long))
+
+#define FP_FRAME_SIZE (27)
+#define FPX_FRAME_SIZE (128)
+
+#ifdef PTRACE_GETREGS
+#define UM_HAVE_GETREGS
+#endif
+
+#ifdef PTRACE_SETREGS
+#define UM_HAVE_SETREGS
+#endif
+
+#ifdef PTRACE_GETFPREGS
+#define UM_HAVE_GETFPREGS
+#endif
+
+#ifdef PTRACE_SETFPREGS
+#define UM_HAVE_SETFPREGS
+#endif
+
+#ifdef PTRACE_GETFPXREGS
+#define UM_HAVE_GETFPXREGS
+#endif
+
+#ifdef PTRACE_SETFPXREGS
+#define UM_HAVE_SETFPXREGS
+#endif
+
+#endif
diff --git a/arch/um/include/sysdep-i386/sigcontext.h b/arch/um/include/sysdep-i386/sigcontext.h
new file mode 100644
index 000000000000..dfee589de360
--- /dev/null
+++ b/arch/um/include/sysdep-i386/sigcontext.h
@@ -0,0 +1,49 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYS_SIGCONTEXT_I386_H
+#define __SYS_SIGCONTEXT_I386_H
+
+#include <sysdep/sc.h>
+
+#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
+
+#define SC_RESTART_SYSCALL(sc) IP_RESTART_SYSCALL(SC_IP(sc))
+#define SC_SET_SYSCALL_RETURN(sc, result) SC_EAX(sc) = (result)
+
+#define SC_FAULT_ADDR(sc) SC_CR2(sc)
+#define SC_FAULT_TYPE(sc) SC_ERR(sc)
+
+#define FAULT_WRITE(err) (err & 2)
+#define TO_SC_ERR(is_write) ((is_write) ? 2 : 0)
+
+#define SC_FAULT_WRITE(sc) (FAULT_WRITE(SC_ERR(sc)))
+
+#define SC_TRAP_TYPE(sc) SC_TRAPNO(sc)
+
+/* ptrace expects that, at the start of a system call, %eax contains
+ * -ENOSYS, so this makes it so.
+ */
+#define SC_START_SYSCALL(sc) do SC_EAX(sc) = -ENOSYS; while(0)
+
+/* This is Page Fault */
+#define SEGV_IS_FIXABLE(trap) (trap == 14)
+
+#define SC_SEGV_IS_FIXABLE(sc) (SEGV_IS_FIXABLE(SC_TRAPNO(sc)))
+
+extern unsigned long *sc_sigmask(void *sc_ptr);
+extern int sc_get_fpregs(unsigned long buf, void *sc_ptr);
+
+#endif
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-i386/signal.h b/arch/um/include/sysdep-i386/signal.h
new file mode 100644
index 000000000000..b1e1f7a77499
--- /dev/null
+++ b/arch/um/include/sysdep-i386/signal.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#ifndef __I386_SIGNAL_H_
+#define __I386_SIGNAL_H_
+
+#include <signal.h>
+
+#define ARCH_GET_SIGCONTEXT(sc, sig) \
+        do sc = (struct sigcontext *) (&sig + 1); while(0)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-i386/syscalls.h b/arch/um/include/sysdep-i386/syscalls.h
new file mode 100644
index 000000000000..5db81ec9087d
--- /dev/null
+++ b/arch/um/include/sysdep-i386/syscalls.h
@@ -0,0 +1,123 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "asm/unistd.h"
+#include "sysdep/ptrace.h"
+
+typedef long syscall_handler_t(struct pt_regs);
+
+/* Not declared on x86, incompatible declarations on x86_64, so these have
+ * to go here rather than in sys_call_table.c
+ */
+extern syscall_handler_t sys_ptrace;
+extern syscall_handler_t sys_rt_sigaction;
+
+extern syscall_handler_t old_mmap_i386;
+
+#define EXECUTE_SYSCALL(syscall, regs) \
+        ((long (*)(struct syscall_args)) (*sys_call_table[syscall]))(SYSCALL_ARGS(&regs->regs))
+
+extern long sys_mmap2(unsigned long addr, unsigned long len,
+                      unsigned long prot, unsigned long flags,
+                      unsigned long fd, unsigned long pgoff);
+
+/* On i386 they choose a meaningless naming.*/
+#define __NR_kexec_load __NR_sys_kexec_load
+
+#define ARCH_SYSCALLS \
+        [ __NR_waitpid ] = (syscall_handler_t *) sys_waitpid, \
+        [ __NR_break ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_oldstat ] = (syscall_handler_t *) sys_stat, \
+        [ __NR_umount ] = (syscall_handler_t *) sys_oldumount, \
+        [ __NR_stime ] = um_stime, \
+        [ __NR_oldfstat ] = (syscall_handler_t *) sys_fstat, \
+        [ __NR_stty ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_gtty ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_nice ] = (syscall_handler_t *) sys_nice, \
+        [ __NR_ftime ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_prof ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_signal ] = (syscall_handler_t *) sys_signal, \
+        [ __NR_lock ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_mpx ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_ulimit ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_oldolduname ] = (syscall_handler_t *) sys_olduname, \
+        [ __NR_sigaction ] = (syscall_handler_t *) sys_sigaction, \
+        [ __NR_sgetmask ] = (syscall_handler_t *) sys_sgetmask, \
+        [ __NR_ssetmask ] = (syscall_handler_t *) sys_ssetmask, \
+        [ __NR_sigsuspend ] = (syscall_handler_t *) sys_sigsuspend, \
+        [ __NR_sigpending ] = (syscall_handler_t *) sys_sigpending, \
+        [ __NR_oldlstat ] = (syscall_handler_t *) sys_lstat, \
+        [ __NR_readdir ] = old_readdir, \
+        [ __NR_profil ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_socketcall ] = (syscall_handler_t *) sys_socketcall, \
+        [ __NR_olduname ] = (syscall_handler_t *) sys_uname, \
+        [ __NR_iopl ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_idle ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_ipc ] = (syscall_handler_t *) sys_ipc, \
+        [ __NR_sigreturn ] = (syscall_handler_t *) sys_sigreturn, \
+        [ __NR_sigprocmask ] = (syscall_handler_t *) sys_sigprocmask, \
+        [ __NR_bdflush ] = (syscall_handler_t *) sys_bdflush, \
+        [ __NR__llseek ] = (syscall_handler_t *) sys_llseek, \
+        [ __NR__newselect ] = (syscall_handler_t *) sys_select, \
+        [ __NR_vm86 ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_mmap ] = (syscall_handler_t *) old_mmap_i386, \
+        [ __NR_ugetrlimit ] = (syscall_handler_t *) sys_getrlimit, \
+        [ __NR_mmap2 ] = (syscall_handler_t *) sys_mmap2, \
+        [ __NR_truncate64 ] = (syscall_handler_t *) sys_truncate64, \
+        [ __NR_ftruncate64 ] = (syscall_handler_t *) sys_ftruncate64, \
+        [ __NR_stat64 ] = (syscall_handler_t *) sys_stat64, \
+        [ __NR_lstat64 ] = (syscall_handler_t *) sys_lstat64, \
+        [ __NR_fstat64 ] = (syscall_handler_t *) sys_fstat64, \
+        [ __NR_fcntl64 ] = (syscall_handler_t *) sys_fcntl64, \
+        [ __NR_sendfile64 ] = (syscall_handler_t *) sys_sendfile64, \
+        [ __NR_statfs64 ] = (syscall_handler_t *) sys_statfs64, \
+        [ __NR_fstatfs64 ] = (syscall_handler_t *) sys_fstatfs64, \
+        [ __NR_fadvise64_64 ] = (syscall_handler_t *) sys_fadvise64_64, \
+        [ __NR_select ] = (syscall_handler_t *) old_select, \
+        [ __NR_vm86old ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_modify_ldt ] = (syscall_handler_t *) sys_modify_ldt, \
+        [ __NR_lchown32 ] = (syscall_handler_t *) sys_lchown, \
+        [ __NR_getuid32 ] = (syscall_handler_t *) sys_getuid, \
+        [ __NR_getgid32 ] = (syscall_handler_t *) sys_getgid, \
+        [ __NR_geteuid32 ] = (syscall_handler_t *) sys_geteuid, \
+        [ __NR_getegid32 ] = (syscall_handler_t *) sys_getegid, \
+        [ __NR_setreuid32 ] = (syscall_handler_t *) sys_setreuid, \
+        [ __NR_setregid32 ] = (syscall_handler_t *) sys_setregid, \
+        [ __NR_getgroups32 ] = (syscall_handler_t *) sys_getgroups, \
+        [ __NR_setgroups32 ] = (syscall_handler_t *) sys_setgroups, \
+        [ __NR_fchown32 ] = (syscall_handler_t *) sys_fchown, \
+        [ __NR_setresuid32 ] = (syscall_handler_t *) sys_setresuid, \
+        [ __NR_getresuid32 ] = (syscall_handler_t *) sys_getresuid, \
+        [ __NR_setresgid32 ] = (syscall_handler_t *) sys_setresgid, \
+        [ __NR_getresgid32 ] = (syscall_handler_t *) sys_getresgid, \
+        [ __NR_chown32 ] = (syscall_handler_t *) sys_chown, \
+        [ __NR_setuid32 ] = (syscall_handler_t *) sys_setuid, \
+        [ __NR_setgid32 ] = (syscall_handler_t *) sys_setgid, \
+        [ __NR_setfsuid32 ] = (syscall_handler_t *) sys_setfsuid, \
+        [ __NR_setfsgid32 ] = (syscall_handler_t *) sys_setfsgid, \
+        [ __NR_pivot_root ] = (syscall_handler_t *) sys_pivot_root, \
+        [ __NR_mincore ] = (syscall_handler_t *) sys_mincore, \
+        [ __NR_madvise ] = (syscall_handler_t *) sys_madvise, \
+        [ 222 ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ 223 ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_set_thread_area ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_get_thread_area ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ 251 ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ 285 ] = (syscall_handler_t *) sys_ni_syscall,
+
+/* 222 doesn't yet have a name in include/asm-i386/unistd.h */
+
+#define LAST_ARCH_SYSCALL 285
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ia64/ptrace.h b/arch/um/include/sysdep-ia64/ptrace.h
new file mode 100644
index 000000000000..42dd8fb6f2f9
--- /dev/null
+++ b/arch/um/include/sysdep-ia64/ptrace.h
@@ -0,0 +1,26 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_IA64_PTRACE_H
+#define __SYSDEP_IA64_PTRACE_H
+
+struct sys_pt_regs {
+  int foo;
+};
+
+#define EMPTY_REGS { 0 }
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ia64/sigcontext.h b/arch/um/include/sysdep-ia64/sigcontext.h
new file mode 100644
index 000000000000..f15fb25260ba
--- /dev/null
+++ b/arch/um/include/sysdep-ia64/sigcontext.h
@@ -0,0 +1,20 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_IA64_SIGCONTEXT_H
+#define __SYSDEP_IA64_SIGCONTEXT_H
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ia64/syscalls.h b/arch/um/include/sysdep-ia64/syscalls.h
new file mode 100644
index 000000000000..4a1f46ef1ebc
--- /dev/null
+++ b/arch/um/include/sysdep-ia64/syscalls.h
@@ -0,0 +1,20 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_IA64_SYSCALLS_H
+#define __SYSDEP_IA64_SYSCALLS_H
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ppc/ptrace.h b/arch/um/include/sysdep-ppc/ptrace.h
new file mode 100644
index 000000000000..8a27353733a9
--- /dev/null
+++ b/arch/um/include/sysdep-ppc/ptrace.h
@@ -0,0 +1,104 @@
+/* 
+ * Licensed under the GPL
+ */
+
+#ifndef __SYS_PTRACE_PPC_H
+#define __SYS_PTRACE_PPC_H
+
+#include "linux/config.h"
+#include "linux/types.h"
+
+/* the following taken from <asm-ppc/ptrace.h> */
+
+#ifdef CONFIG_PPC64
+#define PPC_REG unsigned long /*long*/
+#else
+#define PPC_REG unsigned long
+#endif
+struct sys_pt_regs_s {
+        PPC_REG gpr[32];
+        PPC_REG nip;
+        PPC_REG msr;
+        PPC_REG orig_gpr3;      /* Used for restarting system calls */
+        PPC_REG ctr;
+        PPC_REG link;
+        PPC_REG xer;
+        PPC_REG ccr;
+        PPC_REG mq;             /* 601 only (not used at present) */
+                                /* Used on APUS to hold IPL value. */
+        PPC_REG trap;           /* Reason for being here */
+        PPC_REG dar;            /* Fault registers */
+        PPC_REG dsisr;
+        PPC_REG result;         /* Result of a system call */
+};
+
+#define NUM_REGS (sizeof(struct sys_pt_regs_s) / sizeof(PPC_REG))
+
+struct sys_pt_regs {
+    PPC_REG regs[sizeof(struct sys_pt_regs_s) / sizeof(PPC_REG)];
+};
+
+#define UM_MAX_REG (PT_FPR0)
+#define UM_MAX_REG_OFFSET (UM_MAX_REG * sizeof(PPC_REG))
+
+#define EMPTY_REGS { { [ 0 ... NUM_REGS - 1] = 0 } }
+
+#define UM_REG(r, n) ((r)->regs[n])
+
+#define UM_SYSCALL_RET(r) UM_REG(r, PT_R3)
+#define UM_SP(r) UM_REG(r, PT_R1)
+#define UM_IP(r) UM_REG(r, PT_NIP)
+#define UM_ELF_ZERO(r) UM_REG(r, PT_FPSCR)
+#define UM_SYSCALL_NR(r) UM_REG(r, PT_R0)
+#define UM_SYSCALL_ARG1(r) UM_REG(r, PT_ORIG_R3)
+#define UM_SYSCALL_ARG2(r) UM_REG(r, PT_R4)
+#define UM_SYSCALL_ARG3(r) UM_REG(r, PT_R5)
+#define UM_SYSCALL_ARG4(r) UM_REG(r, PT_R6)
+#define UM_SYSCALL_ARG5(r) UM_REG(r, PT_R7)
+#define UM_SYSCALL_ARG6(r) UM_REG(r, PT_R8)
+
+#define UM_SYSCALL_NR_OFFSET (PT_R0 * sizeof(PPC_REG))
+#define UM_SYSCALL_RET_OFFSET (PT_R3 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG1_OFFSET (PT_R3 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG2_OFFSET (PT_R4 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG3_OFFSET (PT_R5 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG4_OFFSET (PT_R6 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG5_OFFSET (PT_R7 * sizeof(PPC_REG))
+#define UM_SYSCALL_ARG6_OFFSET (PT_R8 * sizeof(PPC_REG))
+#define UM_SP_OFFSET (PT_R1 * sizeof(PPC_REG))
+#define UM_IP_OFFSET (PT_NIP * sizeof(PPC_REG))
+#define UM_ELF_ZERO_OFFSET (PT_R3 * sizeof(PPC_REG))
+
+#define UM_SET_SYSCALL_RETURN(_regs, result)            \
+do {                                                    \
+        if (result < 0) {                               \
+                (_regs)->regs[PT_CCR] |= 0x10000000;    \
+                UM_SYSCALL_RET((_regs)) = -result;      \
+        } else {                                        \
+                UM_SYSCALL_RET((_regs)) = result;       \
+        }                                               \
+} while(0)
+
+extern void shove_aux_table(unsigned long sp);
+#define UM_FIX_EXEC_STACK(sp) shove_aux_table(sp);
+
+/* These aren't actually defined.  The undefs are just to make sure
+ * everyone's clear on the concept.
+ */
+#undef UML_HAVE_GETREGS
+#undef UML_HAVE_GETFPREGS
+#undef UML_HAVE_SETREGS
+#undef UML_HAVE_SETFPREGS
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ppc/sigcontext.h b/arch/um/include/sysdep-ppc/sigcontext.h
new file mode 100644
index 000000000000..f20d965de9c7
--- /dev/null
+++ b/arch/um/include/sysdep-ppc/sigcontext.h
@@ -0,0 +1,62 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SYS_SIGCONTEXT_PPC_H
+#define __SYS_SIGCONTEXT_PPC_H
+
+#define DSISR_WRITE 0x02000000
+
+#define SC_FAULT_ADDR(sc) ({ \
+                struct sigcontext *_sc = (sc); \
+                long retval = -1; \
+                switch (_sc->regs->trap) { \
+                case 0x300: \
+                        /* data exception */ \
+                        retval = _sc->regs->dar; \
+                        break; \
+                case 0x400: \
+                        /* instruction exception */ \
+                        retval = _sc->regs->nip; \
+                        break; \
+                default: \
+                        panic("SC_FAULT_ADDR: unhandled trap type\n"); \
+                } \
+                retval; \
+        })
+
+#define SC_FAULT_WRITE(sc) ({ \
+                struct sigcontext *_sc = (sc); \
+                long retval = -1; \
+                switch (_sc->regs->trap) { \
+                case 0x300: \
+                        /* data exception */ \
+                        retval = !!(_sc->regs->dsisr & DSISR_WRITE); \
+                        break; \
+                case 0x400: \
+                        /* instruction exception: not a write */ \
+                        retval = 0; \
+                        break; \
+                default: \
+                        panic("SC_FAULT_ADDR: unhandled trap type\n"); \
+                } \
+                retval; \
+        })
+
+#define SC_IP(sc) ((sc)->regs->nip)
+#define SC_SP(sc) ((sc)->regs->gpr[1])
+#define SEGV_IS_FIXABLE(sc) (1)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-ppc/syscalls.h b/arch/um/include/sysdep-ppc/syscalls.h
new file mode 100644
index 000000000000..679df351e19b
--- /dev/null
+++ b/arch/um/include/sysdep-ppc/syscalls.h
@@ -0,0 +1,53 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+typedef long syscall_handler_t(unsigned long arg1, unsigned long arg2,
+                               unsigned long arg3, unsigned long arg4,
+                               unsigned long arg5, unsigned long arg6);
+
+#define EXECUTE_SYSCALL(syscall, regs) \
+        (*sys_call_table[syscall])(UM_SYSCALL_ARG1(&regs), \
+                                   UM_SYSCALL_ARG2(&regs), \
+                                   UM_SYSCALL_ARG3(&regs), \
+                                   UM_SYSCALL_ARG4(&regs), \
+                                   UM_SYSCALL_ARG5(&regs), \
+                                   UM_SYSCALL_ARG6(&regs))
+
+extern syscall_handler_t sys_mincore;
+extern syscall_handler_t sys_madvise;
+
+/* old_mmap needs the correct prototype since syscall_kern.c includes
+ * this file.
+ */
+int old_mmap(unsigned long addr, unsigned long len,
+             unsigned long prot, unsigned long flags,
+             unsigned long fd, unsigned long offset);
+
+#define ARCH_SYSCALLS \
+        [ __NR_modify_ldt ] = sys_ni_syscall, \
+        [ __NR_pciconfig_read ] = sys_ni_syscall, \
+        [ __NR_pciconfig_write ] = sys_ni_syscall, \
+        [ __NR_pciconfig_iobase ] = sys_ni_syscall, \
+        [ __NR_pivot_root ] = sys_ni_syscall, \
+        [ __NR_multiplexer ] = sys_ni_syscall, \
+        [ __NR_mmap ] = old_mmap, \
+        [ __NR_madvise ] = sys_madvise, \
+        [ __NR_mincore ] = sys_mincore, \
+        [ __NR_iopl ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_utimes ] = (syscall_handler_t *) sys_utimes, \
+        [ __NR_fadvise64 ] = (syscall_handler_t *) sys_fadvise64,
+
+#define LAST_ARCH_SYSCALL __NR_fadvise64
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-x86_64/checksum.h b/arch/um/include/sysdep-x86_64/checksum.h
new file mode 100644
index 000000000000..572c6c19be33
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/checksum.h
@@ -0,0 +1,151 @@
+/*
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_SYSDEP_CHECKSUM_H
+#define __UM_SYSDEP_CHECKSUM_H
+
+#include "linux/string.h"
+#include "linux/in6.h"
+#include "asm/uaccess.h"
+
+extern unsigned int csum_partial_copy_from(const unsigned char *src, unsigned char *dst, int len,
+                                           int sum, int *err_ptr);
+extern unsigned csum_partial(const unsigned char *buff, unsigned len,
+                             unsigned sum);
+
+/*
+ *      Note: when you get a NULL pointer exception here this means someone
+ *      passed in an incorrect kernel address to one of these functions.
+ *
+ *      If you use these functions directly please don't forget the
+ *      access_ok().
+ */
+
+static __inline__
+unsigned int csum_partial_copy_nocheck(const unsigned char *src, unsigned char *dst,
+                                       int len, int sum)
+{
+        memcpy(dst, src, len);
+        return(csum_partial(dst, len, sum));
+}
+
+static __inline__
+unsigned int csum_partial_copy_from_user(const unsigned char *src, unsigned char *dst,
+                                         int len, int sum, int *err_ptr)
+{
+        return csum_partial_copy_from(src, dst, len, sum, err_ptr);
+}
+
+/**
+ * csum_fold - Fold and invert a 32bit checksum.
+ * sum: 32bit unfolded sum
+ *
+ * Fold a 32bit running checksum to 16bit and invert it. This is usually
+ * the last step before putting a checksum into a packet.
+ * Make sure not to mix with 64bit checksums.
+ */
+static inline unsigned int csum_fold(unsigned int sum)
+{
+        __asm__(
+                "  addl %1,%0\n"
+                "  adcl $0xffff,%0"
+                : "=r" (sum)
+                : "r" (sum << 16), "0" (sum & 0xffff0000)
+        );
+        return (~sum) >> 16;
+}
+
+/**
+ * csum_tcpup_nofold - Compute an IPv4 pseudo header checksum.
+ * @saddr: source address
+ * @daddr: destination address
+ * @len: length of packet
+ * @proto: ip protocol of packet
+ * @sum: initial sum to be added in (32bit unfolded)
+ *
+ * Returns the pseudo header checksum the input data. Result is
+ * 32bit unfolded.
+ */
+static inline unsigned long
+csum_tcpudp_nofold(unsigned saddr, unsigned daddr, unsigned short len,
+                   unsigned short proto, unsigned int sum)
+{
+        asm("  addl %1, %0\n"
+            "  adcl %2, %0\n"
+            "  adcl %3, %0\n"
+            "  adcl $0, %0\n"
+                : "=r" (sum)
+            : "g" (daddr), "g" (saddr), "g" ((ntohs(len)<<16)+proto*256), "0" (sum));
+    return sum;
+}
+
+/*
+ * computes the checksum of the TCP/UDP pseudo-header
+ * returns a 16-bit checksum, already complemented
+ */
+static inline unsigned short int csum_tcpudp_magic(unsigned long saddr,
+                                                   unsigned long daddr,
+                                                   unsigned short len,
+                                                   unsigned short proto,
+                                                   unsigned int sum)
+{
+        return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
+}
+
+/**
+ * ip_fast_csum - Compute the IPv4 header checksum efficiently.
+ * iph: ipv4 header
+ * ihl: length of header / 4
+ */
+static inline unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl)
+{
+        unsigned int sum;
+
+        asm(    "  movl (%1), %0\n"
+                "  subl $4, %2\n"
+                "  jbe 2f\n"
+                "  addl 4(%1), %0\n"
+                "  adcl 8(%1), %0\n"
+                "  adcl 12(%1), %0\n"
+                "1: adcl 16(%1), %0\n"
+                "  lea 4(%1), %1\n"
+                "  decl %2\n"
+                "  jne  1b\n"
+                "  adcl $0, %0\n"
+                "  movl %0, %2\n"
+                "  shrl $16, %0\n"
+                "  addw %w2, %w0\n"
+                "  adcl $0, %0\n"
+                "  notl %0\n"
+                "2:"
+        /* Since the input registers which are loaded with iph and ipl
+           are modified, we must also specify them as outputs, or gcc
+           will assume they contain their original values. */
+        : "=r" (sum), "=r" (iph), "=r" (ihl)
+        : "1" (iph), "2" (ihl)
+        : "memory");
+        return(sum);
+}
+
+static inline unsigned add32_with_carry(unsigned a, unsigned b)
+{
+        asm("addl %2,%0\n\t"
+            "adcl $0,%0"
+            : "=r" (a)
+            : "0" (a), "r" (b));
+        return a;
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-x86_64/ptrace.h b/arch/um/include/sysdep-x86_64/ptrace.h
new file mode 100644
index 000000000000..915c82daffbd
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/ptrace.h
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_X86_64_PTRACE_H
+#define __SYSDEP_X86_64_PTRACE_H
+
+#include "uml-config.h"
+#include "user_constants.h"
+
+#define MAX_REG_OFFSET (UM_FRAME_SIZE)
+#define MAX_REG_NR ((MAX_REG_OFFSET) / sizeof(unsigned long))
+
+#ifdef UML_CONFIG_MODE_TT
+#include "sysdep/sc.h"
+#endif
+
+#ifdef UML_CONFIG_MODE_SKAS
+#include "skas_ptregs.h"
+
+#define REGS_IP(r) ((r)[HOST_IP])
+#define REGS_SP(r) ((r)[HOST_SP])
+
+#define REGS_RBX(r) ((r)[HOST_RBX])
+#define REGS_RCX(r) ((r)[HOST_RCX])
+#define REGS_RDX(r) ((r)[HOST_RDX])
+#define REGS_RSI(r) ((r)[HOST_RSI])
+#define REGS_RDI(r) ((r)[HOST_RDI])
+#define REGS_RBP(r) ((r)[HOST_RBP])
+#define REGS_RAX(r) ((r)[HOST_RAX])
+#define REGS_R8(r) ((r)[HOST_R8])
+#define REGS_R9(r) ((r)[HOST_R9])
+#define REGS_R10(r) ((r)[HOST_R10])
+#define REGS_R11(r) ((r)[HOST_R11])
+#define REGS_R12(r) ((r)[HOST_R12])
+#define REGS_R13(r) ((r)[HOST_R13])
+#define REGS_R14(r) ((r)[HOST_R14])
+#define REGS_R15(r) ((r)[HOST_R15])
+#define REGS_CS(r) ((r)[HOST_CS])
+#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
+#define REGS_SS(r) ((r)[HOST_SS])
+
+#define HOST_FS_BASE 21
+#define HOST_GS_BASE 22
+#define HOST_DS 23
+#define HOST_ES 24
+#define HOST_FS 25
+#define HOST_GS 26
+
+#define REGS_FS_BASE(r) ((r)[HOST_FS_BASE])
+#define REGS_GS_BASE(r) ((r)[HOST_GS_BASE])
+#define REGS_DS(r) ((r)[HOST_DS])
+#define REGS_ES(r) ((r)[HOST_ES])
+#define REGS_FS(r) ((r)[HOST_FS])
+#define REGS_GS(r) ((r)[HOST_GS])
+
+#define REGS_ORIG_RAX(r) ((r)[HOST_ORIG_RAX])
+
+#define REGS_SET_SYSCALL_RETURN(r, res) REGS_RAX(r) = (res)
+
+#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
+
+#define REGS_SEGV_IS_FIXABLE(r) SEGV_IS_FIXABLE((r)->trap_type)
+
+#define REGS_FAULT_ADDR(r) ((r)->fault_addr)
+
+#define REGS_FAULT_WRITE(r) FAULT_WRITE((r)->fault_type)
+
+#define REGS_TRAP(r) ((r)->trap_type)
+
+#define REGS_ERR(r) ((r)->fault_type)
+
+#endif
+
+#include "choose-mode.h"
+
+/* XXX */
+union uml_pt_regs {
+#ifdef UML_CONFIG_MODE_TT
+        struct tt_regs {
+                long syscall;
+                unsigned long orig_rax;
+                void *sc;
+        } tt;
+#endif
+#ifdef UML_CONFIG_MODE_SKAS
+        struct skas_regs {
+                /* XXX */
+                unsigned long regs[27];
+                unsigned long fp[65];
+                unsigned long fault_addr;
+                unsigned long fault_type;
+                unsigned long trap_type;
+                long syscall;
+                int is_user;
+        } skas;
+#endif
+};
+
+#define EMPTY_UML_PT_REGS { }
+
+/* XXX */
+extern int mode_tt;
+
+#define UPT_RBX(r) __CHOOSE_MODE(SC_RBX(UPT_SC(r)), REGS_RBX((r)->skas.regs))
+#define UPT_RCX(r) __CHOOSE_MODE(SC_RCX(UPT_SC(r)), REGS_RCX((r)->skas.regs))
+#define UPT_RDX(r) __CHOOSE_MODE(SC_RDX(UPT_SC(r)), REGS_RDX((r)->skas.regs))
+#define UPT_RSI(r) __CHOOSE_MODE(SC_RSI(UPT_SC(r)), REGS_RSI((r)->skas.regs))
+#define UPT_RDI(r) __CHOOSE_MODE(SC_RDI(UPT_SC(r)), REGS_RDI((r)->skas.regs))
+#define UPT_RBP(r) __CHOOSE_MODE(SC_RBP(UPT_SC(r)), REGS_RBP((r)->skas.regs))
+#define UPT_RAX(r) __CHOOSE_MODE(SC_RAX(UPT_SC(r)), REGS_RAX((r)->skas.regs))
+#define UPT_R8(r) __CHOOSE_MODE(SC_R8(UPT_SC(r)), REGS_R8((r)->skas.regs))
+#define UPT_R9(r) __CHOOSE_MODE(SC_R9(UPT_SC(r)), REGS_R9((r)->skas.regs))
+#define UPT_R10(r) __CHOOSE_MODE(SC_R10(UPT_SC(r)), REGS_R10((r)->skas.regs))
+#define UPT_R11(r) __CHOOSE_MODE(SC_R11(UPT_SC(r)), REGS_R11((r)->skas.regs))
+#define UPT_R12(r) __CHOOSE_MODE(SC_R12(UPT_SC(r)), REGS_R12((r)->skas.regs))
+#define UPT_R13(r) __CHOOSE_MODE(SC_R13(UPT_SC(r)), REGS_R13((r)->skas.regs))
+#define UPT_R14(r) __CHOOSE_MODE(SC_R14(UPT_SC(r)), REGS_R14((r)->skas.regs))
+#define UPT_R15(r) __CHOOSE_MODE(SC_R15(UPT_SC(r)), REGS_R15((r)->skas.regs))
+#define UPT_CS(r) __CHOOSE_MODE(SC_CS(UPT_SC(r)), REGS_CS((r)->skas.regs))
+#define UPT_FS(r) __CHOOSE_MODE(SC_FS(UPT_SC(r)), REGS_FS((r)->skas.regs))
+#define UPT_GS(r) __CHOOSE_MODE(SC_GS(UPT_SC(r)), REGS_GS((r)->skas.regs))
+#define UPT_DS(r) __CHOOSE_MODE(SC_DS(UPT_SC(r)), REGS_DS((r)->skas.regs))
+#define UPT_ES(r) __CHOOSE_MODE(SC_ES(UPT_SC(r)), REGS_ES((r)->skas.regs))
+#define UPT_CS(r) __CHOOSE_MODE(SC_CS(UPT_SC(r)), REGS_CS((r)->skas.regs))
+#define UPT_ORIG_RAX(r) \
+        __CHOOSE_MODE((r)->tt.orig_rax, REGS_ORIG_RAX((r)->skas.regs))
+
+#define UPT_IP(r) __CHOOSE_MODE(SC_IP(UPT_SC(r)), REGS_IP((r)->skas.regs))
+#define UPT_SP(r) __CHOOSE_MODE(SC_SP(UPT_SC(r)), REGS_SP((r)->skas.regs))
+
+#define UPT_EFLAGS(r) \
+        __CHOOSE_MODE(SC_EFLAGS(UPT_SC(r)), REGS_EFLAGS((r)->skas.regs))
+#define UPT_SC(r) ((r)->tt.sc)
+#define UPT_SYSCALL_NR(r) __CHOOSE_MODE((r)->tt.syscall, (r)->skas.syscall)
+
+extern int user_context(unsigned long sp);
+
+#define UPT_IS_USER(r) \
+        CHOOSE_MODE(user_context(UPT_SP(r)), (r)->skas.is_user)
+
+#define UPT_SYSCALL_ARG1(r) UPT_RDI(r)
+#define UPT_SYSCALL_ARG2(r) UPT_RSI(r)
+#define UPT_SYSCALL_ARG3(r) UPT_RDX(r)
+#define UPT_SYSCALL_ARG4(r) UPT_R10(r)
+#define UPT_SYSCALL_ARG5(r) UPT_R8(r)
+#define UPT_SYSCALL_ARG6(r) UPT_R9(r)
+
+struct syscall_args {
+        unsigned long args[6];
+};
+
+#define SYSCALL_ARGS(r) ((struct syscall_args) \
+                        { .args = { UPT_SYSCALL_ARG1(r), \
+                                    UPT_SYSCALL_ARG2(r), \
+                                    UPT_SYSCALL_ARG3(r), \
+                                    UPT_SYSCALL_ARG4(r), \
+                                    UPT_SYSCALL_ARG5(r), \
+                                    UPT_SYSCALL_ARG6(r) } } )
+
+#define UPT_REG(regs, reg) \
+        ({      unsigned long val; \
+                switch(reg){ \
+                case R8: val = UPT_R8(regs); break; \
+                case R9: val = UPT_R9(regs); break; \
+                case R10: val = UPT_R10(regs); break; \
+                case R11: val = UPT_R11(regs); break; \
+                case R12: val = UPT_R12(regs); break; \
+                case R13: val = UPT_R13(regs); break; \
+                case R14: val = UPT_R14(regs); break; \
+                case R15: val = UPT_R15(regs); break; \
+                case RIP: val = UPT_IP(regs); break; \
+                case RSP: val = UPT_SP(regs); break; \
+                case RAX: val = UPT_RAX(regs); break; \
+                case RBX: val = UPT_RBX(regs); break; \
+                case RCX: val = UPT_RCX(regs); break; \
+                case RDX: val = UPT_RDX(regs); break; \
+                case RSI: val = UPT_RSI(regs); break; \
+                case RDI: val = UPT_RDI(regs); break; \
+                case RBP: val = UPT_RBP(regs); break; \
+                case ORIG_RAX: val = UPT_ORIG_RAX(regs); break; \
+                case CS: val = UPT_CS(regs); break; \
+                case DS: val = UPT_DS(regs); break; \
+                case ES: val = UPT_ES(regs); break; \
+                case FS: val = UPT_FS(regs); break; \
+                case GS: val = UPT_GS(regs); break; \
+                case EFLAGS: val = UPT_EFLAGS(regs); break; \
+                default :  \
+                        panic("Bad register in UPT_REG : %d\n", reg);  \
+                        val = -1; \
+                } \
+                val; \
+        })
+
+
+#define UPT_SET(regs, reg, val) \
+        ({      unsigned long val; \
+                switch(reg){ \
+                case R8: UPT_R8(regs) = val; break; \
+                case R9: UPT_R9(regs) = val; break; \
+                case R10: UPT_R10(regs) = val; break; \
+                case R11: UPT_R11(regs) = val; break; \
+                case R12: UPT_R12(regs) = val; break; \
+                case R13: UPT_R13(regs) = val; break; \
+                case R14: UPT_R14(regs) = val; break; \
+                case R15: UPT_R15(regs) = val; break; \
+                case RIP: UPT_IP(regs) = val; break; \
+                case RSP: UPT_SP(regs) = val; break; \
+                case RAX: UPT_RAX(regs) = val; break; \
+                case RBX: UPT_RBX(regs) = val; break; \
+                case RCX: UPT_RCX(regs) = val; break; \
+                case RDX: UPT_RDX(regs) = val; break; \
+                case RSI: UPT_RSI(regs) = val; break; \
+                case RDI: UPT_RDI(regs) = val; break; \
+                case RBP: UPT_RBP(regs) = val; break; \
+                case ORIG_RAX: UPT_ORIG_RAX(regs) = val; break; \
+                case CS: UPT_CS(regs) = val; break; \
+                case DS: UPT_DS(regs) = val; break; \
+                case ES: UPT_ES(regs) = val; break; \
+                case FS: UPT_FS(regs) = val; break; \
+                case GS: UPT_GS(regs) = val; break; \
+                case EFLAGS: UPT_EFLAGS(regs) = val; break; \
+                default :  \
+                        panic("Bad register in UPT_SET : %d\n", reg);  \
+                        break; \
+                } \
+                val; \
+        })
+
+#define UPT_SET_SYSCALL_RETURN(r, res) \
+        CHOOSE_MODE(SC_SET_SYSCALL_RETURN(UPT_SC(r), (res)), \
+                    REGS_SET_SYSCALL_RETURN((r)->skas.regs, (res)))
+
+#define UPT_RESTART_SYSCALL(r) \
+        CHOOSE_MODE(SC_RESTART_SYSCALL(UPT_SC(r)), \
+                    REGS_RESTART_SYSCALL((r)->skas.regs))
+
+#define UPT_SEGV_IS_FIXABLE(r) \
+        CHOOSE_MODE(SC_SEGV_IS_FIXABLE(UPT_SC(r)), \
+                    REGS_SEGV_IS_FIXABLE(&r->skas))
+
+#define UPT_FAULT_ADDR(r) \
+        __CHOOSE_MODE(SC_FAULT_ADDR(UPT_SC(r)), REGS_FAULT_ADDR(&r->skas))
+
+#define UPT_FAULT_WRITE(r) \
+        CHOOSE_MODE(SC_FAULT_WRITE(UPT_SC(r)), REGS_FAULT_WRITE(&r->skas))
+
+#define UPT_TRAP(r) __CHOOSE_MODE(SC_TRAP_TYPE(UPT_SC(r)), REGS_TRAP(&r->skas))
+#define UPT_ERR(r) __CHOOSE_MODE(SC_FAULT_TYPE(UPT_SC(r)), REGS_ERR(&r->skas))
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-x86_64/ptrace_user.h b/arch/um/include/sysdep-x86_64/ptrace_user.h
new file mode 100644
index 000000000000..31729973fb14
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/ptrace_user.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_X86_64_PTRACE_USER_H__
+#define __SYSDEP_X86_64_PTRACE_USER_H__
+
+#define __FRAME_OFFSETS
+#include <sys/ptrace.h>
+#include <linux/ptrace.h>
+#include <asm/ptrace.h>
+#undef __FRAME_OFFSETS
+
+#define PT_INDEX(off) ((off) / sizeof(unsigned long))
+
+#define PT_SYSCALL_NR(regs) ((regs)[PT_INDEX(ORIG_RAX)])
+#define PT_SYSCALL_NR_OFFSET (ORIG_RAX)
+
+#define PT_SYSCALL_ARG1(regs) (((unsigned long *) (regs))[PT_INDEX(RDI)])
+#define PT_SYSCALL_ARG1_OFFSET (RDI)
+
+#define PT_SYSCALL_ARG2(regs) (((unsigned long *) (regs))[PT_INDEX(RSI)])
+#define PT_SYSCALL_ARG2_OFFSET (RSI)
+
+#define PT_SYSCALL_ARG3(regs) (((unsigned long *) (regs))[PT_INDEX(RDX)])
+#define PT_SYSCALL_ARG3_OFFSET (RDX)
+
+#define PT_SYSCALL_ARG4(regs) (((unsigned long *) (regs))[PT_INDEX(RCX)])
+#define PT_SYSCALL_ARG4_OFFSET (RCX)
+
+#define PT_SYSCALL_ARG5(regs) (((unsigned long *) (regs))[PT_INDEX(R8)])
+#define PT_SYSCALL_ARG5_OFFSET (R8)
+
+#define PT_SYSCALL_ARG6(regs) (((unsigned long *) (regs))[PT_INDEX(R9)])
+#define PT_SYSCALL_ARG6_OFFSET (R9)
+
+#define PT_SYSCALL_RET_OFFSET (RAX)
+
+#define PT_IP_OFFSET (RIP)
+#define PT_IP(regs) ((regs)[PT_INDEX(RIP)])
+
+#define PT_SP_OFFSET (RSP)
+#define PT_SP(regs) ((regs)[PT_INDEX(RSP)])
+
+#define PT_ORIG_RAX_OFFSET (ORIG_RAX)
+#define PT_ORIG_RAX(regs) ((regs)[PT_INDEX(ORIG_RAX)])
+
+/* x86_64 FC3 doesn't define this in /usr/include/linux/ptrace.h even though
+ * it's defined in the kernel's include/linux/ptrace.h. Additionally, use the
+ * 2.4 name and value for 2.4 host compatibility.
+ */
+#ifndef PTRACE_OLDSETOPTIONS
+#define PTRACE_OLDSETOPTIONS 21
+#endif
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-x86_64/sigcontext.h b/arch/um/include/sysdep-x86_64/sigcontext.h
new file mode 100644
index 000000000000..1e38a54ff4cf
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/sigcontext.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_X86_64_SIGCONTEXT_H
+#define __SYSDEP_X86_64_SIGCONTEXT_H
+
+#include <sysdep/sc.h>
+
+#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
+
+#define SC_RESTART_SYSCALL(sc) IP_RESTART_SYSCALL(SC_IP(sc))
+#define SC_SET_SYSCALL_RETURN(sc, result) SC_RAX(sc) = (result)
+
+#define SC_FAULT_ADDR(sc) SC_CR2(sc)
+#define SC_FAULT_TYPE(sc) SC_ERR(sc)
+
+#define FAULT_WRITE(err) ((err) & 2)
+
+#define SC_FAULT_WRITE(sc) FAULT_WRITE(SC_FAULT_TYPE(sc))
+
+#define SC_TRAP_TYPE(sc) SC_TRAPNO(sc)
+
+/* ptrace expects that, at the start of a system call, %eax contains
+ * -ENOSYS, so this makes it so.
+ */
+
+#define SC_START_SYSCALL(sc) do SC_RAX(sc) = -ENOSYS; while(0)
+
+#define SEGV_IS_FIXABLE(trap) ((trap) == 14)
+#define SC_SEGV_IS_FIXABLE(sc) SEGV_IS_FIXABLE(SC_TRAP_TYPE(sc))
+
+extern unsigned long *sc_sigmask(void *sc_ptr);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
+
diff --git a/arch/um/include/sysdep-x86_64/signal.h b/arch/um/include/sysdep-x86_64/signal.h
new file mode 100644
index 000000000000..e5e52756fab4
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/signal.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#ifndef __X86_64_SIGNAL_H_
+#define __X86_64_SIGNAL_H_
+
+#define ARCH_GET_SIGCONTEXT(sc, sig_addr) \
+        do { \
+                struct ucontext *__uc; \
+                asm("movq %%rdx, %0" : "=r" (__uc)); \
+                sc = (struct sigcontext *) &__uc->uc_mcontext; \
+        } while(0)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysdep-x86_64/syscalls.h b/arch/um/include/sysdep-x86_64/syscalls.h
new file mode 100644
index 000000000000..b187a4157ff3
--- /dev/null
+++ b/arch/um/include/sysdep-x86_64/syscalls.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#ifndef __SYSDEP_X86_64_SYSCALLS_H__
+#define __SYSDEP_X86_64_SYSCALLS_H__
+
+#include <linux/msg.h>
+#include <linux/shm.h>
+
+typedef long syscall_handler_t(void);
+
+extern syscall_handler_t *ia32_sys_call_table[];
+
+#define EXECUTE_SYSCALL(syscall, regs) \
+        (((long (*)(long, long, long, long, long, long)) \
+          (*sys_call_table[syscall]))(UPT_SYSCALL_ARG1(&regs->regs), \
+                                      UPT_SYSCALL_ARG2(&regs->regs), \
+                                      UPT_SYSCALL_ARG3(&regs->regs), \
+                                      UPT_SYSCALL_ARG4(&regs->regs), \
+                                      UPT_SYSCALL_ARG5(&regs->regs), \
+                                      UPT_SYSCALL_ARG6(&regs->regs)))
+
+extern long old_mmap(unsigned long addr, unsigned long len,
+                     unsigned long prot, unsigned long flags,
+                     unsigned long fd, unsigned long pgoff);
+extern syscall_handler_t wrap_sys_shmat;
+extern syscall_handler_t sys_modify_ldt;
+extern syscall_handler_t sys_arch_prctl;
+
+#define ARCH_SYSCALLS \
+        [ __NR_mmap ] = (syscall_handler_t *) old_mmap, \
+        [ __NR_select ] = (syscall_handler_t *) sys_select, \
+        [ __NR_mincore ] = (syscall_handler_t *) sys_mincore, \
+        [ __NR_madvise ] = (syscall_handler_t *) sys_madvise, \
+        [ __NR_shmget ] = (syscall_handler_t *) sys_shmget, \
+        [ __NR_shmat ] = (syscall_handler_t *) wrap_sys_shmat, \
+        [ __NR_shmctl ] = (syscall_handler_t *) sys_shmctl, \
+        [ __NR_semop ] = (syscall_handler_t *) sys_semop, \
+        [ __NR_semget ] = (syscall_handler_t *) sys_semget, \
+        [ __NR_semctl ] = (syscall_handler_t *) sys_semctl, \
+        [ __NR_shmdt ] = (syscall_handler_t *) sys_shmdt, \
+        [ __NR_msgget ] = (syscall_handler_t *) sys_msgget, \
+        [ __NR_msgsnd ] = (syscall_handler_t *) sys_msgsnd, \
+        [ __NR_msgrcv ] = (syscall_handler_t *) sys_msgrcv, \
+        [ __NR_msgctl ] = (syscall_handler_t *) sys_msgctl, \
+        [ __NR_pivot_root ] = (syscall_handler_t *) sys_pivot_root, \
+        [ __NR_tuxcall ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_security ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_epoll_ctl_old ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_epoll_wait_old ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_modify_ldt ] = (syscall_handler_t *) sys_modify_ldt, \
+        [ __NR_arch_prctl ] = (syscall_handler_t *) sys_arch_prctl, \
+        [ __NR_socket ] = (syscall_handler_t *) sys_socket, \
+        [ __NR_connect ] = (syscall_handler_t *) sys_connect, \
+        [ __NR_accept ] = (syscall_handler_t *) sys_accept, \
+        [ __NR_recvfrom ] = (syscall_handler_t *) sys_recvfrom, \
+        [ __NR_recvmsg ] = (syscall_handler_t *) sys_recvmsg, \
+        [ __NR_sendmsg ] = (syscall_handler_t *) sys_sendmsg, \
+        [ __NR_bind ] = (syscall_handler_t *) sys_bind, \
+        [ __NR_listen ] = (syscall_handler_t *) sys_listen, \
+        [ __NR_getsockname ] = (syscall_handler_t *) sys_getsockname, \
+        [ __NR_getpeername ] = (syscall_handler_t *) sys_getpeername, \
+        [ __NR_socketpair ] = (syscall_handler_t *) sys_socketpair, \
+        [ __NR_sendto ] = (syscall_handler_t *) sys_sendto, \
+        [ __NR_shutdown ] = (syscall_handler_t *) sys_shutdown, \
+        [ __NR_setsockopt ] = (syscall_handler_t *) sys_setsockopt, \
+        [ __NR_getsockopt ] = (syscall_handler_t *) sys_getsockopt, \
+        [ __NR_iopl ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_set_thread_area ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_get_thread_area ] = (syscall_handler_t *) sys_ni_syscall, \
+        [ __NR_semtimedop ] = (syscall_handler_t *) sys_semtimedop, \
+        [ 251 ] = (syscall_handler_t *) sys_ni_syscall,
+
+#define LAST_ARCH_SYSCALL 251
+#define NR_syscalls 1024
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/sysrq.h b/arch/um/include/sysrq.h
new file mode 100644
index 000000000000..2ce9423460b3
--- /dev/null
+++ b/arch/um/include/sysrq.h
@@ -0,0 +1,6 @@
+#ifndef __UM_SYSRQ_H
+#define __UM_SYSRQ_H
+
+extern void show_trace(unsigned long *stack);
+
+#endif
diff --git a/arch/um/include/tempfile.h b/arch/um/include/tempfile.h
new file mode 100644
index 000000000000..e36d9e0f5105
--- /dev/null
+++ b/arch/um/include/tempfile.h
@@ -0,0 +1,21 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TEMPFILE_H__
+#define __TEMPFILE_H__
+
+extern int make_tempfile(const char *template, char **tempname, int do_unlink);
+
+#endif
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/time_user.h b/arch/um/include/time_user.h
new file mode 100644
index 000000000000..6793a2fcd0ae
--- /dev/null
+++ b/arch/um/include/time_user.h
@@ -0,0 +1,18 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TIME_USER_H__
+#define __TIME_USER_H__
+
+extern void timer(void);
+extern void switch_timers(int to_real);
+extern void set_interval(int timer_type);
+extern void idle_sleep(int secs);
+extern void enable_timer(void);
+extern void disable_timer(void);
+extern unsigned long time_lock(void);
+extern void time_unlock(unsigned long);
+
+#endif
diff --git a/arch/um/include/tlb.h b/arch/um/include/tlb.h
new file mode 100644
index 000000000000..da1097285b8c
--- /dev/null
+++ b/arch/um/include/tlb.h
@@ -0,0 +1,67 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TLB_H__
+#define __TLB_H__
+
+#include "um_mmu.h"
+
+struct host_vm_op {
+        enum { MMAP, MUNMAP, MPROTECT } type;
+        union {
+                struct {
+                        unsigned long addr;
+                        unsigned long len;
+                        unsigned int r:1;
+                        unsigned int w:1;
+                        unsigned int x:1;
+                        int fd;
+                        __u64 offset;
+                } mmap;
+                struct {
+                        unsigned long addr;
+                        unsigned long len;
+                } munmap;
+                struct {
+                        unsigned long addr;
+                        unsigned long len;
+                        unsigned int r:1;
+                        unsigned int w:1;
+                        unsigned int x:1;
+                } mprotect;
+        } u;
+};
+
+extern void mprotect_kernel_vm(int w);
+extern void force_flush_all(void);
+extern void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
+                             unsigned long end_addr, int force, int data,
+                             void (*do_ops)(int, struct host_vm_op *, int));
+extern int flush_tlb_kernel_range_common(unsigned long start,
+                                         unsigned long end);
+
+extern int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
+                    int r, int w, int x, struct host_vm_op *ops, int index,
+                    int last_filled, int data,
+                    void (*do_ops)(int, struct host_vm_op *, int));
+extern int add_munmap(unsigned long addr, unsigned long len,
+                      struct host_vm_op *ops, int index, int last_filled,
+                      int data, void (*do_ops)(int, struct host_vm_op *, int));
+extern int add_mprotect(unsigned long addr, unsigned long len, int r, int w,
+                        int x, struct host_vm_op *ops, int index,
+                        int last_filled, int data,
+                        void (*do_ops)(int, struct host_vm_op *, int));
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/ubd_user.h b/arch/um/include/ubd_user.h
new file mode 100644
index 000000000000..bb66517f0739
--- /dev/null
+++ b/arch/um/include/ubd_user.h
@@ -0,0 +1,26 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001 RidgeRun, Inc (glonnon@ridgerun.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_UBD_USER_H
+#define __UM_UBD_USER_H
+
+extern void ignore_sigwinch_sig(void);
+extern int start_io_thread(unsigned long sp, int *fds_out);
+extern int io_thread(void *arg);
+extern int kernel_fd;
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/um_mmu.h b/arch/um/include/um_mmu.h
new file mode 100644
index 000000000000..0fa643238300
--- /dev/null
+++ b/arch/um/include/um_mmu.h
@@ -0,0 +1,40 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __ARCH_UM_MMU_H
+#define __ARCH_UM_MMU_H
+
+#include "uml-config.h"
+#include "choose-mode.h"
+
+#ifdef UML_CONFIG_MODE_TT
+#include "mmu-tt.h"
+#endif
+
+#ifdef UML_CONFIG_MODE_SKAS
+#include "mmu-skas.h"
+#endif
+
+typedef union mm_context {
+#ifdef UML_CONFIG_MODE_TT
+        struct mmu_context_tt tt;
+#endif
+#ifdef UML_CONFIG_MODE_SKAS
+        struct mmu_context_skas skas;
+#endif
+} mm_context_t;
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/um_uaccess.h b/arch/um/include/um_uaccess.h
new file mode 100644
index 000000000000..6e348cb6de24
--- /dev/null
+++ b/arch/um/include/um_uaccess.h
@@ -0,0 +1,125 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __ARCH_UM_UACCESS_H
+#define __ARCH_UM_UACCESS_H
+
+#include "linux/config.h"
+#include "choose-mode.h"
+
+#ifdef CONFIG_MODE_TT
+#include "uaccess-tt.h"
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+#include "uaccess-skas.h"
+#endif
+
+#define access_ok(type, addr, size) \
+        CHOOSE_MODE_PROC(access_ok_tt, access_ok_skas, type, addr, size)
+
+/* this function will go away soon - use access_ok() instead */
+static inline int __deprecated verify_area(int type, const void __user *addr, unsigned long size)
+{
+        return (CHOOSE_MODE_PROC(verify_area_tt, verify_area_skas, type, addr,
+                                size));
+}
+
+static inline int copy_from_user(void *to, const void __user *from, int n)
+{
+        return(CHOOSE_MODE_PROC(copy_from_user_tt, copy_from_user_skas, to,
+                                from, n));
+}
+
+static inline int copy_to_user(void __user *to, const void *from, int n)
+{
+        return(CHOOSE_MODE_PROC(copy_to_user_tt, copy_to_user_skas, to, 
+                                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 __user *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 __user *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 __user *str, long len)
+{
+        return(CHOOSE_MODE_PROC(strnlen_user_tt, strnlen_user_skas, str, len));
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/umid.h b/arch/um/include/umid.h
new file mode 100644
index 000000000000..11373c851f15
--- /dev/null
+++ b/arch/um/include/umid.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UMID_H__
+#define __UMID_H__
+
+extern int umid_file_name(char *name, char *buf, int len);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/uml_uaccess.h b/arch/um/include/uml_uaccess.h
new file mode 100644
index 000000000000..f77eb6428453
--- /dev/null
+++ b/arch/um/include/uml_uaccess.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UML_UACCESS_H__
+#define __UML_UACCESS_H__
+
+extern int __do_copy_to_user(void *to, const void *from, int n,
+                             void **fault_addr, void **fault_catcher);
+extern unsigned long __do_user_copy(void *to, const void *from, int n,
+                                    void **fault_addr, void **fault_catcher,
+                                    void (*op)(void *to, const void *from,
+                                               int n), int *faulted_out);
+void __do_copy(void *to, const void *from, int n);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/user.h b/arch/um/include/user.h
new file mode 100644
index 000000000000..57ee9e261228
--- /dev/null
+++ b/arch/um/include/user.h
@@ -0,0 +1,32 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __USER_H__
+#define __USER_H__
+
+extern void panic(const char *fmt, ...);
+extern int printk(const char *fmt, ...);
+extern void schedule(void);
+extern void *um_kmalloc(int size);
+extern void *um_kmalloc_atomic(int size);
+extern void kfree(void *ptr);
+extern int in_aton(char *str);
+extern int open_gdb_chan(void);
+extern int strlcpy(char *, const char *, int);
+extern void *um_vmalloc(int size);
+extern void vfree(void *ptr);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/include/user_util.h b/arch/um/include/user_util.h
new file mode 100644
index 000000000000..103cd320386c
--- /dev/null
+++ b/arch/um/include/user_util.h
@@ -0,0 +1,106 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __USER_UTIL_H__
+#define __USER_UTIL_H__
+
+#include "sysdep/ptrace.h"
+
+#define CATCH_EINTR(expr) while ((errno = 0, ((expr) < 0)) && (errno == EINTR))
+
+extern int mode_tt;
+
+extern int grantpt(int __fd);
+extern int unlockpt(int __fd);
+extern char *ptsname(int __fd);
+
+struct cpu_task {
+        int pid;
+        void *task;
+};
+
+extern struct cpu_task cpu_tasks[];
+
+struct signal_info {
+        void (*handler)(int, union uml_pt_regs *);
+        int is_irq;
+};
+
+extern struct signal_info sig_info[];
+
+extern unsigned long low_physmem;
+extern unsigned long high_physmem;
+extern unsigned long uml_physmem;
+extern unsigned long uml_reserved;
+extern unsigned long end_vm;
+extern unsigned long start_vm;
+extern unsigned long highmem;
+
+extern char host_info[];
+
+extern char saved_command_line[];
+extern char command_line[];
+
+extern char *tempdir;
+
+extern unsigned long _stext, _etext, _sdata, _edata, __bss_start, _end;
+extern unsigned long _unprotected_end;
+extern unsigned long brk_start;
+
+extern int pty_output_sigio;
+extern int pty_close_sigio;
+
+extern void stop(void);
+extern void stack_protections(unsigned long address);
+extern void task_protections(unsigned long address);
+extern int wait_for_stop(int pid, int sig, int cont_type, void *relay);
+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 linux_main(int argc, char **argv);
+extern void set_cmdline(char *cmd);
+extern void input_cb(void (*proc)(void *), void *arg, int arg_len);
+extern int get_pty(void);
+extern void *um_kmalloc(int size);
+extern int switcheroo(int fd, int prot, void *from, void *to, int size);
+extern void setup_machinename(char *machine_out);
+extern void setup_hostinfo(void);
+extern void add_arg(char *arg);
+extern void init_new_thread_stack(void *sig_stack, void (*usr1_handler)(int));
+extern void init_new_thread_signals(int altstack);
+extern void do_exec(int old_pid, int new_pid);
+extern void tracer_panic(char *msg, ...);
+extern char *get_umid(int only_if_set);
+extern void do_longjmp(void *p, int val);
+extern int detach(int pid, int sig);
+extern int attach(int pid);
+extern void kill_child_dead(int pid);
+extern int cont(int pid);
+extern void check_ptrace(void);
+extern void check_sigio(void);
+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);
+extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
+extern int raw(int fd);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/Makefile b/arch/um/kernel/Makefile
new file mode 100644
index 000000000000..dc796c1bf39e
--- /dev/null
+++ b/arch/um/kernel/Makefile
@@ -0,0 +1,58 @@
+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+extra-y := vmlinux.lds
+clean-files := vmlinux.lds.S config.tmp
+
+obj-y = checksum.o config.o exec_kern.o exitcode.o \
+        helper.o init_task.o irq.o irq_user.o ksyms.o main.o mem.o mem_user.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 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_util.o
+
+obj-$(CONFIG_BLK_DEV_INITRD) += initrd_kern.o initrd_user.o
+obj-$(CONFIG_GPROF)     += gprof_syms.o
+obj-$(CONFIG_GCOV)      += gmon_syms.o
+obj-$(CONFIG_TTY_LOG)   += tty_log.o
+obj-$(CONFIG_SYSCALL_DEBUG) += syscall_user.o
+
+obj-$(CONFIG_MODE_TT) += tt/
+obj-$(CONFIG_MODE_SKAS) += skas/
+
+# This needs be compiled with frame pointers regardless of how the rest of the
+# kernel is built.
+CFLAGS_frame.o := -fno-omit-frame-pointer
+
+user-objs-$(CONFIG_TTY_LOG) += tty_log.o
+
+USER_OBJS := $(user-objs-y) config.o helper.o main.o process.o tempfile.o \
+        time.o tty_log.o umid.o user_util.o frame.o
+
+include arch/um/scripts/Makefile.rules
+
+targets += config.c
+
+# Be careful with the below Sed code - sed is pitfall-rich!
+# We use sed to lower build requirements, for "embedded" builders for instance.
+
+$(obj)/config.tmp: $(objtree)/.config FORCE
+        $(call if_changed,quote1)
+
+quiet_cmd_quote1 = QUOTE   $@
+      cmd_quote1 = sed -e 's/"/\\"/g' -e 's/^/"/' -e 's/$$/\\n"/' \
+                   $< > $@
+
+$(obj)/config.c: $(src)/config.c.in $(obj)/config.tmp FORCE
+        $(call if_changed,quote2)
+
+quiet_cmd_quote2 = QUOTE   $@
+      cmd_quote2 = sed -e '/CONFIG/{'          \
+                  -e 's/"CONFIG"\;/""/'        \
+                  -e 'r $(obj)/config.tmp'     \
+                  -e 'a""\;'                   \
+                  -e '}'                       \
+                  $< > $@
diff --git a/arch/um/kernel/checksum.c b/arch/um/kernel/checksum.c
new file mode 100644
index 000000000000..e69b2be951d1
--- /dev/null
+++ b/arch/um/kernel/checksum.c
@@ -0,0 +1,36 @@
+#include "asm/uaccess.h"
+#include "linux/errno.h"
+#include "linux/module.h"
+
+unsigned int arch_csum_partial(const unsigned char *buff, int len, int sum);
+
+unsigned int csum_partial(unsigned char *buff, int len, int sum)
+{
+        return arch_csum_partial(buff, len, sum);
+}
+
+EXPORT_SYMBOL(csum_partial);
+
+unsigned int csum_partial_copy_to(const unsigned char *src,
+                                  unsigned char __user *dst, int len, int sum,
+                                  int *err_ptr)
+{
+        if(copy_to_user(dst, src, len)){
+                *err_ptr = -EFAULT;
+                return(-1);
+        }
+
+        return(arch_csum_partial(src, len, sum));
+}
+
+unsigned int csum_partial_copy_from(const unsigned char __user *src,
+                                    unsigned char *dst, int len, int sum,
+                                    int *err_ptr)
+{
+        if(copy_from_user(dst, src, len)){
+                *err_ptr = -EFAULT;
+                return(-1);
+        }
+
+        return arch_csum_partial(dst, len, sum);
+}
diff --git a/arch/um/kernel/config.c.in b/arch/um/kernel/config.c.in
new file mode 100644
index 000000000000..c062cbfe386e
--- /dev/null
+++ b/arch/um/kernel/config.c.in
@@ -0,0 +1,32 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "init.h"
+
+static __initdata char *config = "CONFIG";
+
+static int __init print_config(char *line, int *add)
+{
+        printf("%s", config);
+        exit(0);
+}
+
+__uml_setup("--showconfig", print_config,
+"--showconfig\n"
+"    Prints the config file that this UML binary was generated from.\n\n"
+);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/dyn.lds.S b/arch/um/kernel/dyn.lds.S
new file mode 100644
index 000000000000..715b0838a68c
--- /dev/null
+++ b/arch/um/kernel/dyn.lds.S
@@ -0,0 +1,176 @@
+#include <asm-generic/vmlinux.lds.h>
+
+OUTPUT_FORMAT(ELF_FORMAT)
+OUTPUT_ARCH(ELF_ARCH)
+ENTRY(_start)
+jiffies = jiffies_64;
+
+SECTIONS
+{
+  PROVIDE (__executable_start = START);
+  . = START + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  /* Used in arch/um/kernel/mem.c. Any memory between START and __binary_start
+   * is remapped.*/
+  __binary_start = .;
+  . = ALIGN(4096);              /* Init code and data */
+  _stext = .;
+  __init_begin = .;
+  .init.text : {
+        _sinittext = .;
+        *(.init.text)
+        _einittext = .;
+  }
+
+  . = ALIGN(4096);
+
+  /* Read-only sections, merged into text segment: */
+  .hash           : { *(.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+  .rel.init       : { *(.rel.init) }
+  .rela.init      : { *(.rela.init) }
+  .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
+  .rela.text      : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
+  .rel.fini       : { *(.rel.fini) }
+  .rela.fini      : { *(.rela.fini) }
+  .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
+  .rela.rodata    : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
+  .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
+  .rela.data      : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
+  .rel.tdata      : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
+  .rela.tdata     : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
+  .rel.tbss       : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
+  .rela.tbss      : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
+  .rel.ctors      : { *(.rel.ctors) }
+  .rela.ctors     : { *(.rela.ctors) }
+  .rel.dtors      : { *(.rel.dtors) }
+  .rela.dtors     : { *(.rela.dtors) }
+  .rel.got        : { *(.rel.got) }
+  .rela.got       : { *(.rela.got) }
+  .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
+  .rela.bss       : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
+  .rel.plt        : { *(.rel.plt) }
+  .rela.plt       : { *(.rela.plt) }
+  .init           : {
+    KEEP (*(.init))
+  } =0x90909090
+  .plt            : { *(.plt) }
+  .text           : {
+    *(.text)
+    SCHED_TEXT
+    LOCK_TEXT
+    *(.fixup)
+    *(.stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+  } =0x90909090
+  .fini           : {
+    KEEP (*(.fini))
+  } =0x90909090
+
+  .kstrtab : { *(.kstrtab) }
+
+  #include "asm/common.lds.S"
+
+  init.data : { *(.init.data) }
+
+  /* Ensure the __preinit_array_start label is properly aligned.  We
+     could instead move the label definition inside the section, but
+     the linker would then create the section even if it turns out to
+     be empty, which isn't pretty.  */
+  . = ALIGN(32 / 8);
+  .preinit_array     : { *(.preinit_array) }
+  .init_array     : { *(.init_array) }
+  .fini_array     : { *(.fini_array) }
+  .data           : {
+    . = ALIGN(KERNEL_STACK_SIZE);               /* init_task */
+    *(.data.init_task)
+    *(.data .data.* .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+  }
+  .data1          : { *(.data1) }
+  .tdata          : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
+  .tbss           : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
+  .eh_frame       : { KEEP (*(.eh_frame)) }
+  .gcc_except_table   : { *(.gcc_except_table) }
+  .dynamic        : { *(.dynamic) }
+  .ctors          : {
+    /* gcc uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    /* We don't want to include the .ctor section from
+       from the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          : {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  .jcr            : { KEEP (*(.jcr)) }
+  .got            : { *(.got.plt) *(.got) }
+  _edata = .;
+  PROVIDE (edata = .);
+  __bss_start = .;
+  .bss            : {
+   *(.dynbss)
+   *(.bss .bss.* .gnu.linkonce.b.*)
+   *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections.  */
+   . = ALIGN(32 / 8);
+  . = ALIGN(32 / 8);
+  }
+  _end = .;
+  PROVIDE (end = .);
+   /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+}
diff --git a/arch/um/kernel/exec_kern.c b/arch/um/kernel/exec_kern.c
new file mode 100644
index 000000000000..49ddabe69be7
--- /dev/null
+++ b/arch/um/kernel/exec_kern.c
@@ -0,0 +1,91 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/slab.h"
+#include "linux/smp_lock.h"
+#include "linux/ptrace.h"
+#include "asm/ptrace.h"
+#include "asm/pgtable.h"
+#include "asm/tlbflush.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "mem_user.h"
+#include "kern.h"
+#include "irq_user.h"
+#include "tlb.h"
+#include "2_5compat.h"
+#include "os.h"
+#include "time_user.h"
+#include "choose-mode.h"
+#include "mode_kern.h"
+
+void flush_thread(void)
+{
+        CHOOSE_MODE(flush_thread_tt(), flush_thread_skas());
+}
+
+void start_thread(struct pt_regs *regs, unsigned long eip, unsigned long esp)
+{
+        CHOOSE_MODE_PROC(start_thread_tt, start_thread_skas, regs, eip, esp);
+}
+
+extern void log_exec(char **argv, void *tty);
+
+static long execve1(char *file, char __user * __user *argv,
+                    char *__user __user *env)
+{
+        long error;
+
+#ifdef CONFIG_TTY_LOG
+        log_exec(argv, current->tty);
+#endif
+        error = do_execve(file, argv, env, &current->thread.regs);
+        if (error == 0){
+                task_lock(current);
+                current->ptrace &= ~PT_DTRACE;
+                task_unlock(current);
+                set_cmdline(current_cmd());
+        }
+        return(error);
+}
+
+long um_execve(char *file, char __user *__user *argv, char __user *__user *env)
+{
+        long err;
+
+        err = execve1(file, argv, env);
+        if(!err)
+                do_longjmp(current->thread.exec_buf, 1);
+        return(err);
+}
+
+long sys_execve(char *file, char __user *__user *argv,
+                char __user *__user *env)
+{
+        long error;
+        char *filename;
+
+        lock_kernel();
+        filename = getname((char __user *) file);
+        error = PTR_ERR(filename);
+        if (IS_ERR(filename)) goto out;
+        error = execve1(filename, argv, env);
+        putname(filename);
+ out:
+        unlock_kernel();
+        return(error);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/exitcode.c b/arch/um/kernel/exitcode.c
new file mode 100644
index 000000000000..0ea87f24b36f
--- /dev/null
+++ b/arch/um/kernel/exitcode.c
@@ -0,0 +1,73 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/init.h"
+#include "linux/ctype.h"
+#include "linux/proc_fs.h"
+#include "asm/uaccess.h"
+
+/* If read and write race, the read will still atomically read a valid
+ * value.
+ */
+int uml_exitcode = 0;
+
+static int read_proc_exitcode(char *page, char **start, off_t off,
+                              int count, int *eof, void *data)
+{
+        int len;
+
+        len = sprintf(page, "%d\n", uml_exitcode);
+        len -= off;
+        if(len <= off+count) *eof = 1;
+        *start = page + off;
+        if(len > count) len = count;
+        if(len < 0) len = 0;
+        return(len);
+}
+
+static int write_proc_exitcode(struct file *file, const char __user *buffer,
+                               unsigned long count, void *data)
+{
+        char *end, buf[sizeof("nnnnn\0")];
+        int tmp;
+
+        if(copy_from_user(buf, buffer, count))
+                return(-EFAULT);
+        tmp = simple_strtol(buf, &end, 0);
+        if((*end != '\0') && !isspace(*end))
+                return(-EINVAL);
+        uml_exitcode = tmp;
+        return(count);
+}
+
+static int make_proc_exitcode(void)
+{
+        struct proc_dir_entry *ent;
+
+        ent = create_proc_entry("exitcode", 0600, &proc_root);
+        if(ent == NULL){
+                printk("make_proc_exitcode : Failed to register "
+                       "/proc/exitcode\n");
+                return(0);
+        }
+
+        ent->read_proc = read_proc_exitcode;
+        ent->write_proc = write_proc_exitcode;
+        
+        return(0);
+}
+
+__initcall(make_proc_exitcode);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/gmon_syms.c b/arch/um/kernel/gmon_syms.c
new file mode 100644
index 000000000000..2c86e7fdb014
--- /dev/null
+++ b/arch/um/kernel/gmon_syms.c
@@ -0,0 +1,34 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/module.h"
+
+extern void __bb_init_func(void *);
+EXPORT_SYMBOL(__bb_init_func);
+
+/* This is defined (and referred to in profiling stub code) only by some GCC
+ * versions in libgcov.
+ *
+ * Since SuSE backported the fix, we cannot handle it depending on GCC version.
+ * So, unconditinally export it. But also give it a weak declaration, which will
+ * be overriden by any other one.
+ */
+
+extern void __gcov_init(void *) __attribute__((weak));
+EXPORT_SYMBOL(__gcov_init);
+
+extern void __gcov_merge_add(void *) __attribute__((weak));
+EXPORT_SYMBOL(__gcov_merge_add);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/gprof_syms.c b/arch/um/kernel/gprof_syms.c
new file mode 100644
index 000000000000..9244f018d44c
--- /dev/null
+++ b/arch/um/kernel/gprof_syms.c
@@ -0,0 +1,20 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/module.h"
+
+extern void mcount(void);
+EXPORT_SYMBOL(mcount);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/helper.c b/arch/um/kernel/helper.c
new file mode 100644
index 000000000000..13b1f5c2f7ee
--- /dev/null
+++ b/arch/um/kernel/helper.c
@@ -0,0 +1,173 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+#include <sys/signal.h>
+#include <sys/wait.h>
+#include "user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+
+struct helper_data {
+        void (*pre_exec)(void*);
+        void *pre_data;
+        char **argv;
+        int fd;
+};
+
+/* Debugging aid, changed only from gdb */
+int helper_pause = 0;
+
+static void helper_hup(int sig)
+{
+}
+
+static int helper_child(void *arg)
+{
+        struct helper_data *data = arg;
+        char **argv = data->argv;
+        int errval;
+
+        if(helper_pause){
+                signal(SIGHUP, helper_hup);
+                pause();
+        }
+        if(data->pre_exec != NULL)
+                (*data->pre_exec)(data->pre_data);
+        execvp(argv[0], argv);
+        errval = errno;
+        printk("execvp of '%s' failed - errno = %d\n", argv[0], errno);
+        os_write_file(data->fd, &errval, sizeof(errval));
+        os_kill_process(os_getpid(), 0);
+        return(0);
+}
+
+/* Returns either the pid of the child process we run or -E* on failure.
+ * XXX The alloc_stack here breaks if this is called in the tracing thread */
+int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
+               unsigned long *stack_out)
+{
+        struct helper_data data;
+        unsigned long stack, sp;
+        int pid, fds[2], ret, n;
+
+        if((stack_out != NULL) && (*stack_out != 0))
+                stack = *stack_out;
+        else stack = alloc_stack(0, um_in_interrupt());
+        if(stack == 0)
+                return(-ENOMEM);
+
+        ret = os_pipe(fds, 1, 0);
+        if(ret < 0){
+                printk("run_helper : pipe failed, ret = %d\n", -ret);
+                goto out_free;
+        }
+
+        ret = os_set_exec_close(fds[1], 1);
+        if(ret < 0){
+                printk("run_helper : setting FD_CLOEXEC failed, ret = %d\n",
+                       -ret);
+                goto out_close;
+        }
+
+        sp = stack + page_size() - sizeof(void *);
+        data.pre_exec = pre_exec;
+        data.pre_data = pre_data;
+        data.argv = argv;
+        data.fd = fds[1];
+        pid = clone(helper_child, (void *) sp, CLONE_VM | SIGCHLD, &data);
+        if(pid < 0){
+                printk("run_helper : clone failed, errno = %d\n", errno);
+                ret = -errno;
+                goto out_close;
+        }
+
+        os_close_file(fds[1]);
+        fds[1] = -1;
+
+        /*Read the errno value from the child.*/
+        n = os_read_file(fds[0], &ret, sizeof(ret));
+        if(n < 0){
+                printk("run_helper : read on pipe failed, ret = %d\n", -n);
+                ret = n;
+                os_kill_process(pid, 1);
+        }
+        else if(n != 0){
+                CATCH_EINTR(n = waitpid(pid, NULL, 0));
+                ret = -errno;
+        } else {
+                ret = pid;
+        }
+
+out_close:
+        if (fds[1] != -1)
+                os_close_file(fds[1]);
+        os_close_file(fds[0]);
+out_free:
+        if(stack_out == NULL)
+                free_stack(stack, 0);
+        else *stack_out = stack;
+        return(ret);
+}
+
+int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags, 
+                      unsigned long *stack_out, int stack_order)
+{
+        unsigned long stack, sp;
+        int pid, status;
+
+        stack = alloc_stack(stack_order, um_in_interrupt());
+        if(stack == 0) return(-ENOMEM);
+
+        sp = stack + (page_size() << stack_order) - sizeof(void *);
+        pid = clone(proc, (void *) sp, flags | SIGCHLD, arg);
+        if(pid < 0){
+                printk("run_helper_thread : clone failed, errno = %d\n", 
+                       errno);
+                return(-errno);
+        }
+        if(stack_out == NULL){
+                CATCH_EINTR(pid = waitpid(pid, &status, 0));
+                if(pid < 0){
+                        printk("run_helper_thread - wait failed, errno = %d\n",
+                               errno);
+                        pid = -errno;
+                }
+                if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
+                        printk("run_helper_thread - thread returned status "
+                               "0x%x\n", status);
+                free_stack(stack, stack_order);
+        }
+        else *stack_out = stack;
+        return(pid);
+}
+
+int helper_wait(int pid, int block)
+{
+        int ret;
+
+        CATCH_EINTR(ret = waitpid(pid, NULL, WNOHANG));
+        if(ret < 0){
+                printk("helper_wait : waitpid failed, errno = %d\n", errno);
+                return(-errno);
+        }
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/init_task.c b/arch/um/kernel/init_task.c
new file mode 100644
index 000000000000..cd7c85be0a1b
--- /dev/null
+++ b/arch/um/kernel/init_task.c
@@ -0,0 +1,61 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/mm.h"
+#include "linux/module.h"
+#include "linux/sched.h"
+#include "linux/init_task.h"
+#include "linux/mqueue.h"
+#include "asm/uaccess.h"
+#include "asm/pgtable.h"
+#include "user_util.h"
+#include "mem_user.h"
+
+static struct fs_struct init_fs = INIT_FS;
+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);
+
+/*
+ * Initial task structure.
+ *
+ * All other task structs will be allocated on slabs in fork.c
+ */
+
+struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
+
+/*
+ * Initial thread structure.
+ *
+ * We need to make sure that this is 16384-byte aligned due to the
+ * way process stacks are handled. This is done by having a special
+ * "init_task" linker map entry..
+ */
+
+union thread_union init_thread_union 
+__attribute__((__section__(".data.init_task"))) = 
+{ INIT_THREAD_INFO(init_task) };
+
+void unprotect_stack(unsigned long stack)
+{
+        protect_memory(stack, (1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE, 
+                       1, 1, 0, 1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/initrd_kern.c b/arch/um/kernel/initrd_kern.c
new file mode 100644
index 000000000000..fc568af468b9
--- /dev/null
+++ b/arch/um/kernel/initrd_kern.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/init.h"
+#include "linux/bootmem.h"
+#include "linux/initrd.h"
+#include "asm/types.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "initrd.h"
+#include "init.h"
+#include "os.h"
+
+/* Changed by uml_initrd_setup, which is a setup */
+static char *initrd __initdata = NULL;
+
+static int __init read_initrd(void)
+{
+        void *area;
+        long long size;
+        int err;
+
+        if(initrd == NULL) return 0;
+        err = os_file_size(initrd, &size);
+        if(err) return 0;
+        area = alloc_bootmem(size);
+        if(area == NULL) return 0;
+        if(load_initrd(initrd, area, size) == -1) return 0;
+        initrd_start = (unsigned long) area;
+        initrd_end = initrd_start + size;
+        return 0;
+}
+
+__uml_postsetup(read_initrd);
+
+static int __init uml_initrd_setup(char *line, int *add)
+{
+        initrd = line;
+        return 0;
+}
+
+__uml_setup("initrd=", uml_initrd_setup, 
+"initrd=<initrd image>\n"
+"    This is used to boot UML from an initrd image.  The argument is the\n"
+"    name of the file containing the image.\n\n"
+);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/initrd_user.c b/arch/um/kernel/initrd_user.c
new file mode 100644
index 000000000000..cb90681e151c
--- /dev/null
+++ b/arch/um/kernel/initrd_user.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "initrd.h"
+#include "os.h"
+
+int load_initrd(char *filename, void *buf, int size)
+{
+        int fd, n;
+
+        fd = os_open_file(filename, of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("Opening '%s' failed - err = %d\n", filename, -fd);
+                return(-1);
+        }
+        n = os_read_file(fd, buf, size);
+        if(n != size){
+                printk("Read of %d bytes from '%s' failed, err = %d\n", size,
+                       filename, -n);
+                return(-1);
+        }
+
+        os_close_file(fd);
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
new file mode 100644
index 000000000000..d71e8f00810f
--- /dev/null
+++ b/arch/um/kernel/irq.c
@@ -0,0 +1,178 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ * Derived (i.e. mostly copied) from arch/i386/kernel/irq.c:
+ *      Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
+ */
+
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/module.h"
+#include "linux/smp.h"
+#include "linux/irq.h"
+#include "linux/kernel_stat.h"
+#include "linux/interrupt.h"
+#include "linux/random.h"
+#include "linux/slab.h"
+#include "linux/file.h"
+#include "linux/proc_fs.h"
+#include "linux/init.h"
+#include "linux/seq_file.h"
+#include "linux/profile.h"
+#include "linux/hardirq.h"
+#include "asm/irq.h"
+#include "asm/hw_irq.h"
+#include "asm/atomic.h"
+#include "asm/signal.h"
+#include "asm/system.h"
+#include "asm/errno.h"
+#include "asm/uaccess.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "irq_user.h"
+#include "irq_kern.h"
+
+
+/*
+ * Generic, controller-independent functions:
+ */
+
+int show_interrupts(struct seq_file *p, void *v)
+{
+        int i = *(loff_t *) v, j;
+        struct irqaction * action;
+        unsigned long flags;
+
+        if (i == 0) {
+                seq_printf(p, "           ");
+                for_each_online_cpu(j)
+                        seq_printf(p, "CPU%d       ",j);
+                seq_putc(p, '\n');
+        }
+
+        if (i < NR_IRQS) {
+                spin_lock_irqsave(&irq_desc[i].lock, flags);
+                action = irq_desc[i].action;
+                if (!action) 
+                        goto skip;
+                seq_printf(p, "%3d: ",i);
+#ifndef CONFIG_SMP
+                seq_printf(p, "%10u ", kstat_irqs(i));
+#else
+                for_each_online_cpu(j)
+                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+#endif
+                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, "  %s", action->name);
+
+                for (action=action->next; action; action = action->next)
+                        seq_printf(p, ", %s", action->name);
+
+                seq_putc(p, '\n');
+skip:
+                spin_unlock_irqrestore(&irq_desc[i].lock, flags);
+        } else if (i == NR_IRQS) {
+                seq_putc(p, '\n');
+        }
+
+        return 0;
+}
+
+/*
+ * do_IRQ handles all normal device IRQ's (the special
+ * SMP cross-CPU interrupts have their own specific
+ * handlers).
+ */
+unsigned int do_IRQ(int irq, union uml_pt_regs *regs)
+{
+       irq_enter();
+       __do_IRQ(irq, (struct pt_regs *) regs);
+       irq_exit();
+       return 1;
+}
+
+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)
+{
+        int err;
+
+        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);
+}
+EXPORT_SYMBOL(um_request_irq);
+EXPORT_SYMBOL(reactivate_fd);
+
+static DEFINE_SPINLOCK(irq_spinlock);
+
+unsigned long irq_lock(void)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&irq_spinlock, flags);
+        return(flags);
+}
+
+void irq_unlock(unsigned long flags)
+{
+        spin_unlock_irqrestore(&irq_spinlock, flags);
+}
+
+/*  presently hw_interrupt_type must define (startup || enable) &&
+ *  disable && end */
+static void dummy(unsigned int irq)
+{
+}
+
+static struct hw_interrupt_type SIGIO_irq_type = {
+        .typename = "SIGIO",
+        .disable = dummy,
+        .enable = dummy,
+        .ack = dummy,
+        .end = dummy
+};
+
+static struct hw_interrupt_type SIGVTALRM_irq_type = {
+        .typename = "SIGVTALRM",
+        .shutdown = dummy, /* never called */
+        .disable = dummy,
+        .enable = dummy,
+        .ack = dummy,
+        .end = dummy
+};
+
+void __init init_IRQ(void)
+{
+        int i;
+
+        irq_desc[TIMER_IRQ].status = IRQ_DISABLED;
+        irq_desc[TIMER_IRQ].action = NULL;
+        irq_desc[TIMER_IRQ].depth = 1;
+        irq_desc[TIMER_IRQ].handler = &SIGVTALRM_irq_type;
+        enable_irq(TIMER_IRQ);
+        for(i=1;i<NR_IRQS;i++){
+                irq_desc[i].status = IRQ_DISABLED;
+                irq_desc[i].action = NULL;
+                irq_desc[i].depth = 1;
+                irq_desc[i].handler = &SIGIO_irq_type;
+                enable_irq(i);
+        }
+        init_irq_signals(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/irq_user.c b/arch/um/kernel/irq_user.c
new file mode 100644
index 000000000000..6d6f9484b884
--- /dev/null
+++ b/arch/um/kernel/irq_user.c
@@ -0,0 +1,443 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "process.h"
+#include "signal_user.h"
+#include "sigio.h"
+#include "irq_user.h"
+#include "os.h"
+
+struct irq_fd {
+        struct irq_fd *next;
+        void *id;
+        int fd;
+        int type;
+        int irq;
+        int pid;
+        int events;
+        int current_events;
+        int freed;
+};
+
+static struct irq_fd *active_fds = NULL;
+static struct irq_fd **last_irq_ptr = &active_fds;
+
+static struct pollfd *pollfds = NULL;
+static int pollfds_num = 0;
+static int pollfds_size = 0;
+
+extern int io_count, intr_count;
+
+void sigio_handler(int sig, union uml_pt_regs *regs)
+{
+        struct irq_fd *irq_fd, *next;
+        int i, n;
+
+        if(smp_sigio_handler()) return;
+        while(1){
+                n = poll(pollfds, pollfds_num, 0);
+                if(n < 0){
+                        if(errno == EINTR) continue;
+                        printk("sigio_handler : poll returned %d, "
+                               "errno = %d\n", n, errno);
+                        break;
+                }
+                if(n == 0) break;
+
+                irq_fd = active_fds;
+                for(i = 0; i < pollfds_num; i++){
+                        if(pollfds[i].revents != 0){
+                                irq_fd->current_events = pollfds[i].revents;
+                                pollfds[i].fd = -1;
+                        }
+                        irq_fd = irq_fd->next;
+                }
+
+                for(irq_fd = active_fds; irq_fd != NULL; irq_fd = next){
+                        next = irq_fd->next;
+                        if(irq_fd->current_events != 0){
+                                irq_fd->current_events = 0;
+                                do_IRQ(irq_fd->irq, regs);
+
+                                /* This is here because the next irq may be
+                                 * freed in the handler.  If a console goes
+                                 * away, both the read and write irqs will be
+                                 * freed.  After do_IRQ, ->next will point to
+                                 * a good IRQ.
+                                 * Irqs can't be freed inside their handlers,
+                                 * so the next best thing is to have them
+                                 * marked as needing freeing, so that they
+                                 * can be freed here.
+                                 */
+                                next = irq_fd->next;
+                                if(irq_fd->freed){
+                                        free_irq(irq_fd->irq, irq_fd->id);
+                                        free_irq_by_irq_and_dev(irq_fd->irq,
+                                                                irq_fd->id);
+                                }
+                        }
+                }
+        }
+}
+
+int activate_ipi(int fd, int pid)
+{
+        return(os_set_fd_async(fd, pid));
+}
+
+static void maybe_sigio_broken(int fd, int type)
+{
+        if(isatty(fd)){
+                if((type == IRQ_WRITE) && !pty_output_sigio){
+                        write_sigio_workaround();
+                        add_sigio_fd(fd, 0);
+                }
+                else if((type == IRQ_READ) && !pty_close_sigio){
+                        write_sigio_workaround();
+                        add_sigio_fd(fd, 1);                    
+                }
+        }
+}
+
+int activate_fd(int irq, int fd, int type, void *dev_id)
+{
+        struct pollfd *tmp_pfd;
+        struct irq_fd *new_fd, *irq_fd;
+        unsigned long flags;
+        int pid, events, err, n, size;
+
+        pid = os_getpid();
+        err = os_set_fd_async(fd, pid);
+        if(err < 0)
+                goto out;
+
+        new_fd = um_kmalloc(sizeof(*new_fd));
+        err = -ENOMEM;
+        if(new_fd == NULL)
+                goto out;
+
+        if(type == IRQ_READ) events = POLLIN | POLLPRI;
+        else events = POLLOUT;
+        *new_fd = ((struct irq_fd) { .next              = NULL,
+                                     .id                = dev_id,
+                                     .fd                = fd,
+                                     .type              = type,
+                                     .irq               = irq,
+                                     .pid               = pid,
+                                     .events            = events,
+                                     .current_events    = 0,
+                                     .freed             = 0  } );
+
+        /* Critical section - locked by a spinlock because this stuff can
+         * be changed from interrupt handlers.  The stuff above is done 
+         * outside the lock because it allocates memory.
+         */
+
+        /* Actually, it only looks like it can be called from interrupt
+         * context.  The culprit is reactivate_fd, which calls 
+         * maybe_sigio_broken, which calls write_sigio_workaround,
+         * which calls activate_fd.  However, write_sigio_workaround should
+         * only be called once, at boot time.  That would make it clear that
+         * this is called only from process context, and can be locked with
+         * a semaphore.
+         */
+        flags = irq_lock();
+        for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
+                if((irq_fd->fd == fd) && (irq_fd->type == type)){
+                        printk("Registering fd %d twice\n", fd);
+                        printk("Irqs : %d, %d\n", irq_fd->irq, irq);
+                        printk("Ids : 0x%x, 0x%x\n", irq_fd->id, dev_id);
+                        goto out_unlock;
+                }
+        }
+
+        n = pollfds_num;
+        if(n == pollfds_size){
+                while(1){
+                        /* Here we have to drop the lock in order to call 
+                         * kmalloc, which might sleep.  If something else
+                         * came in and changed the pollfds array, we free
+                         * the buffer and try again.
+                         */
+                        irq_unlock(flags);
+                        size = (pollfds_num + 1) * sizeof(pollfds[0]);
+                        tmp_pfd = um_kmalloc(size);
+                        flags = irq_lock();
+                        if(tmp_pfd == NULL)
+                                goto out_unlock;
+                        if(n == pollfds_size)
+                                break;
+                        kfree(tmp_pfd);
+                }
+                if(pollfds != NULL){
+                        memcpy(tmp_pfd, pollfds,
+                               sizeof(pollfds[0]) * pollfds_size);
+                        kfree(pollfds);
+                }
+                pollfds = tmp_pfd;
+                pollfds_size++;
+        }
+
+        if(type == IRQ_WRITE) 
+                fd = -1;
+
+        pollfds[pollfds_num] = ((struct pollfd) { .fd   = fd,
+                                                  .events       = events,
+                                                  .revents      = 0 });
+        pollfds_num++;
+
+        *last_irq_ptr = new_fd;
+        last_irq_ptr = &new_fd->next;
+
+        irq_unlock(flags);
+
+        /* This calls activate_fd, so it has to be outside the critical
+         * section.
+         */
+        maybe_sigio_broken(fd, type);
+
+        return(0);
+
+ out_unlock:
+        irq_unlock(flags);
+        kfree(new_fd);
+ out:
+        return(err);
+}
+
+static void free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg)
+{
+        struct irq_fd **prev;
+        unsigned long flags;
+        int i = 0;
+
+        flags = irq_lock();
+        prev = &active_fds;
+        while(*prev != NULL){
+                if((*test)(*prev, arg)){
+                        struct irq_fd *old_fd = *prev;
+                        if((pollfds[i].fd != -1) && 
+                           (pollfds[i].fd != (*prev)->fd)){
+                                printk("free_irq_by_cb - mismatch between "
+                                       "active_fds and pollfds, fd %d vs %d\n",
+                                       (*prev)->fd, pollfds[i].fd);
+                                goto out;
+                        }
+                        memcpy(&pollfds[i], &pollfds[i + 1],
+                               (pollfds_num - i - 1) * sizeof(pollfds[0]));
+                        pollfds_num--;
+                        if(last_irq_ptr == &old_fd->next) 
+                                last_irq_ptr = prev;
+                        *prev = (*prev)->next;
+                        if(old_fd->type == IRQ_WRITE) 
+                                ignore_sigio_fd(old_fd->fd);
+                        kfree(old_fd);
+                        continue;
+                }
+                prev = &(*prev)->next;
+                i++;
+        }
+ out:
+        irq_unlock(flags);
+}
+
+struct irq_and_dev {
+        int irq;
+        void *dev;
+};
+
+static int same_irq_and_dev(struct irq_fd *irq, void *d)
+{
+        struct irq_and_dev *data = d;
+
+        return((irq->irq == data->irq) && (irq->id == data->dev));
+}
+
+void free_irq_by_irq_and_dev(unsigned int irq, void *dev)
+{
+        struct irq_and_dev data = ((struct irq_and_dev) { .irq  = irq,
+                                                          .dev  = dev });
+
+        free_irq_by_cb(same_irq_and_dev, &data);
+}
+
+static int same_fd(struct irq_fd *irq, void *fd)
+{
+        return(irq->fd == *((int *) fd));
+}
+
+void free_irq_by_fd(int fd)
+{
+        free_irq_by_cb(same_fd, &fd);
+}
+
+static struct irq_fd *find_irq_by_fd(int fd, int irqnum, int *index_out)
+{
+        struct irq_fd *irq;
+        int i = 0;
+
+        for(irq=active_fds; irq != NULL; irq = irq->next){
+                if((irq->fd == fd) && (irq->irq == irqnum)) break;
+                i++;
+        }
+        if(irq == NULL){
+                printk("find_irq_by_fd doesn't have descriptor %d\n", fd);
+                goto out;
+        }
+        if((pollfds[i].fd != -1) && (pollfds[i].fd != fd)){
+                printk("find_irq_by_fd - mismatch between active_fds and "
+                       "pollfds, fd %d vs %d, need %d\n", irq->fd, 
+                       pollfds[i].fd, fd);
+                irq = NULL;
+                goto out;
+        }
+        *index_out = i;
+ out:
+        return(irq);
+}
+
+void free_irq_later(int irq, void *dev_id)
+{
+        struct irq_fd *irq_fd;
+        unsigned long flags;
+
+        flags = irq_lock();
+        for(irq_fd = active_fds; irq_fd != NULL; irq_fd = irq_fd->next){
+                if((irq_fd->irq == irq) && (irq_fd->id == dev_id))
+                        break;
+        }
+        if(irq_fd == NULL){
+                printk("free_irq_later found no irq, irq = %d, "
+                       "dev_id = 0x%p\n", irq, dev_id);
+                goto out;
+        }
+        irq_fd->freed = 1;
+ out:
+        irq_unlock(flags);
+}
+
+void reactivate_fd(int fd, int irqnum)
+{
+        struct irq_fd *irq;
+        unsigned long flags;
+        int i;
+
+        flags = irq_lock();
+        irq = find_irq_by_fd(fd, irqnum, &i);
+        if(irq == NULL){
+                irq_unlock(flags);
+                return;
+        }
+
+        pollfds[i].fd = irq->fd;
+
+        irq_unlock(flags);
+
+        /* This calls activate_fd, so it has to be outside the critical
+         * section.
+         */
+        maybe_sigio_broken(fd, irq->type);
+}
+
+void deactivate_fd(int fd, int irqnum)
+{
+        struct irq_fd *irq;
+        unsigned long flags;
+        int i;
+
+        flags = irq_lock();
+        irq = find_irq_by_fd(fd, irqnum, &i);
+        if(irq == NULL)
+                goto out;
+        pollfds[i].fd = -1;
+ out:
+        irq_unlock(flags);
+}
+
+int deactivate_all_fds(void)
+{
+        struct irq_fd *irq;
+        int err;
+
+        for(irq=active_fds;irq != NULL;irq = irq->next){
+                err = os_clear_fd_async(irq->fd);
+                if(err)
+                        return(err);
+        }
+        /* If there is a signal already queued, after unblocking ignore it */
+        set_handler(SIGIO, SIG_IGN, 0, -1);
+
+        return(0);
+}
+
+void forward_ipi(int fd, int pid)
+{
+        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){
+                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);
+}
+
+void init_irq_signals(int on_sigstack)
+{
+        __sighandler_t h;
+        int flags;
+
+        flags = on_sigstack ? SA_ONSTACK : 0;
+        if(timer_irq_inited) h = (__sighandler_t) alarm_handler;
+        else h = boot_timer_handler;
+
+        set_handler(SIGVTALRM, h, flags | SA_RESTART, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, -1);
+        set_handler(SIGIO, (__sighandler_t) sig_handler, flags | SA_RESTART,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        signal(SIGWINCH, SIG_IGN);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/ksyms.c b/arch/um/kernel/ksyms.c
new file mode 100644
index 000000000000..b41d3397d07b
--- /dev/null
+++ b/arch/um/kernel/ksyms.c
@@ -0,0 +1,137 @@
+/* 
+ * Copyright (C) 2001 - 2004 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/module.h"
+#include "linux/string.h"
+#include "linux/smp_lock.h"
+#include "linux/spinlock.h"
+#include "linux/highmem.h"
+#include "asm/current.h"
+#include "asm/delay.h"
+#include "asm/processor.h"
+#include "asm/unistd.h"
+#include "asm/pgalloc.h"
+#include "asm/pgtable.h"
+#include "asm/page.h"
+#include "asm/tlbflush.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "os.h"
+#include "helper.h"
+
+EXPORT_SYMBOL(stop);
+EXPORT_SYMBOL(uml_physmem);
+EXPORT_SYMBOL(set_signals);
+EXPORT_SYMBOL(get_signals);
+EXPORT_SYMBOL(kernel_thread);
+EXPORT_SYMBOL(__const_udelay);
+EXPORT_SYMBOL(__udelay);
+EXPORT_SYMBOL(sys_waitpid);
+EXPORT_SYMBOL(task_size);
+EXPORT_SYMBOL(flush_tlb_range);
+EXPORT_SYMBOL(host_task_size);
+EXPORT_SYMBOL(arch_validate);
+EXPORT_SYMBOL(get_kmem_end);
+
+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);
+EXPORT_SYMBOL(find_iomem);
+EXPORT_SYMBOL(end_iomem);
+
+#ifdef CONFIG_MODE_TT
+EXPORT_SYMBOL(strncpy_from_user_tt);
+EXPORT_SYMBOL(copy_from_user_tt);
+EXPORT_SYMBOL(copy_to_user_tt);
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+EXPORT_SYMBOL(strncpy_from_user_skas);
+EXPORT_SYMBOL(copy_to_user_skas);
+EXPORT_SYMBOL(copy_from_user_skas);
+#endif
+EXPORT_SYMBOL(uml_strdup);
+
+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_ioctl_generic);
+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.
+ */
+EXPORT_SYMBOL(sys_open);
+EXPORT_SYMBOL(sys_lseek);
+EXPORT_SYMBOL(sys_read);
+EXPORT_SYMBOL(sys_wait4);
+
+#ifdef CONFIG_SMP
+
+/* required for SMP */
+
+extern void FASTCALL( __write_lock_failed(rwlock_t *rw));
+EXPORT_SYMBOL(__write_lock_failed);
+
+extern void FASTCALL( __read_lock_failed(rwlock_t *rw));
+EXPORT_SYMBOL(__read_lock_failed);
+
+#endif
+
+#ifdef CONFIG_HIGHMEM
+EXPORT_SYMBOL(kmap);
+EXPORT_SYMBOL(kunmap);
+EXPORT_SYMBOL(kmap_atomic);
+EXPORT_SYMBOL(kunmap_atomic);
+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 --git a/arch/um/kernel/main.c b/arch/um/kernel/main.c
new file mode 100644
index 000000000000..a17c49703f9b
--- /dev/null
+++ b/arch/um/kernel/main.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/resource.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <asm/page.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "mem_user.h"
+#include "signal_user.h"
+#include "time_user.h"
+#include "irq_user.h"
+#include "user.h"
+#include "init.h"
+#include "mode.h"
+#include "choose-mode.h"
+#include "uml-config.h"
+#include "irq_user.h"
+#include "time_user.h"
+#include "os.h"
+
+/* Set in set_stklim, which is called from main and __wrap_malloc.
+ * __wrap_malloc only calls it if main hasn't started.
+ */
+unsigned long stacksizelim;
+
+/* Set in main */
+char *linux_prog;
+
+#define PGD_BOUND (4 * 1024 * 1024)
+#define STACKSIZE (8 * 1024 * 1024)
+#define THREAD_NAME_LEN (256)
+
+static void set_stklim(void)
+{
+        struct rlimit lim;
+
+        if(getrlimit(RLIMIT_STACK, &lim) < 0){
+                perror("getrlimit");
+                exit(1);
+        }
+        if((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)){
+                lim.rlim_cur = STACKSIZE;
+                if(setrlimit(RLIMIT_STACK, &lim) < 0){
+                        perror("setrlimit");
+                        exit(1);
+                }
+        }
+        stacksizelim = (lim.rlim_cur + PGD_BOUND - 1) & ~(PGD_BOUND - 1);
+}
+
+static __init void do_uml_initcalls(void)
+{
+        initcall_t *call;
+
+        call = &__uml_initcall_start;
+        while (call < &__uml_initcall_end){;
+                (*call)();
+                call++;
+        }
+}
+
+static void last_ditch_exit(int sig)
+{
+        CHOOSE_MODE(kmalloc_ok = 0, (void) 0);
+        signal(SIGINT, SIG_DFL);
+        signal(SIGTERM, SIG_DFL);
+        signal(SIGHUP, SIG_DFL);
+        uml_cleanup();
+        exit(1);
+}
+
+extern int uml_exitcode;
+
+extern void scan_elf_aux( char **envp);
+
+int main(int argc, char **argv, char **envp)
+{
+        char **new_argv;
+        sigset_t mask;
+        int ret, i;
+
+        /* Enable all signals except SIGIO - in some environments, we can
+         * enter with some signals blocked
+         */
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGIO);
+        if(sigprocmask(SIG_SETMASK, &mask, NULL) < 0){
+                perror("sigprocmask");
+                exit(1);
+        }
+
+#ifdef UML_CONFIG_MODE_TT
+        /* Allocate memory for thread command lines */
+        if(argc < 2 || strlen(argv[1]) < THREAD_NAME_LEN - 1){
+
+                char padding[THREAD_NAME_LEN] = {
+                        [ 0 ...  THREAD_NAME_LEN - 2] = ' ', '\0'
+                };
+
+                new_argv = malloc((argc + 2) * sizeof(char*));
+                if(!new_argv) {
+                        perror("Allocating extended argv");
+                        exit(1);
+                }
+
+                new_argv[0] = argv[0];
+                new_argv[1] = padding;
+
+                for(i = 2; i <= argc; i++)
+                        new_argv[i] = argv[i - 1];
+                new_argv[argc + 1] = NULL;
+
+                execvp(new_argv[0], new_argv);
+                perror("execing with extended args");
+                exit(1);
+        }
+#endif
+
+        linux_prog = argv[0];
+
+        set_stklim();
+
+        new_argv = malloc((argc + 1) * sizeof(char *));
+        if(new_argv == NULL){
+                perror("Mallocing argv");
+                exit(1);
+        }
+        for(i=0;i<argc;i++){
+                new_argv[i] = strdup(argv[i]);
+                if(new_argv[i] == NULL){
+                        perror("Mallocing an arg");
+                        exit(1);
+                }
+        }
+        new_argv[argc] = NULL;
+
+        set_handler(SIGINT, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+        set_handler(SIGTERM, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+        set_handler(SIGHUP, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+
+        scan_elf_aux( envp);
+
+        do_uml_initcalls();
+        ret = linux_main(argc, argv);
+
+        /* Disable SIGPROF - I have no idea why libc doesn't do this or turn
+         * off the profiling time, but UML dies with a SIGPROF just before
+         * exiting when profiling is active.
+         */
+        change_sig(SIGPROF, 0);
+
+        /* Reboot */
+        if(ret){
+                int err;
+
+                printf("\n");
+
+                /* stop timers and set SIG*ALRM to be ignored */
+                disable_timer();
+
+                /* disable SIGIO for the fds and set SIGIO to be ignored */
+                err = deactivate_all_fds();
+                if(err)
+                        printf("deactivate_all_fds failed, errno = %d\n",
+                               -err);
+
+                /* Let any pending signals fire now.  This ensures
+                 * that they won't be delivered after the exec, when
+                 * they are definitely not expected.
+                 */
+                unblock_signals();
+
+                execvp(new_argv[0], new_argv);
+                perror("Failed to exec kernel");
+                ret = 1;
+        }
+        printf("\n");
+        return(uml_exitcode);
+}
+
+#define CAN_KMALLOC() \
+        (kmalloc_ok && CHOOSE_MODE((os_getpid() != tracing_pid), 1))
+
+extern void *__real_malloc(int);
+
+void *__wrap_malloc(int size)
+{
+        void *ret;
+
+        if(!CAN_KMALLOC())
+                return(__real_malloc(size));
+        else if(size <= PAGE_SIZE) /* finding contiguos pages can be hard*/
+                ret = um_kmalloc(size);
+        else ret = um_vmalloc(size);
+
+        /* glibc people insist that if malloc fails, errno should be
+         * set by malloc as well. So we do.
+         */
+        if(ret == NULL)
+                errno = ENOMEM;
+
+        return(ret);
+}
+
+void *__wrap_calloc(int n, int size)
+{
+        void *ptr = __wrap_malloc(n * size);
+
+        if(ptr == NULL) return(NULL);
+        memset(ptr, 0, n * size);
+        return(ptr);
+}
+
+extern void __real_free(void *);
+
+extern unsigned long high_physmem;
+
+void __wrap_free(void *ptr)
+{
+        unsigned long addr = (unsigned long) ptr;
+
+        /* We need to know how the allocation happened, so it can be correctly
+         * freed.  This is done by seeing what region of memory the pointer is
+         * in -
+         *      physical memory - kmalloc/kfree
+         *      kernel virtual memory - vmalloc/vfree
+         *      anywhere else - malloc/free
+         * If kmalloc is not yet possible, then either high_physmem and/or
+         * end_vm are still 0 (as at startup), in which case we call free, or
+         * we have set them, but anyway addr has not been allocated from those
+         * areas. So, in both cases __real_free is called.
+         *
+         * CAN_KMALLOC is checked because it would be bad to free a buffer
+         * with kmalloc/vmalloc after they have been turned off during
+         * shutdown.
+         * XXX: However, we sometimes shutdown CAN_KMALLOC temporarily, so
+         * there is a possibility for memory leaks.
+         */
+
+        if((addr >= uml_physmem) && (addr < high_physmem)){
+                if(CAN_KMALLOC())
+                        kfree(ptr);
+        }
+        else if((addr >= start_vm) && (addr < end_vm)){
+                if(CAN_KMALLOC())
+                        vfree(ptr);
+        }
+        else __real_free(ptr);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
new file mode 100644
index 000000000000..f156661781cb
--- /dev/null
+++ b/arch/um/kernel/mem.c
@@ -0,0 +1,359 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/kernel.h"
+#include "linux/mm.h"
+#include "linux/bootmem.h"
+#include "linux/swap.h"
+#include "linux/highmem.h"
+#include "linux/gfp.h"
+#include "asm/page.h"
+#include "asm/fixmap.h"
+#include "asm/pgalloc.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mem_user.h"
+#include "uml_uaccess.h"
+#include "os.h"
+
+extern char __binary_start;
+
+/* Changed during early boot */
+unsigned long *empty_zero_page = NULL;
+unsigned long *empty_bad_page = NULL;
+pgd_t swapper_pg_dir[PTRS_PER_PGD];
+unsigned long highmem;
+int kmalloc_ok = 0;
+
+static unsigned long brk_end;
+
+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);
+}
+
+#ifdef CONFIG_HIGHMEM
+static void setup_highmem(unsigned long highmem_start,
+                          unsigned long highmem_len)
+{
+        struct page *page;
+        unsigned long highmem_pfn;
+        int i;
+
+        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);
+                set_page_count(page, 1);
+                __free_page(page);
+        }
+}
+#endif
+
+void mem_init(void)
+{
+        unsigned long start;
+
+        max_low_pfn = (high_physmem - uml_physmem) >> PAGE_SHIFT;
+
+        /* clear the zero-page */
+        memset((void *) empty_zero_page, 0, PAGE_SIZE);
+
+        /* Map in the area just after the brk now that kmalloc is about
+         * to be turned on.
+         */
+        brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
+        map_cb(NULL);
+        initial_thread_cb(map_cb, NULL);
+        free_bootmem(__pa(brk_end), uml_reserved - brk_end);
+        uml_reserved = brk_end;
+
+        /* Fill in any hole at the start of the binary */
+        start = (unsigned long) &__binary_start & PAGE_MASK;
+        if(uml_physmem != start){
+                map_memory(uml_physmem, __pa(uml_physmem), start - uml_physmem,
+                           1, 1, 0);
+        }
+
+        /* this will put all low memory onto the freelists */
+        totalram_pages = free_all_bootmem();
+        totalhigh_pages = highmem >> PAGE_SHIFT;
+        totalram_pages += totalhigh_pages;
+        num_physpages = totalram_pages;
+        max_pfn = totalram_pages;
+        printk(KERN_INFO "Memory: %luk available\n", 
+               (unsigned long) nr_free_pages() << (PAGE_SHIFT-10));
+        kmalloc_ok = 1;
+
+#ifdef CONFIG_HIGHMEM
+        setup_highmem(end_iomem, highmem);
+#endif
+}
+
+static void __init fixrange_init(unsigned long start, unsigned long end, 
+                                 pgd_t *pgd_base)
+{
+        pgd_t *pgd;
+        pmd_t *pmd;
+        pte_t *pte;
+        int i, j;
+        unsigned long vaddr;
+
+        vaddr = start;
+        i = pgd_index(vaddr);
+        j = pmd_index(vaddr);
+        pgd = pgd_base + i;
+
+        for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
+                pmd = (pmd_t *)pgd;
+                for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
+                        if (pmd_none(*pmd)) {
+                                pte = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE);
+                                set_pmd(pmd, __pmd(_KERNPG_TABLE + 
+                                                   (unsigned long) __pa(pte)));
+                                if (pte != pte_offset_kernel(pmd, 0))
+                                        BUG();
+                        }
+                        vaddr += PMD_SIZE;
+                }
+                j = 0;
+        }
+}
+
+#ifdef CONFIG_HIGHMEM
+pte_t *kmap_pte;
+pgprot_t kmap_prot;
+
+#define kmap_get_fixmap_pte(vaddr)                                      \
+        pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
+                          (vaddr)), (vaddr))
+
+static 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;
+}
+
+static void init_highmem(void)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long vaddr;
+
+        /*
+         * Permanent kmaps:
+         */
+        vaddr = PKMAP_BASE;
+        fixrange_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, swapper_pg_dir);
+
+        pgd = swapper_pg_dir + pgd_index(vaddr);
+        pud = pud_offset(pgd, vaddr);
+        pmd = pmd_offset(pud, vaddr);
+        pte = pte_offset_kernel(pmd, vaddr);
+        pkmap_page_table = pte;
+
+        kmap_init();
+}
+#endif /* CONFIG_HIGHMEM */
+
+static void __init fixaddr_user_init( void)
+{
+#if CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
+        long size = FIXADDR_USER_END - FIXADDR_USER_START;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long paddr, vaddr = FIXADDR_USER_START;
+
+        if (  ! size )
+                return;
+
+        fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
+        paddr = (unsigned long)alloc_bootmem_low_pages( size);
+        memcpy( (void *)paddr, (void *)FIXADDR_USER_START, size);
+        paddr = __pa(paddr);
+        for ( ; size > 0; size-=PAGE_SIZE, vaddr+=PAGE_SIZE, paddr+=PAGE_SIZE){
+                pgd = swapper_pg_dir + pgd_index(vaddr);
+                pud = pud_offset(pgd, vaddr);
+                pmd = pmd_offset(pud, vaddr);
+                pte = pte_offset_kernel(pmd, vaddr);
+                pte_set_val( (*pte), paddr, PAGE_READONLY);
+        }
+#endif
+}
+
+void paging_init(void)
+{
+        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] = (end_iomem >> PAGE_SHIFT) - (uml_physmem >> PAGE_SHIFT);
+        zones_size[2] = highmem >> PAGE_SHIFT;
+        free_area_init(zones_size);
+
+        /*
+         * Fixed mappings, only the page table structure has to be
+         * created - mappings will be set by set_fixmap():
+         */
+        vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
+        fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);
+
+        fixaddr_user_init();
+
+#ifdef CONFIG_HIGHMEM
+        init_highmem();
+#endif
+}
+
+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 __user *) 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
+ * since it's not in kernel physical memory.
+ */
+
+void free_initmem(void)
+{
+}
+
+#ifdef CONFIG_BLK_DEV_INITRD
+
+void free_initrd_mem(unsigned long start, unsigned long end)
+{
+        if (start < end)
+                printk ("Freeing initrd memory: %ldk freed\n", 
+                        (end - start) >> 10);
+        for (; start < end; start += PAGE_SIZE) {
+                ClearPageReserved(virt_to_page(start));
+                set_page_count(virt_to_page(start), 1);
+                free_page(start);
+                totalram_pages++;
+        }
+}
+        
+#endif
+
+void show_mem(void)
+{
+        int pfn, total = 0, reserved = 0;
+        int shared = 0, cached = 0;
+        int highmem = 0;
+        struct page *page;
+
+        printk("Mem-info:\n");
+        show_free_areas();
+        printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
+        pfn = max_mapnr;
+        while(pfn-- > 0) {
+                page = pfn_to_page(pfn);
+                total++;
+                if(PageHighMem(page))
+                        highmem++;
+                if(PageReserved(page))
+                        reserved++;
+                else if(PageSwapCache(page))
+                        cached++;
+                else if(page_count(page))
+                        shared += page_count(page) - 1;
+        }
+        printk("%d pages of RAM\n", total);
+        printk("%d pages of HIGHMEM\n", highmem);
+        printk("%d reserved pages\n", reserved);
+        printk("%d pages shared\n", shared);
+        printk("%d pages swap cached\n", cached);
+}
+
+/*
+ * Allocate and free page tables.
+ */
+
+pgd_t *pgd_alloc(struct mm_struct *mm)
+{
+        pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);
+
+        if (pgd) {
+                memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
+                memcpy(pgd + USER_PTRS_PER_PGD, 
+                       swapper_pg_dir + USER_PTRS_PER_PGD, 
+                       (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
+        }
+        return pgd;
+}
+
+void pgd_free(pgd_t *pgd)
+{
+        free_page((unsigned long) pgd);
+}
+
+pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
+{
+        pte_t *pte;
+
+        pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
+        return pte;
+}
+
+struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
+{
+        struct page *pte;
+   
+        pte = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
+        return pte;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/mem_user.c b/arch/um/kernel/mem_user.c
new file mode 100644
index 000000000000..4a663fd434bb
--- /dev/null
+++ b/arch/um/kernel/mem_user.c
@@ -0,0 +1,273 @@
+/*
+ * arch/um/kernel/mem_user.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ * user side memory routines for supporting IO memory inside user mode linux
+ *
+ * Copyright (C) 2001 RidgeRun, Inc.
+ * Author: RidgeRun, Inc.
+ *         Greg Lonnon glonnon@ridgerun.com or info@ridgerun.com
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include "kern_util.h"
+#include "user.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "init.h"
+#include "os.h"
+#include "tempfile.h"
+#include "kern_constants.h"
+
+#define TEMPNAME_TEMPLATE "vm_file-XXXXXX"
+
+static int create_tmp_file(unsigned long len)
+{
+        int fd, err;
+        char zero;
+
+        fd = make_tempfile(TEMPNAME_TEMPLATE, NULL, 1);
+        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);
+        }
+        err = os_seek_file(fd, len);
+        if(err < 0){
+                os_print_error(err, "os_seek_file");
+                exit(1);
+        }
+        zero = 0;
+        err = os_write_file(fd, &zero, 1);
+        if(err != 1){
+                os_print_error(err, "os_write_file");
+                exit(1);
+        }
+
+        return(fd);
+}
+
+void check_tmpexec(void)
+{
+        void *addr;
+        int err, fd = create_tmp_file(UM_KERN_PAGE_SIZE);
+
+        addr = mmap(NULL, UM_KERN_PAGE_SIZE,
+                    PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd, 0);
+        printf("Checking PROT_EXEC mmap in /tmp...");
+        fflush(stdout);
+        if(addr == MAP_FAILED){
+                err = errno;
+                perror("failed");
+                if(err == EPERM)
+                        printf("/tmp must be not mounted noexec\n");
+                exit(1);
+        }
+        printf("OK\n");
+        munmap(addr, UM_KERN_PAGE_SIZE);
+
+        os_close_file(fd);
+}
+
+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 *addr;
+        int fd;
+
+        fd = open("/dev/anon", O_RDWR);
+        if(fd < 0) {
+                os_print_error(fd, "opening /dev/anon");
+                exit(1);
+        }
+
+        addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+        if(addr == MAP_FAILED){
+                perror("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 iomem_region *new;
+        struct uml_stat buf;
+        char *file, *driver;
+        int fd, err, size;
+
+        driver = str;
+        file = strchr(str,',');
+        if(file == NULL){
+                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){
+                os_print_error(fd, "parse_iomem - Couldn't open io file");
+                goto out;
+        }
+
+        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;
+        }
+
+        size = (buf.ust_size + UM_KERN_PAGE_SIZE) & ~(UM_KERN_PAGE_SIZE - 1);
+
+        *new = ((struct iomem_region) { .next           = iomem_regions,
+                                        .driver         = driver,
+                                        .fd             = fd,
+                                        .size           = 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,
+"iomem=<name>,<file>\n"
+"    Configure <file> as an IO memory region named <name>.\n\n"
+);
+
+int protect_memory(unsigned long addr, unsigned long len, int r, int w, int x,
+                   int must_succeed)
+{
+        int err;
+
+        err = os_protect_memory((void *) addr, len, r, w, x);
+        if(err < 0){
+                if(must_succeed)
+                        panic("protect failed, err = %d", -err);
+                else return(err);
+        }
+        return(0);
+}
+
+#if 0
+/* Debugging facility for dumping stuff out to the host, avoiding the timing
+ * problems that come with printf and breakpoints.
+ * Enable in case of emergency.
+ */
+
+int logging = 1;
+int logging_fd = -1;
+
+int logging_line = 0;
+char logging_buf[512];
+
+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_rdwr(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
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
new file mode 100644
index 000000000000..420e6d51fa0f
--- /dev/null
+++ b/arch/um/kernel/physmem.c
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/mm.h"
+#include "linux/rbtree.h"
+#include "linux/slab.h"
+#include "linux/vmalloc.h"
+#include "linux/bootmem.h"
+#include "linux/module.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"
+
+struct phys_desc {
+        struct rb_node rb;
+        int fd;
+        __u64 offset;
+        void *virt;
+        unsigned long phys;
+        struct list_head list;
+};
+
+static struct rb_root phys_mappings = RB_ROOT;
+
+static struct rb_node **find_rb(void *virt)
+{
+        struct rb_node **n = &phys_mappings.rb_node;
+        struct phys_desc *d;
+
+        while(*n != NULL){
+                d = rb_entry(*n, struct phys_desc, rb);
+                if(d->virt == virt)
+                        return(n);
+
+                if(d->virt > virt)
+                        n = &(*n)->rb_left;
+                else
+                        n = &(*n)->rb_right;
+        }
+
+        return(n);
+}
+
+static struct phys_desc *find_phys_mapping(void *virt)
+{
+        struct rb_node **n = find_rb(virt);
+
+        if(*n == NULL)
+                return(NULL);
+
+        return(rb_entry(*n, struct phys_desc, rb));
+}
+
+static void insert_phys_mapping(struct phys_desc *desc)
+{
+        struct rb_node **n = find_rb(desc->virt);
+
+        if(*n != NULL)
+                panic("Physical remapping for %p already present",
+                      desc->virt);
+
+        rb_link_node(&desc->rb, (*n)->rb_parent, n);
+        rb_insert_color(&desc->rb, &phys_mappings);
+}
+
+LIST_HEAD(descriptor_mappings);
+
+struct desc_mapping {
+        int fd;
+        struct list_head list;
+        struct list_head pages;
+};
+
+static struct desc_mapping *find_mapping(int fd)
+{
+        struct desc_mapping *desc;
+        struct list_head *ele;
+
+        list_for_each(ele, &descriptor_mappings){
+                desc = list_entry(ele, struct desc_mapping, list);
+                if(desc->fd == fd)
+                        return(desc);
+        }
+
+        return(NULL);
+}
+
+static struct desc_mapping *descriptor_mapping(int fd)
+{
+        struct desc_mapping *desc;
+
+        desc = find_mapping(fd);
+        if(desc != NULL)
+                return(desc);
+
+        desc = kmalloc(sizeof(*desc), GFP_ATOMIC);
+        if(desc == NULL)
+                return(NULL);
+
+        *desc = ((struct desc_mapping)
+                { .fd =         fd,
+                  .list =       LIST_HEAD_INIT(desc->list),
+                  .pages =      LIST_HEAD_INIT(desc->pages) });
+        list_add(&desc->list, &descriptor_mappings);
+
+        return(desc);
+}
+
+int physmem_subst_mapping(void *virt, int fd, __u64 offset, int w)
+{
+        struct desc_mapping *fd_maps;
+        struct phys_desc *desc;
+        unsigned long phys;
+        int err;
+
+        fd_maps = descriptor_mapping(fd);
+        if(fd_maps == NULL)
+                return(-ENOMEM);
+
+        phys = __pa(virt);
+        desc = find_phys_mapping(virt);
+        if(desc != NULL)
+                panic("Address 0x%p is already substituted\n", virt);
+
+        err = -ENOMEM;
+        desc = kmalloc(sizeof(*desc), GFP_ATOMIC);
+        if(desc == NULL)
+                goto out;
+
+        *desc = ((struct phys_desc)
+                { .fd =                 fd,
+                  .offset =             offset,
+                  .virt =               virt,
+                  .phys =               __pa(virt),
+                  .list =               LIST_HEAD_INIT(desc->list) });
+        insert_phys_mapping(desc);
+
+        list_add(&desc->list, &fd_maps->pages);
+
+        virt = (void *) ((unsigned long) virt & PAGE_MASK);
+        err = os_map_memory(virt, fd, offset, PAGE_SIZE, 1, w, 0);
+        if(!err)
+                goto out;
+
+        rb_erase(&desc->rb, &phys_mappings);
+        kfree(desc);
+ out:
+        return(err);
+}
+
+static int physmem_fd = -1;
+
+static void remove_mapping(struct phys_desc *desc)
+{
+        void *virt = desc->virt;
+        int err;
+
+        rb_erase(&desc->rb, &phys_mappings);
+        list_del(&desc->list);
+        kfree(desc);
+
+        err = os_map_memory(virt, physmem_fd, __pa(virt), PAGE_SIZE, 1, 1, 0);
+        if(err)
+                panic("Failed to unmap block device page from physical memory, "
+                      "errno = %d", -err);
+}
+
+int physmem_remove_mapping(void *virt)
+{
+        struct phys_desc *desc;
+
+        virt = (void *) ((unsigned long) virt & PAGE_MASK);
+        desc = find_phys_mapping(virt);
+        if(desc == NULL)
+                return(0);
+
+        remove_mapping(desc);
+        return(1);
+}
+
+void physmem_forget_descriptor(int fd)
+{
+        struct desc_mapping *desc;
+        struct phys_desc *page;
+        struct list_head *ele, *next;
+        __u64 offset;
+        void *addr;
+        int err;
+
+        desc = find_mapping(fd);
+        if(desc == NULL)
+                return;
+
+        list_for_each_safe(ele, next, &desc->pages){
+                page = list_entry(ele, struct phys_desc, list);
+                offset = page->offset;
+                addr = page->virt;
+                remove_mapping(page);
+                err = os_seek_file(fd, offset);
+                if(err)
+                        panic("physmem_forget_descriptor - failed to seek "
+                              "to %lld in fd %d, error = %d\n",
+                              offset, fd, -err);
+                err = os_read_file(fd, addr, PAGE_SIZE);
+                if(err < 0)
+                        panic("physmem_forget_descriptor - failed to read "
+                              "from fd %d to 0x%p, error = %d\n",
+                              fd, addr, -err);
+        }
+
+        list_del(&desc->list);
+        kfree(desc);
+}
+
+EXPORT_SYMBOL(physmem_forget_descriptor);
+EXPORT_SYMBOL(physmem_remove_mapping);
+EXPORT_SYMBOL(physmem_subst_mapping);
+
+void arch_free_page(struct page *page, int order)
+{
+        void *virt;
+        int i;
+
+        for(i = 0; i < (1 << order); i++){
+                virt = __va(page_to_phys(page + i));
+                physmem_remove_mapping(virt);
+        }
+}
+
+int is_remapped(void *virt)
+{
+        struct phys_desc *desc = find_phys_mapping(virt);
+
+        return(desc != NULL);
+}
+
+/* Changed during early boot */
+unsigned long high_physmem;
+
+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->lru);
+        }
+
+        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]);
+}
+
+phys_t 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_set_val(pte, page_to_phys(page), 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) {
+                if(err == -ENOMEM)
+                        printk("try increasing the host's "
+                               "/proc/sys/vm/max_map_count to <physical "
+                               "memory size>/4096\n");
+                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_phys_mapping(__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 --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
new file mode 100644
index 000000000000..f76a2692adca
--- /dev/null
+++ b/arch/um/kernel/process.c
@@ -0,0 +1,423 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sched.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <asm/unistd.h>
+#include <asm/page.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "process.h"
+#include "signal_kern.h"
+#include "signal_user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+#include "irq_user.h"
+#include "ptrace_user.h"
+#include "time_user.h"
+#include "init.h"
+#include "os.h"
+#include "uml-config.h"
+#include "ptrace_user.h"
+#include "choose-mode.h"
+#include "mode.h"
+#ifdef UML_CONFIG_MODE_SKAS
+#include "skas.h"
+#include "skas_ptrace.h"
+#include "registers.h"
+#endif
+
+void init_new_thread_stack(void *sig_stack, void (*usr1_handler)(int))
+{
+        int flags = 0, pages;
+
+        if(sig_stack != NULL){
+                pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER);
+                set_sigstack(sig_stack, pages * page_size());
+                flags = SA_ONSTACK;
+        }
+        if(usr1_handler) set_handler(SIGUSR1, usr1_handler, flags, -1);
+}
+
+void init_new_thread_signals(int altstack)
+{
+        int flags = altstack ? SA_ONSTACK : 0;
+
+        set_handler(SIGSEGV, (__sighandler_t) sig_handler, flags,
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGTRAP, (__sighandler_t) sig_handler, flags, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGFPE, (__sighandler_t) sig_handler, flags, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGILL, (__sighandler_t) sig_handler, flags, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGBUS, (__sighandler_t) sig_handler, flags, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGWINCH, (__sighandler_t) sig_handler, flags, 
+                    SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        set_handler(SIGUSR2, (__sighandler_t) sig_handler, 
+                    flags, SIGUSR1, SIGIO, SIGWINCH, SIGALRM, SIGVTALRM, -1);
+        signal(SIGHUP, SIG_IGN);
+
+        init_irq_signals(altstack);
+}
+
+struct tramp {
+        int (*tramp)(void *);
+        void *tramp_data;
+        unsigned long temp_stack;
+        int flags;
+        int pid;
+};
+
+/* See above for why sigkill is here */
+
+int sigkill = SIGKILL;
+
+int outer_tramp(void *arg)
+{
+        struct tramp *t;
+        int sig = sigkill;
+
+        t = arg;
+        t->pid = clone(t->tramp, (void *) t->temp_stack + page_size()/2,
+                       t->flags, t->tramp_data);
+        if(t->pid > 0) wait_for_stop(t->pid, SIGSTOP, PTRACE_CONT, NULL);
+        kill(os_getpid(), sig);
+        _exit(0);
+}
+
+int start_fork_tramp(void *thread_arg, unsigned long temp_stack, 
+                     int clone_flags, int (*tramp)(void *))
+{
+        struct tramp arg;
+        unsigned long sp;
+        int new_pid, status, err;
+
+        /* The trampoline will run on the temporary stack */
+        sp = stack_sp(temp_stack);
+
+        clone_flags |= CLONE_FILES | SIGCHLD;
+
+        arg.tramp = tramp;
+        arg.tramp_data = thread_arg;
+        arg.temp_stack = temp_stack;
+        arg.flags = clone_flags;
+
+        /* 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(new_pid);
+
+        CATCH_EINTR(err = waitpid(new_pid, &status, 0));
+        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, "
+                      "status = %d", status);
+
+        return(arg.pid);
+}
+
+static int ptrace_child(void *arg)
+{
+        int ret;
+        int pid = os_getpid(), ppid = getppid();
+        int sc_result;
+
+        if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0){
+                perror("ptrace");
+                os_kill_process(pid, 0);
+        }
+        os_stop_process(pid);
+
+        /*This syscall will be intercepted by the parent. Don't call more than
+         * once, please.*/
+        sc_result = os_getpid();
+
+        if (sc_result == pid)
+                ret = 1; /*Nothing modified by the parent, we are running
+                           normally.*/
+        else if (sc_result == ppid)
+                ret = 0; /*Expected in check_ptrace and check_sysemu when they
+                           succeed in modifying the stack frame*/
+        else
+                ret = 2; /*Serious trouble! This could be caused by a bug in
+                           host 2.6 SKAS3/2.6 patch before release -V6, together
+                           with a bug in the UML code itself.*/
+        _exit(ret);
+}
+
+static int start_ptraced_child(void **stack_out)
+{
+        void *stack;
+        unsigned long sp;
+        int pid, n, status;
+        
+        stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
+                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+        if(stack == MAP_FAILED)
+                panic("check_ptrace : mmap failed, errno = %d", errno);
+        sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
+        pid = clone(ptrace_child, (void *) sp, SIGCHLD, NULL);
+        if(pid < 0)
+                panic("check_ptrace : clone failed, errno = %d", errno);
+        CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+        if(n < 0)
+                panic("check_ptrace : wait failed, errno = %d", errno);
+        if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
+                panic("check_ptrace : expected SIGSTOP, got status = %d",
+                      status);
+
+        *stack_out = stack;
+        return(pid);
+}
+
+/* When testing for SYSEMU support, if it is one of the broken versions, we must
+ * just avoid using sysemu, not panic, but only if SYSEMU features are broken.
+ * So only for SYSEMU features we test mustpanic, while normal host features
+ * must work anyway!*/
+static int stop_ptraced_child(int pid, void *stack, int exitcode, int mustpanic)
+{
+        int status, n, ret = 0;
+
+        if(ptrace(PTRACE_CONT, pid, 0, 0) < 0)
+                panic("check_ptrace : ptrace failed, errno = %d", errno);
+        CATCH_EINTR(n = waitpid(pid, &status, 0));
+        if(!WIFEXITED(status) || (WEXITSTATUS(status) != exitcode)) {
+                int exit_with = WEXITSTATUS(status);
+                if (exit_with == 2)
+                        printk("check_ptrace : child exited with status 2. "
+                               "Serious trouble happening! Try updating your "
+                               "host skas patch!\nDisabling SYSEMU support.");
+                printk("check_ptrace : child exited with exitcode %d, while "
+                      "expecting %d; status 0x%x", exit_with,
+                      exitcode, status);
+                if (mustpanic)
+                        panic("\n");
+                else
+                        printk("\n");
+                ret = -1;
+        }
+
+        if(munmap(stack, PAGE_SIZE) < 0)
+                panic("check_ptrace : munmap failed, errno = %d", errno);
+        return ret;
+}
+
+static int force_sysemu_disabled = 0;
+
+static int __init nosysemu_cmd_param(char *str, int* add)
+{
+        force_sysemu_disabled = 1;
+        return 0;
+}
+
+__uml_setup("nosysemu", nosysemu_cmd_param,
+                "nosysemu\n"
+                "    Turns off syscall emulation patch for ptrace (SYSEMU) on.\n"
+                "    SYSEMU is a performance-patch introduced by Laurent Vivier. It changes\n"
+                "    behaviour of ptrace() and helps reducing host context switch rate.\n"
+                "    To make it working, you need a kernel patch for your host, too.\n"
+                "    See http://perso.wanadoo.fr/laurent.vivier/UML/ for further information.\n\n");
+
+static void __init check_sysemu(void)
+{
+        void *stack;
+        int pid, syscall, n, status, count=0;
+
+        printk("Checking syscall emulation patch for ptrace...");
+        sysemu_supported = 0;
+        pid = start_ptraced_child(&stack);
+
+        if(ptrace(PTRACE_SYSEMU, pid, 0, 0) < 0)
+                goto fail;
+
+        CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+        if (n < 0)
+                panic("check_sysemu : wait failed, errno = %d", errno);
+        if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP))
+                panic("check_sysemu : expected SIGTRAP, "
+                      "got status = %d", status);
+
+        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET,
+                   os_getpid());
+        if(n < 0)
+                panic("check_sysemu : failed to modify system "
+                      "call return, errno = %d", errno);
+
+        if (stop_ptraced_child(pid, stack, 0, 0) < 0)
+                goto fail_stopped;
+
+        sysemu_supported = 1;
+        printk("OK\n");
+        set_using_sysemu(!force_sysemu_disabled);
+
+        printk("Checking advanced syscall emulation patch for ptrace...");
+        pid = start_ptraced_child(&stack);
+        while(1){
+                count++;
+                if(ptrace(PTRACE_SYSEMU_SINGLESTEP, pid, 0, 0) < 0)
+                        goto fail;
+                CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+                if(n < 0)
+                        panic("check_ptrace : wait failed, errno = %d", errno);
+                if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP))
+                        panic("check_ptrace : expected (SIGTRAP|SYSCALL_TRAP), "
+                              "got status = %d", status);
+
+                syscall = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_NR_OFFSET,
+                                 0);
+                if(syscall == __NR_getpid){
+                        if (!count)
+                                panic("check_ptrace : SYSEMU_SINGLESTEP doesn't singlestep");
+                        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET,
+                                   os_getpid());
+                        if(n < 0)
+                                panic("check_sysemu : failed to modify system "
+                                      "call return, errno = %d", errno);
+                        break;
+                }
+        }
+        if (stop_ptraced_child(pid, stack, 0, 0) < 0)
+                goto fail_stopped;
+
+        sysemu_supported = 2;
+        printk("OK\n");
+
+        if ( !force_sysemu_disabled )
+                set_using_sysemu(sysemu_supported);
+        return;
+
+fail:
+        stop_ptraced_child(pid, stack, 1, 0);
+fail_stopped:
+        printk("missing\n");
+}
+
+void __init check_ptrace(void)
+{
+        void *stack;
+        int pid, syscall, n, status;
+
+        printk("Checking that ptrace can change system call numbers...");
+        pid = start_ptraced_child(&stack);
+
+        if (ptrace(PTRACE_OLDSETOPTIONS, pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0)
+                panic("check_ptrace: PTRACE_SETOPTIONS failed, errno = %d", errno);
+
+        while(1){
+                if(ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)
+                        panic("check_ptrace : ptrace failed, errno = %d", 
+                              errno);
+                CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+                if(n < 0)
+                        panic("check_ptrace : wait failed, errno = %d", errno);
+                if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP + 0x80))
+                        panic("check_ptrace : expected SIGTRAP + 0x80, "
+                              "got status = %d", status);
+                
+                syscall = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_NR_OFFSET,
+                                 0);
+                if(syscall == __NR_getpid){
+                        n = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
+                                   __NR_getppid);
+                        if(n < 0)
+                                panic("check_ptrace : failed to modify system "
+                                      "call, errno = %d", errno);
+                        break;
+                }
+        }
+        stop_ptraced_child(pid, stack, 0, 1);
+        printk("OK\n");
+        check_sysemu();
+}
+
+int run_kernel_thread(int (*fn)(void *), void *arg, void **jmp_ptr)
+{
+        sigjmp_buf buf;
+        int n;
+
+        *jmp_ptr = &buf;
+        n = sigsetjmp(buf, 1);
+        if(n != 0)
+                return(n);
+        (*fn)(arg);
+        return(0);
+}
+
+void forward_pending_sigio(int target)
+{
+        sigset_t sigs;
+
+        if(sigpending(&sigs)) 
+                panic("forward_pending_sigio : sigpending failed");
+        if(sigismember(&sigs, SIGIO))
+                kill(target, SIGIO);
+}
+
+#ifdef UML_CONFIG_MODE_SKAS
+static inline int check_skas3_ptrace_support(void)
+{
+        struct ptrace_faultinfo fi;
+        void *stack;
+        int pid, n, ret = 1;
+
+        printf("Checking for the skas3 patch in the host...");
+        pid = start_ptraced_child(&stack);
+
+        n = ptrace(PTRACE_FAULTINFO, pid, 0, &fi);
+        if (n < 0) {
+                if(errno == EIO)
+                        printf("not found\n");
+                else {
+                        perror("not found");
+                }
+                ret = 0;
+        } else {
+                printf("found\n");
+        }
+
+        init_registers(pid);
+        stop_ptraced_child(pid, stack, 1, 1);
+
+        return(ret);
+}
+
+int can_do_skas(void)
+{
+        int ret = 1;
+
+        printf("Checking for /proc/mm...");
+        if (os_access("/proc/mm", OS_ACC_W_OK) < 0) {
+                printf("not found\n");
+                ret = 0;
+                goto out;
+        } else {
+                printf("found\n");
+        }
+
+        ret = check_skas3_ptrace_support();
+out:
+        return ret;
+}
+#else
+int can_do_skas(void)
+{
+        return(0);
+}
+#endif
diff --git a/arch/um/kernel/process_kern.c b/arch/um/kernel/process_kern.c
new file mode 100644
index 000000000000..1d719d5b4bb9
--- /dev/null
+++ b/arch/um/kernel/process_kern.c
@@ -0,0 +1,500 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright 2003 PathScale, Inc.
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/sched.h"
+#include "linux/interrupt.h"
+#include "linux/mm.h"
+#include "linux/slab.h"
+#include "linux/utsname.h"
+#include "linux/fs.h"
+#include "linux/utime.h"
+#include "linux/smp_lock.h"
+#include "linux/module.h"
+#include "linux/init.h"
+#include "linux/capability.h"
+#include "linux/vmalloc.h"
+#include "linux/spinlock.h"
+#include "linux/proc_fs.h"
+#include "linux/ptrace.h"
+#include "linux/random.h"
+#include "asm/unistd.h"
+#include "asm/mman.h"
+#include "asm/segment.h"
+#include "asm/stat.h"
+#include "asm/pgtable.h"
+#include "asm/processor.h"
+#include "asm/tlbflush.h"
+#include "asm/uaccess.h"
+#include "asm/user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "signal_kern.h"
+#include "signal_user.h"
+#include "init.h"
+#include "irq_user.h"
+#include "mem_user.h"
+#include "time_user.h"
+#include "tlb.h"
+#include "frame_kern.h"
+#include "sigcontext.h"
+#include "2_5compat.h"
+#include "os.h"
+#include "mode.h"
+#include "mode_kern.h"
+#include "choose-mode.h"
+
+/* This is a per-cpu array.  A processor only modifies its entry and it only
+ * cares about its entry, so it's OK if another processor is modifying its
+ * entry.
+ */
+struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
+
+struct task_struct *get_task(int pid, int require)
+{
+        struct task_struct *ret;
+
+        read_lock(&tasklist_lock);
+        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);
+}
+
+int external_pid(void *t)
+{
+        struct task_struct *task = t ? t : current;
+
+        return(CHOOSE_MODE_PROC(external_pid_tt, external_pid_skas, task));
+}
+
+int pid_to_processor_id(int pid)
+{
+        int i;
+
+        for(i = 0; i < ncpus; i++){
+                if(cpu_tasks[i].pid == pid) return(i);
+        }
+        return(-1);
+}
+
+void free_stack(unsigned long stack, int order)
+{
+        free_pages(stack, order);
+}
+
+unsigned long alloc_stack(int order, int atomic)
+{
+        unsigned long page;
+        int flags = GFP_KERNEL;
+
+        if(atomic) flags |= GFP_ATOMIC;
+        page = __get_free_pages(flags, order);
+        if(page == 0)
+                return(0);
+        stack_protections(page);
+        return(page);
+}
+
+int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+{
+        int pid;
+
+        current->thread.request.u.thread.proc = fn;
+        current->thread.request.u.thread.arg = arg;
+        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, 
+               struct task_struct *tsk)
+{
+        int cpu = smp_processor_id();
+
+        if (prev != next) 
+                cpu_clear(cpu, prev->cpu_vm_mask);
+        cpu_set(cpu, next->cpu_vm_mask);
+}
+
+void set_current(void *t)
+{
+        struct task_struct *task = t;
+
+        cpu_tasks[task->thread_info->cpu] = ((struct cpu_task) 
+                { external_pid(task), task });
+}
+
+void *_switch_to(void *prev, void *next, void *last)
+{
+        return(CHOOSE_MODE(switch_to_tt(prev, next), 
+                           switch_to_skas(prev, next)));
+}
+
+void interrupt_end(void)
+{
+        if(need_resched()) schedule();
+        if(test_tsk_thread_flag(current, TIF_SIGPENDING)) do_signal();
+}
+
+void release_thread(struct task_struct *task)
+{
+        CHOOSE_MODE(release_thread_tt(task), release_thread_skas(task));
+}
+ 
+void exit_thread(void)
+{
+        CHOOSE_MODE(exit_thread_tt(), exit_thread_skas());
+        unprotect_stack((unsigned long) current_thread);
+}
+ 
+void *get_current(void)
+{
+        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)
+{
+        p->thread = (struct thread_struct) INIT_THREAD;
+        return(CHOOSE_MODE_PROC(copy_thread_tt, copy_thread_skas, nr, 
+                                clone_flags, sp, stack_top, p, regs));
+}
+
+void initial_thread_cb(void (*proc)(void *), void *arg)
+{
+        int save_kmalloc_ok = kmalloc_ok;
+
+        kmalloc_ok = 0;
+        CHOOSE_MODE_PROC(initial_thread_cb_tt, initial_thread_cb_skas, proc, 
+                         arg);
+        kmalloc_ok = save_kmalloc_ok;
+}
+ 
+unsigned long stack_sp(unsigned long page)
+{
+        return(page + PAGE_SIZE - sizeof(void *));
+}
+
+int current_pid(void)
+{
+        return(current->pid);
+}
+
+void default_idle(void)
+{
+        uml_idle_timer();
+
+        atomic_inc(&init_mm.mm_count);
+        current->mm = &init_mm;
+        current->active_mm = &init_mm;
+
+        while(1){
+                /* endless idle loop with no priority at all */
+                SET_PRI(current);
+
+                /*
+                 * although we are an idle CPU, we do not want to
+                 * get into the scheduler unnecessarily.
+                 */
+                if(need_resched())
+                        schedule();
+                
+                idle_sleep(10);
+        }
+}
+
+void cpu_idle(void)
+{
+        CHOOSE_MODE(init_idle_tt(), init_idle_skas());
+}
+
+int page_size(void)
+{
+        return(PAGE_SIZE);
+}
+
+unsigned long page_mask(void)
+{
+        return(PAGE_MASK);
+}
+
+void *um_virt_to_phys(struct task_struct *task, unsigned long addr, 
+                      pte_t *pte_out)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+
+        if(task->mm == NULL) 
+                return(ERR_PTR(-EINVAL));
+        pgd = pgd_offset(task->mm, addr);
+        if(!pgd_present(*pgd))
+                return(ERR_PTR(-EINVAL));
+
+        pud = pud_offset(pgd, addr);
+        if(!pud_present(*pud))
+                return(ERR_PTR(-EINVAL));
+
+        pmd = pmd_offset(pud, addr);
+        if(!pmd_present(*pmd)) 
+                return(ERR_PTR(-EINVAL));
+
+        pte = pte_offset_kernel(pmd, addr);
+        if(!pte_present(*pte)) 
+                return(ERR_PTR(-EINVAL));
+
+        if(pte_out != NULL)
+                *pte_out = *pte;
+        return((void *) (pte_val(*pte) & PAGE_MASK) + (addr & ~PAGE_MASK));
+}
+
+char *current_cmd(void)
+{
+#if defined(CONFIG_SMP) || defined(CONFIG_HIGHMEM)
+        return("(Unknown)");
+#else
+        void *addr = um_virt_to_phys(current, current->mm->arg_start, NULL);
+        return IS_ERR(addr) ? "(Unknown)": __va((unsigned long) addr);
+#endif
+}
+
+void force_sigbus(void)
+{
+        printk(KERN_ERR "Killing pid %d because of a lack of memory\n", 
+               current->pid);
+        lock_kernel();
+        sigaddset(&current->pending.signal, SIGBUS);
+        recalc_sigpending();
+        current->flags |= PF_SIGNALED;
+        do_exit(SIGBUS | 0x80);
+}
+
+void dump_thread(struct pt_regs *regs, struct user *u)
+{
+}
+
+void enable_hlt(void)
+{
+        panic("enable_hlt");
+}
+
+EXPORT_SYMBOL(enable_hlt);
+
+void disable_hlt(void)
+{
+        panic("disable_hlt");
+}
+
+EXPORT_SYMBOL(disable_hlt);
+
+void *um_kmalloc(int size)
+{
+        return(kmalloc(size, GFP_KERNEL));
+}
+
+void *um_kmalloc_atomic(int size)
+{
+        return(kmalloc(size, GFP_ATOMIC));
+}
+
+void *um_vmalloc(int size)
+{
+        return(vmalloc(size));
+}
+
+unsigned long get_fault_addr(void)
+{
+        return((unsigned long) current->thread.fault_addr);
+}
+
+EXPORT_SYMBOL(get_fault_addr);
+
+void not_implemented(void)
+{
+        printk(KERN_DEBUG "Something isn't implemented in here\n");
+}
+
+EXPORT_SYMBOL(not_implemented);
+
+int user_context(unsigned long sp)
+{
+        unsigned long stack;
+
+        stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
+        return(stack != (unsigned long) current_thread);
+}
+
+extern void remove_umid_dir(void);
+
+__uml_exitcall(remove_umid_dir);
+
+extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
+
+void do_uml_exitcalls(void)
+{
+        exitcall_t *call;
+
+        call = &__uml_exitcall_end;
+        while (--call >= &__uml_exitcall_begin)
+                (*call)();
+}
+
+char *uml_strdup(char *string)
+{
+        char *new;
+
+        new = kmalloc(strlen(string) + 1, GFP_KERNEL);
+        if(new == NULL) return(NULL);
+        strcpy(new, string);
+        return(new);
+}
+
+void *get_init_task(void)
+{
+        return(&init_thread_union.thread_info.task);
+}
+
+int copy_to_user_proc(void __user *to, void *from, int size)
+{
+        return(copy_to_user(to, from, size));
+}
+
+int copy_from_user_proc(void *to, void __user *from, int size)
+{
+        return(copy_from_user(to, from, size));
+}
+
+int clear_user_proc(void __user *buf, int size)
+{
+        return(clear_user(buf, size));
+}
+
+int strlen_user_proc(char __user *str)
+{
+        return(strlen_user(str));
+}
+
+int smp_sigio_handler(void)
+{
+#ifdef CONFIG_SMP
+        int cpu = current_thread->cpu;
+        IPI_handler(cpu);
+        if(cpu != 0)
+                return(1);
+#endif
+        return(0);
+}
+
+int um_in_interrupt(void)
+{
+        return(in_interrupt());
+}
+
+int cpu(void)
+{
+        return(current_thread->cpu);
+}
+
+static atomic_t using_sysemu = ATOMIC_INIT(0);
+int sysemu_supported;
+
+void set_using_sysemu(int value)
+{
+        if (value > sysemu_supported)
+                return;
+        atomic_set(&using_sysemu, value);
+}
+
+int get_using_sysemu(void)
+{
+        return atomic_read(&using_sysemu);
+}
+
+static int proc_read_sysemu(char *buf, char **start, off_t offset, int size,int *eof, void *data)
+{
+        if (snprintf(buf, size, "%d\n", get_using_sysemu()) < size) /*No overflow*/
+                *eof = 1;
+
+        return strlen(buf);
+}
+
+static int proc_write_sysemu(struct file *file,const char *buf, unsigned long count,void *data)
+{
+        char tmp[2];
+
+        if (copy_from_user(tmp, buf, 1))
+                return -EFAULT;
+
+        if (tmp[0] >= '0' && tmp[0] <= '2')
+                set_using_sysemu(tmp[0] - '0');
+        return count; /*We use the first char, but pretend to write everything*/
+}
+
+int __init make_proc_sysemu(void)
+{
+        struct proc_dir_entry *ent;
+        if (!sysemu_supported)
+                return 0;
+
+        ent = create_proc_entry("sysemu", 0600, &proc_root);
+
+        if (ent == NULL)
+        {
+                printk("Failed to register /proc/sysemu\n");
+                return(0);
+        }
+
+        ent->read_proc  = proc_read_sysemu;
+        ent->write_proc = proc_write_sysemu;
+
+        return 0;
+}
+
+late_initcall(make_proc_sysemu);
+
+int singlestepping(void * t)
+{
+        struct task_struct *task = t ? t : current;
+
+        if ( ! (task->ptrace & PT_DTRACE) )
+                return(0);
+
+        if (task->thread.singlestep_syscall)
+                return(1);
+
+        return 2;
+}
+
+unsigned long arch_align_stack(unsigned long sp)
+{
+        if (randomize_va_space)
+                sp -= get_random_int() % 8192;
+        return sp & ~0xf;
+}
+
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/ptrace.c b/arch/um/kernel/ptrace.c
new file mode 100644
index 000000000000..3a99ee6d94eb
--- /dev/null
+++ b/arch/um/kernel/ptrace.c
@@ -0,0 +1,388 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/mm.h"
+#include "linux/errno.h"
+#include "linux/smp_lock.h"
+#include "linux/security.h"
+#include "linux/ptrace.h"
+#include "linux/audit.h"
+#ifdef CONFIG_PROC_MM
+#include "linux/proc_mm.h"
+#endif
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+#include "kern_util.h"
+#include "skas_ptrace.h"
+#include "sysdep/ptrace.h"
+
+/*
+ * Called by kernel/ptrace.c when detaching..
+ */
+void ptrace_disable(struct task_struct *child)
+{ 
+        child->ptrace &= ~PT_DTRACE;
+        child->thread.singlestep_syscall = 0;
+}
+
+long sys_ptrace(long request, long pid, long addr, long data)
+{
+        struct task_struct *child;
+        int i, ret;
+
+        lock_kernel();
+        ret = -EPERM;
+        if (request == PTRACE_TRACEME) {
+                /* are we already being traced? */
+                if (current->ptrace & PT_PTRACED)
+                        goto out;
+
+                ret = security_ptrace(current->parent, current);
+                if (ret)
+                        goto out;
+
+                /* set the ptrace bit in the process flags. */
+                current->ptrace |= PT_PTRACED;
+                ret = 0;
+                goto out;
+        }
+        ret = -ESRCH;
+        read_lock(&tasklist_lock);
+        child = find_task_by_pid(pid);
+        if (child)
+                get_task_struct(child);
+        read_unlock(&tasklist_lock);
+        if (!child)
+                goto out;
+
+        ret = -EPERM;
+        if (pid == 1)           /* you may not mess with init */
+                goto out_tsk;
+
+        if (request == PTRACE_ATTACH) {
+                ret = ptrace_attach(child);
+                goto out_tsk;
+        }
+
+        ret = ptrace_check_attach(child, request == PTRACE_KILL);
+        if (ret < 0)
+                goto out_tsk;
+
+        switch (request) {
+                /* when I and D space are separate, these will need to be fixed. */
+        case PTRACE_PEEKTEXT: /* read word at location addr. */ 
+        case PTRACE_PEEKDATA: {
+                unsigned long tmp;
+                int copied;
+
+                ret = -EIO;
+                copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
+                if (copied != sizeof(tmp))
+                        break;
+                ret = put_user(tmp, (unsigned long __user *) data);
+                break;
+        }
+
+        /* read the word at location addr in the USER area. */
+        case PTRACE_PEEKUSR: {
+                unsigned long tmp;
+
+                ret = -EIO;
+                if ((addr & 3) || addr < 0) 
+                        break;
+
+                tmp = 0;  /* Default return condition */
+                if(addr < MAX_REG_OFFSET){
+                        tmp = getreg(child, addr);
+                }
+                else if((addr >= offsetof(struct user, u_debugreg[0])) &&
+                        (addr <= offsetof(struct user, u_debugreg[7]))){
+                        addr -= offsetof(struct user, u_debugreg[0]);
+                        addr = addr >> 2;
+                        tmp = child->thread.arch.debugregs[addr];
+                }
+                ret = put_user(tmp, (unsigned long __user *) data);
+                break;
+        }
+
+        /* when I and D space are separate, this will have to be fixed. */
+        case PTRACE_POKETEXT: /* write the word at location addr. */
+        case PTRACE_POKEDATA:
+                ret = -EIO;
+                if (access_process_vm(child, addr, &data, sizeof(data), 
+                                      1) != sizeof(data))
+                        break;
+                ret = 0;
+                break;
+
+        case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
+                ret = -EIO;
+                if ((addr & 3) || addr < 0)
+                        break;
+
+                if (addr < MAX_REG_OFFSET) {
+                        ret = putreg(child, addr, data);
+                        break;
+                }
+#if 0 /* XXX x86_64 */
+                else if((addr >= offsetof(struct user, u_debugreg[0])) &&
+                        (addr <= offsetof(struct user, u_debugreg[7]))){
+                          addr -= offsetof(struct user, u_debugreg[0]);
+                          addr = addr >> 2;
+                          if((addr == 4) || (addr == 5)) break;
+                          child->thread.arch.debugregs[addr] = data;
+                          ret = 0;
+                }
+#endif
+
+                break;
+
+        case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
+        case PTRACE_CONT: { /* restart after signal. */
+                ret = -EIO;
+                if ((unsigned long) data > _NSIG)
+                        break;
+
+                child->ptrace &= ~PT_DTRACE;
+                child->thread.singlestep_syscall = 0;
+                if (request == PTRACE_SYSCALL) {
+                        set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+                }
+                else {
+                        clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+                }
+                child->exit_code = data;
+                wake_up_process(child);
+                ret = 0;
+                break;
+        }
+
+/*
+ * make the child exit.  Best I can do is send it a sigkill. 
+ * perhaps it should be put in the status that it wants to 
+ * exit.
+ */
+        case PTRACE_KILL: {
+                ret = 0;
+                if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
+                        break;
+
+                child->ptrace &= ~PT_DTRACE;
+                child->thread.singlestep_syscall = 0;
+                child->exit_code = SIGKILL;
+                wake_up_process(child);
+                break;
+        }
+
+        case PTRACE_SINGLESTEP: {  /* set the trap flag. */
+                ret = -EIO;
+                if ((unsigned long) data > _NSIG)
+                        break;
+                clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+                child->ptrace |= PT_DTRACE;
+                child->thread.singlestep_syscall = 0;
+                child->exit_code = data;
+                /* give it a chance to run. */
+                wake_up_process(child);
+                ret = 0;
+                break;
+        }
+
+        case PTRACE_DETACH:
+                /* detach a process that was attached. */
+                ret = ptrace_detach(child, data);
+                break;
+
+#ifdef PTRACE_GETREGS
+        case PTRACE_GETREGS: { /* Get all gp regs from the child. */
+                if (!access_ok(VERIFY_WRITE, (unsigned long *)data, 
+                               MAX_REG_OFFSET)) {
+                        ret = -EIO;
+                        break;
+                }
+                for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
+                        __put_user(getreg(child, i),
+                                   (unsigned long __user *) data);
+                        data += sizeof(long);
+                }
+                ret = 0;
+                break;
+        }
+#endif
+#ifdef PTRACE_SETREGS
+        case PTRACE_SETREGS: { /* Set all gp regs in the child. */
+                unsigned long tmp = 0;
+                if (!access_ok(VERIFY_READ, (unsigned *)data, 
+                               MAX_REG_OFFSET)) {
+                        ret = -EIO;
+                        break;
+                }
+                for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
+                        __get_user(tmp, (unsigned long __user *) data);
+                        putreg(child, i, tmp);
+                        data += sizeof(long);
+                }
+                ret = 0;
+                break;
+        }
+#endif
+#ifdef PTRACE_GETFPREGS
+        case PTRACE_GETFPREGS: /* Get the child FPU state. */
+                ret = get_fpregs(data, child);
+                break;
+#endif
+#ifdef PTRACE_SETFPREGS
+        case PTRACE_SETFPREGS: /* Set the child FPU state. */
+                ret = set_fpregs(data, child);
+                break;
+#endif
+#ifdef PTRACE_GETFPXREGS
+        case PTRACE_GETFPXREGS: /* Get the child FPU state. */
+                ret = get_fpxregs(data, child);
+                break;
+#endif
+#ifdef PTRACE_SETFPXREGS
+        case PTRACE_SETFPXREGS: /* Set the child FPU state. */
+                ret = set_fpxregs(data, child);
+                break;
+#endif
+        case PTRACE_FAULTINFO: {
+                struct ptrace_faultinfo fault;
+
+                fault = ((struct ptrace_faultinfo) 
+                        { .is_write     = child->thread.err,
+                          .addr         = child->thread.cr2 });
+                ret = copy_to_user((unsigned long __user *) data, &fault,
+                                   sizeof(fault));
+                if(ret)
+                        break;
+                break;
+        }
+        case PTRACE_SIGPENDING:
+                ret = copy_to_user((unsigned long __user *) data,
+                                   &child->pending.signal,
+                                   sizeof(child->pending.signal));
+                break;
+
+        case PTRACE_LDT: {
+                struct ptrace_ldt ldt;
+
+                if(copy_from_user(&ldt, (unsigned long __user *) data,
+                                  sizeof(ldt))){
+                        ret = -EIO;
+                        break;
+                }
+
+                /* This one is confusing, so just punt and return -EIO for 
+                 * now
+                 */
+                ret = -EIO;
+                break;
+        }
+#ifdef CONFIG_PROC_MM
+        case PTRACE_SWITCH_MM: {
+                struct mm_struct *old = child->mm;
+                struct mm_struct *new = proc_mm_get_mm(data);
+
+                if(IS_ERR(new)){
+                        ret = PTR_ERR(new);
+                        break;
+                }
+
+                atomic_inc(&new->mm_users);
+                child->mm = new;
+                child->active_mm = new;
+                mmput(old);
+                ret = 0;
+                break;
+        }
+#endif
+        default:
+                ret = ptrace_request(child, request, addr, data);
+                break;
+        }
+ out_tsk:
+        put_task_struct(child);
+ out:
+        unlock_kernel();
+        return ret;
+}
+
+void send_sigtrap(struct task_struct *tsk, union uml_pt_regs *regs,
+                  int error_code)
+{
+        struct siginfo info;
+
+        memset(&info, 0, sizeof(info));
+        info.si_signo = SIGTRAP;
+        info.si_code = TRAP_BRKPT;
+
+        /* User-mode eip? */
+        info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;
+
+        /* Send us the fakey SIGTRAP */
+        force_sig_info(SIGTRAP, &info, tsk);
+}
+
+/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
+ * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
+ */
+void syscall_trace(union uml_pt_regs *regs, int entryexit)
+{
+        int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
+        int tracesysgood;
+
+        if (unlikely(current->audit_context)) {
+                if (!entryexit)
+                        audit_syscall_entry(current, 
+                                            UPT_SYSCALL_NR(&regs->regs),
+                                            UPT_SYSCALL_ARG1(&regs->regs),
+                                            UPT_SYSCALL_ARG2(&regs->regs),
+                                            UPT_SYSCALL_ARG3(&regs->regs),
+                                            UPT_SYSCALL_ARG4(&regs->regs));
+                else
+                        audit_syscall_exit(current, 
+                                           UPT_SYSCALL_RET(&regs->regs));
+        }
+
+        /* Fake a debug trap */
+        if (is_singlestep)
+                send_sigtrap(current, regs, 0);
+
+        if (!test_thread_flag(TIF_SYSCALL_TRACE))
+                return;
+
+        if (!(current->ptrace & PT_PTRACED))
+                return;
+
+        /* the 0x80 provides a way for the tracing parent to distinguish
+           between a syscall stop and SIGTRAP delivery */
+        tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
+        ptrace_notify(SIGTRAP | (tracesysgood ? 0x80 : 0));
+
+        if (entryexit) /* force do_signal() --> is_syscall() */
+                set_thread_flag(TIF_SIGPENDING);
+
+        /* this isn't the same as continuing with a signal, but it will do
+         * for normal use.  strace only continues with a signal if the
+         * stopping signal is not SIGTRAP.  -brl
+         */
+        if (current->exit_code) {
+                send_sig(current->exit_code, current, 1);
+                current->exit_code = 0;
+        }
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/reboot.c b/arch/um/kernel/reboot.c
new file mode 100644
index 000000000000..207f89d74908
--- /dev/null
+++ b/arch/um/kernel/reboot.c
@@ -0,0 +1,79 @@
+/* 
+ * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/module.h"
+#include "linux/sched.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "os.h"
+#include "mode.h"
+#include "choose-mode.h"
+
+#ifdef CONFIG_SMP
+static void kill_idlers(int me)
+{
+#ifdef CONFIG_MODE_TT
+        struct task_struct *p;
+        int i;
+
+        for(i = 0; i < sizeof(idle_threads)/sizeof(idle_threads[0]); i++){
+                p = idle_threads[i];
+                if((p != NULL) && (p->thread.mode.tt.extern_pid != me))
+                        os_kill_process(p->thread.mode.tt.extern_pid, 0);
+        }
+#endif
+}
+#endif
+
+static void kill_off_processes(void)
+{
+        CHOOSE_MODE(kill_off_processes_tt(), kill_off_processes_skas());
+#ifdef CONFIG_SMP
+        kill_idlers(os_getpid());
+#endif
+}
+
+void uml_cleanup(void)
+{
+        kill_off_processes();
+        do_uml_exitcalls();
+}
+
+void machine_restart(char * __unused)
+{
+        do_uml_exitcalls();
+        kill_off_processes();
+        CHOOSE_MODE(reboot_tt(), reboot_skas());
+}
+
+EXPORT_SYMBOL(machine_restart);
+
+void machine_power_off(void)
+{
+        do_uml_exitcalls();
+        kill_off_processes();
+        CHOOSE_MODE(halt_tt(), halt_skas());
+}
+
+EXPORT_SYMBOL(machine_power_off);
+
+void machine_halt(void)
+{
+        machine_power_off();
+}
+
+EXPORT_SYMBOL(machine_halt);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/resource.c b/arch/um/kernel/resource.c
new file mode 100644
index 000000000000..32188e12e8af
--- /dev/null
+++ b/arch/um/kernel/resource.c
@@ -0,0 +1,23 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/pci.h"
+
+unsigned long resource_fixup(struct pci_dev * dev, struct resource * res,
+                             unsigned long start, unsigned long size)
+{
+        return start;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/sigio_kern.c b/arch/um/kernel/sigio_kern.c
new file mode 100644
index 000000000000..229988463c4c
--- /dev/null
+++ b/arch/um/kernel/sigio_kern.c
@@ -0,0 +1,63 @@
+/* 
+ * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/list.h"
+#include "linux/slab.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;
+
+static 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)
+{
+        int err;
+
+        err = um_request_irq(SIGIO_WRITE_IRQ, fd, IRQ_READ, sigio_interrupt,
+                             SA_INTERRUPT | SA_SAMPLE_RANDOM, "write sigio",
+                             NULL);
+        if(err){
+                printk("write_sigio_irq : um_request_irq failed, err = %d\n",
+                       err);
+                return(-1);
+        }
+        sigio_irq_fd = fd;
+        return(0);
+}
+
+static DEFINE_SPINLOCK(sigio_spinlock);
+
+void sigio_lock(void)
+{
+        spin_lock(&sigio_spinlock);
+}
+
+void sigio_unlock(void)
+{
+        spin_unlock(&sigio_spinlock);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/sigio_user.c b/arch/um/kernel/sigio_user.c
new file mode 100644
index 000000000000..668df13d8c9d
--- /dev/null
+++ b/arch/um/kernel/sigio_user.c
@@ -0,0 +1,431 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <pty.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sched.h>
+#include <sys/socket.h>
+#include <sys/poll.h>
+#include "init.h"
+#include "user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "sigio.h"
+#include "helper.h"
+#include "os.h"
+
+/* Changed during early boot */
+int pty_output_sigio = 0;
+int pty_close_sigio = 0;
+
+/* Used as a flag during SIGIO testing early in boot */
+static volatile int got_sigio = 0;
+
+void __init handler(int sig)
+{
+        got_sigio = 1;
+}
+
+struct openpty_arg {
+        int master;
+        int slave;
+        int err;
+};
+
+static void openpty_cb(void *arg)
+{
+        struct openpty_arg *info = arg;
+
+        info->err = 0;
+        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
+                info->err = -errno;
+}
+
+void __init check_one_sigio(void (*proc)(int, int))
+{
+        struct sigaction old, new;
+        struct openpty_arg pty = { .master = -1, .slave = -1 };
+        int master, slave, err;
+
+        initial_thread_cb(openpty_cb, &pty);
+        if(pty.err){
+                printk("openpty failed, errno = %d\n", -pty.err);
+                return;
+        }
+
+        master = pty.master;
+        slave = pty.slave;
+
+        if((master == -1) || (slave == -1)){
+                printk("openpty failed to allocate a pty\n");
+                return;
+        }
+
+        /* Not now, but complain so we now where we failed. */
+        err = raw(master);
+        if (err < 0)
+                panic("check_sigio : __raw failed, errno = %d\n", -err);
+
+        err = 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);
+        new = old;
+        new.sa_handler = handler;
+        if(sigaction(SIGIO, &new, NULL) < 0)
+                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
+
+        got_sigio = 0;
+        (*proc)(master, slave);
+                
+        os_close_file(master);
+        os_close_file(slave);
+
+        if(sigaction(SIGIO, &old, NULL) < 0)
+                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
+}
+
+static void tty_output(int master, int slave)
+{
+        int n;
+        char buf[512];
+
+        printk("Checking that host ptys support output SIGIO...");
+
+        memset(buf, 0, sizeof(buf));
+
+        while(os_write_file(master, buf, sizeof(buf)) > 0) ;
+        if(errno != EAGAIN)
+                panic("check_sigio : write failed, errno = %d\n", errno);
+        while(((n = os_read_file(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
+
+        if (got_sigio) {
+                printk("Yes\n");
+                pty_output_sigio = 1;
+        } else if (n == -EAGAIN) {
+                printk("No, enabling workaround\n");
+        } else {
+                panic("check_sigio : read failed, err = %d\n", n);
+        }
+}
+
+static void tty_close(int master, int slave)
+{
+        printk("Checking that host ptys support SIGIO on close...");
+
+        os_close_file(slave);
+        if(got_sigio){
+                printk("Yes\n");
+                pty_close_sigio = 1;
+        }
+        else printk("No, enabling workaround\n");
+}
+
+void __init check_sigio(void)
+{
+        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
+           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
+                printk("No pseudo-terminals available - skipping pty SIGIO "
+                       "check\n");
+                return;
+        }
+        check_one_sigio(tty_output);
+        check_one_sigio(tty_close);
+}
+
+/* Protected by sigio_lock(), also used by sigio_cleanup, which is an 
+ * exitcall.
+ */
+static int write_sigio_pid = -1;
+
+/* These arrays are initialized before the sigio thread is started, and
+ * the descriptors closed after it is killed.  So, it can't see them change.
+ * On the UML side, they are changed under the sigio_lock.
+ */
+static int write_sigio_fds[2] = { -1, -1 };
+static int sigio_private[2] = { -1, -1 };
+
+struct pollfds {
+        struct pollfd *poll;
+        int size;
+        int used;
+};
+
+/* Protected by sigio_lock().  Used by the sigio thread, but the UML thread
+ * synchronizes with it.
+ */
+struct pollfds current_poll = {
+        .poll           = NULL,
+        .size           = 0,
+        .used           = 0
+};
+
+struct pollfds next_poll = {
+        .poll           = NULL,
+        .size           = 0,
+        .used           = 0
+};
+
+static int write_sigio_thread(void *unused)
+{
+        struct pollfds *fds, tmp;
+        struct pollfd *p;
+        int i, n, respond_fd;
+        char c;
+
+        fds = &current_poll;
+        while(1){
+                n = poll(fds->poll, fds->used, -1);
+                if(n < 0){
+                        if(errno == EINTR) continue;
+                        printk("write_sigio_thread : poll returned %d, "
+                               "errno = %d\n", n, errno);
+                }
+                for(i = 0; i < fds->used; i++){
+                        p = &fds->poll[i];
+                        if(p->revents == 0) continue;
+                        if(p->fd == sigio_private[1]){
+                                n = os_read_file(sigio_private[1], &c, sizeof(c));
+                                if(n != sizeof(c))
+                                        printk("write_sigio_thread : "
+                                               "read failed, err = %d\n", -n);
+                                tmp = current_poll;
+                                current_poll = next_poll;
+                                next_poll = tmp;
+                                respond_fd = sigio_private[1];
+                        }
+                        else {
+                                respond_fd = write_sigio_fds[1];
+                                fds->used--;
+                                memmove(&fds->poll[i], &fds->poll[i + 1],
+                                        (fds->used - i) * sizeof(*fds->poll));
+                        }
+
+                        n = os_write_file(respond_fd, &c, sizeof(c));
+                        if(n != sizeof(c))
+                                printk("write_sigio_thread : write failed, "
+                                       "err = %d\n", -n);
+                }
+        }
+}
+
+static int need_poll(int n)
+{
+        if(n <= next_poll.size){
+                next_poll.used = n;
+                return(0);
+        }
+        if(next_poll.poll != NULL) kfree(next_poll.poll);
+        next_poll.poll = um_kmalloc_atomic(n * sizeof(struct pollfd));
+        if(next_poll.poll == NULL){
+                printk("need_poll : failed to allocate new pollfds\n");
+                next_poll.size = 0;
+                next_poll.used = 0;
+                return(-1);
+        }
+        next_poll.size = n;
+        next_poll.used = n;
+        return(0);
+}
+
+/* Must be called with sigio_lock held, because it's needed by the marked
+ * critical section. */
+static void update_thread(void)
+{
+        unsigned long flags;
+        int n;
+        char c;
+
+        flags = set_signals(0);
+        n = os_write_file(sigio_private[0], &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("update_thread : write failed, err = %d\n", -n);
+                goto fail;
+        }
+
+        n = os_read_file(sigio_private[0], &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("update_thread : read failed, err = %d\n", -n);
+                goto fail;
+        }
+
+        set_signals(flags);
+        return;
+ fail:
+        /* Critical section start */
+        if(write_sigio_pid != -1) 
+                os_kill_process(write_sigio_pid, 1);
+        write_sigio_pid = -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]);
+        /* Critical section end */
+        set_signals(flags);
+}
+
+int add_sigio_fd(int fd, int read)
+{
+        int err = 0, i, n, events;
+
+        sigio_lock();
+        for(i = 0; i < current_poll.used; i++){
+                if(current_poll.poll[i].fd == fd) 
+                        goto out;
+        }
+
+        n = current_poll.used + 1;
+        err = need_poll(n);
+        if(err) 
+                goto out;
+
+        for(i = 0; i < current_poll.used; i++)
+                next_poll.poll[i] = current_poll.poll[i];
+
+        if(read) events = POLLIN;
+        else events = POLLOUT;
+
+        next_poll.poll[n - 1] = ((struct pollfd) { .fd          = fd,
+                                                   .events      = events,
+                                                   .revents     = 0 });
+        update_thread();
+ out:
+        sigio_unlock();
+        return(err);
+}
+
+int ignore_sigio_fd(int fd)
+{
+        struct pollfd *p;
+        int err = 0, i, n = 0;
+
+        sigio_lock();
+        for(i = 0; i < current_poll.used; i++){
+                if(current_poll.poll[i].fd == fd) break;
+        }
+        if(i == current_poll.used)
+                goto out;
+        
+        err = need_poll(current_poll.used - 1);
+        if(err)
+                goto out;
+
+        for(i = 0; i < current_poll.used; i++){
+                p = &current_poll.poll[i];
+                if(p->fd != fd) next_poll.poll[n++] = current_poll.poll[i];
+        }
+        if(n == i){
+                printk("ignore_sigio_fd : fd %d not found\n", fd);
+                err = -1;
+                goto out;
+        }
+
+        update_thread();
+ out:
+        sigio_unlock();
+        return(err);
+}
+
+static int setup_initial_poll(int fd)
+{
+        struct pollfd *p;
+
+        p = um_kmalloc(sizeof(struct pollfd));
+        if(p == NULL){
+                printk("setup_initial_poll : failed to allocate poll\n");
+                return(-1);
+        }
+        *p = ((struct pollfd) { .fd     = fd,
+                                .events         = POLLIN,
+                                .revents        = 0 });
+        current_poll = ((struct pollfds) { .poll        = p,
+                                           .used        = 1,
+                                           .size        = 1 });
+        return(0);
+}
+
+void write_sigio_workaround(void)
+{
+        unsigned long stack;
+        int err;
+
+        sigio_lock();
+        if(write_sigio_pid != -1)
+                goto out;
+
+        err = os_pipe(write_sigio_fds, 1, 1);
+        if(err < 0){
+                printk("write_sigio_workaround - os_pipe 1 failed, "
+                       "err = %d\n", -err);
+                goto out;
+        }
+        err = os_pipe(sigio_private, 1, 1);
+        if(err < 0){
+                printk("write_sigio_workaround - os_pipe 2 failed, "
+                       "err = %d\n", -err);
+                goto out_close1;
+        }
+        if(setup_initial_poll(sigio_private[1]))
+                goto out_close2;
+
+        write_sigio_pid = run_helper_thread(write_sigio_thread, NULL, 
+                                            CLONE_FILES | CLONE_VM, &stack, 0);
+
+        if(write_sigio_pid < 0) goto out_close2;
+
+        if(write_sigio_irq(write_sigio_fds[0])) 
+                goto out_kill;
+
+ out:
+        sigio_unlock();
+        return;
+
+ out_kill:
+        os_kill_process(write_sigio_pid, 1);
+        write_sigio_pid = -1;
+ out_close2:
+        os_close_file(sigio_private[0]);
+        os_close_file(sigio_private[1]);
+ out_close1:
+        os_close_file(write_sigio_fds[0]);
+        os_close_file(write_sigio_fds[1]);
+        sigio_unlock();
+}
+
+int read_sigio_fd(int fd)
+{
+        int n;
+        char c;
+
+        n = os_read_file(fd, &c, sizeof(c));
+        if(n != sizeof(c)){
+                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);
+}
+
+static void sigio_cleanup(void)
+{
+        if (write_sigio_pid != -1) {
+                os_kill_process(write_sigio_pid, 1);
+                write_sigio_pid = -1;
+        }
+}
+
+__uml_exitcall(sigio_cleanup);
diff --git a/arch/um/kernel/signal_kern.c b/arch/um/kernel/signal_kern.c
new file mode 100644
index 000000000000..7807a3e8c426
--- /dev/null
+++ b/arch/um/kernel/signal_kern.c
@@ -0,0 +1,213 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/stddef.h"
+#include "linux/sys.h"
+#include "linux/sched.h"
+#include "linux/wait.h"
+#include "linux/kernel.h"
+#include "linux/smp_lock.h"
+#include "linux/module.h"
+#include "linux/slab.h"
+#include "linux/tty.h"
+#include "linux/binfmts.h"
+#include "linux/ptrace.h"
+#include "asm/signal.h"
+#include "asm/uaccess.h"
+#include "asm/unistd.h"
+#include "user_util.h"
+#include "asm/ucontext.h"
+#include "kern_util.h"
+#include "signal_kern.h"
+#include "signal_user.h"
+#include "kern.h"
+#include "frame_kern.h"
+#include "sigcontext.h"
+#include "mode.h"
+
+EXPORT_SYMBOL(block_signals);
+EXPORT_SYMBOL(unblock_signals);
+
+#define _S(nr) (1<<((nr)-1))
+
+#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
+
+/*
+ * OK, we're invoking a handler
+ */     
+static int handle_signal(struct pt_regs *regs, unsigned long signr,
+                         struct k_sigaction *ka, siginfo_t *info,
+                         sigset_t *oldset)
+{
+        unsigned long sp;
+        int err;
+
+        /* Always make any pending restarted system calls return -EINTR */
+        current_thread_info()->restart_block.fn = do_no_restart_syscall;
+
+        /* Did we come from a system call? */
+        if(PT_REGS_SYSCALL_NR(regs) >= 0){
+                /* If so, check system call restarting.. */
+                switch(PT_REGS_SYSCALL_RET(regs)){
+                case -ERESTART_RESTARTBLOCK:
+                case -ERESTARTNOHAND:
+                        PT_REGS_SYSCALL_RET(regs) = -EINTR;
+                        break;
+
+                case -ERESTARTSYS:
+                        if (!(ka->sa.sa_flags & SA_RESTART)) {
+                                PT_REGS_SYSCALL_RET(regs) = -EINTR;
+                                break;
+                        }
+                /* fallthrough */
+                case -ERESTARTNOINTR:
+                        PT_REGS_RESTART_SYSCALL(regs);
+                        PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs);
+                        break;
+                }
+        }
+
+        sp = PT_REGS_SP(regs);
+        if((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0))
+                sp = current->sas_ss_sp + current->sas_ss_size;
+
+#ifdef CONFIG_ARCH_HAS_SC_SIGNALS
+        if(!(ka->sa.sa_flags & SA_SIGINFO))
+                err = setup_signal_stack_sc(sp, signr, ka, regs, oldset);
+        else
+#endif
+                err = setup_signal_stack_si(sp, signr, ka, regs, info, oldset);
+
+        if(err){
+                spin_lock_irq(&current->sighand->siglock);
+                current->blocked = *oldset;
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+                force_sigsegv(signr, current);
+        }
+        else if(!(ka->sa.sa_flags & SA_NODEFER)){
+                spin_lock_irq(&current->sighand->siglock);
+                sigorsets(&current->blocked, &current->blocked, 
+                          &ka->sa.sa_mask);
+                sigaddset(&current->blocked, signr);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
+
+        return err;
+}
+
+static int kern_do_signal(struct pt_regs *regs, sigset_t *oldset)
+{
+        struct k_sigaction ka_copy;
+        siginfo_t info;
+        int sig, handled_sig = 0;
+
+        while((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0){
+                handled_sig = 1;
+                /* Whee!  Actually deliver the signal.  */
+                if(!handle_signal(regs, sig, &ka_copy, &info, oldset))
+                        break;
+        }
+
+        /* Did we come from a system call? */
+        if(!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)){
+                /* Restart the system call - no handlers present */
+                if(PT_REGS_SYSCALL_RET(regs) == -ERESTARTNOHAND ||
+                   PT_REGS_SYSCALL_RET(regs) == -ERESTARTSYS ||
+                   PT_REGS_SYSCALL_RET(regs) == -ERESTARTNOINTR){
+                        PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs);
+                        PT_REGS_RESTART_SYSCALL(regs);
+                }
+                else if(PT_REGS_SYSCALL_RET(regs) == -ERESTART_RESTARTBLOCK){
+                        PT_REGS_SYSCALL_RET(regs) = __NR_restart_syscall;
+                        PT_REGS_RESTART_SYSCALL(regs);
+                }
+        }
+
+        /* This closes a way to execute a system call on the host.  If
+         * you set a breakpoint on a system call instruction and singlestep
+         * from it, the tracing thread used to PTRACE_SINGLESTEP the process
+         * rather than PTRACE_SYSCALL it, allowing the system call to execute
+         * on the host.  The tracing thread will check this flag and 
+         * PTRACE_SYSCALL if necessary.
+         */
+        if(current->ptrace & PT_DTRACE)
+                current->thread.singlestep_syscall =
+                        is_syscall(PT_REGS_IP(&current->thread.regs));
+        return(handled_sig);
+}
+
+int do_signal(void)
+{
+        return(kern_do_signal(&current->thread.regs, &current->blocked));
+}
+
+/*
+ * Atomically swap in the new signal mask, and wait for a signal.
+ */
+long sys_sigsuspend(int history0, int history1, old_sigset_t mask)
+{
+        sigset_t saveset;
+
+        mask &= _BLOCKABLE;
+        spin_lock_irq(&current->sighand->siglock);
+        saveset = current->blocked;
+        siginitset(&current->blocked, mask);
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        PT_REGS_SYSCALL_RET(&current->thread.regs) = -EINTR;
+        while (1) {
+                current->state = TASK_INTERRUPTIBLE;
+                schedule();
+                if(kern_do_signal(&current->thread.regs, &saveset))
+                        return(-EINTR);
+        }
+}
+
+long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
+{
+        sigset_t saveset, newset;
+
+        /* XXX: Don't preclude handling different sized sigset_t's.  */
+        if (sigsetsize != sizeof(sigset_t))
+                return -EINVAL;
+
+        if (copy_from_user(&newset, unewset, sizeof(newset)))
+                return -EFAULT;
+        sigdelsetmask(&newset, ~_BLOCKABLE);
+
+        spin_lock_irq(&current->sighand->siglock);
+        saveset = current->blocked;
+        current->blocked = newset;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        PT_REGS_SYSCALL_RET(&current->thread.regs) = -EINTR;
+        while (1) {
+                current->state = TASK_INTERRUPTIBLE;
+                schedule();
+                if (kern_do_signal(&current->thread.regs, &saveset))
+                        return(-EINTR);
+        }
+}
+
+long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
+{
+        return(do_sigaltstack(uss, uoss, PT_REGS_SP(&current->thread.regs)));
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/signal_user.c b/arch/um/kernel/signal_user.c
new file mode 100644
index 000000000000..62f457835fb1
--- /dev/null
+++ b/arch/um/kernel/signal_user.c
@@ -0,0 +1,157 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/mman.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "signal_user.h"
+#include "signal_kern.h"
+#include "sysdep/sigcontext.h"
+#include "sigcontext.h"
+
+void set_sigstack(void *sig_stack, int size)
+{
+        stack_t stack = ((stack_t) { .ss_flags  = 0,
+                                     .ss_sp     = (__ptr_t) sig_stack,
+                                     .ss_size   = size - sizeof(void *) });
+
+        if(sigaltstack(&stack, NULL) != 0)
+                panic("enabling signal stack failed, errno = %d\n", errno);
+}
+
+void set_handler(int sig, void (*handler)(int), int flags, ...)
+{
+        struct sigaction action;
+        va_list ap;
+        int mask;
+
+        va_start(ap, flags);
+        action.sa_handler = handler;
+        sigemptyset(&action.sa_mask);
+        while((mask = va_arg(ap, int)) != -1){
+                sigaddset(&action.sa_mask, mask);
+        }
+        va_end(ap);
+        action.sa_flags = flags;
+        action.sa_restorer = NULL;
+        if(sigaction(sig, &action, NULL) < 0)
+                panic("sigaction failed");
+}
+
+int change_sig(int signal, int on)
+{
+        sigset_t sigset, old;
+
+        sigemptyset(&sigset);
+        sigaddset(&sigset, signal);
+        sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
+        return(!sigismember(&old, signal));
+}
+
+/* Both here and in set/get_signal we don't touch SIGPROF, because we must not
+ * disable profiling; it's safe because the profiling code does not interact
+ * with the kernel code at all.*/
+
+static void change_signals(int type)
+{
+        sigset_t mask;
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGVTALRM);
+        sigaddset(&mask, SIGALRM);
+        sigaddset(&mask, SIGIO);
+        if(sigprocmask(type, &mask, NULL) < 0)
+                panic("Failed to change signal mask - errno = %d", errno);
+}
+
+void block_signals(void)
+{
+        change_signals(SIG_BLOCK);
+}
+
+void unblock_signals(void)
+{
+        change_signals(SIG_UNBLOCK);
+}
+
+/* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
+ * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
+ * be able to profile all of UML, not just the non-critical sections.  If
+ * profiling is not thread-safe, then that is not my problem.  We can disable
+ * profiling when SMP is enabled in that case.
+ */
+#define SIGIO_BIT 0
+#define SIGVTALRM_BIT 1
+
+static int enable_mask(sigset_t *mask)
+{
+        int sigs;
+
+        sigs = sigismember(mask, SIGIO) ? 0 : 1 << SIGIO_BIT;
+        sigs |= sigismember(mask, SIGVTALRM) ? 0 : 1 << SIGVTALRM_BIT;
+        sigs |= sigismember(mask, SIGALRM) ? 0 : 1 << SIGVTALRM_BIT;
+        return(sigs);
+}
+
+int get_signals(void)
+{
+        sigset_t mask;
+        
+        if(sigprocmask(SIG_SETMASK, NULL, &mask) < 0)
+                panic("Failed to get signal mask");
+        return(enable_mask(&mask));
+}
+
+int set_signals(int enable)
+{
+        sigset_t mask;
+        int ret;
+
+        sigemptyset(&mask);
+        if(enable & (1 << SIGIO_BIT)) 
+                sigaddset(&mask, SIGIO);
+        if(enable & (1 << SIGVTALRM_BIT)){
+                sigaddset(&mask, SIGVTALRM);
+                sigaddset(&mask, SIGALRM);
+        }
+
+        /* This is safe - sigprocmask is guaranteed to copy locally the
+         * value of new_set, do his work and then, at the end, write to
+         * old_set.
+         */
+        if(sigprocmask(SIG_UNBLOCK, &mask, &mask) < 0)
+                panic("Failed to enable signals");
+        ret = enable_mask(&mask);
+        sigemptyset(&mask);
+        if((enable & (1 << SIGIO_BIT)) == 0) 
+                sigaddset(&mask, SIGIO);
+        if((enable & (1 << SIGVTALRM_BIT)) == 0){
+                sigaddset(&mask, SIGVTALRM);
+                sigaddset(&mask, SIGALRM);
+        }
+        if(sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
+                panic("Failed to block signals");
+
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/Makefile b/arch/um/kernel/skas/Makefile
new file mode 100644
index 000000000000..d37d1bfcd6f7
--- /dev/null
+++ b/arch/um/kernel/skas/Makefile
@@ -0,0 +1,13 @@
+# 
+# Copyright (C) 2002 - 2004 Jeff Dike (jdike@addtoit.com)
+# Licensed under the GPL
+#
+
+obj-y := exec_kern.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 uaccess.o \
+
+subdir- := util
+
+USER_OBJS := process.o time.o
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/kernel/skas/exec_kern.c b/arch/um/kernel/skas/exec_kern.c
new file mode 100644
index 000000000000..c6b4d5dba789
--- /dev/null
+++ b/arch/um/kernel/skas/exec_kern.c
@@ -0,0 +1,41 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "asm/current.h"
+#include "asm/page.h"
+#include "asm/signal.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+#include "asm/mmu_context.h"
+#include "tlb.h"
+#include "skas.h"
+#include "um_mmu.h"
+#include "os.h"
+
+void flush_thread_skas(void)
+{
+        force_flush_all();
+        switch_mm_skas(current->mm->context.skas.mm_fd);
+}
+
+void start_thread_skas(struct pt_regs *regs, unsigned long eip, 
+                       unsigned long esp)
+{
+        set_fs(USER_DS);
+        PT_REGS_IP(regs) = eip;
+        PT_REGS_SP(regs) = esp;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/mmu-skas.h b/arch/um/kernel/skas/include/mmu-skas.h
new file mode 100644
index 000000000000..4cd60d7213f3
--- /dev/null
+++ b/arch/um/kernel/skas/include/mmu-skas.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_MMU_H
+#define __SKAS_MMU_H
+
+struct mmu_context_skas {
+        int mm_fd;
+};
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/mode-skas.h b/arch/um/kernel/skas/include/mode-skas.h
new file mode 100644
index 000000000000..c1e33bd788db
--- /dev/null
+++ b/arch/um/kernel/skas/include/mode-skas.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_SKAS_H__
+#define __MODE_SKAS_H__
+
+#include <sysdep/ptrace.h>
+
+extern unsigned long exec_regs[];
+extern unsigned long exec_fp_regs[];
+extern unsigned long exec_fpx_regs[];
+extern int have_fpx_regs;
+
+extern void user_time_init_skas(void);
+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
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/mode_kern-skas.h b/arch/um/kernel/skas/include/mode_kern-skas.h
new file mode 100644
index 000000000000..94c564962378
--- /dev/null
+++ b/arch/um/kernel/skas/include/mode_kern-skas.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_MODE_KERN_H__
+#define __SKAS_MODE_KERN_H__
+
+#include "linux/sched.h"
+#include "asm/page.h"
+#include "asm/ptrace.h"
+
+extern void flush_thread_skas(void);
+extern void *switch_to_skas(void *prev, void *next);
+extern void start_thread_skas(struct pt_regs *regs, unsigned long eip,
+                              unsigned long esp);
+extern int copy_thread_skas(int nr, unsigned long clone_flags,
+                            unsigned long sp, unsigned long stack_top,
+                            struct task_struct *p, struct pt_regs *regs);
+extern void release_thread_skas(struct task_struct *task);
+extern void exit_thread_skas(void);
+extern void initial_thread_cb_skas(void (*proc)(void *), void *arg);
+extern void init_idle_skas(void);
+extern void flush_tlb_kernel_range_skas(unsigned long start,
+                                        unsigned long end);
+extern void flush_tlb_kernel_vm_skas(void);
+extern void __flush_tlb_one_skas(unsigned long addr);
+extern void flush_tlb_range_skas(struct vm_area_struct *vma,
+                                 unsigned long start, unsigned long end);
+extern void flush_tlb_mm_skas(struct mm_struct *mm);
+extern void force_flush_all_skas(void);
+extern long execute_syscall_skas(void *r);
+extern void before_mem_skas(unsigned long unused);
+extern unsigned long set_task_sizes_skas(int arg, unsigned long *host_size_out,
+                                         unsigned long *task_size_out);
+extern int start_uml_skas(void);
+extern int external_pid_skas(struct task_struct *task);
+extern int thread_pid_skas(struct task_struct *task);
+
+#define kmem_end_skas (host_task_size - 1024 * 1024)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/proc_mm.h b/arch/um/kernel/skas/include/proc_mm.h
new file mode 100644
index 000000000000..cce61a679052
--- /dev/null
+++ b/arch/um/kernel/skas/include/proc_mm.h
@@ -0,0 +1,55 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_PROC_MM_H
+#define __SKAS_PROC_MM_H
+
+#define MM_MMAP 54
+#define MM_MUNMAP 55
+#define MM_MPROTECT 56
+#define MM_COPY_SEGMENTS 57
+
+struct mm_mmap {
+        unsigned long addr;
+        unsigned long len;
+        unsigned long prot;
+        unsigned long flags;
+        unsigned long fd;
+        unsigned long offset;
+};
+
+struct mm_munmap {
+        unsigned long addr;
+        unsigned long len;      
+};
+
+struct mm_mprotect {
+        unsigned long addr;
+        unsigned long len;
+        unsigned int prot;
+};
+
+struct proc_mm_op {
+        int op;
+        union {
+                struct mm_mmap mmap;
+                struct mm_munmap munmap;
+                struct mm_mprotect mprotect;
+                int copy_segments;
+        } u;
+};
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/skas.h b/arch/um/kernel/skas/include/skas.h
new file mode 100644
index 000000000000..f0702c2c7204
--- /dev/null
+++ b/arch/um/kernel/skas/include/skas.h
@@ -0,0 +1,46 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_H
+#define __SKAS_H
+
+#include "sysdep/ptrace.h"
+
+extern int userspace_pid[];
+
+extern void switch_threads(void *me, void *next);
+extern void thread_wait(void *sw, void *fb);
+extern void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
+                       void (*handler)(int));
+extern int start_idle_thread(void *stack, void *switch_buf_ptr, 
+                             void **fork_buf_ptr);
+extern int user_thread(unsigned long stack, int flags);
+extern void userspace(union uml_pt_regs *regs);
+extern void new_thread_proc(void *stack, void (*handler)(int sig));
+extern void remove_sigstack(void);
+extern void new_thread_handler(int sig);
+extern void handle_syscall(union uml_pt_regs *regs);
+extern void map(int fd, unsigned long virt, unsigned long len, int r, int w,
+                int x, int phys_fd, unsigned long long offset);
+extern int unmap(int fd, void *addr, unsigned long len);
+extern int protect(int fd, unsigned long addr, unsigned long len, 
+                   int r, int w, int x);
+extern void user_signal(int sig, union uml_pt_regs *regs);
+extern int new_mm(int from);
+extern void start_userspace(int cpu);
+extern long execute_syscall_skas(void *r);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/include/uaccess-skas.h b/arch/um/kernel/skas/include/uaccess-skas.h
new file mode 100644
index 000000000000..11986c9b9ddf
--- /dev/null
+++ b/arch/um/kernel/skas/include/uaccess-skas.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_UACCESS_H
+#define __SKAS_UACCESS_H
+
+#include "asm/errno.h"
+#include "asm/fixmap.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)) || \
+         ((type == VERIFY_READ ) && \
+          ((unsigned long) (addr) >= FIXADDR_USER_START) && \
+          ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
+          ((unsigned long) (addr) + (size) >= (unsigned long)(addr))))
+
+static inline int verify_area_skas(int type, const void * addr,
+                                   unsigned long size)
+{
+        return(access_ok_skas(type, addr, size) ? 0 : -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
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/mem.c b/arch/um/kernel/skas/mem.c
new file mode 100644
index 000000000000..438db2f43456
--- /dev/null
+++ b/arch/um/kernel/skas/mem.c
@@ -0,0 +1,35 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/mm.h"
+#include "mem_user.h"
+
+unsigned long set_task_sizes_skas(int arg, unsigned long *host_size_out, 
+                                  unsigned long *task_size_out)
+{
+        /* Round up to the nearest 4M */
+        unsigned long top = ROUND_4M((unsigned long) &arg);
+
+#ifdef CONFIG_HOST_TASK_SIZE
+        *host_size_out = CONFIG_HOST_TASK_SIZE;
+        *task_size_out = CONFIG_HOST_TASK_SIZE;
+#else
+        *host_size_out = top;
+        *task_size_out = top;
+#endif
+        return(((unsigned long) set_task_sizes_skas) & ~0xffffff);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/mem_user.c b/arch/um/kernel/skas/mem_user.c
new file mode 100644
index 000000000000..1310bf1e88d1
--- /dev/null
+++ b/arch/um/kernel/skas/mem_user.c
@@ -0,0 +1,102 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <errno.h>
+#include <sys/mman.h>
+#include "mem_user.h"
+#include "mem.h"
+#include "user.h"
+#include "os.h"
+#include "proc_mm.h"
+
+void map(int fd, unsigned long virt, unsigned long len, int r, int w,
+         int x, int phys_fd, unsigned long long offset)
+{
+        struct proc_mm_op map;
+        int prot, n;
+
+        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
+                (x ? PROT_EXEC : 0);
+
+        map = ((struct proc_mm_op) { .op        = MM_MMAP,
+                                     .u         = 
+                                     { .mmap    = 
+                                       { .addr          = virt,
+                                         .len           = len,
+                                         .prot          = prot,
+                                         .flags         = MAP_SHARED | 
+                                                          MAP_FIXED,
+                                         .fd            = phys_fd,
+                                         .offset        = offset
+                                       } } } );
+        n = os_write_file(fd, &map, sizeof(map));
+        if(n != sizeof(map)) 
+                printk("map : /proc/mm map failed, err = %d\n", -n);
+}
+
+int unmap(int fd, void *addr, unsigned long len)
+{
+        struct proc_mm_op unmap;
+        int n;
+
+        unmap = ((struct proc_mm_op) { .op      = MM_MUNMAP,
+                                       .u       = 
+                                       { .munmap        = 
+                                         { .addr        = (unsigned long) addr,
+                                           .len         = len } } } );
+        n = os_write_file(fd, &unmap, sizeof(unmap));
+        if(n != sizeof(unmap)) {
+                if(n < 0)
+                        return(n);
+                else if(n > 0)
+                        return(-EIO);
+        }
+
+        return(0);
+}
+
+int protect(int fd, unsigned long addr, unsigned long len, int r, int w, 
+            int x, int must_succeed)
+{
+        struct proc_mm_op protect;
+        int prot, n;
+
+        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
+                (x ? PROT_EXEC : 0);
+
+        protect = ((struct proc_mm_op) { .op    = MM_MPROTECT,
+                                       .u       = 
+                                       { .mprotect      = 
+                                         { .addr        = (unsigned long) addr,
+                                           .len         = len,
+                                           .prot        = prot } } } );
+
+        n = os_write_file(fd, &protect, sizeof(protect));
+        if(n != sizeof(protect)) {
+                if(n == 0) return(0);
+
+                if(must_succeed)
+                        panic("protect failed, err = %d", -n);
+
+                return(-EIO);
+        }
+
+        return(0);
+}
+
+void before_mem_skas(unsigned long unused)
+{
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/mmu.c b/arch/um/kernel/skas/mmu.c
new file mode 100644
index 000000000000..6cb9a6d028a9
--- /dev/null
+++ b/arch/um/kernel/skas/mmu.c
@@ -0,0 +1,48 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/list.h"
+#include "linux/spinlock.h"
+#include "linux/slab.h"
+#include "asm/current.h"
+#include "asm/segment.h"
+#include "asm/mmu.h"
+#include "os.h"
+#include "skas.h"
+
+int init_new_context_skas(struct task_struct *task, struct mm_struct *mm)
+{
+        int from;
+
+        if((current->mm != NULL) && (current->mm != &init_mm))
+                from = current->mm->context.skas.mm_fd;
+        else from = -1;
+
+        mm->context.skas.mm_fd = new_mm(from);
+        if(mm->context.skas.mm_fd < 0){
+                printk("init_new_context_skas - new_mm failed, errno = %d\n",
+                       mm->context.skas.mm_fd);
+                return(mm->context.skas.mm_fd);
+        }
+
+        return(0);
+}
+
+void destroy_context_skas(struct mm_struct *mm)
+{
+        os_close_file(mm->context.skas.mm_fd);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/process.c b/arch/um/kernel/skas/process.c
new file mode 100644
index 000000000000..b4ffaaa81241
--- /dev/null
+++ b/arch/um/kernel/skas/process.c
@@ -0,0 +1,339 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <sched.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <asm/unistd.h>
+#include "user.h"
+#include "ptrace_user.h"
+#include "time_user.h"
+#include "sysdep/ptrace.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "skas.h"
+#include "sysdep/sigcontext.h"
+#include "os.h"
+#include "proc_mm.h"
+#include "skas_ptrace.h"
+#include "chan_user.h"
+#include "signal_user.h"
+#include "registers.h"
+
+int is_skas_winch(int pid, int fd, void *data)
+{
+        if(pid != os_getpid())
+                return(0);
+
+        register_winch_irq(-1, fd, -1, data);
+        return(1);
+}
+
+static void handle_segv(int pid)
+{
+        struct ptrace_faultinfo fault;
+        int err;
+
+        err = ptrace(PTRACE_FAULTINFO, pid, 0, &fault);
+        if(err)
+                panic("handle_segv - PTRACE_FAULTINFO failed, errno = %d\n",
+                      errno);
+
+        segv(fault.addr, 0, FAULT_WRITE(fault.is_write), 1, NULL);
+}
+
+/*To use the same value of using_sysemu as the caller, ask it that value (in local_using_sysemu)*/
+static void handle_trap(int pid, union uml_pt_regs *regs, int local_using_sysemu)
+{
+        int err, status;
+
+        /* Mark this as a syscall */
+        UPT_SYSCALL_NR(regs) = PT_SYSCALL_NR(regs->skas.regs);
+
+        if (!local_using_sysemu)
+        {
+                err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid);
+                if(err < 0)
+                        panic("handle_trap - nullifying syscall failed errno = %d\n",
+                              errno);
+
+                err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
+                if(err < 0)
+                        panic("handle_trap - continuing to end of syscall failed, "
+                              "errno = %d\n", errno);
+
+                CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
+                if((err < 0) || !WIFSTOPPED(status) ||
+                   (WSTOPSIG(status) != SIGTRAP + 0x80))
+                        panic("handle_trap - failed to wait at end of syscall, "
+                              "errno = %d, status = %d\n", errno, status);
+        }
+
+        handle_syscall(regs);
+}
+
+static int userspace_tramp(void *arg)
+{
+        init_new_thread_signals(0);
+        enable_timer();
+        ptrace(PTRACE_TRACEME, 0, 0, 0);
+        os_stop_process(os_getpid());
+        return(0);
+}
+
+/* Each element set once, and only accessed by a single processor anyway */
+#undef NR_CPUS
+#define NR_CPUS 1
+int userspace_pid[NR_CPUS];
+
+void start_userspace(int cpu)
+{
+        void *stack;
+        unsigned long sp;
+        int pid, status, n;
+
+        stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
+                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+        if(stack == MAP_FAILED)
+                panic("start_userspace : mmap failed, errno = %d", errno);
+        sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
+
+        pid = clone(userspace_tramp, (void *) sp, 
+                    CLONE_FILES | CLONE_VM | SIGCHLD, NULL);
+        if(pid < 0)
+                panic("start_userspace : clone failed, errno = %d", errno);
+
+        do {
+                CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+                if(n < 0)
+                        panic("start_userspace : wait failed, errno = %d", 
+                              errno);
+        } while(WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
+
+        if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
+                panic("start_userspace : expected SIGSTOP, got status = %d",
+                      status);
+
+        if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, (void *)PTRACE_O_TRACESYSGOOD) < 0)
+                panic("start_userspace : PTRACE_SETOPTIONS failed, errno=%d\n",
+                      errno);
+
+        if(munmap(stack, PAGE_SIZE) < 0)
+                panic("start_userspace : munmap failed, errno = %d\n", errno);
+
+        userspace_pid[cpu] = pid;
+}
+
+void userspace(union uml_pt_regs *regs)
+{
+        int err, status, op, pid = userspace_pid[0];
+        int local_using_sysemu; /*To prevent races if using_sysemu changes under us.*/
+
+        while(1){
+                restore_registers(pid, regs);
+
+                /* Now we set local_using_sysemu to be used for one loop */
+                local_using_sysemu = get_using_sysemu();
+
+                op = SELECT_PTRACE_OPERATION(local_using_sysemu, singlestepping(NULL));
+
+                err = ptrace(op, pid, 0, 0);
+                if(err)
+                        panic("userspace - could not resume userspace process, "
+                              "pid=%d, ptrace operation = %d, errno = %d\n",
+                              op, errno);
+
+                CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
+                if(err < 0)
+                        panic("userspace - waitpid failed, errno = %d\n", 
+                              errno);
+
+                regs->skas.is_user = 1;
+                save_registers(pid, regs);
+                UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
+
+                if(WIFSTOPPED(status)){
+                        switch(WSTOPSIG(status)){
+                        case SIGSEGV:
+                                handle_segv(pid);
+                                break;
+                        case SIGTRAP + 0x80:
+                                handle_trap(pid, regs, local_using_sysemu);
+                                break;
+                        case SIGTRAP:
+                                relay_signal(SIGTRAP, regs);
+                                break;
+                        case SIGIO:
+                        case SIGVTALRM:
+                        case SIGILL:
+                        case SIGBUS:
+                        case SIGFPE:
+                        case SIGWINCH:
+                                user_signal(WSTOPSIG(status), regs);
+                                break;
+                        default:
+                                printk("userspace - child stopped with signal "
+                                       "%d\n", WSTOPSIG(status));
+                        }
+                        interrupt_end();
+
+                        /* Avoid -ERESTARTSYS handling in host */
+                        PT_SYSCALL_NR(regs->skas.regs) = -1;
+                }
+        }
+}
+
+void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
+                void (*handler)(int))
+{
+        unsigned long flags;
+        sigjmp_buf switch_buf, fork_buf;
+
+        *switch_buf_ptr = &switch_buf;
+        *fork_buf_ptr = &fork_buf;
+
+        /* Somewhat subtle - siglongjmp restores the signal mask before doing
+         * the longjmp.  This means that when jumping from one stack to another
+         * when the target stack has interrupts enabled, an interrupt may occur
+         * on the source stack.  This is bad when starting up a process because
+         * it's not supposed to get timer ticks until it has been scheduled.
+         * So, we disable interrupts around the sigsetjmp to ensure that
+         * they can't happen until we get back here where they are safe.
+         */
+        flags = get_signals();
+        block_signals();
+        if(sigsetjmp(fork_buf, 1) == 0)
+                new_thread_proc(stack, handler);
+
+        remove_sigstack();
+
+        set_signals(flags);
+}
+
+void thread_wait(void *sw, void *fb)
+{
+        sigjmp_buf buf, **switch_buf = sw, *fork_buf;
+
+        *switch_buf = &buf;
+        fork_buf = fb;
+        if(sigsetjmp(buf, 1) == 0)
+                siglongjmp(*fork_buf, 1);
+}
+
+void switch_threads(void *me, void *next)
+{
+        sigjmp_buf my_buf, **me_ptr = me, *next_buf = next;
+        
+        *me_ptr = &my_buf;
+        if(sigsetjmp(my_buf, 1) == 0)
+                siglongjmp(*next_buf, 1);
+}
+
+static sigjmp_buf initial_jmpbuf;
+
+/* XXX Make these percpu */
+static void (*cb_proc)(void *arg);
+static void *cb_arg;
+static sigjmp_buf *cb_back;
+
+int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
+{
+        sigjmp_buf **switch_buf = switch_buf_ptr;
+        int n;
+
+        *fork_buf_ptr = &initial_jmpbuf;
+        n = sigsetjmp(initial_jmpbuf, 1);
+        if(n == 0)
+                new_thread_proc((void *) stack, new_thread_handler);
+        else if(n == 1)
+                remove_sigstack();
+        else if(n == 2){
+                (*cb_proc)(cb_arg);
+                siglongjmp(*cb_back, 1);
+        }
+        else if(n == 3){
+                kmalloc_ok = 0;
+                return(0);
+        }
+        else if(n == 4){
+                kmalloc_ok = 0;
+                return(1);
+        }
+        siglongjmp(**switch_buf, 1);
+}
+
+void remove_sigstack(void)
+{
+        stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
+                                     .ss_sp     = NULL,
+                                     .ss_size   = 0 });
+
+        if(sigaltstack(&stack, NULL) != 0)
+                panic("disabling signal stack failed, errno = %d\n", errno);
+}
+
+void initial_thread_cb_skas(void (*proc)(void *), void *arg)
+{
+        sigjmp_buf here;
+
+        cb_proc = proc;
+        cb_arg = arg;
+        cb_back = &here;
+
+        block_signals();
+        if(sigsetjmp(here, 1) == 0)
+                siglongjmp(initial_jmpbuf, 2);
+        unblock_signals();
+
+        cb_proc = NULL;
+        cb_arg = NULL;
+        cb_back = NULL;
+}
+
+void halt_skas(void)
+{
+        block_signals();
+        siglongjmp(initial_jmpbuf, 3);
+}
+
+void reboot_skas(void)
+{
+        block_signals();
+        siglongjmp(initial_jmpbuf, 4);
+}
+
+void switch_mm_skas(int mm_fd)
+{
+        int err;
+
+#warning need cpu pid in switch_mm_skas
+        err = ptrace(PTRACE_SWITCH_MM, userspace_pid[0], 0, mm_fd);
+        if(err)
+                panic("switch_mm_skas - PTRACE_SWITCH_MM failed, errno = %d\n",
+                      errno);
+}
+
+void kill_off_processes_skas(void)
+{
+#warning need to loop over userspace_pids in kill_off_processes_skas
+        os_kill_ptraced_process(userspace_pid[0], 1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/process_kern.c b/arch/um/kernel/skas/process_kern.c
new file mode 100644
index 000000000000..5d096ea63b97
--- /dev/null
+++ b/arch/um/kernel/skas/process_kern.c
@@ -0,0 +1,213 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/slab.h"
+#include "linux/ptrace.h"
+#include "linux/proc_fs.h"
+#include "linux/file.h"
+#include "linux/errno.h"
+#include "linux/init.h"
+#include "asm/uaccess.h"
+#include "asm/atomic.h"
+#include "kern_util.h"
+#include "time_user.h"
+#include "signal_user.h"
+#include "skas.h"
+#include "os.h"
+#include "user_util.h"
+#include "tlb.h"
+#include "kern.h"
+#include "mode.h"
+#include "proc_mm.h"
+#include "registers.h"
+
+void *switch_to_skas(void *prev, void *next)
+{
+        struct task_struct *from, *to;
+
+        from = prev;
+        to = next;
+
+        /* XXX need to check runqueues[cpu].idle */
+        if(current->pid == 0)
+                switch_timers(0);
+
+        to->thread.prev_sched = from;
+        set_current(to);
+
+        switch_threads(&from->thread.mode.skas.switch_buf, 
+                       to->thread.mode.skas.switch_buf);
+
+        if(current->pid == 0)
+                switch_timers(1);
+
+        return(current->thread.prev_sched);
+}
+
+extern void schedule_tail(struct task_struct *prev);
+
+void new_thread_handler(int sig)
+{
+        int (*fn)(void *), n;
+        void *arg;
+
+        fn = current->thread.request.u.thread.proc;
+        arg = current->thread.request.u.thread.arg;
+        change_sig(SIGUSR1, 1);
+        thread_wait(&current->thread.mode.skas.switch_buf, 
+                    current->thread.mode.skas.fork_buf);
+
+        if(current->thread.prev_sched != NULL)
+                schedule_tail(current->thread.prev_sched);
+        current->thread.prev_sched = NULL;
+
+        /* The return value is 1 if the kernel thread execs a process,
+         * 0 if it just exits
+         */
+        n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
+        if(n == 1)
+                userspace(&current->thread.regs.regs);
+        else do_exit(0);
+}
+
+void new_thread_proc(void *stack, void (*handler)(int sig))
+{
+        init_new_thread_stack(stack, handler);
+        os_usr1_process(os_getpid());
+}
+
+void release_thread_skas(struct task_struct *task)
+{
+}
+
+void exit_thread_skas(void)
+{
+}
+
+void fork_handler(int sig)
+{
+        change_sig(SIGUSR1, 1);
+        thread_wait(&current->thread.mode.skas.switch_buf, 
+                    current->thread.mode.skas.fork_buf);
+        
+        force_flush_all();
+        if(current->thread.prev_sched == NULL)
+                panic("blech");
+
+        schedule_tail(current->thread.prev_sched);
+        current->thread.prev_sched = NULL;
+
+        userspace(&current->thread.regs.regs);
+}
+
+int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
+                     unsigned long stack_top, struct task_struct * p, 
+                     struct pt_regs *regs)
+{
+        void (*handler)(int);
+
+        if(current->thread.forking){
+                memcpy(&p->thread.regs.regs.skas, 
+                       &current->thread.regs.regs.skas, 
+                       sizeof(p->thread.regs.regs.skas));
+                REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.skas.regs, 0);
+                if(sp != 0) REGS_SP(p->thread.regs.regs.skas.regs) = sp;
+
+                handler = fork_handler;
+        }
+        else {
+                init_thread_registers(&p->thread.regs.regs);
+                p->thread.request.u.thread = current->thread.request.u.thread;
+                handler = new_thread_handler;
+        }
+
+        new_thread(p->thread_info, &p->thread.mode.skas.switch_buf,
+                   &p->thread.mode.skas.fork_buf, handler);
+        return(0);
+}
+
+int new_mm(int from)
+{
+        struct proc_mm_op copy;
+        int n, fd;
+
+        fd = os_open_file("/proc/mm", of_cloexec(of_write(OPENFLAGS())), 0);
+        if(fd < 0)
+                return(fd);
+
+        if(from != -1){
+                copy = ((struct proc_mm_op) { .op       = MM_COPY_SEGMENTS,
+                                              .u        =
+                                              { .copy_segments  = from } } );
+                n = os_write_file(fd, &copy, sizeof(copy));
+                if(n != sizeof(copy))
+                        printk("new_mm : /proc/mm copy_segments failed, "
+                               "err = %d\n", -n);
+        }
+
+        return(fd);
+}
+
+void init_idle_skas(void)
+{
+        cpu_tasks[current_thread->cpu].pid = os_getpid();
+        default_idle();
+}
+
+extern void start_kernel(void);
+
+static int start_kernel_proc(void *unused)
+{
+        int pid;
+
+        block_signals();
+        pid = os_getpid();
+
+        cpu_tasks[0].pid = pid;
+        cpu_tasks[0].task = current;
+#ifdef CONFIG_SMP
+        cpu_online_map = cpumask_of_cpu(0);
+#endif
+        start_kernel();
+        return(0);
+}
+
+int start_uml_skas(void)
+{
+        start_userspace(0);
+
+        init_new_thread_signals(1);
+        uml_idle_timer();
+
+        init_task.thread.request.u.thread.proc = start_kernel_proc;
+        init_task.thread.request.u.thread.arg = NULL;
+        return(start_idle_thread(init_task.thread_info,
+                                 &init_task.thread.mode.skas.switch_buf,
+                                 &init_task.thread.mode.skas.fork_buf));
+}
+
+int external_pid_skas(struct task_struct *task)
+{
+#warning Need to look up userspace_pid by cpu
+        return(userspace_pid[0]);
+}
+
+int thread_pid_skas(struct task_struct *task)
+{
+#warning Need to look up userspace_pid by cpu
+        return(userspace_pid[0]);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/syscall_kern.c b/arch/um/kernel/skas/syscall_kern.c
new file mode 100644
index 000000000000..bdf040ce5b8e
--- /dev/null
+++ b/arch/um/kernel/skas/syscall_kern.c
@@ -0,0 +1,43 @@
+/* 
+ * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sys.h"
+#include "linux/ptrace.h"
+#include "asm/errno.h"
+#include "asm/unistd.h"
+#include "asm/ptrace.h"
+#include "asm/current.h"
+#include "sysdep/syscalls.h"
+#include "kern_util.h"
+
+extern syscall_handler_t *sys_call_table[];
+
+long execute_syscall_skas(void *r)
+{
+        struct pt_regs *regs = r;
+        long res;
+        int syscall;
+
+        current->thread.nsyscalls++;
+        nsyscalls++;
+        syscall = UPT_SYSCALL_NR(&regs->regs);
+
+        if((syscall >= NR_syscalls) || (syscall < 0))
+                res = -ENOSYS;
+        else res = EXECUTE_SYSCALL(syscall, regs);
+
+        return(res);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/syscall_user.c b/arch/um/kernel/skas/syscall_user.c
new file mode 100644
index 000000000000..2828e6e37721
--- /dev/null
+++ b/arch/um/kernel/skas/syscall_user.c
@@ -0,0 +1,44 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <signal.h>
+#include "kern_util.h"
+#include "uml-config.h"
+#include "syscall_user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+#include "skas.h"
+
+void handle_syscall(union uml_pt_regs *regs)
+{
+        long result;
+#if UML_CONFIG_SYSCALL_DEBUG
+        int index;
+
+        index = record_syscall_start(UPT_SYSCALL_NR(regs));
+#endif
+
+        syscall_trace(regs, 0);
+        result = execute_syscall_skas(regs);
+
+        REGS_SET_SYSCALL_RETURN(regs->skas.regs, result);
+
+        syscall_trace(regs, 1);
+#if UML_CONFIG_SYSCALL_DEBUG
+        record_syscall_end(index, result);
+#endif
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/time.c b/arch/um/kernel/skas/time.c
new file mode 100644
index 000000000000..98091494b897
--- /dev/null
+++ b/arch/um/kernel/skas/time.c
@@ -0,0 +1,30 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <sys/signal.h>
+#include <sys/time.h>
+#include "time_user.h"
+#include "process.h"
+#include "user.h"
+
+void user_time_init_skas(void)
+{
+        if(signal(SIGALRM, (__sighandler_t) alarm_handler) == SIG_ERR)
+                panic("Couldn't set SIGALRM handler");
+        if(signal(SIGVTALRM, (__sighandler_t) alarm_handler) == SIG_ERR)
+                panic("Couldn't set SIGVTALRM handler");
+        set_interval(ITIMER_VIRTUAL);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/tlb.c b/arch/um/kernel/skas/tlb.c
new file mode 100644
index 000000000000..b8c5e71763d1
--- /dev/null
+++ b/arch/um/kernel/skas/tlb.c
@@ -0,0 +1,85 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright 2003 PathScale, Inc.
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/sched.h"
+#include "linux/mm.h"
+#include "asm/page.h"
+#include "asm/pgtable.h"
+#include "asm/mmu.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "mem.h"
+#include "skas.h"
+#include "os.h"
+#include "tlb.h"
+
+static void do_ops(int fd, struct host_vm_op *ops, int last)
+{
+        struct host_vm_op *op;
+        int i;
+
+        for(i = 0; i <= last; i++){
+                op = &ops[i];
+                switch(op->type){
+                case MMAP:
+                        map(fd, op->u.mmap.addr, op->u.mmap.len,
+                            op->u.mmap.r, op->u.mmap.w, op->u.mmap.x,
+                            op->u.mmap.fd, op->u.mmap.offset);
+                        break;
+                case MUNMAP:
+                        unmap(fd, (void *) op->u.munmap.addr,
+                              op->u.munmap.len);
+                        break;
+                case MPROTECT:
+                        protect(fd, op->u.mprotect.addr, op->u.mprotect.len,
+                                op->u.mprotect.r, op->u.mprotect.w,
+                                op->u.mprotect.x);
+                        break;
+                default:
+                        printk("Unknown op type %d in do_ops\n", op->type);
+                        break;
+                }
+        }
+}
+
+static void fix_range(struct mm_struct *mm, unsigned long start_addr,
+                      unsigned long end_addr, int force)
+{
+        int fd = mm->context.skas.mm_fd;
+
+        fix_range_common(mm, start_addr, end_addr, force, fd, do_ops);
+}
+
+void __flush_tlb_one_skas(unsigned long addr)
+{
+        flush_tlb_kernel_range_common(addr, addr + PAGE_SIZE);
+}
+
+void flush_tlb_range_skas(struct vm_area_struct *vma, unsigned long start, 
+                     unsigned long end)
+{
+        if(vma->vm_mm == NULL)
+                flush_tlb_kernel_range_common(start, end);
+        else fix_range(vma->vm_mm, start, end, 0);
+}
+
+void flush_tlb_mm_skas(struct mm_struct *mm)
+{
+        /* Don't bother flushing if this address space is about to be
+         * destroyed.
+         */
+        if(atomic_read(&mm->mm_users) == 0)
+                return;
+
+        fix_range(mm, 0, host_task_size, 0);
+        flush_tlb_kernel_range_common(start_vm, end_vm);
+}
+
+void force_flush_all_skas(void)
+{
+        fix_range(current->mm, 0, host_task_size, 1);
+}
diff --git a/arch/um/kernel/skas/trap_user.c b/arch/um/kernel/skas/trap_user.c
new file mode 100644
index 000000000000..8e9b46d4702e
--- /dev/null
+++ b/arch/um/kernel/skas/trap_user.c
@@ -0,0 +1,71 @@
+/* 
+ * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include <errno.h>
+#include "sysdep/ptrace.h"
+#include "signal_user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "task.h"
+#include "sigcontext.h"
+
+void sig_handler_common_skas(int sig, void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        struct skas_regs *r;
+        struct signal_info *info;
+        int save_errno = errno;
+        int save_user;
+
+        /* This is done because to allow SIGSEGV to be delivered inside a SEGV
+         * handler.  This can happen in copy_user, and if SEGV is disabled,
+         * the process will die.
+         * XXX Figure out why this is better than SA_NODEFER
+         */
+        if(sig == SIGSEGV)
+                change_sig(SIGSEGV, 1);
+
+        r = &TASK_REGS(get_current())->skas;
+        save_user = r->is_user;
+        r->is_user = 0;
+        r->fault_addr = SC_FAULT_ADDR(sc);
+        r->fault_type = SC_FAULT_TYPE(sc);
+        r->trap_type = SC_TRAP_TYPE(sc);
+
+        change_sig(SIGUSR1, 1);
+        info = &sig_info[sig];
+        if(!info->is_irq) unblock_signals();
+
+        (*info->handler)(sig, (union uml_pt_regs *) r);
+
+        errno = save_errno;
+        r->is_user = save_user;
+}
+
+void user_signal(int sig, union uml_pt_regs *regs)
+{
+        struct signal_info *info;
+
+        regs->skas.is_user = 1;
+        regs->skas.fault_addr = 0;
+        regs->skas.fault_type = 0;
+        regs->skas.trap_type = 0;
+        info = &sig_info[sig];
+        (*info->handler)(sig, regs);
+
+        unblock_signals();
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/uaccess.c b/arch/um/kernel/skas/uaccess.c
new file mode 100644
index 000000000000..7575ec489b63
--- /dev/null
+++ b/arch/um/kernel/skas/uaccess.c
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/kernel.h"
+#include "linux/string.h"
+#include "linux/fs.h"
+#include "linux/highmem.h"
+#include "asm/page.h"
+#include "asm/pgtable.h"
+#include "asm/uaccess.h"
+#include "kern_util.h"
+#include "user_util.h"
+
+extern void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
+                             pte_t *pte_out);
+
+static unsigned long maybe_map(unsigned long virt, int is_write)
+{
+        pte_t pte;
+        int err;
+
+        void *phys = um_virt_to_phys(current, virt, &pte);
+        int dummy_code;
+
+        if(IS_ERR(phys) || (is_write && !pte_write(pte))){
+                err = handle_page_fault(virt, 0, is_write, 1, &dummy_code);
+                if(err)
+                        return(0);
+                phys = um_virt_to_phys(current, virt, NULL);
+        }
+        return((unsigned long) phys);
+}
+
+static int do_op(unsigned long addr, int len, int is_write,
+                 int (*op)(unsigned long addr, int len, void *arg), void *arg)
+{
+        struct page *page;
+        int n;
+
+        addr = maybe_map(addr, is_write);
+        if(addr == -1)
+                return(-1);
+
+        page = phys_to_page(addr);
+        addr = (unsigned long) kmap(page) + (addr & ~PAGE_MASK);
+        n = (*op)(addr, len, arg);
+        kunmap(page);
+
+        return(n);
+}
+
+static void do_buffer_op(void *jmpbuf, void *arg_ptr)
+{
+        va_list args;
+        unsigned long addr;
+        int len, is_write, size, remain, n;
+        int (*op)(unsigned long, int, void *);
+        void *arg;
+        int *res;
+
+        /* Some old gccs recognize __va_copy, but not va_copy */
+        __va_copy(args, *(va_list *)arg_ptr);
+        addr = va_arg(args, unsigned long);
+        len = va_arg(args, int);
+        is_write = va_arg(args, int);
+        op = va_arg(args, void *);
+        arg = va_arg(args, void *);
+        res = va_arg(args, int *);
+        va_end(args);
+        size = min(PAGE_ALIGN(addr) - addr, (unsigned long) len);
+        remain = len;
+
+        current->thread.fault_catcher = jmpbuf;
+        n = do_op(addr, size, is_write, op, arg);
+        if(n != 0){
+                *res = (n < 0 ? remain : 0);
+                goto out;
+        }
+
+        addr += size;
+        remain -= size;
+        if(remain == 0){
+                *res = 0;
+                goto out;
+        }
+
+        while(addr < ((addr + remain) & PAGE_MASK)){
+                n = do_op(addr, PAGE_SIZE, is_write, op, arg);
+                if(n != 0){
+                        *res = (n < 0 ? remain : 0);
+                        goto out;
+                }
+
+                addr += PAGE_SIZE;
+                remain -= PAGE_SIZE;
+        }
+        if(remain == 0){
+                *res = 0;
+                goto out;
+        }
+
+        n = do_op(addr, remain, is_write, op, arg);
+        if(n != 0)
+                *res = (n < 0 ? remain : 0);
+        else *res = 0;
+ out:
+        current->thread.fault_catcher = NULL;
+}
+
+static int buffer_op(unsigned long addr, int len, int is_write,
+                     int (*op)(unsigned long addr, int len, void *arg),
+                     void *arg)
+{
+        int faulted, res;
+
+        faulted = setjmp_wrapper(do_buffer_op, addr, len, is_write, op, arg,
+                                 &res);
+        if(!faulted)
+                return(res);
+
+        return(addr + len - (unsigned long) current->thread.fault_addr);
+}
+
+static int copy_chunk_from_user(unsigned long from, int len, void *arg)
+{
+        unsigned long *to_ptr = arg, to = *to_ptr;
+
+        memcpy((void *) to, (void *) from, len);
+        *to_ptr += len;
+        return(0);
+}
+
+int copy_from_user_skas(void *to, const void __user *from, int n)
+{
+        if(segment_eq(get_fs(), KERNEL_DS)){
+                memcpy(to, (__force void*)from, n);
+                return(0);
+        }
+
+        return(access_ok_skas(VERIFY_READ, from, n) ?
+               buffer_op((unsigned long) from, n, 0, copy_chunk_from_user, &to):
+               n);
+}
+
+static int copy_chunk_to_user(unsigned long to, int len, void *arg)
+{
+        unsigned long *from_ptr = arg, from = *from_ptr;
+
+        memcpy((void *) to, (void *) from, len);
+        *from_ptr += len;
+        return(0);
+}
+
+int copy_to_user_skas(void __user *to, const void *from, int n)
+{
+        if(segment_eq(get_fs(), KERNEL_DS)){
+                memcpy((__force void*)to, from, n);
+                return(0);
+        }
+
+        return(access_ok_skas(VERIFY_WRITE, to, n) ?
+               buffer_op((unsigned long) to, n, 1, copy_chunk_to_user, &from) :
+               n);
+}
+
+static int strncpy_chunk_from_user(unsigned long from, int len, void *arg)
+{
+        char **to_ptr = arg, *to = *to_ptr;
+        int n;
+
+        strncpy(to, (void *) from, len);
+        n = strnlen(to, len);
+        *to_ptr += n;
+
+        if(n < len)
+                return(1);
+        return(0);
+}
+
+int strncpy_from_user_skas(char *dst, const char __user *src, int count)
+{
+        int n;
+        char *ptr = dst;
+
+        if(segment_eq(get_fs(), KERNEL_DS)){
+                strncpy(dst, (__force void*)src, count);
+                return(strnlen(dst, count));
+        }
+
+        if(!access_ok_skas(VERIFY_READ, src, 1))
+                return(-EFAULT);
+
+        n = buffer_op((unsigned long) src, count, 0, strncpy_chunk_from_user,
+                      &ptr);
+        if(n != 0)
+                return(-EFAULT);
+        return(strnlen(dst, count));
+}
+
+static int clear_chunk(unsigned long addr, int len, void *unused)
+{
+        memset((void *) addr, 0, len);
+        return(0);
+}
+
+int __clear_user_skas(void __user *mem, int len)
+{
+        return(buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL));
+}
+
+int clear_user_skas(void __user *mem, int len)
+{
+        if(segment_eq(get_fs(), KERNEL_DS)){
+                memset((__force void*)mem, 0, len);
+                return(0);
+        }
+
+        return(access_ok_skas(VERIFY_WRITE, mem, len) ?
+               buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL) : len);
+}
+
+static int strnlen_chunk(unsigned long str, int len, void *arg)
+{
+        int *len_ptr = arg, n;
+
+        n = strnlen((void *) str, len);
+        *len_ptr += n;
+
+        if(n < len)
+                return(1);
+        return(0);
+}
+
+int strnlen_user_skas(const void __user *str, int len)
+{
+        int count = 0, n;
+
+        if(segment_eq(get_fs(), KERNEL_DS))
+                return(strnlen((__force char*)str, len) + 1);
+
+        n = buffer_op((unsigned long) str, len, 0, strnlen_chunk, &count);
+        if(n == 0)
+                return(count + 1);
+        return(-EFAULT);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/util/Makefile b/arch/um/kernel/skas/util/Makefile
new file mode 100644
index 000000000000..17f5909d60f7
--- /dev/null
+++ b/arch/um/kernel/skas/util/Makefile
@@ -0,0 +1,4 @@
+hostprogs-y             := mk_ptregs
+always                  := $(hostprogs-y)
+
+mk_ptregs-objs := mk_ptregs-$(SUBARCH).o
diff --git a/arch/um/kernel/skas/util/mk_ptregs-i386.c b/arch/um/kernel/skas/util/mk_ptregs-i386.c
new file mode 100644
index 000000000000..0788dd05bcac
--- /dev/null
+++ b/arch/um/kernel/skas/util/mk_ptregs-i386.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <asm/ptrace.h>
+#include <asm/user.h>
+
+#define PRINT_REG(name, val) printf("#define HOST_%s %d\n", (name), (val))
+
+int main(int argc, char **argv)
+{
+        printf("/* Automatically generated by "
+               "arch/um/kernel/skas/util/mk_ptregs */\n");
+        printf("\n");
+        printf("#ifndef __SKAS_PT_REGS_\n");
+        printf("#define __SKAS_PT_REGS_\n");
+        printf("\n");
+        printf("#define HOST_FRAME_SIZE %d\n", FRAME_SIZE);
+        printf("#define HOST_FP_SIZE %d\n",
+               sizeof(struct user_i387_struct) / sizeof(unsigned long));
+        printf("#define HOST_XFP_SIZE %d\n",
+               sizeof(struct user_fxsr_struct) / sizeof(unsigned long));
+
+        PRINT_REG("IP", EIP);
+        PRINT_REG("SP", UESP);
+        PRINT_REG("EFLAGS", EFL);
+        PRINT_REG("EAX", EAX);
+        PRINT_REG("EBX", EBX);
+        PRINT_REG("ECX", ECX);
+        PRINT_REG("EDX", EDX);
+        PRINT_REG("ESI", ESI);
+        PRINT_REG("EDI", EDI);
+        PRINT_REG("EBP", EBP);
+        PRINT_REG("CS", CS);
+        PRINT_REG("SS", SS);
+        PRINT_REG("DS", DS);
+        PRINT_REG("FS", FS);
+        PRINT_REG("ES", ES);
+        PRINT_REG("GS", GS);
+        printf("\n");
+        printf("#endif\n");
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/skas/util/mk_ptregs-x86_64.c b/arch/um/kernel/skas/util/mk_ptregs-x86_64.c
new file mode 100644
index 000000000000..67aee92a70ef
--- /dev/null
+++ b/arch/um/kernel/skas/util/mk_ptregs-x86_64.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#define __FRAME_OFFSETS
+#include <asm/ptrace.h>
+
+#define PRINT_REG(name, val) \
+        printf("#define HOST_%s (%d / sizeof(unsigned long))\n", (name), (val))
+
+int main(int argc, char **argv)
+{
+        printf("/* Automatically generated by "
+               "arch/um/kernel/skas/util/mk_ptregs */\n");
+        printf("\n");
+        printf("#ifndef __SKAS_PT_REGS_\n");
+        printf("#define __SKAS_PT_REGS_\n");
+        printf("#define HOST_FRAME_SIZE (%d / sizeof(unsigned long))\n",
+               FRAME_SIZE);
+        PRINT_REG("RBX", RBX);
+        PRINT_REG("RCX", RCX);
+        PRINT_REG("RDI", RDI);
+        PRINT_REG("RSI", RSI);
+        PRINT_REG("RDX", RDX);
+        PRINT_REG("RBP", RBP);
+        PRINT_REG("RAX", RAX);
+        PRINT_REG("R8", R8);
+        PRINT_REG("R9", R9);
+        PRINT_REG("R10", R10);
+        PRINT_REG("R11", R11);
+        PRINT_REG("R12", R12);
+        PRINT_REG("R13", R13);
+        PRINT_REG("R14", R14);
+        PRINT_REG("R15", R15);
+        PRINT_REG("ORIG_RAX", ORIG_RAX);
+        PRINT_REG("CS", CS);
+        PRINT_REG("SS", SS);
+        PRINT_REG("EFLAGS", EFLAGS);
+#if 0
+        PRINT_REG("FS", FS);
+        PRINT_REG("GS", GS);
+        PRINT_REG("DS", DS);
+        PRINT_REG("ES", ES);
+#endif
+
+        PRINT_REG("IP", RIP);
+        PRINT_REG("SP", RSP);
+        printf("#define HOST_FP_SIZE 0\n");
+        printf("#define HOST_XFP_SIZE 0\n");
+        printf("\n");
+        printf("\n");
+        printf("#endif\n");
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/smp.c b/arch/um/kernel/smp.c
new file mode 100644
index 000000000000..72113b0a96e7
--- /dev/null
+++ b/arch/um/kernel/smp.c
@@ -0,0 +1,269 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/percpu.h"
+#include "asm/pgalloc.h"
+#include "asm/tlb.h"
+
+/* For some reason, mmu_gathers are referenced when CONFIG_SMP is off. */
+DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
+
+#ifdef CONFIG_SMP
+
+#include "linux/sched.h"
+#include "linux/module.h"
+#include "linux/threads.h"
+#include "linux/interrupt.h"
+#include "linux/err.h"
+#include "linux/hardirq.h"
+#include "asm/smp.h"
+#include "asm/processor.h"
+#include "asm/spinlock.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "irq_user.h"
+#include "os.h"
+
+/* CPU online map, set by smp_boot_cpus */
+cpumask_t cpu_online_map = CPU_MASK_NONE;
+cpumask_t cpu_possible_map = CPU_MASK_NONE;
+
+EXPORT_SYMBOL(cpu_online_map);
+EXPORT_SYMBOL(cpu_possible_map);
+
+/* Per CPU bogomips and other parameters
+ * The only piece used here is the ipi pipe, which is set before SMP is
+ * started and never changed.
+ */
+struct cpuinfo_um cpu_data[NR_CPUS];
+
+/* A statistic, can be a little off */
+int num_reschedules_sent = 0;
+
+/* Not changed after boot */
+struct task_struct *idle_threads[NR_CPUS];
+
+void smp_send_reschedule(int cpu)
+{
+        os_write_file(cpu_data[cpu].ipi_pipe[1], "R", 1);
+        num_reschedules_sent++;
+}
+
+void smp_send_stop(void)
+{
+        int i;
+
+        printk(KERN_INFO "Stopping all CPUs...");
+        for(i = 0; i < num_online_cpus(); i++){
+                if(i == current_thread->cpu)
+                        continue;
+                os_write_file(cpu_data[i].ipi_pipe[1], "S", 1);
+        }
+        printk("done\n");
+}
+
+static cpumask_t smp_commenced_mask = CPU_MASK_NONE;
+static cpumask_t cpu_callin_map = CPU_MASK_NONE;
+
+static int idle_proc(void *cpup)
+{
+        int cpu = (int) cpup, err;
+
+        err = os_pipe(cpu_data[cpu].ipi_pipe, 1, 1);
+        if(err < 0)
+                panic("CPU#%d failed to create IPI pipe, err = %d", cpu, -err);
+
+        activate_ipi(cpu_data[cpu].ipi_pipe[0], 
+                     current->thread.mode.tt.extern_pid);
+ 
+        wmb();
+        if (cpu_test_and_set(cpu, cpu_callin_map)) {
+                printk("huh, CPU#%d already present??\n", cpu);
+                BUG();
+        }
+
+        while (!cpu_isset(cpu, smp_commenced_mask))
+                cpu_relax();
+
+        cpu_set(cpu, cpu_online_map);
+        default_idle();
+        return(0);
+}
+
+static struct task_struct *idle_thread(int cpu)
+{
+        struct task_struct *new_task;
+        unsigned char c;
+
+        current->thread.request.u.thread.proc = idle_proc;
+        current->thread.request.u.thread.arg = (void *) cpu;
+        new_task = fork_idle(cpu);
+        if(IS_ERR(new_task))
+                panic("copy_process failed in idle_thread, error = %ld",
+                      PTR_ERR(new_task));
+
+        cpu_tasks[cpu] = ((struct cpu_task) 
+                          { .pid =      new_task->thread.mode.tt.extern_pid,
+                            .task =     new_task } );
+        idle_threads[cpu] = new_task;
+        CHOOSE_MODE(os_write_file(new_task->thread.mode.tt.switch_pipe[1], &c,
+                          sizeof(c)),
+                    ({ panic("skas mode doesn't support SMP"); }));
+        return(new_task);
+}
+
+void smp_prepare_cpus(unsigned int maxcpus)
+{
+        struct task_struct *idle;
+        unsigned long waittime;
+        int err, cpu, me = smp_processor_id();
+        int i;
+
+        for (i = 0; i < ncpus; ++i)
+                cpu_set(i, cpu_possible_map);
+
+        cpu_clear(me, cpu_online_map);
+        cpu_set(me, cpu_online_map);
+        cpu_set(me, cpu_callin_map);
+
+        err = os_pipe(cpu_data[me].ipi_pipe, 1, 1);
+        if(err < 0)
+                panic("CPU#0 failed to create IPI pipe, errno = %d", -err);
+
+        activate_ipi(cpu_data[me].ipi_pipe[0],
+                     current->thread.mode.tt.extern_pid);
+
+        for(cpu = 1; cpu < ncpus; cpu++){
+                printk("Booting processor %d...\n", cpu);
+                
+                idle = idle_thread(cpu);
+
+                init_idle(idle, cpu);
+                unhash_process(idle);
+
+                waittime = 200000000;
+                while (waittime-- && !cpu_isset(cpu, cpu_callin_map))
+                        cpu_relax();
+
+                if (cpu_isset(cpu, cpu_callin_map))
+                        printk("done\n");
+                else printk("failed\n");
+        }
+}
+
+void smp_prepare_boot_cpu(void)
+{
+        cpu_set(smp_processor_id(), cpu_online_map);
+}
+
+int __cpu_up(unsigned int cpu)
+{
+        cpu_set(cpu, smp_commenced_mask);
+        while (!cpu_isset(cpu, cpu_online_map))
+                mb();
+        return(0);
+}
+
+int setup_profiling_timer(unsigned int multiplier)
+{
+        printk(KERN_INFO "setup_profiling_timer\n");
+        return(0);
+}
+
+void smp_call_function_slave(int cpu);
+
+void IPI_handler(int cpu)
+{
+        unsigned char c;
+        int fd;
+
+        fd = cpu_data[cpu].ipi_pipe[0];
+        while (os_read_file(fd, &c, 1) == 1) {
+                switch (c) {
+                case 'C':
+                        smp_call_function_slave(cpu);
+                        break;
+
+                case 'R':
+                        set_tsk_need_resched(current);
+                        break;
+
+                case 'S':
+                        printk("CPU#%d stopping\n", cpu);
+                        while(1)
+                                pause();
+                        break;
+
+                default:
+                        printk("CPU#%d received unknown IPI [%c]!\n", cpu, c);
+                        break;
+                }
+        }
+}
+
+int hard_smp_processor_id(void)
+{
+        return(pid_to_processor_id(os_getpid()));
+}
+
+static DEFINE_SPINLOCK(call_lock);
+static atomic_t scf_started;
+static atomic_t scf_finished;
+static void (*func)(void *info);
+static void *info;
+
+void smp_call_function_slave(int cpu)
+{
+        atomic_inc(&scf_started);
+        (*func)(info);
+        atomic_inc(&scf_finished);
+}
+
+int smp_call_function(void (*_func)(void *info), void *_info, int nonatomic, 
+                      int wait)
+{
+        int cpus = num_online_cpus() - 1;
+        int i;
+
+        if (!cpus)
+                return 0;
+
+        /* Can deadlock when called with interrupts disabled */
+        WARN_ON(irqs_disabled());
+
+        spin_lock_bh(&call_lock);
+        atomic_set(&scf_started, 0);
+        atomic_set(&scf_finished, 0);
+        func = _func;
+        info = _info;
+
+        for_each_online_cpu(i)
+                os_write_file(cpu_data[i].ipi_pipe[1], "C", 1);
+
+        while (atomic_read(&scf_started) != cpus)
+                barrier();
+
+        if (wait)
+                while (atomic_read(&scf_finished) != cpus)
+                        barrier();
+
+        spin_unlock_bh(&call_lock);
+        return 0;
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/sys_call_table.c b/arch/um/kernel/sys_call_table.c
new file mode 100644
index 000000000000..7fc06c85b29d
--- /dev/null
+++ b/arch/um/kernel/sys_call_table.c
@@ -0,0 +1,276 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Copyright 2003 PathScale, Inc.
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/unistd.h"
+#include "linux/sys.h"
+#include "linux/swap.h"
+#include "linux/syscalls.h"
+#include "linux/sysctl.h"
+#include "asm/signal.h"
+#include "sysdep/syscalls.h"
+#include "kern_util.h"
+
+#ifdef CONFIG_NFSD
+#define NFSSERVCTL sys_nfsservctl
+#else
+#define NFSSERVCTL sys_ni_syscall
+#endif
+
+#define LAST_GENERIC_SYSCALL __NR_keyctl
+
+#if LAST_GENERIC_SYSCALL > LAST_ARCH_SYSCALL
+#define LAST_SYSCALL LAST_GENERIC_SYSCALL
+#else
+#define LAST_SYSCALL LAST_ARCH_SYSCALL
+#endif
+
+extern syscall_handler_t sys_fork;
+extern syscall_handler_t sys_execve;
+extern syscall_handler_t um_time;
+extern syscall_handler_t um_stime;
+extern syscall_handler_t sys_pipe;
+extern syscall_handler_t sys_olduname;
+extern syscall_handler_t sys_sigaction;
+extern syscall_handler_t sys_sigsuspend;
+extern syscall_handler_t old_readdir;
+extern syscall_handler_t sys_uname;
+extern syscall_handler_t sys_ipc;
+extern syscall_handler_t sys_sigreturn;
+extern syscall_handler_t sys_clone;
+extern syscall_handler_t sys_rt_sigreturn;
+extern syscall_handler_t sys_sigaltstack;
+extern syscall_handler_t sys_vfork;
+extern syscall_handler_t old_select;
+extern syscall_handler_t sys_modify_ldt;
+extern syscall_handler_t sys_rt_sigsuspend;
+extern syscall_handler_t sys_mbind;
+extern syscall_handler_t sys_get_mempolicy;
+extern syscall_handler_t sys_set_mempolicy;
+extern syscall_handler_t sys_sys_setaltroot;
+
+syscall_handler_t *sys_call_table[] = {
+        [ __NR_restart_syscall ] = (syscall_handler_t *) sys_restart_syscall,
+        [ __NR_exit ] = (syscall_handler_t *) sys_exit,
+        [ __NR_fork ] = (syscall_handler_t *) sys_fork,
+        [ __NR_read ] = (syscall_handler_t *) sys_read,
+        [ __NR_write ] = (syscall_handler_t *) sys_write,
+
+        /* These three are declared differently in asm/unistd.h */
+        [ __NR_open ] = (syscall_handler_t *) sys_open,
+        [ __NR_close ] = (syscall_handler_t *) sys_close,
+        [ __NR_creat ] = (syscall_handler_t *) sys_creat,
+        [ __NR_link ] = (syscall_handler_t *) sys_link,
+        [ __NR_unlink ] = (syscall_handler_t *) sys_unlink,
+        [ __NR_execve ] = (syscall_handler_t *) sys_execve,
+
+        /* declared differently in kern_util.h */
+        [ __NR_chdir ] = (syscall_handler_t *) sys_chdir,
+        [ __NR_time ] = um_time,
+        [ __NR_mknod ] = (syscall_handler_t *) sys_mknod,
+        [ __NR_chmod ] = (syscall_handler_t *) sys_chmod,
+        [ __NR_lchown ] = (syscall_handler_t *) sys_lchown16,
+        [ __NR_lseek ] = (syscall_handler_t *) sys_lseek,
+        [ __NR_getpid ] = (syscall_handler_t *) sys_getpid,
+        [ __NR_mount ] = (syscall_handler_t *) sys_mount,
+        [ __NR_setuid ] = (syscall_handler_t *) sys_setuid16,
+        [ __NR_getuid ] = (syscall_handler_t *) sys_getuid16,
+        [ __NR_ptrace ] = (syscall_handler_t *) sys_ptrace,
+        [ __NR_alarm ] = (syscall_handler_t *) sys_alarm,
+        [ __NR_pause ] = (syscall_handler_t *) sys_pause,
+        [ __NR_utime ] = (syscall_handler_t *) sys_utime,
+        [ __NR_access ] = (syscall_handler_t *) sys_access,
+        [ __NR_sync ] = (syscall_handler_t *) sys_sync,
+        [ __NR_kill ] = (syscall_handler_t *) sys_kill,
+        [ __NR_rename ] = (syscall_handler_t *) sys_rename,
+        [ __NR_mkdir ] = (syscall_handler_t *) sys_mkdir,
+        [ __NR_rmdir ] = (syscall_handler_t *) sys_rmdir,
+
+        /* Declared differently in asm/unistd.h */
+        [ __NR_dup ] = (syscall_handler_t *) sys_dup,
+        [ __NR_pipe ] = (syscall_handler_t *) sys_pipe,
+        [ __NR_times ] = (syscall_handler_t *) sys_times,
+        [ __NR_brk ] = (syscall_handler_t *) sys_brk,
+        [ __NR_setgid ] = (syscall_handler_t *) sys_setgid16,
+        [ __NR_getgid ] = (syscall_handler_t *) sys_getgid16,
+        [ __NR_geteuid ] = (syscall_handler_t *) sys_geteuid16,
+        [ __NR_getegid ] = (syscall_handler_t *) sys_getegid16,
+        [ __NR_acct ] = (syscall_handler_t *) sys_acct,
+        [ __NR_umount2 ] = (syscall_handler_t *) sys_umount,
+        [ __NR_ioctl ] = (syscall_handler_t *) sys_ioctl,
+        [ __NR_fcntl ] = (syscall_handler_t *) sys_fcntl,
+        [ __NR_setpgid ] = (syscall_handler_t *) sys_setpgid,
+        [ __NR_umask ] = (syscall_handler_t *) sys_umask,
+        [ __NR_chroot ] = (syscall_handler_t *) sys_chroot,
+        [ __NR_ustat ] = (syscall_handler_t *) sys_ustat,
+        [ __NR_dup2 ] = (syscall_handler_t *) sys_dup2,
+        [ __NR_getppid ] = (syscall_handler_t *) sys_getppid,
+        [ __NR_getpgrp ] = (syscall_handler_t *) sys_getpgrp,
+        [ __NR_setsid ] = (syscall_handler_t *) sys_setsid,
+        [ __NR_setreuid ] = (syscall_handler_t *) sys_setreuid16,
+        [ __NR_setregid ] = (syscall_handler_t *) sys_setregid16,
+        [ __NR_sethostname ] = (syscall_handler_t *) sys_sethostname,
+        [ __NR_setrlimit ] = (syscall_handler_t *) sys_setrlimit,
+        [ __NR_getrlimit ] = (syscall_handler_t *) sys_old_getrlimit,
+        [ __NR_getrusage ] = (syscall_handler_t *) sys_getrusage,
+        [ __NR_gettimeofday ] = (syscall_handler_t *) sys_gettimeofday,
+        [ __NR_settimeofday ] = (syscall_handler_t *) sys_settimeofday,
+        [ __NR_getgroups ] = (syscall_handler_t *) sys_getgroups16,
+        [ __NR_setgroups ] = (syscall_handler_t *) sys_setgroups16,
+        [ __NR_symlink ] = (syscall_handler_t *) sys_symlink,
+        [ __NR_readlink ] = (syscall_handler_t *) sys_readlink,
+        [ __NR_uselib ] = (syscall_handler_t *) sys_uselib,
+        [ __NR_swapon ] = (syscall_handler_t *) sys_swapon,
+        [ __NR_reboot ] = (syscall_handler_t *) sys_reboot,
+        [ __NR_munmap ] = (syscall_handler_t *) sys_munmap,
+        [ __NR_truncate ] = (syscall_handler_t *) sys_truncate,
+        [ __NR_ftruncate ] = (syscall_handler_t *) sys_ftruncate,
+        [ __NR_fchmod ] = (syscall_handler_t *) sys_fchmod,
+        [ __NR_fchown ] = (syscall_handler_t *) sys_fchown16,
+        [ __NR_getpriority ] = (syscall_handler_t *) sys_getpriority,
+        [ __NR_setpriority ] = (syscall_handler_t *) sys_setpriority,
+        [ __NR_statfs ] = (syscall_handler_t *) sys_statfs,
+        [ __NR_fstatfs ] = (syscall_handler_t *) sys_fstatfs,
+        [ __NR_ioperm ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_syslog ] = (syscall_handler_t *) sys_syslog,
+        [ __NR_setitimer ] = (syscall_handler_t *) sys_setitimer,
+        [ __NR_getitimer ] = (syscall_handler_t *) sys_getitimer,
+        [ __NR_stat ] = (syscall_handler_t *) sys_newstat,
+        [ __NR_lstat ] = (syscall_handler_t *) sys_newlstat,
+        [ __NR_fstat ] = (syscall_handler_t *) sys_newfstat,
+        [ __NR_vhangup ] = (syscall_handler_t *) sys_vhangup,
+        [ __NR_wait4 ] = (syscall_handler_t *) sys_wait4,
+        [ __NR_swapoff ] = (syscall_handler_t *) sys_swapoff,
+        [ __NR_sysinfo ] = (syscall_handler_t *) sys_sysinfo,
+        [ __NR_fsync ] = (syscall_handler_t *) sys_fsync,
+        [ __NR_clone ] = (syscall_handler_t *) sys_clone,
+        [ __NR_setdomainname ] = (syscall_handler_t *) sys_setdomainname,
+        [ __NR_uname ] = (syscall_handler_t *) sys_newuname,
+        [ __NR_adjtimex ] = (syscall_handler_t *) sys_adjtimex,
+        [ __NR_mprotect ] = (syscall_handler_t *) sys_mprotect,
+        [ __NR_create_module ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_init_module ] = (syscall_handler_t *) sys_init_module,
+        [ __NR_delete_module ] = (syscall_handler_t *) sys_delete_module,
+        [ __NR_get_kernel_syms ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_quotactl ] = (syscall_handler_t *) sys_quotactl,
+        [ __NR_getpgid ] = (syscall_handler_t *) sys_getpgid,
+        [ __NR_fchdir ] = (syscall_handler_t *) sys_fchdir,
+        [ __NR_sysfs ] = (syscall_handler_t *) sys_sysfs,
+        [ __NR_personality ] = (syscall_handler_t *) sys_personality,
+        [ __NR_afs_syscall ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_setfsuid ] = (syscall_handler_t *) sys_setfsuid16,
+        [ __NR_setfsgid ] = (syscall_handler_t *) sys_setfsgid16,
+        [ __NR_getdents ] = (syscall_handler_t *) sys_getdents,
+        [ __NR_flock ] = (syscall_handler_t *) sys_flock,
+        [ __NR_msync ] = (syscall_handler_t *) sys_msync,
+        [ __NR_readv ] = (syscall_handler_t *) sys_readv,
+        [ __NR_writev ] = (syscall_handler_t *) sys_writev,
+        [ __NR_getsid ] = (syscall_handler_t *) sys_getsid,
+        [ __NR_fdatasync ] = (syscall_handler_t *) sys_fdatasync,
+        [ __NR__sysctl ] = (syscall_handler_t *) sys_sysctl,
+        [ __NR_mlock ] = (syscall_handler_t *) sys_mlock,
+        [ __NR_munlock ] = (syscall_handler_t *) sys_munlock,
+        [ __NR_mlockall ] = (syscall_handler_t *) sys_mlockall,
+        [ __NR_munlockall ] = (syscall_handler_t *) sys_munlockall,
+        [ __NR_sched_setparam ] = (syscall_handler_t *) sys_sched_setparam,
+        [ __NR_sched_getparam ] = (syscall_handler_t *) sys_sched_getparam,
+        [ __NR_sched_setscheduler ] = (syscall_handler_t *) sys_sched_setscheduler,
+        [ __NR_sched_getscheduler ] = (syscall_handler_t *) sys_sched_getscheduler,
+        [ __NR_sched_yield ] = (syscall_handler_t *) yield,
+        [ __NR_sched_get_priority_max ] = (syscall_handler_t *) sys_sched_get_priority_max,
+        [ __NR_sched_get_priority_min ] = (syscall_handler_t *) sys_sched_get_priority_min,
+        [ __NR_sched_rr_get_interval ] = (syscall_handler_t *) sys_sched_rr_get_interval,
+        [ __NR_nanosleep ] = (syscall_handler_t *) sys_nanosleep,
+        [ __NR_mremap ] = (syscall_handler_t *) sys_mremap,
+        [ __NR_setresuid ] = (syscall_handler_t *) sys_setresuid16,
+        [ __NR_getresuid ] = (syscall_handler_t *) sys_getresuid16,
+        [ __NR_query_module ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_poll ] = (syscall_handler_t *) sys_poll,
+        [ __NR_nfsservctl ] = (syscall_handler_t *) NFSSERVCTL,
+        [ __NR_setresgid ] = (syscall_handler_t *) sys_setresgid16,
+        [ __NR_getresgid ] = (syscall_handler_t *) sys_getresgid16,
+        [ __NR_prctl ] = (syscall_handler_t *) sys_prctl,
+        [ __NR_rt_sigreturn ] = (syscall_handler_t *) sys_rt_sigreturn,
+        [ __NR_rt_sigaction ] = (syscall_handler_t *) sys_rt_sigaction,
+        [ __NR_rt_sigprocmask ] = (syscall_handler_t *) sys_rt_sigprocmask,
+        [ __NR_rt_sigpending ] = (syscall_handler_t *) sys_rt_sigpending,
+        [ __NR_rt_sigtimedwait ] = (syscall_handler_t *) sys_rt_sigtimedwait,
+        [ __NR_rt_sigqueueinfo ] = (syscall_handler_t *) sys_rt_sigqueueinfo,
+        [ __NR_rt_sigsuspend ] = (syscall_handler_t *) sys_rt_sigsuspend,
+        [ __NR_pread64 ] = (syscall_handler_t *) sys_pread64,
+        [ __NR_pwrite64 ] = (syscall_handler_t *) sys_pwrite64,
+        [ __NR_chown ] = (syscall_handler_t *) sys_chown16,
+        [ __NR_getcwd ] = (syscall_handler_t *) sys_getcwd,
+        [ __NR_capget ] = (syscall_handler_t *) sys_capget,
+        [ __NR_capset ] = (syscall_handler_t *) sys_capset,
+        [ __NR_sigaltstack ] = (syscall_handler_t *) sys_sigaltstack,
+        [ __NR_sendfile ] = (syscall_handler_t *) sys_sendfile,
+        [ __NR_getpmsg ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_putpmsg ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_vfork ] = (syscall_handler_t *) sys_vfork,
+        [ __NR_getdents64 ] = (syscall_handler_t *) sys_getdents64,
+        [ __NR_gettid ] = (syscall_handler_t *) sys_gettid,
+        [ __NR_readahead ] = (syscall_handler_t *) sys_readahead,
+        [ __NR_setxattr ] = (syscall_handler_t *) sys_setxattr,
+        [ __NR_lsetxattr ] = (syscall_handler_t *) sys_lsetxattr,
+        [ __NR_fsetxattr ] = (syscall_handler_t *) sys_fsetxattr,
+        [ __NR_getxattr ] = (syscall_handler_t *) sys_getxattr,
+        [ __NR_lgetxattr ] = (syscall_handler_t *) sys_lgetxattr,
+        [ __NR_fgetxattr ] = (syscall_handler_t *) sys_fgetxattr,
+        [ __NR_listxattr ] = (syscall_handler_t *) sys_listxattr,
+        [ __NR_llistxattr ] = (syscall_handler_t *) sys_llistxattr,
+        [ __NR_flistxattr ] = (syscall_handler_t *) sys_flistxattr,
+        [ __NR_removexattr ] = (syscall_handler_t *) sys_removexattr,
+        [ __NR_lremovexattr ] = (syscall_handler_t *) sys_lremovexattr,
+        [ __NR_fremovexattr ] = (syscall_handler_t *) sys_fremovexattr,
+        [ __NR_tkill ] = (syscall_handler_t *) sys_tkill,
+        [ __NR_futex ] = (syscall_handler_t *) sys_futex,
+        [ __NR_sched_setaffinity ] = (syscall_handler_t *) sys_sched_setaffinity,
+        [ __NR_sched_getaffinity ] = (syscall_handler_t *) sys_sched_getaffinity,
+        [ __NR_io_setup ] = (syscall_handler_t *) sys_io_setup,
+        [ __NR_io_destroy ] = (syscall_handler_t *) sys_io_destroy,
+        [ __NR_io_getevents ] = (syscall_handler_t *) sys_io_getevents,
+        [ __NR_io_submit ] = (syscall_handler_t *) sys_io_submit,
+        [ __NR_io_cancel ] = (syscall_handler_t *) sys_io_cancel,
+        [ __NR_exit_group ] = (syscall_handler_t *) sys_exit_group,
+        [ __NR_lookup_dcookie ] = (syscall_handler_t *) sys_lookup_dcookie,
+        [ __NR_epoll_create ] = (syscall_handler_t *) sys_epoll_create,
+        [ __NR_epoll_ctl ] = (syscall_handler_t *) sys_epoll_ctl,
+        [ __NR_epoll_wait ] = (syscall_handler_t *) sys_epoll_wait,
+        [ __NR_remap_file_pages ] = (syscall_handler_t *) sys_remap_file_pages,
+        [ __NR_set_tid_address ] = (syscall_handler_t *) sys_set_tid_address,
+        [ __NR_timer_create ] = (syscall_handler_t *) sys_timer_create,
+        [ __NR_timer_settime ] = (syscall_handler_t *) sys_timer_settime,
+        [ __NR_timer_gettime ] = (syscall_handler_t *) sys_timer_gettime,
+        [ __NR_timer_getoverrun ] = (syscall_handler_t *) sys_timer_getoverrun,
+        [ __NR_timer_delete ] = (syscall_handler_t *) sys_timer_delete,
+        [ __NR_clock_settime ] = (syscall_handler_t *) sys_clock_settime,
+        [ __NR_clock_gettime ] = (syscall_handler_t *) sys_clock_gettime,
+        [ __NR_clock_getres ] = (syscall_handler_t *) sys_clock_getres,
+        [ __NR_clock_nanosleep ] = (syscall_handler_t *) sys_clock_nanosleep,
+        [ __NR_tgkill ] = (syscall_handler_t *) sys_tgkill,
+        [ __NR_utimes ] = (syscall_handler_t *) sys_utimes,
+        [ __NR_fadvise64 ] = (syscall_handler_t *) sys_fadvise64,
+        [ __NR_vserver ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_mbind ] = (syscall_handler_t *) sys_mbind,
+        [ __NR_get_mempolicy ] = (syscall_handler_t *) sys_get_mempolicy,
+        [ __NR_set_mempolicy ] = (syscall_handler_t *) sys_set_mempolicy,
+        [ __NR_mq_open ] = (syscall_handler_t *) sys_mq_open,
+        [ __NR_mq_unlink ] = (syscall_handler_t *) sys_mq_unlink,
+        [ __NR_mq_timedsend ] = (syscall_handler_t *) sys_mq_timedsend,
+        [ __NR_mq_timedreceive ] = (syscall_handler_t *) sys_mq_timedreceive,
+        [ __NR_mq_notify ] = (syscall_handler_t *) sys_mq_notify,
+        [ __NR_mq_getsetattr ] = (syscall_handler_t *) sys_mq_getsetattr,
+        [ __NR_kexec_load ] = (syscall_handler_t *) sys_ni_syscall,
+        [ __NR_waitid ] = (syscall_handler_t *) sys_waitid,
+        [ __NR_add_key ] = (syscall_handler_t *) sys_add_key,
+        [ __NR_request_key ] = (syscall_handler_t *) sys_request_key,
+        [ __NR_keyctl ] = (syscall_handler_t *) sys_keyctl,
+
+        ARCH_SYSCALLS
+        [ LAST_SYSCALL + 1 ... NR_syscalls ] = 
+                (syscall_handler_t *) sys_ni_syscall
+};
diff --git a/arch/um/kernel/syscall_kern.c b/arch/um/kernel/syscall_kern.c
new file mode 100644
index 000000000000..42731e04f50f
--- /dev/null
+++ b/arch/um/kernel/syscall_kern.c
@@ -0,0 +1,176 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/file.h"
+#include "linux/smp_lock.h"
+#include "linux/mm.h"
+#include "linux/utsname.h"
+#include "linux/msg.h"
+#include "linux/shm.h"
+#include "linux/sys.h"
+#include "linux/syscalls.h"
+#include "linux/unistd.h"
+#include "linux/slab.h"
+#include "linux/utime.h"
+#include "asm/mman.h"
+#include "asm/uaccess.h"
+#include "asm/ipc.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "sysdep/syscalls.h"
+#include "mode_kern.h"
+#include "choose-mode.h"
+
+/*  Unlocked, I don't care if this is a bit off */
+int nsyscalls = 0;
+
+long sys_fork(void)
+{
+        long ret;
+
+        current->thread.forking = 1;
+        ret = do_fork(SIGCHLD, 0, NULL, 0, NULL, NULL);
+        current->thread.forking = 0;
+        return(ret);
+}
+
+long sys_vfork(void)
+{
+        long ret;
+
+        current->thread.forking = 1;
+        ret = do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, NULL, 0, NULL,
+                      NULL);
+        current->thread.forking = 0;
+        return(ret);
+}
+
+/* common code for old and new mmaps */
+long sys_mmap2(unsigned long addr, unsigned long len,
+               unsigned long prot, unsigned long flags,
+               unsigned long fd, unsigned long pgoff)
+{
+        long error = -EBADF;
+        struct file * file = NULL;
+
+        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
+        if (!(flags & MAP_ANONYMOUS)) {
+                file = fget(fd);
+                if (!file)
+                        goto out;
+        }
+
+        down_write(&current->mm->mmap_sem);
+        error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
+        up_write(&current->mm->mmap_sem);
+
+        if (file)
+                fput(file);
+ out:
+        return error;
+}
+
+long old_mmap(unsigned long addr, unsigned long len,
+              unsigned long prot, unsigned long flags,
+              unsigned long fd, unsigned long offset)
+{
+        long err = -EINVAL;
+        if (offset & ~PAGE_MASK)
+                goto out;
+
+        err = sys_mmap2(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
+ out:
+        return err;
+}
+/*
+ * sys_pipe() is the normal C calling standard for creating
+ * a pipe. It's not the way unix traditionally does this, though.
+ */
+long sys_pipe(unsigned long __user * fildes)
+{
+        int fd[2];
+        long error;
+
+        error = do_pipe(fd);
+        if (!error) {
+                if (copy_to_user(fildes, fd, sizeof(fd)))
+                        error = -EFAULT;
+        }
+        return error;
+}
+
+
+long sys_uname(struct old_utsname * name)
+{
+        long err;
+        if (!name)
+                return -EFAULT;
+        down_read(&uts_sem);
+        err=copy_to_user(name, &system_utsname, sizeof (*name));
+        up_read(&uts_sem);
+        return err?-EFAULT:0;
+}
+
+long sys_olduname(struct oldold_utsname * name)
+{
+        long error;
+
+        if (!name)
+                return -EFAULT;
+        if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
+                return -EFAULT;
+  
+        down_read(&uts_sem);
+        
+        error = __copy_to_user(&name->sysname,&system_utsname.sysname,
+                               __OLD_UTS_LEN);
+        error |= __put_user(0,name->sysname+__OLD_UTS_LEN);
+        error |= __copy_to_user(&name->nodename,&system_utsname.nodename,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0,name->nodename+__OLD_UTS_LEN);
+        error |= __copy_to_user(&name->release,&system_utsname.release,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0,name->release+__OLD_UTS_LEN);
+        error |= __copy_to_user(&name->version,&system_utsname.version,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0,name->version+__OLD_UTS_LEN);
+        error |= __copy_to_user(&name->machine,&system_utsname.machine,
+                                __OLD_UTS_LEN);
+        error |= __put_user(0,name->machine+__OLD_UTS_LEN);
+        
+        up_read(&uts_sem);
+        
+        error = error ? -EFAULT : 0;
+
+        return error;
+}
+
+DEFINE_SPINLOCK(syscall_lock);
+
+static int syscall_index = 0;
+
+int next_syscall_index(int limit)
+{
+        int ret;
+
+        spin_lock(&syscall_lock);
+        ret = syscall_index;
+        if(++syscall_index == limit)
+                syscall_index = 0;
+        spin_unlock(&syscall_lock);
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/syscall_user.c b/arch/um/kernel/syscall_user.c
new file mode 100644
index 000000000000..01b711e00a85
--- /dev/null
+++ b/arch/um/kernel/syscall_user.c
@@ -0,0 +1,48 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <sys/time.h>
+#include "kern_util.h"
+#include "syscall_user.h"
+
+struct {
+        int syscall;
+        int pid;
+        long result;
+        struct timeval start;
+        struct timeval end;
+} syscall_record[1024];
+
+int record_syscall_start(int syscall)
+{
+        int max, index;
+
+        max = sizeof(syscall_record)/sizeof(syscall_record[0]);
+        index = next_syscall_index(max);
+
+        syscall_record[index].syscall = syscall;
+        syscall_record[index].pid = current_pid();
+        syscall_record[index].result = 0xdeadbeef;
+        gettimeofday(&syscall_record[index].start, NULL);
+        return(index);
+}
+
+void record_syscall_end(int index, long result)
+{
+        syscall_record[index].result = result;
+        gettimeofday(&syscall_record[index].end, NULL);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/sysrq.c b/arch/um/kernel/sysrq.c
new file mode 100644
index 000000000000..e630438f9e73
--- /dev/null
+++ b/arch/um/kernel/sysrq.c
@@ -0,0 +1,81 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/kernel.h"
+#include "linux/module.h"
+#include "linux/kallsyms.h"
+#include "asm/page.h"
+#include "asm/processor.h"
+#include "sysrq.h"
+#include "user_util.h"
+
+void show_trace(unsigned long * stack)
+{
+        /* XXX: Copy the CONFIG_FRAME_POINTER stack-walking backtrace from
+         * arch/i386/kernel/traps.c, and then move this to sys-i386/sysrq.c.*/
+        unsigned long addr;
+
+        if (!stack) {
+                stack = (unsigned long*) &stack;
+                WARN_ON(1);
+        }
+
+        printk("Call Trace: \n");
+        while (((long) stack & (THREAD_SIZE-1)) != 0) {
+                addr = *stack;
+                if (__kernel_text_address(addr)) {
+                        printk("%08lx:  [<%08lx>]", (unsigned long) stack, addr);
+                        print_symbol(" %s", addr);
+                        printk("\n");
+                }
+                stack++;
+        }
+        printk("\n");
+}
+
+/*
+ * stack dumps generator - this is used by arch-independent code.
+ * And this is identical to i386 currently.
+ */
+void dump_stack(void)
+{
+        unsigned long stack;
+
+        show_trace(&stack);
+}
+EXPORT_SYMBOL(dump_stack);
+
+/*Stolen from arch/i386/kernel/traps.c */
+static int kstack_depth_to_print = 24;
+
+/* This recently started being used in arch-independent code too, as in
+ * kernel/sched.c.*/
+void show_stack(struct task_struct *task, unsigned long *esp)
+{
+        unsigned long *stack;
+        int i;
+
+        if (esp == NULL) {
+                if (task != current) {
+                        esp = (unsigned long *) KSTK_ESP(task);
+                        /* Which one? No actual difference - just coding style.*/
+                        //esp = (unsigned long *) PT_REGS_IP(&task->thread.regs);
+                } else {
+                        esp = (unsigned long *) &esp;
+                }
+        }
+
+        stack = esp;
+        for(i = 0; i < kstack_depth_to_print; i++) {
+                if (kstack_end(stack))
+                        break;
+                if (i && ((i % 8) == 0))
+                        printk("\n       ");
+                printk("%08lx ", *stack++);
+        }
+
+        show_trace(esp);
+}
diff --git a/arch/um/kernel/tempfile.c b/arch/um/kernel/tempfile.c
new file mode 100644
index 000000000000..b1674bc1395d
--- /dev/null
+++ b/arch/um/kernel/tempfile.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/param.h>
+#include "init.h"
+
+/* Modified from create_mem_file and start_debugger */
+static char *tempdir = NULL;
+
+static void __init find_tempdir(void)
+{
+        char *dirs[] = { "TMP", "TEMP", "TMPDIR", NULL };
+        int i;
+        char *dir = NULL;
+
+        if(tempdir != NULL) return;     /* We've already been called */
+        for(i = 0; dirs[i]; i++){
+                dir = getenv(dirs[i]);
+                if((dir != NULL) && (*dir != '\0'))
+                        break;
+        }
+        if((dir == NULL) || (*dir == '\0')) 
+                dir = "/tmp";
+
+        tempdir = malloc(strlen(dir) + 2);
+        if(tempdir == NULL){
+                fprintf(stderr, "Failed to malloc tempdir, "
+                        "errno = %d\n", errno);
+                return;
+        }
+        strcpy(tempdir, dir);
+        strcat(tempdir, "/");
+}
+
+int make_tempfile(const char *template, char **out_tempname, int do_unlink)
+{
+        char tempname[MAXPATHLEN];
+        int fd;
+
+        find_tempdir();
+        if (*template != '/')
+                strcpy(tempname, tempdir);
+        else
+                *tempname = 0;
+        strcat(tempname, template);
+        fd = mkstemp(tempname);
+        if(fd < 0){
+                fprintf(stderr, "open - cannot create %s: %s\n", tempname, 
+                        strerror(errno));
+                return -1;
+        }
+        if(do_unlink && (unlink(tempname) < 0)){
+                perror("unlink");
+                return -1;
+        }
+        if(out_tempname){
+                *out_tempname = strdup(tempname);
+                if(*out_tempname == NULL){
+                        perror("strdup");
+                        return -1;
+                }
+        }
+        return(fd);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/time.c b/arch/um/kernel/time.c
new file mode 100644
index 000000000000..c40c86a3f918
--- /dev/null
+++ b/arch/um/kernel/time.c
@@ -0,0 +1,167 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <errno.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "process.h"
+#include "signal_user.h"
+#include "time_user.h"
+#include "kern_constants.h"
+
+/* XXX This really needs to be declared and initialized in a kernel file since
+ * it's in <linux/time.h>
+ */
+extern struct timespec wall_to_monotonic;
+
+extern struct timeval xtime;
+
+struct timeval local_offset = { 0, 0 };
+
+void timer(void)
+{
+        gettimeofday(&xtime, NULL);
+        timeradd(&xtime, &local_offset, &xtime);
+}
+
+void set_interval(int timer_type)
+{
+        int usec = 1000000/hz();
+        struct itimerval interval = ((struct itimerval) { { 0, usec },
+                                                          { 0, usec } });
+
+        if(setitimer(timer_type, &interval, NULL) == -1)
+                panic("setitimer failed - errno = %d\n", errno);
+}
+
+void enable_timer(void)
+{
+        int usec = 1000000/hz();
+        struct itimerval enable = ((struct itimerval) { { 0, usec },
+                                                        { 0, usec }});
+        if(setitimer(ITIMER_VIRTUAL, &enable, NULL))
+                printk("enable_timer - setitimer failed, errno = %d\n",
+                       errno);
+}
+
+void disable_timer(void)
+{
+        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
+        if((setitimer(ITIMER_VIRTUAL, &disable, NULL) < 0) ||
+           (setitimer(ITIMER_REAL, &disable, NULL) < 0))
+                printk("disnable_timer - setitimer failed, errno = %d\n",
+                       errno);
+        /* If there are signals already queued, after unblocking ignore them */
+        set_handler(SIGALRM, SIG_IGN, 0, -1);
+        set_handler(SIGVTALRM, SIG_IGN, 0, -1);
+}
+
+void switch_timers(int to_real)
+{
+        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
+        struct itimerval enable = ((struct itimerval) { { 0, 1000000/hz() },
+                                                        { 0, 1000000/hz() }});
+        int old, new;
+
+        if(to_real){
+                old = ITIMER_VIRTUAL;
+                new = ITIMER_REAL;
+        }
+        else {
+                old = ITIMER_REAL;
+                new = ITIMER_VIRTUAL;
+        }
+
+        if((setitimer(old, &disable, NULL) < 0) ||
+           (setitimer(new, &enable, NULL)))
+                printk("switch_timers - setitimer failed, errno = %d\n",
+                       errno);
+}
+
+void uml_idle_timer(void)
+{
+        if(signal(SIGVTALRM, SIG_IGN) == SIG_ERR)
+                panic("Couldn't unset SIGVTALRM handler");
+        
+        set_handler(SIGALRM, (__sighandler_t) alarm_handler, 
+                    SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_interval(ITIMER_REAL);
+}
+
+extern int do_posix_clock_monotonic_gettime(struct timespec *tp);
+
+void time_init(void)
+{
+        struct timespec now;
+
+        if(signal(SIGVTALRM, boot_timer_handler) == SIG_ERR)
+                panic("Couldn't set SIGVTALRM handler");
+        set_interval(ITIMER_VIRTUAL);
+
+        do_posix_clock_monotonic_gettime(&now);
+        wall_to_monotonic.tv_sec = -now.tv_sec;
+        wall_to_monotonic.tv_nsec = -now.tv_nsec;
+}
+
+/* Declared in linux/time.h, which can't be included here */
+extern void clock_was_set(void);
+
+void do_gettimeofday(struct timeval *tv)
+{
+        unsigned long flags;
+
+        flags = time_lock();
+        gettimeofday(tv, NULL);
+        timeradd(tv, &local_offset, tv);
+        time_unlock(flags);
+        clock_was_set();
+}
+
+int do_settimeofday(struct timespec *tv)
+{
+        struct timeval now;
+        unsigned long flags;
+        struct timeval tv_in;
+
+        if ((unsigned long) tv->tv_nsec >= UM_NSEC_PER_SEC)
+                return -EINVAL;
+
+        tv_in.tv_sec = tv->tv_sec;
+        tv_in.tv_usec = tv->tv_nsec / 1000;
+
+        flags = time_lock();
+        gettimeofday(&now, NULL);
+        timersub(&tv_in, &now, &local_offset);
+        time_unlock(flags);
+
+        return(0);
+}
+
+void idle_sleep(int secs)
+{
+        struct timespec ts;
+
+        ts.tv_sec = secs;
+        ts.tv_nsec = 0;
+        nanosleep(&ts, NULL);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/time_kern.c b/arch/um/kernel/time_kern.c
new file mode 100644
index 000000000000..2461cd73ca87
--- /dev/null
+++ b/arch/um/kernel/time_kern.c
@@ -0,0 +1,203 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/module.h"
+#include "linux/unistd.h"
+#include "linux/stddef.h"
+#include "linux/spinlock.h"
+#include "linux/time.h"
+#include "linux/sched.h"
+#include "linux/interrupt.h"
+#include "linux/init.h"
+#include "linux/delay.h"
+#include "asm/irq.h"
+#include "asm/param.h"
+#include "asm/current.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "time_user.h"
+#include "mode.h"
+#include "os.h"
+
+u64 jiffies_64 = INITIAL_JIFFIES;
+
+EXPORT_SYMBOL(jiffies_64);
+
+int hz(void)
+{
+        return(HZ);
+}
+
+/*
+ * Scheduler clock - returns current time in nanosec units.
+ */
+unsigned long long sched_clock(void)
+{
+        return (unsigned long long)jiffies_64 * (1000000000 / HZ);
+}
+
+/* Changed at early boot */
+int timer_irq_inited = 0;
+
+static int first_tick;
+static unsigned long long prev_usecs;
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
+static long long delta;                 /* Deviation per interval */
+#endif
+
+#define MILLION 1000000
+
+void timer_irq(union uml_pt_regs *regs)
+{
+        unsigned long long ticks = 0;
+
+        if(!timer_irq_inited){
+                /* This is to ensure that ticks don't pile up when
+                 * the timer handler is suspended */
+                first_tick = 0;
+                return;
+        }
+
+        if(first_tick){
+#ifdef CONFIG_UML_REAL_TIME_CLOCK
+                /* We've had 1 tick */
+                unsigned long long usecs = os_usecs();
+
+                delta += usecs - prev_usecs;
+                prev_usecs = usecs;
+
+                /* Protect against the host clock being set backwards */
+                if(delta < 0)
+                        delta = 0;
+
+                ticks += (delta * HZ) / MILLION;
+                delta -= (ticks * MILLION) / HZ;
+#else
+                ticks = 1;
+#endif
+        }
+        else {
+                prev_usecs = os_usecs();
+                first_tick = 1;
+        }
+
+        while(ticks > 0){
+                do_IRQ(TIMER_IRQ, regs);
+                ticks--;
+        }
+}
+
+void boot_timer_handler(int sig)
+{
+        struct pt_regs regs;
+
+        CHOOSE_MODE((void) 
+                    (UPT_SC(&regs.regs) = (struct sigcontext *) (&sig + 1)),
+                    (void) (regs.regs.skas.is_user = 0));
+        do_timer(&regs);
+}
+
+irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
+{
+        unsigned long flags;
+
+        do_timer(regs);
+        write_seqlock_irqsave(&xtime_lock, flags);
+        timer();
+        write_sequnlock_irqrestore(&xtime_lock, flags);
+        return(IRQ_HANDLED);
+}
+
+long um_time(int __user *tloc)
+{
+        struct timeval now;
+
+        do_gettimeofday(&now);
+        if (tloc) {
+                if (put_user(now.tv_sec, tloc))
+                        now.tv_sec = -EFAULT;
+        }
+        return now.tv_sec;
+}
+
+long um_stime(int __user *tptr)
+{
+        int value;
+        struct timespec new;
+
+        if (get_user(value, tptr))
+                return -EFAULT;
+        new.tv_sec = value;
+        new.tv_nsec = 0;
+        do_settimeofday(&new);
+        return 0;
+}
+
+void __udelay(unsigned long usecs)
+{
+        int i, n;
+
+        n = (loops_per_jiffy * HZ * usecs) / MILLION;
+        for(i=0;i<n;i++) ;
+}
+
+void __const_udelay(unsigned long usecs)
+{
+        int i, n;
+
+        n = (loops_per_jiffy * HZ * usecs) / MILLION;
+        for(i=0;i<n;i++) ;
+}
+
+void timer_handler(int sig, union uml_pt_regs *regs)
+{
+        local_irq_disable();
+        update_process_times(CHOOSE_MODE(user_context(UPT_SP(regs)), (regs)->skas.is_user));
+        local_irq_enable();
+        if(current_thread->cpu == 0)
+                timer_irq(regs);
+}
+
+static DEFINE_SPINLOCK(timer_spinlock);
+
+unsigned long time_lock(void)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&timer_spinlock, flags);
+        return(flags);
+}
+
+void time_unlock(unsigned long flags)
+{
+        spin_unlock_irqrestore(&timer_spinlock, flags);
+}
+
+int __init timer_init(void)
+{
+        int err;
+
+        CHOOSE_MODE(user_time_init_tt(), user_time_init_skas());
+        err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
+        if(err != 0)
+                printk(KERN_ERR "timer_init : request_irq failed - "
+                       "errno = %d\n", -err);
+        timer_irq_inited = 1;
+        return(0);
+}
+
+__initcall(timer_init);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tlb.c b/arch/um/kernel/tlb.c
new file mode 100644
index 000000000000..eda477edfdf5
--- /dev/null
+++ b/arch/um/kernel/tlb.c
@@ -0,0 +1,369 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/mm.h"
+#include "asm/page.h"
+#include "asm/pgalloc.h"
+#include "asm/tlbflush.h"
+#include "choose-mode.h"
+#include "mode_kern.h"
+#include "user_util.h"
+#include "tlb.h"
+#include "mem.h"
+#include "mem_user.h"
+#include "os.h"
+
+#define ADD_ROUND(n, inc) (((n) + (inc)) & ~((inc) - 1))
+
+void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
+                      unsigned long end_addr, int force, int data,
+                      void (*do_ops)(int, struct host_vm_op *, int))
+{
+        pgd_t *npgd;
+        pud_t *npud;
+        pmd_t *npmd;
+        pte_t *npte;
+        unsigned long addr, end;
+        int r, w, x;
+        struct host_vm_op ops[16];
+        int op_index = -1, last_op = sizeof(ops) / sizeof(ops[0]) - 1;
+
+        if(mm == NULL) return;
+
+        for(addr = start_addr; addr < end_addr;){
+                npgd = pgd_offset(mm, addr);
+                if(!pgd_present(*npgd)){
+                        end = ADD_ROUND(addr, PGDIR_SIZE);
+                        if(end > end_addr)
+                                end = end_addr;
+                        if(force || pgd_newpage(*npgd)){
+                                op_index = add_munmap(addr, end - addr, ops,
+                                                      op_index, last_op, data,
+                                                      do_ops);
+                                pgd_mkuptodate(*npgd);
+                        }
+                        addr = end;
+                        continue;
+                }
+
+                npud = pud_offset(npgd, addr);
+                if(!pud_present(*npud)){
+                        end = ADD_ROUND(addr, PUD_SIZE);
+                        if(end > end_addr)
+                                end = end_addr;
+                        if(force || pud_newpage(*npud)){
+                                op_index = add_munmap(addr, end - addr, ops,
+                                                      op_index, last_op, data,
+                                                      do_ops);
+                                pud_mkuptodate(*npud);
+                        }
+                        addr = end;
+                        continue;
+                }
+
+                npmd = pmd_offset(npud, addr);
+                if(!pmd_present(*npmd)){
+                        end = ADD_ROUND(addr, PMD_SIZE);
+                        if(end > end_addr)
+                                end = end_addr;
+                        if(force || pmd_newpage(*npmd)){
+                                op_index = add_munmap(addr, end - addr, ops,
+                                                      op_index, last_op, data,
+                                                      do_ops);
+                                pmd_mkuptodate(*npmd);
+                        }
+                        addr = end;
+                        continue;
+                }
+
+                npte = pte_offset_kernel(npmd, addr);
+                r = pte_read(*npte);
+                w = pte_write(*npte);
+                x = pte_exec(*npte);
+                if(!pte_dirty(*npte))
+                        w = 0;
+                if(!pte_young(*npte)){
+                        r = 0;
+                        w = 0;
+                }
+                if(force || pte_newpage(*npte)){
+                        if(pte_present(*npte))
+                                op_index = add_mmap(addr,
+                                                    pte_val(*npte) & PAGE_MASK,
+                                                    PAGE_SIZE, r, w, x, ops,
+                                                    op_index, last_op, data,
+                                                    do_ops);
+                        else op_index = add_munmap(addr, PAGE_SIZE, ops,
+                                                   op_index, last_op, data,
+                                                   do_ops);
+                }
+                else if(pte_newprot(*npte))
+                        op_index = add_mprotect(addr, PAGE_SIZE, r, w, x, ops,
+                                                op_index, last_op, data,
+                                                do_ops);
+
+                *npte = pte_mkuptodate(*npte);
+                addr += PAGE_SIZE;
+        }
+        (*do_ops)(data, ops, op_index);
+}
+
+int flush_tlb_kernel_range_common(unsigned long start, unsigned long end)
+{
+        struct mm_struct *mm;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long addr, last;
+        int updated = 0, err;
+
+        mm = &init_mm;
+        for(addr = start; addr < end;){
+                pgd = pgd_offset(mm, addr);
+                if(!pgd_present(*pgd)){
+                        last = ADD_ROUND(addr, PGDIR_SIZE);
+                        if(last > end)
+                                last = end;
+                        if(pgd_newpage(*pgd)){
+                                updated = 1;
+                                err = os_unmap_memory((void *) addr,
+                                                      last - addr);
+                                if(err < 0)
+                                        panic("munmap failed, errno = %d\n",
+                                              -err);
+                        }
+                        addr = last;
+                        continue;
+                }
+
+                pud = pud_offset(pgd, addr);
+                if(!pud_present(*pud)){
+                        last = ADD_ROUND(addr, PUD_SIZE);
+                        if(last > end)
+                                last = end;
+                        if(pud_newpage(*pud)){
+                                updated = 1;
+                                err = os_unmap_memory((void *) addr,
+                                                      last - addr);
+                                if(err < 0)
+                                        panic("munmap failed, errno = %d\n",
+                                              -err);
+                        }
+                        addr = last;
+                        continue;
+                }
+
+                pmd = pmd_offset(pud, addr);
+                if(!pmd_present(*pmd)){
+                        last = ADD_ROUND(addr, PMD_SIZE);
+                        if(last > end)
+                                last = end;
+                        if(pmd_newpage(*pmd)){
+                                updated = 1;
+                                err = os_unmap_memory((void *) addr,
+                                                      last - addr);
+                                if(err < 0)
+                                        panic("munmap failed, errno = %d\n",
+                                              -err);
+                        }
+                        addr = last;
+                        continue;
+                }
+
+                pte = pte_offset_kernel(pmd, addr);
+                if(!pte_present(*pte) || pte_newpage(*pte)){
+                        updated = 1;
+                        err = os_unmap_memory((void *) addr,
+                                              PAGE_SIZE);
+                        if(err < 0)
+                                panic("munmap failed, errno = %d\n",
+                                      -err);
+                        if(pte_present(*pte))
+                                map_memory(addr,
+                                           pte_val(*pte) & PAGE_MASK,
+                                           PAGE_SIZE, 1, 1, 1);
+                }
+                else if(pte_newprot(*pte)){
+                        updated = 1;
+                        protect_memory(addr, PAGE_SIZE, 1, 1, 1, 1);
+                }
+                addr += PAGE_SIZE;
+        }
+        return(updated);
+}
+
+void flush_tlb_page(struct vm_area_struct *vma, unsigned long address)
+{
+        address &= PAGE_MASK;
+        flush_tlb_range(vma, address, address + PAGE_SIZE);
+}
+
+void flush_tlb_all(void)
+{
+        flush_tlb_mm(current->mm);
+}
+  
+void flush_tlb_kernel_range(unsigned long start, unsigned long end)
+{
+        CHOOSE_MODE_PROC(flush_tlb_kernel_range_tt,
+                         flush_tlb_kernel_range_common, start, end);
+}
+
+void flush_tlb_kernel_vm(void)
+{
+        CHOOSE_MODE(flush_tlb_kernel_vm_tt(),
+                    flush_tlb_kernel_range_common(start_vm, end_vm));
+}
+
+void __flush_tlb_one(unsigned long addr)
+{
+        CHOOSE_MODE_PROC(__flush_tlb_one_tt, __flush_tlb_one_skas, addr);
+}
+
+void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, 
+     unsigned long end)
+{
+        CHOOSE_MODE_PROC(flush_tlb_range_tt, flush_tlb_range_skas, vma, start,
+                         end);
+}
+
+void flush_tlb_mm(struct mm_struct *mm)
+{
+        CHOOSE_MODE_PROC(flush_tlb_mm_tt, flush_tlb_mm_skas, mm);
+}
+
+void force_flush_all(void)
+{
+        CHOOSE_MODE(force_flush_all_tt(), force_flush_all_skas());
+}
+
+pgd_t *pgd_offset_proc(struct mm_struct *mm, unsigned long address)
+{
+        return(pgd_offset(mm, address));
+}
+
+pud_t *pud_offset_proc(pgd_t *pgd, unsigned long address)
+{
+        return(pud_offset(pgd, address));
+}
+
+pmd_t *pmd_offset_proc(pud_t *pud, unsigned long address)
+{
+        return(pmd_offset(pud, address));
+}
+
+pte_t *pte_offset_proc(pmd_t *pmd, unsigned long address)
+{
+        return(pte_offset_kernel(pmd, address));
+}
+
+pte_t *addr_pte(struct task_struct *task, unsigned long addr)
+{
+        pgd_t *pgd = pgd_offset(task->mm, addr);
+        pud_t *pud = pud_offset(pgd, addr);
+        pmd_t *pmd = pmd_offset(pud, addr);
+
+        return(pte_offset_map(pmd, addr));
+}
+
+int add_mmap(unsigned long virt, unsigned long phys, unsigned long len,
+     int r, int w, int x, struct host_vm_op *ops, int index,
+     int last_filled, int data,
+     void (*do_ops)(int, struct host_vm_op *, int))
+{
+        __u64 offset;
+        struct host_vm_op *last;
+        int fd;
+
+        fd = phys_mapping(phys, &offset);
+        if(index != -1){
+                last = &ops[index];
+                if((last->type == MMAP) &&
+                   (last->u.mmap.addr + last->u.mmap.len == virt) &&
+                   (last->u.mmap.r == r) && (last->u.mmap.w == w) &&
+                   (last->u.mmap.x == x) && (last->u.mmap.fd == fd) &&
+                   (last->u.mmap.offset + last->u.mmap.len == offset)){
+                        last->u.mmap.len += len;
+                        return(index);
+                }
+        }
+
+        if(index == last_filled){
+                (*do_ops)(data, ops, last_filled);
+                index = -1;
+        }
+
+        ops[++index] = ((struct host_vm_op) { .type     = MMAP,
+                                              .u = { .mmap = {
+                                                      .addr     = virt,
+                                                      .len      = len,
+                                                      .r        = r,
+                                                      .w        = w,
+                                                      .x        = x,
+                                                      .fd       = fd,
+                                                      .offset   = offset }
+                                              } });
+        return(index);
+}
+
+int add_munmap(unsigned long addr, unsigned long len, struct host_vm_op *ops,
+               int index, int last_filled, int data,
+               void (*do_ops)(int, struct host_vm_op *, int))
+{
+        struct host_vm_op *last;
+
+        if(index != -1){
+                last = &ops[index];
+                if((last->type == MUNMAP) &&
+                   (last->u.munmap.addr + last->u.mmap.len == addr)){
+                        last->u.munmap.len += len;
+                        return(index);
+                }
+        }
+
+        if(index == last_filled){
+                (*do_ops)(data, ops, last_filled);
+                index = -1;
+        }
+
+        ops[++index] = ((struct host_vm_op) { .type     = MUNMAP,
+                                              .u = { .munmap = {
+                                                      .addr     = addr,
+                                                      .len      = len } } });
+        return(index);
+}
+
+int add_mprotect(unsigned long addr, unsigned long len, int r, int w, int x,
+                 struct host_vm_op *ops, int index, int last_filled, int data,
+                 void (*do_ops)(int, struct host_vm_op *, int))
+{
+        struct host_vm_op *last;
+
+        if(index != -1){
+                last = &ops[index];
+                if((last->type == MPROTECT) &&
+                   (last->u.mprotect.addr + last->u.mprotect.len == addr) &&
+                   (last->u.mprotect.r == r) && (last->u.mprotect.w == w) &&
+                   (last->u.mprotect.x == x)){
+                        last->u.mprotect.len += len;
+                        return(index);
+                }
+        }
+
+        if(index == last_filled){
+                (*do_ops)(data, ops, last_filled);
+                index = -1;
+        }
+
+        ops[++index] = ((struct host_vm_op) { .type     = MPROTECT,
+                                              .u = { .mprotect = {
+                                                      .addr     = addr,
+                                                      .len      = len,
+                                                      .r        = r,
+                                                      .w        = w,
+                                                      .x        = x } } });
+        return(index);
+}
diff --git a/arch/um/kernel/trap_kern.c b/arch/um/kernel/trap_kern.c
new file mode 100644
index 000000000000..47e766e6ba10
--- /dev/null
+++ b/arch/um/kernel/trap_kern.c
@@ -0,0 +1,251 @@
+/* 
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "asm/errno.h"
+#include "linux/sched.h"
+#include "linux/mm.h"
+#include "linux/spinlock.h"
+#include "linux/config.h"
+#include "linux/init.h"
+#include "linux/ptrace.h"
+#include "asm/semaphore.h"
+#include "asm/pgtable.h"
+#include "asm/pgalloc.h"
+#include "asm/tlbflush.h"
+#include "asm/a.out.h"
+#include "asm/current.h"
+#include "asm/irq.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "chan_kern.h"
+#include "mconsole_kern.h"
+#include "2_5compat.h"
+#include "mem.h"
+#include "mem_kern.h"
+
+int handle_page_fault(unsigned long address, unsigned long ip, 
+                      int is_write, int is_user, int *code_out)
+{
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long page;
+        int err = -EFAULT;
+
+        *code_out = SEGV_MAPERR;
+        down_read(&mm->mmap_sem);
+        vma = find_vma(mm, address);
+        if(!vma) 
+                goto out;
+        else if(vma->vm_start <= address) 
+                goto good_area;
+        else if(!(vma->vm_flags & VM_GROWSDOWN)) 
+                goto out;
+        else if(!ARCH_IS_STACKGROW(address))
+                goto out;
+        else if(expand_stack(vma, address)) 
+                goto out;
+
+ good_area:
+        *code_out = SEGV_ACCERR;
+        if(is_write && !(vma->vm_flags & VM_WRITE)) 
+                goto out;
+        page = address & PAGE_MASK;
+        pgd = pgd_offset(mm, page);
+        pud = pud_offset(pgd, page);
+        pmd = pmd_offset(pud, page);
+        do {
+ survive:
+                switch (handle_mm_fault(mm, vma, address, is_write)){
+                case VM_FAULT_MINOR:
+                        current->min_flt++;
+                        break;
+                case VM_FAULT_MAJOR:
+                        current->maj_flt++;
+                        break;
+                case VM_FAULT_SIGBUS:
+                        err = -EACCES;
+                        goto out;
+                case VM_FAULT_OOM:
+                        err = -ENOMEM;
+                        goto out_of_memory;
+                default:
+                        BUG();
+                }
+                pgd = pgd_offset(mm, page);
+                pud = pud_offset(pgd, page);
+                pmd = pmd_offset(pud, page);
+                pte = pte_offset_kernel(pmd, page);
+        } while(!pte_present(*pte));
+        err = 0;
+        *pte = pte_mkyoung(*pte);
+        if(pte_write(*pte)) *pte = pte_mkdirty(*pte);
+        flush_tlb_page(vma, page);
+ out:
+        up_read(&mm->mmap_sem);
+        return(err);
+
+/*
+ * We ran out of memory, or some other thing happened to us that made
+ * us unable to handle the page fault gracefully.
+ */
+out_of_memory:
+        if (current->pid == 1) {
+                up_read(&mm->mmap_sem);
+                yield();
+                down_read(&mm->mmap_sem);
+                goto survive;
+        }
+        goto out;
+}
+
+LIST_HEAD(physmem_remappers);
+
+void register_remapper(struct remapper *info)
+{
+        list_add(&info->list, &physmem_remappers);
+}
+
+static int check_remapped_addr(unsigned long address, int is_write)
+{
+        struct remapper *remapper;
+        struct list_head *ele;
+        __u64 offset;
+        int fd;
+
+        fd = phys_mapping(__pa(address), &offset);
+        if(fd == -1)
+                return(0);
+
+        list_for_each(ele, &physmem_remappers){
+                remapper = list_entry(ele, struct remapper, list);
+                if((*remapper->proc)(fd, address, is_write, offset))
+                        return(1);
+        }
+
+        return(0);
+}
+
+unsigned long segv(unsigned long address, unsigned long ip, int is_write, 
+                   int is_user, void *sc)
+{
+        struct siginfo si;
+        void *catcher;
+        int err;
+
+        if(!is_user && (address >= start_vm) && (address < end_vm)){
+                flush_tlb_kernel_vm();
+                return(0);
+        }
+        else if(check_remapped_addr(address & PAGE_MASK, is_write))
+                return(0);
+        else if(current->mm == NULL)
+                panic("Segfault with no mm");
+        err = handle_page_fault(address, ip, is_write, is_user, &si.si_code);
+
+        catcher = current->thread.fault_catcher;
+        if(!err)
+                return(0);
+        else if(catcher != NULL){
+                current->thread.fault_addr = (void *) address;
+                do_longjmp(catcher, 1);
+        } 
+        else if(current->thread.fault_addr != NULL)
+                panic("fault_addr set but no fault catcher");
+        else if(arch_fixup(ip, sc))
+                return(0);
+
+        if(!is_user) 
+                panic("Kernel mode fault at addr 0x%lx, ip 0x%lx", 
+                      address, ip);
+
+        if(err == -EACCES){
+                si.si_signo = SIGBUS;
+                si.si_errno = 0;
+                si.si_code = BUS_ADRERR;
+                si.si_addr = (void *)address;
+                force_sig_info(SIGBUS, &si, current);
+        }
+        else if(err == -ENOMEM){
+                printk("VM: killing process %s\n", current->comm);
+                do_exit(SIGKILL);
+        }
+        else {
+                si.si_signo = SIGSEGV;
+                si.si_addr = (void *) address;
+                current->thread.cr2 = address;
+                current->thread.err = is_write;
+                force_sig_info(SIGSEGV, &si, current);
+        }
+        return(0);
+}
+
+void bad_segv(unsigned long address, unsigned long ip, int is_write)
+{
+        struct siginfo si;
+
+        si.si_signo = SIGSEGV;
+        si.si_code = SEGV_ACCERR;
+        si.si_addr = (void *) address;
+        current->thread.cr2 = address;
+        current->thread.err = is_write;
+        force_sig_info(SIGSEGV, &si, current);
+}
+
+void relay_signal(int sig, union uml_pt_regs *regs)
+{
+        if(arch_handle_signal(sig, regs)) return;
+        if(!UPT_IS_USER(regs))
+                panic("Kernel mode signal %d", sig);
+        force_sig(sig, current);
+}
+
+void bus_handler(int sig, union uml_pt_regs *regs)
+{
+        if(current->thread.fault_catcher != NULL)
+                do_longjmp(current->thread.fault_catcher, 1);
+        else relay_signal(sig, regs);
+}
+
+void winch(int sig, union uml_pt_regs *regs)
+{
+        do_IRQ(WINCH_IRQ, regs);
+}
+
+void trap_init(void)
+{
+}
+
+DEFINE_SPINLOCK(trap_lock);
+
+static int trap_index = 0;
+
+int next_trap_index(int limit)
+{
+        int ret;
+
+        spin_lock(&trap_lock);
+        ret = trap_index;
+        if(++trap_index == limit)
+                trap_index = 0;
+        spin_unlock(&trap_lock);
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/trap_user.c b/arch/um/kernel/trap_user.c
new file mode 100644
index 000000000000..50a4042a509f
--- /dev/null
+++ b/arch/um/kernel/trap_user.c
@@ -0,0 +1,120 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <asm/page.h>
+#include <asm/unistd.h>
+#include <asm/ptrace.h>
+#include "init.h"
+#include "sysdep/ptrace.h"
+#include "sigcontext.h"
+#include "sysdep/sigcontext.h"
+#include "irq_user.h"
+#include "signal_user.h"
+#include "time_user.h"
+#include "task.h"
+#include "mode.h"
+#include "choose-mode.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+
+void kill_child_dead(int pid)
+{
+        kill(pid, SIGKILL);
+        kill(pid, SIGCONT);
+        do {
+                int n;
+                CATCH_EINTR(n = waitpid(pid, NULL, 0));
+                if (n > 0)
+                        kill(pid, SIGCONT);
+                else
+                        break;
+        } while(1);
+}
+
+/* Unlocked - don't care if this is a bit off */
+int nsegfaults = 0;
+
+struct {
+        unsigned long address;
+        int is_write;
+        int pid;
+        unsigned long sp;
+        int is_user;
+} segfault_record[1024];
+
+void segv_handler(int sig, union uml_pt_regs *regs)
+{
+        int index, max;
+
+        if(UPT_IS_USER(regs) && !UPT_SEGV_IS_FIXABLE(regs)){
+                bad_segv(UPT_FAULT_ADDR(regs), UPT_IP(regs), 
+                         UPT_FAULT_WRITE(regs));
+                return;
+        }
+        max = sizeof(segfault_record)/sizeof(segfault_record[0]);
+        index = next_trap_index(max);
+
+        nsegfaults++;
+        segfault_record[index].address = UPT_FAULT_ADDR(regs);
+        segfault_record[index].pid = os_getpid();
+        segfault_record[index].is_write = UPT_FAULT_WRITE(regs);
+        segfault_record[index].sp = UPT_SP(regs);
+        segfault_record[index].is_user = UPT_IS_USER(regs);
+        segv(UPT_FAULT_ADDR(regs), UPT_IP(regs), UPT_FAULT_WRITE(regs),
+             UPT_IS_USER(regs), regs);
+}
+
+void usr2_handler(int sig, union uml_pt_regs *regs)
+{
+        CHOOSE_MODE(syscall_handler_tt(sig, regs), (void) 0);
+}
+
+struct signal_info sig_info[] = {
+        [ SIGTRAP ] { .handler          = relay_signal,
+                      .is_irq           = 0 },
+        [ SIGFPE ] { .handler           = relay_signal,
+                     .is_irq            = 0 },
+        [ SIGILL ] { .handler           = relay_signal,
+                     .is_irq            = 0 },
+        [ SIGWINCH ] { .handler         = winch,
+                       .is_irq          = 1 },
+        [ SIGBUS ] { .handler           = bus_handler,
+                     .is_irq            = 0 },
+        [ SIGSEGV] { .handler           = segv_handler,
+                     .is_irq            = 0 },
+        [ SIGIO ] { .handler            = sigio_handler,
+                    .is_irq             = 1 },
+        [ SIGVTALRM ] { .handler        = timer_handler,
+                        .is_irq         = 1 },
+        [ SIGALRM ] { .handler          = timer_handler,
+                      .is_irq           = 1 },
+        [ SIGUSR2 ] { .handler          = usr2_handler,
+                      .is_irq           = 0 },
+};
+
+void do_longjmp(void *b, int val)
+{
+        sigjmp_buf *buf = b;
+
+        siglongjmp(*buf, val);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/Makefile b/arch/um/kernel/tt/Makefile
new file mode 100644
index 000000000000..3d5177df3504
--- /dev/null
+++ b/arch/um/kernel/tt/Makefile
@@ -0,0 +1,28 @@
+# 
+# Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+# Licensed under the GPL
+#
+
+extra-y := unmap_fin.o
+clean-files := unmap_tmp.o
+
+obj-y = exec_kern.o exec_user.o gdb.o ksyms.o mem.o mem_user.o process_kern.o \
+        syscall_kern.o syscall_user.o time.o tlb.o tracer.o trap_user.o \
+        uaccess.o uaccess_user.o
+
+obj-$(CONFIG_PT_PROXY) += gdb_kern.o ptproxy/
+
+USER_OBJS := gdb.o time.o tracer.o
+
+include arch/um/scripts/Makefile.rules
+
+UNMAP_CFLAGS := $(patsubst -pg -DPROFILING,,$(USER_CFLAGS))
+UNMAP_CFLAGS := $(patsubst -fprofile-arcs -ftest-coverage,,$(UNMAP_CFLAGS))
+
+#XXX: partially copied from arch/um/scripts/Makefile.rules
+$(obj)/unmap.o: c_flags = -Wp,-MD,$(depfile) $(UNMAP_CFLAGS)
+
+$(obj)/unmap_fin.o : $(obj)/unmap.o
+        $(LD) -r -o $(obj)/unmap_tmp.o $< $(shell $(CC) -print-file-name=libc.a)
+        $(OBJCOPY) $(obj)/unmap_tmp.o $@ -G switcheroo
+
diff --git a/arch/um/kernel/tt/exec_kern.c b/arch/um/kernel/tt/exec_kern.c
new file mode 100644
index 000000000000..065b504a653b
--- /dev/null
+++ b/arch/um/kernel/tt/exec_kern.c
@@ -0,0 +1,87 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/mm.h"
+#include "asm/signal.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+#include "asm/pgalloc.h"
+#include "asm/tlbflush.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "irq_user.h"
+#include "time_user.h"
+#include "signal_user.h"
+#include "mem_user.h"
+#include "os.h"
+#include "tlb.h"
+#include "mode.h"
+
+static int exec_tramp(void *sig_stack)
+{
+        init_new_thread_stack(sig_stack, NULL);
+        init_new_thread_signals(1);
+        os_stop_process(os_getpid());
+        return(0);
+}
+
+void flush_thread_tt(void)
+{
+        unsigned long stack;
+        int new_pid;
+
+        stack = alloc_stack(0, 0);
+        if(stack == 0){
+                printk(KERN_ERR 
+                       "flush_thread : failed to allocate temporary stack\n");
+                do_exit(SIGKILL);
+        }
+                
+        new_pid = start_fork_tramp(current->thread_info, stack, 0, exec_tramp);
+        if(new_pid < 0){
+                printk(KERN_ERR 
+                       "flush_thread : new thread failed, errno = %d\n",
+                       -new_pid);
+                do_exit(SIGKILL);
+        }
+
+        if(current_thread->cpu == 0)
+                forward_interrupts(new_pid);
+        current->thread.request.op = OP_EXEC;
+        current->thread.request.u.exec.pid = new_pid;
+        unprotect_stack((unsigned long) current_thread);
+        os_usr1_process(os_getpid());
+        change_sig(SIGUSR1, 1);
+
+        change_sig(SIGUSR1, 0);
+        enable_timer();
+        free_page(stack);
+        protect_memory(uml_reserved, high_physmem - uml_reserved, 1, 1, 0, 1);
+        task_protections((unsigned long) current_thread);
+        force_flush_all();
+        unblock_signals();
+}
+
+void start_thread_tt(struct pt_regs *regs, unsigned long eip, 
+                     unsigned long esp)
+{
+        set_fs(USER_DS);
+        flush_tlb_mm(current->mm);
+        PT_REGS_IP(regs) = eip;
+        PT_REGS_SP(regs) = esp;
+        PT_FIX_EXEC_STACK(esp);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/exec_user.c b/arch/um/kernel/tt/exec_user.c
new file mode 100644
index 000000000000..a92c02ff2ce3
--- /dev/null
+++ b/arch/um/kernel/tt/exec_user.c
@@ -0,0 +1,57 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "ptrace_user.h"
+#include "os.h"
+
+void do_exec(int old_pid, int new_pid)
+{
+        unsigned long regs[FRAME_SIZE];
+        int err;
+
+        if((ptrace(PTRACE_ATTACH, new_pid, 0, 0) < 0) ||
+           (ptrace(PTRACE_CONT, new_pid, 0, 0) < 0))
+                tracer_panic("do_exec failed to attach proc - errno = %d",
+                             errno);
+
+        CATCH_EINTR(err = waitpid(new_pid, 0, WUNTRACED));
+        if (err < 0)
+                tracer_panic("do_exec failed to attach proc in waitpid - errno = %d",
+                             errno);
+
+        if(ptrace_getregs(old_pid, regs) < 0)
+                tracer_panic("do_exec failed to get registers - errno = %d",
+                             errno);
+
+        os_kill_ptraced_process(old_pid, 0);
+
+        if (ptrace(PTRACE_OLDSETOPTIONS, new_pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0)
+                tracer_panic("do_exec: PTRACE_SETOPTIONS failed, errno = %d", errno);
+
+        if(ptrace_setregs(new_pid, regs) < 0)
+                tracer_panic("do_exec failed to start new proc - errno = %d",
+                             errno);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/gdb.c b/arch/um/kernel/tt/gdb.c
new file mode 100644
index 000000000000..19a0ad7b35b3
--- /dev/null
+++ b/arch/um/kernel/tt/gdb.c
@@ -0,0 +1,278 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include "ptrace_user.h"
+#include "uml-config.h"
+#include "kern_constants.h"
+#include "chan_user.h"
+#include "init.h"
+#include "user.h"
+#include "debug.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "tt.h"
+#include "sysdep/thread.h"
+
+extern int debugger_pid;
+extern int debugger_fd;
+extern int debugger_parent;
+
+int detach(int pid, int sig)
+{
+        return(ptrace(PTRACE_DETACH, pid, 0, sig));
+}
+
+int attach(int pid)
+{
+        int err;
+
+        err = ptrace(PTRACE_ATTACH, pid, 0, 0);
+        if(err < 0) return(-errno);
+        else return(err);
+}
+
+int cont(int pid)
+{
+        return(ptrace(PTRACE_CONT, pid, 0, 0));
+}
+
+#ifdef UML_CONFIG_PT_PROXY
+
+int debugger_signal(int status, pid_t pid)
+{
+        return(debugger_proxy(status, pid));
+}
+
+void child_signal(pid_t pid, int status)
+{
+        child_proxy(pid, status);
+}
+
+static void gdb_announce(char *dev_name, int dev)
+{
+        printf("gdb assigned device '%s'\n", dev_name);
+}
+
+static struct chan_opts opts = {
+        .announce       = gdb_announce,
+        .xterm_title    = "UML kernel debugger",
+        .raw            = 0,
+        .tramp_stack    = 0,
+        .in_kernel      = 0,
+};
+
+/* Accessed by the tracing thread, which automatically serializes access */
+static void *xterm_data;
+static int xterm_fd;
+
+extern void *xterm_init(char *, int, struct chan_opts *);
+extern int xterm_open(int, int, int, void *, char **);
+extern void xterm_close(int, void *);
+
+int open_gdb_chan(void)
+{
+        char stack[UM_KERN_PAGE_SIZE], *dummy;
+
+        opts.tramp_stack = (unsigned long) stack;
+        xterm_data = xterm_init("", 0, &opts);
+        xterm_fd = xterm_open(1, 1, 1, xterm_data, &dummy);
+        return(xterm_fd);
+}
+
+static void exit_debugger_cb(void *unused)
+{
+        if(debugger_pid != -1){
+                if(gdb_pid != -1){
+                        fake_child_exit();
+                        gdb_pid = -1;
+                }
+                else kill_child_dead(debugger_pid);
+                debugger_pid = -1;
+                if(debugger_parent != -1)
+                        detach(debugger_parent, SIGINT);
+        }
+        if(xterm_data != NULL) xterm_close(xterm_fd, xterm_data);
+}
+
+static void exit_debugger(void)
+{
+        initial_thread_cb(exit_debugger_cb, NULL);
+}
+
+__uml_exitcall(exit_debugger);
+
+struct gdb_data {
+        char *str;
+        int err;
+};
+
+static void config_gdb_cb(void *arg)
+{
+        struct gdb_data *data = arg;
+        void *task;
+        int pid;
+
+        data->err = -1;
+        if(debugger_pid != -1) exit_debugger_cb(NULL);
+        if(!strncmp(data->str, "pid,", strlen("pid,"))){
+                data->str += strlen("pid,");
+                pid = strtoul(data->str, NULL, 0);
+                task = cpu_tasks[0].task;
+                debugger_pid = attach_debugger(TASK_EXTERN_PID(task), pid, 0);
+                if(debugger_pid != -1){
+                        data->err = 0;
+                        gdb_pid = pid;
+                }
+                return;
+        }
+        data->err = 0;
+        debugger_pid = start_debugger(linux_prog, 0, 0, &debugger_fd);
+        init_proxy(debugger_pid, 0, 0);
+}
+
+int gdb_config(char *str)
+{
+        struct gdb_data data;
+
+        if(*str++ != '=') return(-1);
+        data.str = str;
+        initial_thread_cb(config_gdb_cb, &data);
+        return(data.err);
+}
+
+void remove_gdb_cb(void *unused)
+{
+        exit_debugger_cb(NULL);
+}
+
+int gdb_remove(char *unused)
+{
+        initial_thread_cb(remove_gdb_cb, NULL);
+        return(0);
+}
+
+void signal_usr1(int sig)
+{
+        if(debugger_pid != -1){
+                printf("The debugger is already running\n");
+                return;
+        }
+        debugger_pid = start_debugger(linux_prog, 0, 0, &debugger_fd);
+        init_proxy(debugger_pid, 0, 0);
+}
+
+int init_ptrace_proxy(int idle_pid, int startup, int stop)
+{
+        int pid, status;
+
+        pid = start_debugger(linux_prog, startup, stop, &debugger_fd);
+        status = wait_for_stop(idle_pid, SIGSTOP, PTRACE_CONT, NULL);
+        if(pid < 0){
+                cont(idle_pid);
+                return(-1);
+        }
+        init_proxy(pid, 1, status);
+        return(pid);
+}
+
+int attach_debugger(int idle_pid, int pid, int stop)
+{
+        int status = 0, err;
+
+        err = attach(pid);
+        if(err < 0){
+                printf("Failed to attach pid %d, errno = %d\n", pid, -err);
+                return(-1);
+        }
+        if(stop) status = wait_for_stop(idle_pid, SIGSTOP, PTRACE_CONT, NULL);
+        init_proxy(pid, 1, status);
+        return(pid);
+}
+
+#ifdef notdef /* Put this back in when it does something useful */
+static int __init uml_gdb_init_setup(char *line, int *add)
+{
+        gdb_init = uml_strdup(line);
+        return 0;
+}
+
+__uml_setup("gdb=", uml_gdb_init_setup, 
+"gdb=<channel description>\n\n"
+);
+#endif
+
+static int __init uml_gdb_pid_setup(char *line, int *add)
+{
+        gdb_pid = strtoul(line, NULL, 0);
+        *add = 0;
+        return 0;
+}
+
+__uml_setup("gdb-pid=", uml_gdb_pid_setup, 
+"gdb-pid=<pid>\n"
+"    gdb-pid is used to attach an external debugger to UML.  This may be\n"
+"    an already-running gdb or a debugger-like process like strace.\n\n"
+);
+
+#else
+
+int debugger_signal(int status, pid_t pid){ return(0); }
+void child_signal(pid_t pid, int status){ }
+int init_ptrace_proxy(int idle_pid, int startup, int stop)
+{
+        printf("debug requested when CONFIG_PT_PROXY is off\n");
+        kill_child_dead(idle_pid);
+        exit(1);
+}
+
+void signal_usr1(int sig)
+{
+        printf("debug requested when CONFIG_PT_PROXY is off\n");
+}
+
+int attach_debugger(int idle_pid, int pid, int stop)
+{
+        printf("attach_debugger called when CONFIG_PT_PROXY "
+               "is off\n");
+        return(-1);
+}
+
+int config_gdb(char *str)
+{
+        return(-1);
+}
+
+int remove_gdb(void)
+{
+        return(-1);
+}
+
+int init_parent_proxy(int pid)
+{
+        return(-1);
+}
+
+void debugger_parent_signal(int status, int pid)
+{
+}
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/gdb_kern.c b/arch/um/kernel/tt/gdb_kern.c
new file mode 100644
index 000000000000..93fb121f86af
--- /dev/null
+++ b/arch/um/kernel/tt/gdb_kern.c
@@ -0,0 +1,40 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/init.h"
+#include "linux/config.h"
+#include "mconsole_kern.h"
+
+#ifdef CONFIG_MCONSOLE
+
+extern int gdb_config(char *str);
+extern int gdb_remove(char *unused);
+
+static struct mc_device gdb_mc = {
+        .name           = "gdb",
+        .config         = gdb_config,
+        .remove         = gdb_remove,
+};
+
+int gdb_mc_init(void)
+{
+        mconsole_register_dev(&gdb_mc);
+        return(0);
+}
+
+__initcall(gdb_mc_init);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/debug.h b/arch/um/kernel/tt/include/debug.h
new file mode 100644
index 000000000000..8eff674107ca
--- /dev/null
+++ b/arch/um/kernel/tt/include/debug.h
@@ -0,0 +1,29 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002  Jeff Dike (jdike@karaya.com) and
+ * Lars Brinkhoff.
+ * Licensed under the GPL
+ */
+
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+extern int debugger_proxy(int status, pid_t pid);
+extern void child_proxy(pid_t pid, int status);
+extern void init_proxy (pid_t pid, int waiting, int status);
+extern int start_debugger(char *prog, int startup, int stop, int *debugger_fd);
+extern void fake_child_exit(void);
+extern int gdb_config(char *str);
+extern int gdb_remove(char *unused);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/mmu-tt.h b/arch/um/kernel/tt/include/mmu-tt.h
new file mode 100644
index 000000000000..0440510ab3fe
--- /dev/null
+++ b/arch/um/kernel/tt/include/mmu-tt.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_MMU_H
+#define __TT_MMU_H
+
+struct mmu_context_tt {
+};
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/mode-tt.h b/arch/um/kernel/tt/include/mode-tt.h
new file mode 100644
index 000000000000..efe462019069
--- /dev/null
+++ b/arch/um/kernel/tt/include/mode-tt.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_TT_H__
+#define __MODE_TT_H__
+
+#include "sysdep/ptrace.h"
+
+enum { OP_NONE, OP_EXEC, OP_FORK, OP_TRACE_ON, OP_REBOOT, OP_HALT, OP_CB };
+
+extern int tracing_pid;
+
+extern int tracer(int (*init_proc)(void *), void *sp);
+extern void user_time_init_tt(void);
+extern void sig_handler_common_tt(int sig, void *sc);
+extern void syscall_handler_tt(int sig, union uml_pt_regs *regs);
+extern void reboot_tt(void);
+extern void halt_tt(void);
+extern int is_tracer_winch(int pid, int fd, void *data);
+extern void kill_off_processes_tt(void);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/mode_kern-tt.h b/arch/um/kernel/tt/include/mode_kern-tt.h
new file mode 100644
index 000000000000..28aaab3448fa
--- /dev/null
+++ b/arch/um/kernel/tt/include/mode_kern-tt.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_MODE_KERN_H__
+#define __TT_MODE_KERN_H__
+
+#include "linux/sched.h"
+#include "asm/page.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+
+extern void *switch_to_tt(void *prev, void *next);
+extern void flush_thread_tt(void);
+extern void start_thread_tt(struct pt_regs *regs, unsigned long eip,
+                           unsigned long esp);
+extern int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
+                          unsigned long stack_top, struct task_struct *p,
+                          struct pt_regs *regs);
+extern void release_thread_tt(struct task_struct *task);
+extern void exit_thread_tt(void);
+extern void initial_thread_cb_tt(void (*proc)(void *), void *arg);
+extern void init_idle_tt(void);
+extern void flush_tlb_kernel_range_tt(unsigned long start, unsigned long end);
+extern void flush_tlb_kernel_vm_tt(void);
+extern void __flush_tlb_one_tt(unsigned long addr);
+extern void flush_tlb_range_tt(struct vm_area_struct *vma,
+                               unsigned long start, unsigned long end);
+extern void flush_tlb_mm_tt(struct mm_struct *mm);
+extern void force_flush_all_tt(void);
+extern long execute_syscall_tt(void *r);
+extern void before_mem_tt(unsigned long brk_start);
+extern unsigned long set_task_sizes_tt(int arg, unsigned long *host_size_out,
+                                       unsigned long *task_size_out);
+extern int start_uml_tt(void);
+extern int external_pid_tt(struct task_struct *task);
+extern int thread_pid_tt(struct task_struct *task);
+
+#define kmem_end_tt (host_task_size - ABOVE_KMEM)
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/tt.h b/arch/um/kernel/tt/include/tt.h
new file mode 100644
index 000000000000..c667b67af405
--- /dev/null
+++ b/arch/um/kernel/tt/include/tt.h
@@ -0,0 +1,46 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_H__
+#define __TT_H__
+
+#include "sysdep/ptrace.h"
+
+extern int gdb_pid;
+extern int debug;
+extern int debug_stop;
+extern int debug_trace;
+
+extern int honeypot;
+
+extern int fork_tramp(void *sig_stack);
+extern int do_proc_op(void *t, int proc_id);
+extern int tracer(int (*init_proc)(void *), void *sp);
+extern void attach_process(int pid);
+extern void tracer_panic(char *format, ...);
+extern void set_init_pid(int pid);
+extern int set_user_mode(void *task);
+extern void set_tracing(void *t, int tracing);
+extern int is_tracing(void *task);
+extern void syscall_handler(int sig, union uml_pt_regs *regs);
+extern void exit_kernel(int pid, void *task);
+extern void do_syscall(void *task, int pid, int local_using_sysemu);
+extern void do_sigtrap(void *task);
+extern int is_valid_pid(int pid);
+extern void remap_data(void *segment_start, void *segment_end, int w);
+extern long execute_syscall_tt(void *r);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/include/uaccess-tt.h b/arch/um/kernel/tt/include/uaccess-tt.h
new file mode 100644
index 000000000000..f0bad010cebd
--- /dev/null
+++ b/arch/um/kernel/tt/include/uaccess-tt.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_UACCESS_H
+#define __TT_UACCESS_H
+
+#include "linux/string.h"
+#include "linux/sched.h"
+#include "asm/processor.h"
+#include "asm/errno.h"
+#include "asm/current.h"
+#include "asm/a.out.h"
+#include "uml_uaccess.h"
+
+#define ABOVE_KMEM (16 * 1024 * 1024)
+
+extern unsigned long end_vm;
+extern unsigned long uml_physmem;
+
+#define under_task_size(addr, size) \
+        (((unsigned long) (addr) < TASK_SIZE) && \
+         (((unsigned long) (addr) + (size)) < TASK_SIZE))
+
+#define is_stack(addr, size) \
+        (((unsigned long) (addr) < STACK_TOP) && \
+         ((unsigned long) (addr) >= STACK_TOP - ABOVE_KMEM) && \
+         (((unsigned long) (addr) + (size)) <= STACK_TOP))
+
+#define access_ok_tt(type, addr, size) \
+        ((type == VERIFY_READ) || (segment_eq(get_fs(), KERNEL_DS)) || \
+         (((unsigned long) (addr) <= ((unsigned long) (addr) + (size))) && \
+          (under_task_size(addr, size) || is_stack(addr, size))))
+
+static inline int verify_area_tt(int type, const void * addr,
+                                 unsigned long size)
+{
+        return(access_ok_tt(type, addr, size) ? 0 : -EFAULT);
+}
+
+extern unsigned long get_fault_addr(void);
+
+extern int __do_copy_from_user(void *to, const void *from, int n,
+                               void **fault_addr, void **fault_catcher);
+extern int __do_strncpy_from_user(char *dst, const char *src, size_t n,
+                                  void **fault_addr, void **fault_catcher);
+extern int __do_clear_user(void *mem, size_t len, void **fault_addr,
+                           void **fault_catcher);
+extern int __do_strnlen_user(const char *str, unsigned long n,
+                             void **fault_addr, void **fault_catcher);
+
+extern int copy_from_user_tt(void *to, const void *from, int n);
+extern int copy_to_user_tt(void *to, const void *from, int n);
+extern int strncpy_from_user_tt(char *dst, const char *src, int count);
+extern int __clear_user_tt(void *mem, int len);
+extern int clear_user_tt(void *mem, int len);
+extern int strnlen_user_tt(const void *str, int len);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ksyms.c b/arch/um/kernel/tt/ksyms.c
new file mode 100644
index 000000000000..92ec85d67c7c
--- /dev/null
+++ b/arch/um/kernel/tt/ksyms.c
@@ -0,0 +1,28 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/module.h"
+#include "asm/uaccess.h"
+#include "mode.h"
+
+EXPORT_SYMBOL(__do_copy_from_user);
+EXPORT_SYMBOL(__do_copy_to_user);
+EXPORT_SYMBOL(__do_strncpy_from_user);
+EXPORT_SYMBOL(__do_strnlen_user); 
+EXPORT_SYMBOL(__do_clear_user);
+
+EXPORT_SYMBOL(tracing_pid);
+EXPORT_SYMBOL(honeypot);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/mem.c b/arch/um/kernel/tt/mem.c
new file mode 100644
index 000000000000..74346a04a2b2
--- /dev/null
+++ b/arch/um/kernel/tt/mem.c
@@ -0,0 +1,51 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/config.h"
+#include "linux/mm.h"
+#include "asm/uaccess.h"
+#include "mem_user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "kern.h"
+#include "tt.h"
+
+void before_mem_tt(unsigned long brk_start)
+{
+        if(debug)
+                remap_data(UML_ROUND_DOWN(&_stext), UML_ROUND_UP(&_etext), 1);
+        remap_data(UML_ROUND_DOWN(&_sdata), UML_ROUND_UP(&_edata), 1);
+        remap_data(UML_ROUND_DOWN(&__bss_start), UML_ROUND_UP(&_end), 1);
+}
+
+#ifdef CONFIG_HOST_2G_2G
+#define TOP 0x80000000
+#else
+#define TOP 0xc0000000
+#endif
+
+#define SIZE ((CONFIG_NEST_LEVEL + CONFIG_KERNEL_HALF_GIGS) * 0x20000000)
+#define START (TOP - SIZE)
+
+unsigned long set_task_sizes_tt(int arg, unsigned long *host_size_out, 
+                                unsigned long *task_size_out)
+{
+        /* Round up to the nearest 4M */
+        *host_size_out = ROUND_4M((unsigned long) &arg);
+        *task_size_out = START;
+        return(START);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/mem_user.c b/arch/um/kernel/tt/mem_user.c
new file mode 100644
index 000000000000..3085267459b1
--- /dev/null
+++ b/arch/um/kernel/tt/mem_user.c
@@ -0,0 +1,49 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include "tt.h"
+#include "mem_user.h"
+#include "user_util.h"
+
+void remap_data(void *segment_start, void *segment_end, int w)
+{
+        void *addr;
+        unsigned long size;
+        int data, prot;
+
+        if(w) prot = PROT_WRITE;
+        else prot = 0;
+        prot |= PROT_READ | PROT_EXEC;
+        size = (unsigned long) segment_end - 
+                (unsigned long) segment_start;
+        data = create_mem_file(size);
+        addr = mmap(NULL, size, PROT_WRITE | PROT_READ, MAP_SHARED, data, 0);
+        if(addr == MAP_FAILED){
+                perror("mapping new data segment");
+                exit(1);
+        }
+        memcpy(addr, segment_start, size);
+        if(switcheroo(data, prot, addr, segment_start, size) < 0){
+                printf("switcheroo failed\n");
+                exit(1);
+        }
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/process_kern.c b/arch/um/kernel/tt/process_kern.c
new file mode 100644
index 000000000000..f19f7c18febe
--- /dev/null
+++ b/arch/um/kernel/tt/process_kern.c
@@ -0,0 +1,476 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/signal.h"
+#include "linux/kernel.h"
+#include "linux/interrupt.h"
+#include "linux/ptrace.h"
+#include "asm/system.h"
+#include "asm/pgalloc.h"
+#include "asm/ptrace.h"
+#include "asm/tlbflush.h"
+#include "irq_user.h"
+#include "signal_user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+#include "kern.h"
+#include "sigcontext.h"
+#include "time_user.h"
+#include "mem_user.h"
+#include "tlb.h"
+#include "mode.h"
+#include "init.h"
+#include "tt.h"
+
+void *switch_to_tt(void *prev, void *next, void *last)
+{
+        struct task_struct *from, *to, *prev_sched;
+        unsigned long flags;
+        int err, vtalrm, alrm, prof, cpu;
+        char c;
+        /* jailing and SMP are incompatible, so this doesn't need to be 
+         * made per-cpu 
+         */
+        static int reading;
+
+        from = prev;
+        to = next;
+
+        to->thread.prev_sched = from;
+
+        cpu = from->thread_info->cpu;
+        if(cpu == 0)
+                forward_interrupts(to->thread.mode.tt.extern_pid);
+#ifdef CONFIG_SMP
+        forward_ipi(cpu_data[cpu].ipi_pipe[0], to->thread.mode.tt.extern_pid);
+#endif
+        local_irq_save(flags);
+
+        vtalrm = change_sig(SIGVTALRM, 0);
+        alrm = change_sig(SIGALRM, 0);
+        prof = change_sig(SIGPROF, 0);
+
+        forward_pending_sigio(to->thread.mode.tt.extern_pid);
+
+        c = 0;
+        set_current(to);
+
+        reading = 0;
+        err = os_write_file(to->thread.mode.tt.switch_pipe[1], &c, sizeof(c));
+        if(err != sizeof(c))
+                panic("write of switch_pipe failed, err = %d", -err);
+
+        reading = 1;
+        if((from->exit_state == EXIT_ZOMBIE) ||
+           (from->exit_state == EXIT_DEAD))
+                os_kill_process(os_getpid(), 0);
+
+        err = os_read_file(from->thread.mode.tt.switch_pipe[0], &c, sizeof(c));
+        if(err != sizeof(c))
+                panic("read of switch_pipe failed, errno = %d", -err);
+
+        /* If the process that we have just scheduled away from has exited,
+         * then it needs to be killed here.  The reason is that, even though
+         * it will kill itself when it next runs, that may be too late.  Its
+         * stack will be freed, possibly before then, and if that happens,
+         * we have a use-after-free situation.  So, it gets killed here
+         * in case it has not already killed itself.
+         */
+        prev_sched = current->thread.prev_sched;
+        if((prev_sched->exit_state == EXIT_ZOMBIE) ||
+           (prev_sched->exit_state == EXIT_DEAD))
+                os_kill_process(prev_sched->thread.mode.tt.extern_pid, 1);
+
+        change_sig(SIGVTALRM, vtalrm);
+        change_sig(SIGALRM, alrm);
+        change_sig(SIGPROF, prof);
+
+        arch_switch();
+
+        flush_tlb_all();
+        local_irq_restore(flags);
+
+        return(current->thread.prev_sched);
+}
+
+void release_thread_tt(struct task_struct *task)
+{
+        int pid = task->thread.mode.tt.extern_pid;
+
+        if(os_getpid() != pid)
+                os_kill_process(pid, 0);
+}
+
+void exit_thread_tt(void)
+{
+        os_close_file(current->thread.mode.tt.switch_pipe[0]);
+        os_close_file(current->thread.mode.tt.switch_pipe[1]);
+}
+
+void suspend_new_thread(int fd)
+{
+        int err;
+        char c;
+
+        os_stop_process(os_getpid());
+        err = os_read_file(fd, &c, sizeof(c));
+        if(err != sizeof(c))
+                panic("read failed in suspend_new_thread, err = %d", -err);
+}
+
+void schedule_tail(task_t *prev);
+
+static void new_thread_handler(int sig)
+{
+        unsigned long disable;
+        int (*fn)(void *);
+        void *arg;
+
+        fn = current->thread.request.u.thread.proc;
+        arg = current->thread.request.u.thread.arg;
+
+        UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
+        disable = (1 << (SIGVTALRM - 1)) | (1 << (SIGALRM - 1)) |
+                (1 << (SIGIO - 1)) | (1 << (SIGPROF - 1));
+        SC_SIGMASK(UPT_SC(&current->thread.regs.regs)) &= ~disable;
+
+        suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
+
+        force_flush_all();
+        if(current->thread.prev_sched != NULL)
+                schedule_tail(current->thread.prev_sched);
+        current->thread.prev_sched = NULL;
+
+        init_new_thread_signals(1);
+        enable_timer();
+        free_page(current->thread.temp_stack);
+        set_cmdline("(kernel thread)");
+
+        change_sig(SIGUSR1, 1);
+        change_sig(SIGVTALRM, 1);
+        change_sig(SIGPROF, 1);
+        local_irq_enable();
+        if(!run_kernel_thread(fn, arg, &current->thread.exec_buf))
+                do_exit(0);
+
+        /* XXX No set_user_mode here because a newly execed process will
+         * immediately segfault on its non-existent IP, coming straight back
+         * to the signal handler, which will call set_user_mode on its way
+         * out.  This should probably change since it's confusing.
+         */
+}
+
+static int new_thread_proc(void *stack)
+{
+        /* local_irq_disable is needed to block out signals until this thread is
+         * properly scheduled.  Otherwise, the tracing thread will get mighty
+         * upset about any signals that arrive before that.
+         * This has the complication that it sets the saved signal mask in
+         * the sigcontext to block signals.  This gets restored when this
+         * thread (or a descendant, since they get a copy of this sigcontext)
+         * returns to userspace.
+         * So, this is compensated for elsewhere.
+         * XXX There is still a small window until local_irq_disable() actually
+         * finishes where signals are possible - shouldn't be a problem in
+         * practice since SIGIO hasn't been forwarded here yet, and the
+         * local_irq_disable should finish before a SIGVTALRM has time to be
+         * delivered.
+         */
+
+        local_irq_disable();
+        init_new_thread_stack(stack, new_thread_handler);
+        os_usr1_process(os_getpid());
+        change_sig(SIGUSR1, 1);
+        return(0);
+}
+
+/* Signal masking - signals are blocked at the start of fork_tramp.  They
+ * are re-enabled when finish_fork_handler is entered by fork_tramp hitting
+ * itself with a SIGUSR1.  set_user_mode has to be run with SIGUSR1 off,
+ * so it is blocked before it's called.  They are re-enabled on sigreturn
+ * despite the fact that they were blocked when the SIGUSR1 was issued because
+ * copy_thread copies the parent's sigcontext, including the signal mask
+ * onto the signal frame.
+ */
+
+void finish_fork_handler(int sig)
+{
+        UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
+        suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
+
+        force_flush_all();
+        if(current->thread.prev_sched != NULL)
+                schedule_tail(current->thread.prev_sched);
+        current->thread.prev_sched = NULL;
+
+        enable_timer();
+        change_sig(SIGVTALRM, 1);
+        local_irq_enable();
+        if(current->mm != current->parent->mm)
+                protect_memory(uml_reserved, high_physmem - uml_reserved, 1, 
+                               1, 0, 1);
+        task_protections((unsigned long) current_thread);
+
+        free_page(current->thread.temp_stack);
+        local_irq_disable();
+        change_sig(SIGUSR1, 0);
+        set_user_mode(current);
+}
+
+int fork_tramp(void *stack)
+{
+        local_irq_disable();
+        arch_init_thread();
+        init_new_thread_stack(stack, finish_fork_handler);
+
+        os_usr1_process(os_getpid());
+        change_sig(SIGUSR1, 1);
+        return(0);
+}
+
+int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
+                   unsigned long stack_top, struct task_struct * p, 
+                   struct pt_regs *regs)
+{
+        int (*tramp)(void *);
+        int new_pid, err;
+        unsigned long stack;
+        
+        if(current->thread.forking)
+                tramp = fork_tramp;
+        else {
+                tramp = new_thread_proc;
+                p->thread.request.u.thread = current->thread.request.u.thread;
+        }
+
+        err = os_pipe(p->thread.mode.tt.switch_pipe, 1, 1);
+        if(err < 0){
+                printk("copy_thread : pipe failed, err = %d\n", -err);
+                return(err);
+        }
+
+        stack = alloc_stack(0, 0);
+        if(stack == 0){
+                printk(KERN_ERR "copy_thread : failed to allocate "
+                       "temporary stack\n");
+                return(-ENOMEM);
+        }
+
+        clone_flags &= CLONE_VM;
+        p->thread.temp_stack = stack;
+        new_pid = start_fork_tramp(p->thread_info, stack, clone_flags, tramp);
+        if(new_pid < 0){
+                printk(KERN_ERR "copy_thread : clone failed - errno = %d\n", 
+                       -new_pid);
+                return(new_pid);
+        }
+
+        if(current->thread.forking){
+                sc_to_sc(UPT_SC(&p->thread.regs.regs), 
+                         UPT_SC(&current->thread.regs.regs));
+                SC_SET_SYSCALL_RETURN(UPT_SC(&p->thread.regs.regs), 0);
+                if(sp != 0) SC_SP(UPT_SC(&p->thread.regs.regs)) = sp;
+        }
+        p->thread.mode.tt.extern_pid = new_pid;
+
+        current->thread.request.op = OP_FORK;
+        current->thread.request.u.fork.pid = new_pid;
+        os_usr1_process(os_getpid());
+
+        /* Enable the signal and then disable it to ensure that it is handled
+         * here, and nowhere else.
+         */
+        change_sig(SIGUSR1, 1);
+
+        change_sig(SIGUSR1, 0);
+        err = 0;
+        return(err);
+}
+
+void reboot_tt(void)
+{
+        current->thread.request.op = OP_REBOOT;
+        os_usr1_process(os_getpid());
+        change_sig(SIGUSR1, 1);
+}
+
+void halt_tt(void)
+{
+        current->thread.request.op = OP_HALT;
+        os_usr1_process(os_getpid());
+        change_sig(SIGUSR1, 1);
+}
+
+void kill_off_processes_tt(void)
+{
+        struct task_struct *p;
+        int me;
+
+        me = os_getpid();
+        for_each_process(p){
+                if(p->thread.mode.tt.extern_pid != me) 
+                        os_kill_process(p->thread.mode.tt.extern_pid, 0);
+        }
+        if(init_task.thread.mode.tt.extern_pid != me) 
+                os_kill_process(init_task.thread.mode.tt.extern_pid, 0);
+}
+
+void initial_thread_cb_tt(void (*proc)(void *), void *arg)
+{
+        if(os_getpid() == tracing_pid){
+                (*proc)(arg);
+        }
+        else {
+                current->thread.request.op = OP_CB;
+                current->thread.request.u.cb.proc = proc;
+                current->thread.request.u.cb.arg = arg;
+                os_usr1_process(os_getpid());
+                change_sig(SIGUSR1, 1);
+
+                change_sig(SIGUSR1, 0);
+        }
+}
+
+int do_proc_op(void *t, int proc_id)
+{
+        struct task_struct *task;
+        struct thread_struct *thread;
+        int op, pid;
+
+        task = t;
+        thread = &task->thread;
+        op = thread->request.op;
+        switch(op){
+        case OP_NONE:
+        case OP_TRACE_ON:
+                break;
+        case OP_EXEC:
+                pid = thread->request.u.exec.pid;
+                do_exec(thread->mode.tt.extern_pid, pid);
+                thread->mode.tt.extern_pid = pid;
+                cpu_tasks[task->thread_info->cpu].pid = pid;
+                break;
+        case OP_FORK:
+                attach_process(thread->request.u.fork.pid);
+                break;
+        case OP_CB:
+                (*thread->request.u.cb.proc)(thread->request.u.cb.arg);
+                break;
+        case OP_REBOOT:
+        case OP_HALT:
+                break;
+        default:
+                tracer_panic("Bad op in do_proc_op");
+                break;
+        }
+        thread->request.op = OP_NONE;
+        return(op);
+}
+
+void init_idle_tt(void)
+{
+        default_idle();
+}
+
+extern void start_kernel(void);
+
+static int start_kernel_proc(void *unused)
+{
+        int pid;
+
+        block_signals();
+        pid = os_getpid();
+
+        cpu_tasks[0].pid = pid;
+        cpu_tasks[0].task = current;
+#ifdef CONFIG_SMP
+        cpu_online_map = cpumask_of_cpu(0);
+#endif
+        if(debug) os_stop_process(pid);
+        start_kernel();
+        return(0);
+}
+
+void set_tracing(void *task, int tracing)
+{
+        ((struct task_struct *) task)->thread.mode.tt.tracing = tracing;
+}
+
+int is_tracing(void *t)
+{
+        return (((struct task_struct *) t)->thread.mode.tt.tracing);
+}
+
+int set_user_mode(void *t)
+{
+        struct task_struct *task;
+
+        task = t ? t : current;
+        if(task->thread.mode.tt.tracing) 
+                return(1);
+        task->thread.request.op = OP_TRACE_ON;
+        os_usr1_process(os_getpid());
+        return(0);
+}
+
+void set_init_pid(int pid)
+{
+        int err;
+
+        init_task.thread.mode.tt.extern_pid = pid;
+        err = os_pipe(init_task.thread.mode.tt.switch_pipe, 1, 1);
+        if(err)
+                panic("Can't create switch pipe for init_task, errno = %d",
+                      -err);
+}
+
+int start_uml_tt(void)
+{
+        void *sp;
+        int pages;
+
+        pages = (1 << CONFIG_KERNEL_STACK_ORDER);
+        sp = (void *) ((unsigned long) init_task.thread_info) +
+                pages * PAGE_SIZE - sizeof(unsigned long);
+        return(tracer(start_kernel_proc, sp));
+}
+
+int external_pid_tt(struct task_struct *task)
+{
+        return(task->thread.mode.tt.extern_pid);
+}
+
+int thread_pid_tt(struct task_struct *task)
+{
+        return(task->thread.mode.tt.extern_pid);
+}
+
+int is_valid_pid(int pid)
+{
+        struct task_struct *task;
+
+        read_lock(&tasklist_lock);
+        for_each_process(task){
+                if(task->thread.mode.tt.extern_pid == pid){
+                        read_unlock(&tasklist_lock);
+                        return(1);
+                }
+        }
+        read_unlock(&tasklist_lock);
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/Makefile b/arch/um/kernel/tt/ptproxy/Makefile
new file mode 100644
index 000000000000..3ad5b774de59
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/Makefile
@@ -0,0 +1,10 @@
+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+obj-y = proxy.o ptrace.o sysdep.o wait.o
+
+USER_OBJS := $(obj-y)
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/kernel/tt/ptproxy/proxy.c b/arch/um/kernel/tt/ptproxy/proxy.c
new file mode 100644
index 000000000000..58800c50b10e
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/proxy.c
@@ -0,0 +1,377 @@
+/**********************************************************************
+proxy.c
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+
+Jeff Dike (jdike@karaya.com) : Modified for integration into uml
+**********************************************************************/
+
+/* XXX This file shouldn't refer to CONFIG_* */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <termios.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <asm/unistd.h>
+#include "ptrace_user.h"
+
+#include "ptproxy.h"
+#include "sysdep.h"
+#include "wait.h"
+
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+#include "tempfile.h"
+
+static int debugger_wait(debugger_state *debugger, int *status, int options,
+                         int (*syscall)(debugger_state *debugger, pid_t child),
+                         int (*normal_return)(debugger_state *debugger, 
+                                              pid_t unused),
+                         int (*wait_return)(debugger_state *debugger, 
+                                            pid_t unused))
+{
+        if(debugger->real_wait){
+                debugger->handle_trace = normal_return;
+                syscall_continue(debugger->pid);
+                debugger->real_wait = 0;
+                return(1);
+        }
+        debugger->wait_status_ptr = status;
+        debugger->wait_options = options;
+        if((debugger->debugee != NULL) && debugger->debugee->event){
+                syscall_continue(debugger->pid);
+                wait_for_stop(debugger->pid, SIGTRAP, PTRACE_SYSCALL,
+                              NULL);
+                (*wait_return)(debugger, -1);
+                return(0);
+        }
+        else if(debugger->wait_options & WNOHANG){
+                syscall_cancel(debugger->pid, 0);
+                debugger->handle_trace = syscall;
+                return(0);
+        }
+        else {
+                syscall_pause(debugger->pid);
+                debugger->handle_trace = wait_return;
+                debugger->waiting = 1;
+        }
+        return(1);
+}
+
+/*
+ * Handle debugger trap, i.e. syscall.
+ */
+
+int debugger_syscall(debugger_state *debugger, pid_t child)
+{
+        long arg1, arg2, arg3, arg4, arg5, result;
+        int syscall, ret = 0;
+
+        syscall = get_syscall(debugger->pid, &arg1, &arg2, &arg3, &arg4, 
+                              &arg5);
+
+        switch(syscall){
+        case __NR_execve:
+                /* execve never returns */
+                debugger->handle_trace = debugger_syscall; 
+                break;
+
+        case __NR_ptrace:
+                if(debugger->debugee->pid != 0) arg2 = debugger->debugee->pid;
+                if(!debugger->debugee->in_context) 
+                        child = debugger->debugee->pid;
+                result = proxy_ptrace(debugger, arg1, arg2, arg3, arg4, child,
+                                      &ret);
+                syscall_cancel(debugger->pid, result);
+                debugger->handle_trace = debugger_syscall;
+                return(ret);
+
+#ifdef __NR_waitpid
+        case __NR_waitpid:
+#endif
+        case __NR_wait4:
+                if(!debugger_wait(debugger, (int *) arg2, arg3, 
+                                  debugger_syscall, debugger_normal_return, 
+                                  proxy_wait_return))
+                        return(0);
+                break;
+
+        case __NR_kill:
+                if(!debugger->debugee->in_context) 
+                        child = debugger->debugee->pid;
+                if(arg1 == debugger->debugee->pid){
+                        result = kill(child, arg2);
+                        syscall_cancel(debugger->pid, result);
+                        debugger->handle_trace = debugger_syscall;
+                        return(0);
+                }
+                else debugger->handle_trace = debugger_normal_return;
+                break;
+
+        default:
+                debugger->handle_trace = debugger_normal_return;
+        }
+
+        syscall_continue(debugger->pid);
+        return(0);
+}
+
+/* Used by the tracing thread */
+static debugger_state parent;
+static int parent_syscall(debugger_state *debugger, int pid);
+
+int init_parent_proxy(int pid)
+{
+        parent = ((debugger_state) { .pid               = pid,
+                                     .wait_options      = 0,
+                                     .wait_status_ptr   = NULL,
+                                     .waiting           = 0,
+                                     .real_wait         = 0,
+                                     .expecting_child   = 0,
+                                     .handle_trace      = parent_syscall,
+                                     .debugee           = NULL } );
+        return(0);
+}
+
+int parent_normal_return(debugger_state *debugger, pid_t unused)
+{
+        debugger->handle_trace = parent_syscall;
+        syscall_continue(debugger->pid);
+        return(0);
+}
+
+static int parent_syscall(debugger_state *debugger, int pid)
+{
+        long arg1, arg2, arg3, arg4, arg5;
+        int syscall;
+
+        syscall = get_syscall(pid, &arg1, &arg2, &arg3, &arg4, &arg5);
+                
+        if((syscall == __NR_wait4)
+#ifdef __NR_waitpid
+           || (syscall == __NR_waitpid)
+#endif
+        ){
+                debugger_wait(&parent, (int *) arg2, arg3, parent_syscall,
+                              parent_normal_return, parent_wait_return);
+        }
+        else ptrace(PTRACE_SYSCALL, pid, 0, 0);
+        return(0);
+}
+
+int debugger_normal_return(debugger_state *debugger, pid_t unused)
+{
+        debugger->handle_trace = debugger_syscall;
+        syscall_continue(debugger->pid);
+        return(0);
+}
+
+void debugger_cancelled_return(debugger_state *debugger, int result)
+{
+        debugger->handle_trace = debugger_syscall;
+        syscall_set_result(debugger->pid, result);
+        syscall_continue(debugger->pid);
+}
+
+/* Used by the tracing thread */
+static debugger_state debugger;
+static debugee_state debugee;
+
+void init_proxy (pid_t debugger_pid, int stopped, int status)
+{
+        debugger.pid = debugger_pid;
+        debugger.handle_trace = debugger_syscall;
+        debugger.debugee = &debugee;
+        debugger.waiting = 0;
+        debugger.real_wait = 0;
+        debugger.expecting_child = 0;
+
+        debugee.pid = 0;
+        debugee.traced = 0;
+        debugee.stopped = stopped;
+        debugee.event = 0;
+        debugee.zombie = 0;
+        debugee.died = 0;
+        debugee.wait_status = status;
+        debugee.in_context = 1;
+}
+
+int debugger_proxy(int status, int pid)
+{
+        int ret = 0, sig;
+
+        if(WIFSTOPPED(status)){
+                sig = WSTOPSIG(status);
+                if (sig == SIGTRAP)
+                        ret = (*debugger.handle_trace)(&debugger, pid);
+                                                       
+                else if(sig == SIGCHLD){
+                        if(debugger.expecting_child){
+                                ptrace(PTRACE_SYSCALL, debugger.pid, 0, sig);
+                                debugger.expecting_child = 0;
+                        }
+                        else if(debugger.waiting)
+                                real_wait_return(&debugger);
+                        else {
+                                ptrace(PTRACE_SYSCALL, debugger.pid, 0, sig);
+                                debugger.real_wait = 1;
+                        }
+                }
+                else ptrace(PTRACE_SYSCALL, debugger.pid, 0, sig);
+        }
+        else if(WIFEXITED(status)){
+                tracer_panic("debugger (pid %d) exited with status %d", 
+                             debugger.pid, WEXITSTATUS(status));
+        }
+        else if(WIFSIGNALED(status)){
+                tracer_panic("debugger (pid %d) exited with signal %d", 
+                             debugger.pid, WTERMSIG(status));
+        }
+        else {
+                tracer_panic("proxy got unknown status (0x%x) on debugger "
+                             "(pid %d)", status, debugger.pid);
+        }
+        return(ret);
+}
+
+void child_proxy(pid_t pid, int status)
+{
+        debugee.event = 1;
+        debugee.wait_status = status;
+
+        if(WIFSTOPPED(status)){
+                debugee.stopped = 1;
+                debugger.expecting_child = 1;
+                kill(debugger.pid, SIGCHLD);
+        }
+        else if(WIFEXITED(status) || WIFSIGNALED(status)){
+                debugee.zombie = 1;
+                debugger.expecting_child = 1;
+                kill(debugger.pid, SIGCHLD);
+        }
+        else panic("proxy got unknown status (0x%x) on child (pid %d)", 
+                   status, pid);
+}
+
+void debugger_parent_signal(int status, int pid)
+{
+        int sig;
+
+        if(WIFSTOPPED(status)){
+                sig = WSTOPSIG(status);
+                if(sig == SIGTRAP) (*parent.handle_trace)(&parent, pid);
+                else ptrace(PTRACE_SYSCALL, pid, 0, sig);
+        }
+}
+
+void fake_child_exit(void)
+{
+        int status, pid;
+
+        child_proxy(1, W_EXITCODE(0, 0));
+        while(debugger.waiting == 1){
+                CATCH_EINTR(pid = waitpid(debugger.pid, &status, WUNTRACED));
+                if(pid != debugger.pid){
+                        printk("fake_child_exit - waitpid failed, "
+                               "errno = %d\n", errno);
+                        return;
+                }
+                debugger_proxy(status, debugger.pid);
+        }
+        CATCH_EINTR(pid = waitpid(debugger.pid, &status, WUNTRACED));
+        if(pid != debugger.pid){
+                printk("fake_child_exit - waitpid failed, "
+                       "errno = %d\n", errno);
+                return;
+        }
+        if(ptrace(PTRACE_DETACH, debugger.pid, 0, SIGCONT) < 0)
+                printk("fake_child_exit - PTRACE_DETACH failed, errno = %d\n",
+                       errno);
+}
+
+char gdb_init_string[] = 
+"att 1 \n\
+b panic \n\
+b stop \n\
+handle SIGWINCH nostop noprint pass \n\
+";
+
+int start_debugger(char *prog, int startup, int stop, int *fd_out)
+{
+        int slave, child;
+
+        slave = open_gdb_chan();
+        child = fork();
+        if(child == 0){
+                char *tempname = NULL;
+                int fd;
+
+                if(setsid() < 0) perror("setsid");
+                if((dup2(slave, 0) < 0) || (dup2(slave, 1) < 0) || 
+                   (dup2(slave, 2) < 0)){
+                        printk("start_debugger : dup2 failed, errno = %d\n",
+                               errno);
+                        exit(1);
+                }
+                if(ioctl(0, TIOCSCTTY, 0) < 0){
+                        printk("start_debugger : TIOCSCTTY failed, "
+                               "errno = %d\n", errno);
+                        exit(1);
+                }
+                if(tcsetpgrp (1, os_getpid()) < 0){
+                        printk("start_debugger : tcsetpgrp failed, "
+                               "errno = %d\n", errno);
+#ifdef notdef
+                        exit(1);
+#endif
+                }
+                fd = make_tempfile("/tmp/gdb_init-XXXXXX", &tempname, 0);
+                if(fd < 0){
+                        printk("start_debugger : make_tempfile failed,"
+                               "err = %d\n", -fd);
+                        exit(1);
+                }
+                os_write_file(fd, gdb_init_string, sizeof(gdb_init_string) - 1);
+                if(startup){
+                        if(stop){
+                                os_write_file(fd, "b start_kernel\n",
+                                      strlen("b start_kernel\n"));
+                        }
+                        os_write_file(fd, "c\n", strlen("c\n"));
+                }
+                if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0){
+                        printk("start_debugger :  PTRACE_TRACEME failed, "
+                               "errno = %d\n", errno);
+                        exit(1);
+                }
+                execlp("gdb", "gdb", "--command", tempname, prog, NULL);
+                printk("start_debugger : exec of gdb failed, errno = %d\n",
+                       errno);
+        }
+        if(child < 0){
+                printk("start_debugger : fork for gdb failed, errno = %d\n",
+                       errno);
+                return(-1);
+        }
+        *fd_out = slave;
+        return(child);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/ptproxy.h b/arch/um/kernel/tt/ptproxy/ptproxy.h
new file mode 100644
index 000000000000..5eb0285b1968
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/ptproxy.h
@@ -0,0 +1,61 @@
+/**********************************************************************
+ptproxy.h
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+**********************************************************************/
+
+#ifndef __PTPROXY_H
+#define __PTPROXY_H
+
+#include <sys/types.h>
+
+typedef struct debugger debugger_state;
+typedef struct debugee debugee_state;
+
+struct debugger
+{
+        pid_t pid;
+        int wait_options;
+        int *wait_status_ptr;
+        unsigned int waiting : 1;
+        unsigned int real_wait : 1;
+        unsigned int expecting_child : 1;
+        int (*handle_trace) (debugger_state *, pid_t);
+
+        debugee_state *debugee;
+};
+
+struct debugee
+{
+        pid_t pid;
+        int wait_status;
+        unsigned int died : 1;
+        unsigned int event : 1;
+        unsigned int stopped : 1;
+        unsigned int trace_singlestep : 1;
+        unsigned int trace_syscall : 1;
+        unsigned int traced : 1;
+        unsigned int zombie : 1;
+        unsigned int in_context : 1;
+};
+
+extern int debugger_syscall(debugger_state *debugger, pid_t pid);
+extern int debugger_normal_return (debugger_state *debugger, pid_t unused);
+
+extern long proxy_ptrace (struct debugger *, int, pid_t, long, long, pid_t,
+                          int *strace_out);
+extern void debugger_cancelled_return(debugger_state *debugger, int result);
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/ptrace.c b/arch/um/kernel/tt/ptproxy/ptrace.c
new file mode 100644
index 000000000000..528a5fc8d887
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/ptrace.c
@@ -0,0 +1,237 @@
+/**********************************************************************
+ptrace.c
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+
+Jeff Dike (jdike@karaya.com) : Modified for integration into uml
+**********************************************************************/
+
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+
+#include "ptproxy.h"
+#include "debug.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "ptrace_user.h"
+#include "tt.h"
+
+long proxy_ptrace(struct debugger *debugger, int arg1, pid_t arg2,
+                  long arg3, long arg4, pid_t child, int *ret)
+{
+        sigset_t relay;
+        long result;
+        int status;
+
+        *ret = 0;
+        if(debugger->debugee->died) return(-ESRCH);
+
+        switch(arg1){
+        case PTRACE_ATTACH:
+                if(debugger->debugee->traced) return(-EPERM);
+
+                debugger->debugee->pid = arg2;
+                debugger->debugee->traced = 1;
+
+                if(is_valid_pid(arg2) && (arg2 != child)){
+                        debugger->debugee->in_context = 0;
+                        kill(arg2, SIGSTOP);
+                        debugger->debugee->event = 1;
+                        debugger->debugee->wait_status = W_STOPCODE(SIGSTOP);
+                }
+                else {
+                        debugger->debugee->in_context = 1;
+                        if(debugger->debugee->stopped) 
+                                child_proxy(child, W_STOPCODE(SIGSTOP));
+                        else kill(child, SIGSTOP);
+                }
+
+                return(0);
+
+        case PTRACE_DETACH:
+                if(!debugger->debugee->traced) return(-EPERM);
+                
+                debugger->debugee->traced = 0;
+                debugger->debugee->pid = 0;
+                if(!debugger->debugee->in_context)
+                        kill(child, SIGCONT);
+
+                return(0);
+
+        case PTRACE_CONT:
+                if(!debugger->debugee->in_context) return(-EPERM);
+                *ret = PTRACE_CONT;
+                return(ptrace(PTRACE_CONT, child, arg3, arg4));
+
+#ifdef UM_HAVE_GETFPREGS
+        case PTRACE_GETFPREGS:
+        {
+                long regs[FP_FRAME_SIZE];
+                int i, result;
+
+                result = ptrace(PTRACE_GETFPREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+                
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        ptrace(PTRACE_POKEDATA, debugger->pid, arg4 + 4 * i,
+                               regs[i]);
+                return(result);
+        }
+#endif
+
+#ifdef UM_HAVE_GETFPXREGS
+        case PTRACE_GETFPXREGS:
+        {
+                long regs[FPX_FRAME_SIZE];
+                int i, result;
+
+                result = ptrace(PTRACE_GETFPXREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+                
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        ptrace(PTRACE_POKEDATA, debugger->pid, arg4 + 4 * i,
+                               regs[i]);
+                return(result);
+        }
+#endif
+
+#ifdef UM_HAVE_GETREGS
+        case PTRACE_GETREGS:
+        {
+                long regs[FRAME_SIZE];
+                int i, result;
+
+                result = ptrace(PTRACE_GETREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        ptrace (PTRACE_POKEDATA, debugger->pid,
+                                arg4 + 4 * i, regs[i]);
+                return(result);
+        }
+        break;
+#endif
+
+        case PTRACE_KILL:
+                result = ptrace(PTRACE_KILL, child, arg3, arg4);
+                if(result == -1) return(-errno);
+
+                return(result);
+
+        case PTRACE_PEEKDATA:
+        case PTRACE_PEEKTEXT:
+        case PTRACE_PEEKUSR:
+                /* The value being read out could be -1, so we have to 
+                 * check errno to see if there's an error, and zero it
+                 * beforehand so we're not faked out by an old error
+                 */
+
+                errno = 0;
+                result = ptrace(arg1, child, arg3, 0);
+                if((result == -1) && (errno != 0)) return(-errno);
+
+                result = ptrace(PTRACE_POKEDATA, debugger->pid, arg4, result);
+                if(result == -1) return(-errno);
+                        
+                return(result);
+
+        case PTRACE_POKEDATA:
+        case PTRACE_POKETEXT:
+        case PTRACE_POKEUSR:
+                result = ptrace(arg1, child, arg3, arg4);
+                if(result == -1) return(-errno);
+
+                if(arg1 == PTRACE_POKEUSR) ptrace_pokeuser(arg3, arg4);
+                return(result);
+
+#ifdef UM_HAVE_SETFPREGS
+        case PTRACE_SETFPREGS:
+        {
+                long regs[FP_FRAME_SIZE];
+                int i;
+
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        regs[i] = ptrace (PTRACE_PEEKDATA, debugger->pid,
+                                          arg4 + 4 * i, 0);
+                result = ptrace(PTRACE_SETFPREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+
+                return(result);
+        }
+#endif
+
+#ifdef UM_HAVE_SETFPXREGS
+        case PTRACE_SETFPXREGS:
+        {
+                long regs[FPX_FRAME_SIZE];
+                int i;
+
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        regs[i] = ptrace (PTRACE_PEEKDATA, debugger->pid,
+                                          arg4 + 4 * i, 0);
+                result = ptrace(PTRACE_SETFPXREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+
+                return(result);
+        }
+#endif
+
+#ifdef UM_HAVE_SETREGS
+        case PTRACE_SETREGS:
+        {
+                long regs[FRAME_SIZE];
+                int i;
+
+                for (i = 0; i < sizeof(regs)/sizeof(regs[0]); i++)
+                        regs[i] = ptrace(PTRACE_PEEKDATA, debugger->pid,
+                                         arg4 + 4 * i, 0);
+                result = ptrace(PTRACE_SETREGS, child, 0, regs);
+                if(result == -1) return(-errno);
+
+                return(result);
+        }
+#endif
+
+        case PTRACE_SINGLESTEP:
+                if(!debugger->debugee->in_context) return(-EPERM);
+                sigemptyset(&relay);
+                sigaddset(&relay, SIGSEGV);
+                sigaddset(&relay, SIGILL);
+                sigaddset(&relay, SIGBUS);
+                result = ptrace(PTRACE_SINGLESTEP, child, arg3, arg4);
+                if(result == -1) return(-errno);
+                
+                status = wait_for_stop(child, SIGTRAP, PTRACE_SINGLESTEP,
+                                       &relay);
+                child_proxy(child, status);
+                return(result);
+
+        case PTRACE_SYSCALL:
+                if(!debugger->debugee->in_context) return(-EPERM);
+                result = ptrace(PTRACE_SYSCALL, child, arg3, arg4);
+                if(result == -1) return(-errno);
+
+                *ret = PTRACE_SYSCALL;
+                return(result);
+
+        case PTRACE_TRACEME:
+        default:
+                return(-EINVAL);
+        }
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/sysdep.c b/arch/um/kernel/tt/ptproxy/sysdep.c
new file mode 100644
index 000000000000..a5f0e01e214e
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/sysdep.c
@@ -0,0 +1,70 @@
+/**********************************************************************
+sysdep.c
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+**********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <linux/unistd.h>
+#include "ptrace_user.h"
+#include "user_util.h"
+#include "user.h"
+
+int get_syscall(pid_t pid, long *arg1, long *arg2, long *arg3, long *arg4, 
+                long *arg5)
+{
+        *arg1 = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_ARG1_OFFSET, 0);
+        *arg2 = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_ARG2_OFFSET, 0);
+        *arg3 = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_ARG3_OFFSET, 0);
+        *arg4 = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_ARG4_OFFSET, 0);
+        *arg5 = ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_ARG5_OFFSET, 0);
+        return(ptrace(PTRACE_PEEKUSR, pid, PT_SYSCALL_NR_OFFSET, 0));
+}
+
+void syscall_cancel(pid_t pid, int result)
+{
+        if((ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
+                   __NR_getpid) < 0) ||
+           (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) ||
+           (wait_for_stop(pid, SIGTRAP, PTRACE_SYSCALL, NULL) < 0) ||
+           (ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET, result) < 0) ||
+           (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0))
+                printk("ptproxy: couldn't cancel syscall: errno = %d\n", 
+                       errno);
+}
+
+void syscall_set_result(pid_t pid, long result)
+{
+        ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET, result);
+}
+
+void syscall_continue(pid_t pid)
+{
+        ptrace(PTRACE_SYSCALL, pid, 0, 0);
+}
+
+int syscall_pause(pid_t pid) 
+{
+        if(ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET, __NR_pause) < 0){
+                printk("syscall_change - ptrace failed, errno = %d\n", errno);
+                return(-1);
+        }
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/sysdep.h b/arch/um/kernel/tt/ptproxy/sysdep.h
new file mode 100644
index 000000000000..735f488049aa
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/sysdep.h
@@ -0,0 +1,25 @@
+/**********************************************************************
+sysdep.h
+
+Copyright (C) 1999 Lars Brinkhoff.
+Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+See the file COPYING for licensing terms and conditions.
+**********************************************************************/
+
+extern int get_syscall(pid_t pid, long *arg1, long *arg2, long *arg3, 
+                       long *arg4, long *arg5);
+extern void syscall_cancel (pid_t pid, long result);
+extern void syscall_set_result (pid_t pid, long result);
+extern void syscall_continue (pid_t pid);
+extern int syscall_pause(pid_t pid);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/wait.c b/arch/um/kernel/tt/ptproxy/wait.c
new file mode 100644
index 000000000000..12f6319d8d76
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/wait.c
@@ -0,0 +1,86 @@
+/**********************************************************************
+wait.c
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+
+**********************************************************************/
+
+#include <errno.h>
+#include <signal.h>
+#include <sys/wait.h>
+
+#include "ptproxy.h"
+#include "sysdep.h"
+#include "wait.h"
+#include "user_util.h"
+#include "ptrace_user.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+
+int proxy_wait_return(struct debugger *debugger, pid_t unused)
+{
+        debugger->waiting = 0;
+
+        if(debugger->debugee->died || (debugger->wait_options & __WCLONE)){
+                debugger_cancelled_return(debugger, -ECHILD);
+                return(0);
+        }
+
+        if(debugger->debugee->zombie && debugger->debugee->event)
+                debugger->debugee->died = 1;
+
+        if(debugger->debugee->event){
+                debugger->debugee->event = 0;
+                ptrace(PTRACE_POKEDATA, debugger->pid,
+                       debugger->wait_status_ptr, 
+                       debugger->debugee->wait_status);
+                /* if (wait4)
+                   ptrace (PTRACE_POKEDATA, pid, rusage_ptr, ...); */
+                debugger_cancelled_return(debugger, debugger->debugee->pid);
+                return(0);
+        }
+
+        /* pause will return -EINTR, which happens to be right for wait */
+        debugger_normal_return(debugger, -1);
+        return(0);
+}
+
+int parent_wait_return(struct debugger *debugger, pid_t unused)
+{
+        return(debugger_normal_return(debugger, -1));
+}
+
+int real_wait_return(struct debugger *debugger)
+{
+        unsigned long ip;
+        int pid;
+
+        pid = debugger->pid;
+
+        ip = ptrace(PTRACE_PEEKUSR, pid, PT_IP_OFFSET, 0);
+        IP_RESTART_SYSCALL(ip);
+
+        if(ptrace(PTRACE_POKEUSR, pid, PT_IP_OFFSET, ip) < 0)
+                tracer_panic("real_wait_return : Failed to restart system "
+                             "call, errno = %d\n", errno);
+
+        if((ptrace(PTRACE_SYSCALL, debugger->pid, 0, SIGCHLD) < 0) ||
+           (ptrace(PTRACE_SYSCALL, debugger->pid, 0, 0) < 0) ||
+           (ptrace(PTRACE_SYSCALL, debugger->pid, 0, 0) < 0) ||
+           debugger_normal_return(debugger, -1))
+                tracer_panic("real_wait_return : gdb failed to wait, "
+                             "errno = %d\n", errno);
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/ptproxy/wait.h b/arch/um/kernel/tt/ptproxy/wait.h
new file mode 100644
index 000000000000..542e73ee2cee
--- /dev/null
+++ b/arch/um/kernel/tt/ptproxy/wait.h
@@ -0,0 +1,15 @@
+/**********************************************************************
+wait.h
+
+Copyright (C) 1999 Lars Brinkhoff.  See the file COPYING for licensing
+terms and conditions.
+**********************************************************************/
+
+#ifndef __PTPROXY_WAIT_H
+#define __PTPROXY_WAIT_H
+
+extern int proxy_wait_return(struct debugger *debugger, pid_t unused);
+extern int real_wait_return(struct debugger *debugger);
+extern int parent_wait_return(struct debugger *debugger, pid_t unused);
+
+#endif
diff --git a/arch/um/kernel/tt/syscall_kern.c b/arch/um/kernel/tt/syscall_kern.c
new file mode 100644
index 000000000000..2650a628719e
--- /dev/null
+++ b/arch/um/kernel/tt/syscall_kern.c
@@ -0,0 +1,47 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/types.h"
+#include "linux/utime.h"
+#include "linux/sys.h"
+#include "linux/ptrace.h"
+#include "asm/unistd.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+#include "asm/stat.h"
+#include "sysdep/syscalls.h"
+#include "kern_util.h"
+
+extern syscall_handler_t *sys_call_table[];
+
+long execute_syscall_tt(void *r)
+{
+        struct pt_regs *regs = r;
+        long res;
+        int syscall;
+
+#ifdef CONFIG_SYSCALL_DEBUG
+        current->thread.nsyscalls++;
+        nsyscalls++;
+#endif
+        syscall = UPT_SYSCALL_NR(&regs->regs);
+
+        if((syscall >= NR_syscalls) || (syscall < 0))
+                res = -ENOSYS;
+        else res = EXECUTE_SYSCALL(syscall, regs);
+
+        return(res);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/syscall_user.c b/arch/um/kernel/tt/syscall_user.c
new file mode 100644
index 000000000000..e4e7e9c2224c
--- /dev/null
+++ b/arch/um/kernel/tt/syscall_user.c
@@ -0,0 +1,90 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <asm/unistd.h>
+#include "sysdep/ptrace.h"
+#include "sigcontext.h"
+#include "ptrace_user.h"
+#include "task.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "syscall_user.h"
+#include "tt.h"
+
+
+void syscall_handler_tt(int sig, union uml_pt_regs *regs)
+{
+        void *sc;
+        long result;
+        int syscall;
+#ifdef UML_CONFIG_DEBUG_SYSCALL
+        int index;
+#endif
+
+        syscall = UPT_SYSCALL_NR(regs);
+        sc = UPT_SC(regs);
+        SC_START_SYSCALL(sc);
+
+#ifdef UML_CONFIG_DEBUG_SYSCALL
+        index = record_syscall_start(syscall);
+#endif
+        syscall_trace(regs, 0);
+        result = execute_syscall_tt(regs);
+
+        /* regs->sc may have changed while the system call ran (there may
+         * have been an interrupt or segfault), so it needs to be refreshed.
+         */
+        UPT_SC(regs) = sc;
+
+        SC_SET_SYSCALL_RETURN(sc, result);
+
+        syscall_trace(regs, 1);
+#ifdef UML_CONFIG_DEBUG_SYSCALL
+        record_syscall_end(index, result);
+#endif
+}
+
+void do_sigtrap(void *task)
+{
+        UPT_SYSCALL_NR(TASK_REGS(task)) = -1;
+}
+
+void do_syscall(void *task, int pid, int local_using_sysemu)
+{
+        unsigned long proc_regs[FRAME_SIZE];
+
+        if(ptrace_getregs(pid, proc_regs) < 0)
+                tracer_panic("Couldn't read registers");
+
+        UPT_SYSCALL_NR(TASK_REGS(task)) = PT_SYSCALL_NR(proc_regs);
+
+        if(((unsigned long *) PT_IP(proc_regs) >= &_stext) &&
+           ((unsigned long *) PT_IP(proc_regs) <= &_etext))
+                tracer_panic("I'm tracing myself and I can't get out");
+
+        /* advanced sysemu mode set syscall number to -1 automatically */
+        if (local_using_sysemu==2)
+                return;
+
+        /* syscall number -1 in sysemu skips syscall restarting in host */
+        if(ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
+                  local_using_sysemu ? -1 : __NR_getpid) < 0)
+                tracer_panic("do_syscall : Nullifying syscall failed, "
+                             "errno = %d", errno);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/time.c b/arch/um/kernel/tt/time.c
new file mode 100644
index 000000000000..8565b71b07cd
--- /dev/null
+++ b/arch/um/kernel/tt/time.c
@@ -0,0 +1,28 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include <sys/time.h>
+#include <time_user.h>
+#include "process.h"
+#include "user.h"
+
+void user_time_init_tt(void)
+{
+        if(signal(SIGVTALRM, (__sighandler_t) alarm_handler) == SIG_ERR)
+                panic("Couldn't set SIGVTALRM handler");
+        set_interval(ITIMER_VIRTUAL);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/tlb.c b/arch/um/kernel/tt/tlb.c
new file mode 100644
index 000000000000..203216ad86f1
--- /dev/null
+++ b/arch/um/kernel/tt/tlb.c
@@ -0,0 +1,149 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright 2003 PathScale, Inc.
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/kernel.h"
+#include "linux/sched.h"
+#include "linux/mm.h"
+#include "asm/page.h"
+#include "asm/pgtable.h"
+#include "asm/uaccess.h"
+#include "asm/tlbflush.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "os.h"
+#include "tlb.h"
+
+static void do_ops(int unused, struct host_vm_op *ops, int last)
+{
+        struct host_vm_op *op;
+        int i;
+
+        for(i = 0; i <= last; i++){
+                op = &ops[i];
+                switch(op->type){
+                case MMAP:
+                        os_map_memory((void *) op->u.mmap.addr, op->u.mmap.fd,
+                                      op->u.mmap.offset, op->u.mmap.len,
+                                      op->u.mmap.r, op->u.mmap.w,
+                                      op->u.mmap.x);
+                        break;
+                case MUNMAP:
+                        os_unmap_memory((void *) op->u.munmap.addr,
+                                        op->u.munmap.len);
+                        break;
+                case MPROTECT:
+                        protect_memory(op->u.mprotect.addr, op->u.munmap.len,
+                                       op->u.mprotect.r, op->u.mprotect.w,
+                                       op->u.mprotect.x, 1);
+                        break;
+                default:
+                        printk("Unknown op type %d in do_ops\n", op->type);
+                        break;
+                }
+        }
+}
+
+static void fix_range(struct mm_struct *mm, unsigned long start_addr, 
+                      unsigned long end_addr, int force)
+{
+        if((current->thread.mode.tt.extern_pid != -1) &&
+           (current->thread.mode.tt.extern_pid != os_getpid()))
+                panic("fix_range fixing wrong address space, current = 0x%p",
+                      current);
+
+        fix_range_common(mm, start_addr, end_addr, force, 0, do_ops);
+}
+
+atomic_t vmchange_seq = ATOMIC_INIT(1);
+
+void flush_tlb_kernel_range_tt(unsigned long start, unsigned long end)
+{
+        if(flush_tlb_kernel_range_common(start, end))
+                atomic_inc(&vmchange_seq);
+}
+
+static void protect_vm_page(unsigned long addr, int w, int must_succeed)
+{
+        int err;
+
+        err = protect_memory(addr, PAGE_SIZE, 1, w, 1, must_succeed);
+        if(err == 0) return;
+        else if((err == -EFAULT) || (err == -ENOMEM)){
+                flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
+                protect_vm_page(addr, w, 1);
+        }
+        else panic("protect_vm_page : protect failed, errno = %d\n", err);
+}
+
+void mprotect_kernel_vm(int w)
+{
+        struct mm_struct *mm;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long addr;
+        
+        mm = &init_mm;
+        for(addr = start_vm; addr < end_vm;){
+                pgd = pgd_offset(mm, addr);
+                pud = pud_offset(pgd, addr);
+                pmd = pmd_offset(pud, addr);
+                if(pmd_present(*pmd)){
+                        pte = pte_offset_kernel(pmd, addr);
+                        if(pte_present(*pte)) protect_vm_page(addr, w, 0);
+                        addr += PAGE_SIZE;
+                }
+                else addr += PMD_SIZE;
+        }
+}
+
+void flush_tlb_kernel_vm_tt(void)
+{
+        flush_tlb_kernel_range(start_vm, end_vm);
+}
+
+void __flush_tlb_one_tt(unsigned long addr)
+{
+        flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
+}
+  
+void flush_tlb_range_tt(struct vm_area_struct *vma, unsigned long start, 
+                     unsigned long end)
+{
+        if(vma->vm_mm != current->mm) return;
+
+        /* Assumes that the range start ... end is entirely within
+         * either process memory or kernel vm
+         */
+        if((start >= start_vm) && (start < end_vm)){
+                if(flush_tlb_kernel_range_common(start, end))
+                        atomic_inc(&vmchange_seq);
+        }
+        else fix_range(vma->vm_mm, start, end, 0);
+}
+
+void flush_tlb_mm_tt(struct mm_struct *mm)
+{
+        unsigned long seq;
+
+        if(mm != current->mm) return;
+
+        fix_range(mm, 0, STACK_TOP, 0);
+
+        seq = atomic_read(&vmchange_seq);
+        if(current->thread.mode.tt.vm_seq == seq)
+                return;
+        current->thread.mode.tt.vm_seq = seq;
+        flush_tlb_kernel_range_common(start_vm, end_vm);
+}
+
+void force_flush_all_tt(void)
+{
+        fix_range(current->mm, 0, STACK_TOP, 1);
+        flush_tlb_kernel_range_common(start_vm, end_vm);
+}
diff --git a/arch/um/kernel/tt/tracer.c b/arch/um/kernel/tt/tracer.c
new file mode 100644
index 000000000000..7b5d937e5955
--- /dev/null
+++ b/arch/um/kernel/tt/tracer.c
@@ -0,0 +1,480 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <sched.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include "user.h"
+#include "sysdep/ptrace.h"
+#include "sigcontext.h"
+#include "sysdep/sigcontext.h"
+#include "os.h"
+#include "signal_user.h"
+#include "user_util.h"
+#include "mem_user.h"
+#include "process.h"
+#include "kern_util.h"
+#include "chan_user.h"
+#include "ptrace_user.h"
+#include "mode.h"
+#include "tt.h"
+
+static int tracer_winch[2];
+
+int is_tracer_winch(int pid, int fd, void *data)
+{
+        if(pid != tracing_pid)
+                return(0);
+
+        register_winch_irq(tracer_winch[0], fd, -1, data);
+        return(1);
+}
+
+static void tracer_winch_handler(int sig)
+{
+        int n;
+        char c = 1;
+
+        n = os_write_file(tracer_winch[1], &c, sizeof(c));
+        if(n != sizeof(c))
+                printk("tracer_winch_handler - write failed, err = %d\n", -n);
+}
+
+/* Called only by the tracing thread during initialization */
+
+static void setup_tracer_winch(void)
+{
+        int err;
+
+        err = os_pipe(tracer_winch, 1, 1);
+        if(err < 0){
+                printk("setup_tracer_winch : os_pipe failed, err = %d\n", -err);
+                return;
+        }
+        signal(SIGWINCH, tracer_winch_handler);
+}
+
+void attach_process(int pid)
+{
+        if((ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) ||
+           (ptrace(PTRACE_CONT, pid, 0, 0) < 0))
+                tracer_panic("OP_FORK failed to attach pid");
+        wait_for_stop(pid, SIGSTOP, PTRACE_CONT, NULL);
+        if (ptrace(PTRACE_OLDSETOPTIONS, pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0)
+                tracer_panic("OP_FORK: PTRACE_SETOPTIONS failed, errno = %d", errno);
+        if(ptrace(PTRACE_CONT, pid, 0, 0) < 0)
+                tracer_panic("OP_FORK failed to continue process");
+}
+
+void tracer_panic(char *format, ...)
+{
+        va_list ap;
+
+        va_start(ap, format);
+        vprintf(format, ap);
+        va_end(ap);
+        printf("\n");
+        while(1) pause();
+}
+
+static void tracer_segv(int sig, struct sigcontext sc)
+{
+        printf("Tracing thread segfault at address 0x%lx, ip 0x%lx\n",
+               SC_FAULT_ADDR(&sc), SC_IP(&sc));
+        while(1)
+                pause();
+}
+
+/* Changed early in boot, and then only read */
+int debug = 0;
+int debug_stop = 1;
+int debug_parent = 0;
+int honeypot = 0;
+
+static int signal_tramp(void *arg)
+{
+        int (*proc)(void *);
+
+        if(honeypot && munmap((void *) (host_task_size - 0x10000000),
+                              0x10000000)) 
+                panic("Unmapping stack failed");
+        if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
+                panic("ptrace PTRACE_TRACEME failed");
+        os_stop_process(os_getpid());
+        change_sig(SIGWINCH, 0);
+        signal(SIGUSR1, SIG_IGN);
+        change_sig(SIGCHLD, 0);
+        signal(SIGSEGV, (__sighandler_t) sig_handler);
+        set_cmdline("(idle thread)");
+        set_init_pid(os_getpid());
+        proc = arg;
+        return((*proc)(NULL));
+}
+
+static void sleeping_process_signal(int pid, int sig)
+{
+        switch(sig){
+        /* These two result from UML being ^Z-ed and bg-ed.  PTRACE_CONT is
+         * right because the process must be in the kernel already.
+         */
+        case SIGCONT:
+        case SIGTSTP:
+                if(ptrace(PTRACE_CONT, pid, 0, sig) < 0)
+                        tracer_panic("sleeping_process_signal : Failed to "
+                                     "continue pid %d, signal = %d, "
+                                     "errno = %d\n", pid, sig, errno);
+                break;
+
+        /* This happens when the debugger (e.g. strace) is doing system call 
+         * tracing on the kernel.  During a context switch, the current task
+         * will be set to the incoming process and the outgoing process will
+         * hop into write and then read.  Since it's not the current process
+         * any more, the trace of those will land here.  So, we need to just 
+         * PTRACE_SYSCALL it.
+         */
+        case (SIGTRAP + 0x80):
+                if(ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)
+                        tracer_panic("sleeping_process_signal : Failed to "
+                                     "PTRACE_SYSCALL pid %d, errno = %d\n",
+                                     pid, errno);
+                break;
+        case SIGSTOP:
+                break;
+        default:
+                tracer_panic("sleeping process %d got unexpected "
+                             "signal : %d\n", pid, sig);
+                break;
+        }
+}
+
+/* Accessed only by the tracing thread */
+int debugger_pid = -1;
+int debugger_parent = -1;
+int debugger_fd = -1;
+int gdb_pid = -1;
+
+struct {
+        int pid;
+        int signal;
+        unsigned long addr;
+        struct timeval time;
+} signal_record[1024][32];
+
+int signal_index[32];
+int nsignals = 0;
+int debug_trace = 0;
+extern int io_nsignals, io_count, intr_count;
+
+extern void signal_usr1(int sig);
+
+int tracing_pid = -1;
+
+int tracer(int (*init_proc)(void *), void *sp)
+{
+        void *task = NULL;
+        int status, pid = 0, sig = 0, cont_type, tracing = 0, op = 0;
+        int proc_id = 0, n, err, old_tracing = 0, strace = 0;
+        int local_using_sysemu = 0;
+#ifdef UML_CONFIG_SYSCALL_DEBUG
+        unsigned long eip = 0;
+        int last_index;
+#endif
+        signal(SIGPIPE, SIG_IGN);
+        setup_tracer_winch();
+        tracing_pid = os_getpid();
+        printf("tracing thread pid = %d\n", tracing_pid);
+
+        pid = clone(signal_tramp, sp, CLONE_FILES | SIGCHLD, init_proc);
+        CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+        if(n < 0){
+                printf("waitpid on idle thread failed, errno = %d\n", errno);
+                exit(1);
+        }
+        if (ptrace(PTRACE_OLDSETOPTIONS, pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0) {
+                printf("Failed to PTRACE_SETOPTIONS for idle thread, errno = %d\n", errno);
+                exit(1);
+        }
+        if((ptrace(PTRACE_CONT, pid, 0, 0) < 0)){
+                printf("Failed to continue idle thread, errno = %d\n", errno);
+                exit(1);
+        }
+
+        signal(SIGSEGV, (sighandler_t) tracer_segv);
+        signal(SIGUSR1, signal_usr1);
+        if(debug_trace){
+                printf("Tracing thread pausing to be attached\n");
+                stop();
+        }
+        if(debug){
+                if(gdb_pid != -1) 
+                        debugger_pid = attach_debugger(pid, gdb_pid, 1);
+                else debugger_pid = init_ptrace_proxy(pid, 1, debug_stop);
+                if(debug_parent){
+                        debugger_parent = os_process_parent(debugger_pid);
+                        init_parent_proxy(debugger_parent);
+                        err = attach(debugger_parent);
+                        if(err){
+                                printf("Failed to attach debugger parent %d, "
+                                       "errno = %d\n", debugger_parent, -err);
+                                debugger_parent = -1;
+                        }
+                        else {
+                                if(ptrace(PTRACE_SYSCALL, debugger_parent, 
+                                          0, 0) < 0){
+                                        printf("Failed to continue debugger "
+                                               "parent, errno = %d\n", errno);
+                                        debugger_parent = -1;
+                                }
+                        }
+                }
+        }
+        set_cmdline("(tracing thread)");
+        while(1){
+                CATCH_EINTR(pid = waitpid(-1, &status, WUNTRACED));
+                if(pid <= 0){
+                        if(errno != ECHILD){
+                                printf("wait failed - errno = %d\n", errno);
+                        }
+                        continue;
+                }
+                if(pid == debugger_pid){
+                        int cont = 0;
+
+                        if(WIFEXITED(status) || WIFSIGNALED(status))
+                                debugger_pid = -1;
+                        /* XXX Figure out how to deal with gdb and SMP */
+                        else cont = debugger_signal(status, cpu_tasks[0].pid);
+                        if(cont == PTRACE_SYSCALL) strace = 1;
+                        continue;
+                }
+                else if(pid == debugger_parent){
+                        debugger_parent_signal(status, pid);
+                        continue;
+                }
+                nsignals++;
+                if(WIFEXITED(status)) ;
+#ifdef notdef
+                {
+                        printf("Child %d exited with status %d\n", pid, 
+                               WEXITSTATUS(status));
+                }
+#endif
+                else if(WIFSIGNALED(status)){
+                        sig = WTERMSIG(status);
+                        if(sig != 9){
+                                printf("Child %d exited with signal %d\n", pid,
+                                       sig);
+                        }
+                }
+                else if(WIFSTOPPED(status)){
+                        proc_id = pid_to_processor_id(pid);
+                        sig = WSTOPSIG(status);
+#ifdef UML_CONFIG_SYSCALL_DEBUG
+                        if(signal_index[proc_id] == 1024){
+                                signal_index[proc_id] = 0;
+                                last_index = 1023;
+                        }
+                        else last_index = signal_index[proc_id] - 1;
+                        if(((sig == SIGPROF) || (sig == SIGVTALRM) ||
+                            (sig == SIGALRM)) &&
+                           (signal_record[proc_id][last_index].signal == sig)&&
+                           (signal_record[proc_id][last_index].pid == pid))
+                                signal_index[proc_id] = last_index;
+                        signal_record[proc_id][signal_index[proc_id]].pid = pid;
+                        gettimeofday(&signal_record[proc_id][signal_index[proc_id]].time, NULL);
+                        eip = ptrace(PTRACE_PEEKUSR, pid, PT_IP_OFFSET, 0);
+                        signal_record[proc_id][signal_index[proc_id]].addr = eip;
+                        signal_record[proc_id][signal_index[proc_id]++].signal = sig;
+#endif
+                        if(proc_id == -1){
+                                sleeping_process_signal(pid, sig);
+                                continue;
+                        }
+
+                        task = cpu_tasks[proc_id].task;
+                        tracing = is_tracing(task);
+                        old_tracing = tracing;
+
+                        /* Assume: no syscall, when coming from user */
+                        if ( tracing )
+                                do_sigtrap(task);
+
+                        switch(sig){
+                        case SIGUSR1:
+                                sig = 0;
+                                op = do_proc_op(task, proc_id);
+                                switch(op){
+                                /*
+                                 * This is called when entering user mode; after
+                                 * this, we start intercepting syscalls.
+                                 *
+                                 * In fact, a process is started in kernel mode,
+                                 * so with is_tracing() == 0 (and that is reset
+                                 * when executing syscalls, since UML kernel has
+                                 * the right to do syscalls);
+                                 */
+                                case OP_TRACE_ON:
+                                        arch_leave_kernel(task, pid);
+                                        tracing = 1;
+                                        break;
+                                case OP_REBOOT:
+                                case OP_HALT:
+                                        unmap_physmem();
+                                        kmalloc_ok = 0;
+                                        os_kill_ptraced_process(pid, 0);
+                                        /* Now let's reap remaining zombies */
+                                        errno = 0;
+                                        do {
+                                                waitpid(-1, &status,
+                                                        WUNTRACED);
+                                        } while (errno != ECHILD);
+                                        return(op == OP_REBOOT);
+                                case OP_NONE:
+                                        printf("Detaching pid %d\n", pid);
+                                        detach(pid, SIGSTOP);
+                                        continue;
+                                default:
+                                        break;
+                                }
+                                /* OP_EXEC switches host processes on us,
+                                 * we want to continue the new one.
+                                 */
+                                pid = cpu_tasks[proc_id].pid;
+                                break;
+                        case (SIGTRAP + 0x80):
+                                if(!tracing && (debugger_pid != -1)){
+                                        child_signal(pid, status & 0x7fff);
+                                        continue;
+                                }
+                                tracing = 0;
+                                /* local_using_sysemu has been already set
+                                 * below, since if we are here, is_tracing() on
+                                 * the traced task was 1, i.e. the process had
+                                 * already run through one iteration of the
+                                 * loop which executed a OP_TRACE_ON request.*/
+                                do_syscall(task, pid, local_using_sysemu);
+                                sig = SIGUSR2;
+                                break;
+                        case SIGTRAP:
+                                if(!tracing && (debugger_pid != -1)){
+                                        child_signal(pid, status);
+                                        continue;
+                                }
+                                tracing = 0;
+                                break;
+                        case SIGPROF:
+                                if(tracing) sig = 0;
+                                break;
+                        case SIGCHLD:
+                        case SIGHUP:
+                                sig = 0;
+                                break;
+                        case SIGSEGV:
+                        case SIGIO:
+                        case SIGALRM:
+                        case SIGVTALRM:
+                        case SIGFPE:
+                        case SIGBUS:
+                        case SIGILL:
+                        case SIGWINCH:
+
+                        default:
+                                tracing = 0;
+                                break;
+                        }
+                        set_tracing(task, tracing);
+
+                        if(!tracing && old_tracing)
+                                arch_enter_kernel(task, pid);
+
+                        if(!tracing && (debugger_pid != -1) && (sig != 0) &&
+                                (sig != SIGALRM) && (sig != SIGVTALRM) &&
+                                (sig != SIGSEGV) && (sig != SIGTRAP) &&
+                                (sig != SIGUSR2) && (sig != SIGIO) &&
+                                (sig != SIGFPE)){
+                                child_signal(pid, status);
+                                continue;
+                        }
+
+                        local_using_sysemu = get_using_sysemu();
+
+                        if(tracing)
+                                cont_type = SELECT_PTRACE_OPERATION(local_using_sysemu,
+                                                                    singlestepping(task));
+                        else if((debugger_pid != -1) && strace)
+                                cont_type = PTRACE_SYSCALL;
+                        else
+                                cont_type = PTRACE_CONT;
+
+                        if(ptrace(cont_type, pid, 0, sig) != 0){
+                                tracer_panic("ptrace failed to continue "
+                                             "process - errno = %d\n", 
+                                             errno);
+                        }
+                }
+        }
+        return(0);
+}
+
+static int __init uml_debug_setup(char *line, int *add)
+{
+        char *next;
+
+        debug = 1;
+        *add = 0;
+        if(*line != '=') return(0);
+        line++;
+
+        while(line != NULL){
+                next = strchr(line, ',');
+                if(next) *next++ = '\0';
+                
+                if(!strcmp(line, "go")) debug_stop = 0;
+                else if(!strcmp(line, "parent")) debug_parent = 1;
+                else printf("Unknown debug option : '%s'\n", line);
+
+                line = next;
+        }
+        return(0);
+}
+
+__uml_setup("debug", uml_debug_setup,
+"debug\n"
+"    Starts up the kernel under the control of gdb. See the \n"
+"    kernel debugging tutorial and the debugging session pages\n"
+"    at http://user-mode-linux.sourceforge.net/ for more information.\n\n"
+);
+
+static int __init uml_debugtrace_setup(char *line, int *add)
+{
+        debug_trace = 1;
+        return 0;
+}
+__uml_setup("debugtrace", uml_debugtrace_setup,
+"debugtrace\n"
+"    Causes the tracing thread to pause until it is attached by a\n"
+"    debugger and continued.  This is mostly for debugging crashes\n"
+"    early during boot, and should be pretty much obsoleted by\n"
+"    the debug switch.\n\n"
+);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/trap_user.c b/arch/um/kernel/tt/trap_user.c
new file mode 100644
index 000000000000..92a3820ca543
--- /dev/null
+++ b/arch/um/kernel/tt/trap_user.c
@@ -0,0 +1,60 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <signal.h>
+#include "sysdep/ptrace.h"
+#include "signal_user.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "task.h"
+#include "tt.h"
+
+void sig_handler_common_tt(int sig, void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        struct tt_regs save_regs, *r;
+        struct signal_info *info;
+        int save_errno = errno, is_user;
+
+        /* This is done because to allow SIGSEGV to be delivered inside a SEGV
+         * handler.  This can happen in copy_user, and if SEGV is disabled,
+         * the process will die.
+         */
+        if(sig == SIGSEGV)
+                change_sig(SIGSEGV, 1);
+
+        r = &TASK_REGS(get_current())->tt;
+        save_regs = *r;
+        is_user = user_context(SC_SP(sc));
+        r->sc = sc;
+        if(sig != SIGUSR2) 
+                r->syscall = -1;
+
+        info = &sig_info[sig];
+        if(!info->is_irq) unblock_signals();
+
+        (*info->handler)(sig, (union uml_pt_regs *) r);
+
+        if(is_user){
+                interrupt_end();
+                block_signals();
+                set_user_mode(NULL);
+        }
+        *r = save_regs;
+        errno = save_errno;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/uaccess.c b/arch/um/kernel/tt/uaccess.c
new file mode 100644
index 000000000000..a72aa632972f
--- /dev/null
+++ b/arch/um/kernel/tt/uaccess.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "asm/uaccess.h"
+
+int copy_from_user_tt(void *to, const void __user *from, int n)
+{
+        if(!access_ok_tt(VERIFY_READ, from, n))
+                return(n);
+
+        return(__do_copy_from_user(to, from, n, &current->thread.fault_addr,
+                                   &current->thread.fault_catcher));
+}
+
+int copy_to_user_tt(void __user *to, const void *from, int n)
+{
+        if(!access_ok_tt(VERIFY_WRITE, to, n))
+                return(n);
+
+        return(__do_copy_to_user(to, from, n, &current->thread.fault_addr,
+                                 &current->thread.fault_catcher));
+}
+
+int strncpy_from_user_tt(char *dst, const char __user *src, int count)
+{
+        int n;
+
+        if(!access_ok_tt(VERIFY_READ, src, 1))
+                return(-EFAULT);
+
+        n = __do_strncpy_from_user(dst, src, count,
+                                   &current->thread.fault_addr,
+                                   &current->thread.fault_catcher);
+        if(n < 0) return(-EFAULT);
+        return(n);
+}
+
+int __clear_user_tt(void __user *mem, int len)
+{
+        return(__do_clear_user(mem, len,
+                               &current->thread.fault_addr,
+                               &current->thread.fault_catcher));
+}
+
+int clear_user_tt(void __user *mem, int len)
+{
+        if(!access_ok_tt(VERIFY_WRITE, mem, len))
+                return(len);
+
+        return(__do_clear_user(mem, len, &current->thread.fault_addr,
+                               &current->thread.fault_catcher));
+}
+
+int strnlen_user_tt(const void __user *str, int len)
+{
+        return(__do_strnlen_user(str, len,
+                                 &current->thread.fault_addr,
+                                 &current->thread.fault_catcher));
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/uaccess_user.c b/arch/um/kernel/tt/uaccess_user.c
new file mode 100644
index 000000000000..f01475512ecb
--- /dev/null
+++ b/arch/um/kernel/tt/uaccess_user.c
@@ -0,0 +1,98 @@
+/* 
+ * Copyright (C) 2001 Chris Emerson (cemerson@chiark.greenend.org.uk)
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <setjmp.h>
+#include <string.h>
+#include "user_util.h"
+#include "uml_uaccess.h"
+#include "task.h"
+#include "kern_util.h"
+
+int __do_copy_from_user(void *to, const void *from, int n,
+                        void **fault_addr, void **fault_catcher)
+{
+        struct tt_regs save = TASK_REGS(get_current())->tt;
+        unsigned long fault;
+        int faulted;
+
+        fault = __do_user_copy(to, from, n, fault_addr, fault_catcher,
+                               __do_copy, &faulted);
+        TASK_REGS(get_current())->tt = save;
+
+        if(!faulted) return(0);
+        else return(n - (fault - (unsigned long) from));
+}
+
+static void __do_strncpy(void *dst, const void *src, int count)
+{
+        strncpy(dst, src, count);
+}       
+
+int __do_strncpy_from_user(char *dst, const char *src, unsigned long count,
+                           void **fault_addr, void **fault_catcher)
+{
+        struct tt_regs save = TASK_REGS(get_current())->tt;
+        unsigned long fault;
+        int faulted;
+
+        fault = __do_user_copy(dst, src, count, fault_addr, fault_catcher,
+                               __do_strncpy, &faulted);
+        TASK_REGS(get_current())->tt = save;
+
+        if(!faulted) return(strlen(dst));
+        else return(-1);
+}
+
+static void __do_clear(void *to, const void *from, int n)
+{
+        memset(to, 0, n);
+}       
+
+int __do_clear_user(void *mem, unsigned long len,
+                    void **fault_addr, void **fault_catcher)
+{
+        struct tt_regs save = TASK_REGS(get_current())->tt;
+        unsigned long fault;
+        int faulted;
+
+        fault = __do_user_copy(mem, NULL, len, fault_addr, fault_catcher,
+                               __do_clear, &faulted);
+        TASK_REGS(get_current())->tt = save;
+
+        if(!faulted) return(0);
+        else return(len - (fault - (unsigned long) mem));
+}
+
+int __do_strnlen_user(const char *str, unsigned long n,
+                      void **fault_addr, void **fault_catcher)
+{
+        struct tt_regs save = TASK_REGS(get_current())->tt;
+        int ret;
+        unsigned long *faddrp = (unsigned long *)fault_addr;
+        sigjmp_buf jbuf;
+
+        *fault_catcher = &jbuf;
+        if(sigsetjmp(jbuf, 1) == 0)
+                ret = strlen(str) + 1;
+        else ret = *faddrp - (unsigned long) str;
+
+        *fault_addr = NULL;
+        *fault_catcher = NULL;
+
+        TASK_REGS(get_current())->tt = save;
+        return ret;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tt/unmap.c b/arch/um/kernel/tt/unmap.c
new file mode 100644
index 000000000000..3f7aecdbe532
--- /dev/null
+++ b/arch/um/kernel/tt/unmap.c
@@ -0,0 +1,31 @@
+/* 
+ * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <sys/mman.h>
+
+int switcheroo(int fd, int prot, void *from, void *to, int size)
+{
+        if(munmap(to, size) < 0){
+                return(-1);
+        }
+        if(mmap(to, size, prot, MAP_SHARED | MAP_FIXED, fd, 0) != to){
+                return(-1);
+        }
+        if(munmap(from, size) < 0){
+                return(-1);
+        }
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/tty_log.c b/arch/um/kernel/tty_log.c
new file mode 100644
index 000000000000..9ada656f68ce
--- /dev/null
+++ b/arch/um/kernel/tty_log.c
@@ -0,0 +1,230 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and 
+ * geoffrey hing <ghing@net.ohio-state.edu>
+ * Licensed under the GPL
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include "init.h"
+#include "user.h"
+#include "kern_util.h"
+#include "os.h"
+
+#define TTY_LOG_DIR "./"
+
+/* Set early in boot and then unchanged */
+static char *tty_log_dir = TTY_LOG_DIR;
+static int tty_log_fd = -1;
+
+#define TTY_LOG_OPEN 1
+#define TTY_LOG_CLOSE 2
+#define TTY_LOG_WRITE 3
+#define TTY_LOG_EXEC 4
+
+#define TTY_READ 1
+#define TTY_WRITE 2
+
+struct tty_log_buf {
+        int what;
+        unsigned long tty;
+        int len;
+        int direction;
+        unsigned long sec;
+        unsigned long usec;
+};
+
+int open_tty_log(void *tty, void *current_tty)
+{
+        struct timeval tv;
+        struct tty_log_buf data;
+        char buf[strlen(tty_log_dir) + sizeof("01234567890-01234567\0")];
+        int fd;
+
+        gettimeofday(&tv, NULL);
+        if(tty_log_fd != -1){
+                data = ((struct tty_log_buf) { .what    = TTY_LOG_OPEN,
+                                               .tty  = (unsigned long) tty,
+                                               .len  = sizeof(current_tty),
+                                               .direction = 0,
+                                               .sec = tv.tv_sec,
+                                               .usec = tv.tv_usec } );
+                os_write_file(tty_log_fd, &data, sizeof(data));
+                os_write_file(tty_log_fd, &current_tty, data.len);
+                return(tty_log_fd);
+        }
+
+        sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec, 
+                (unsigned int) tv.tv_usec);
+
+        fd = os_open_file(buf, of_append(of_create(of_rdwr(OPENFLAGS()))),
+                          0644);
+        if(fd < 0){
+                printk("open_tty_log : couldn't open '%s', errno = %d\n",
+                       buf, -fd);
+        }
+        return(fd);
+}
+
+void close_tty_log(int fd, void *tty)
+{
+        struct tty_log_buf data;
+        struct timeval tv;
+
+        if(tty_log_fd != -1){
+                gettimeofday(&tv, NULL);
+                data = ((struct tty_log_buf) { .what    = TTY_LOG_CLOSE,
+                                               .tty  = (unsigned long) tty,
+                                               .len  = 0,
+                                               .direction = 0,
+                                               .sec = tv.tv_sec,
+                                               .usec = tv.tv_usec } );
+                os_write_file(tty_log_fd, &data, sizeof(data));
+                return;
+        }
+        os_close_file(fd);
+}
+
+static int log_chunk(int fd, const char *buf, int len)
+{
+        int total = 0, try, missed, n;
+        char chunk[64];
+
+        while(len > 0){
+                try = (len > sizeof(chunk)) ? sizeof(chunk) : len;
+                missed = copy_from_user_proc(chunk, (char *) buf, try);
+                try -= missed;
+                n = os_write_file(fd, chunk, try);
+                if(n != try) {
+                        if(n < 0)
+                                return(n);
+                        return(-EIO);
+                }
+                if(missed != 0)
+                        return(-EFAULT);
+
+                len -= try;
+                total += try;
+                buf += try;
+        }
+
+        return(total);
+}
+
+int write_tty_log(int fd, const char *buf, int len, void *tty, int is_read)
+{
+        struct timeval tv;
+        struct tty_log_buf data;
+        int direction;
+
+        if(fd == tty_log_fd){
+                gettimeofday(&tv, NULL);
+                direction = is_read ? TTY_READ : TTY_WRITE;
+                data = ((struct tty_log_buf) { .what    = TTY_LOG_WRITE,
+                                               .tty  = (unsigned long) tty,
+                                               .len  = len,
+                                               .direction = direction,
+                                               .sec = tv.tv_sec,
+                                               .usec = tv.tv_usec } );
+                os_write_file(tty_log_fd, &data, sizeof(data));
+        }
+
+        return(log_chunk(fd, buf, len));
+}
+
+void log_exec(char **argv, void *tty)
+{
+        struct timeval tv;
+        struct tty_log_buf data;
+        char **ptr,*arg;
+        int len;
+
+        if(tty_log_fd == -1) return;
+
+        gettimeofday(&tv, NULL);
+
+        len = 0;
+        for(ptr = argv; ; ptr++){
+                if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
+                        return;
+                if(arg == NULL) break;
+                len += strlen_user_proc(arg);
+        }
+
+        data = ((struct tty_log_buf) { .what    = TTY_LOG_EXEC,
+                                       .tty  = (unsigned long) tty,
+                                       .len  = len,
+                                       .direction = 0,
+                                       .sec = tv.tv_sec,
+                                       .usec = tv.tv_usec } );
+        os_write_file(tty_log_fd, &data, sizeof(data));
+
+        for(ptr = argv; ; ptr++){
+                if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
+                        return;
+                if(arg == NULL) break;
+                log_chunk(tty_log_fd, arg, strlen_user_proc(arg));
+        }
+}
+
+extern void register_tty_logger(int (*opener)(void *, void *),
+                                int (*writer)(int, const char *, int,
+                                              void *, int),
+                                void (*closer)(int, void *));
+
+static int register_logger(void)
+{
+        register_tty_logger(open_tty_log, write_tty_log, close_tty_log);
+        return(0);
+}
+
+__uml_initcall(register_logger);
+
+static int __init set_tty_log_dir(char *name, int *add)
+{
+        tty_log_dir = name;
+        return 0;
+}
+
+__uml_setup("tty_log_dir=", set_tty_log_dir,
+"tty_log_dir=<directory>\n"
+"    This is used to specify the directory where the logs of all pty\n"
+"    data from this UML machine will be written.\n\n"
+);
+
+static int __init set_tty_log_fd(char *name, int *add)
+{
+        char *end;
+
+        tty_log_fd = strtoul(name, &end, 0);
+        if((*end != '\0') || (end == name)){
+                printf("set_tty_log_fd - strtoul failed on '%s'\n", name);
+                tty_log_fd = -1;
+        }
+
+        *add = 0;
+        return 0;
+}
+
+__uml_setup("tty_log_fd=", set_tty_log_fd,
+"tty_log_fd=<fd>\n"
+"    This is used to specify a preconfigured file descriptor to which all\n"
+"    tty data will be written.  Preconfigure the descriptor with something\n"
+"    like '10>tty_log tty_log_fd=10'.\n\n"
+);
+
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/uaccess_user.c b/arch/um/kernel/uaccess_user.c
new file mode 100644
index 000000000000..d035257ed0af
--- /dev/null
+++ b/arch/um/kernel/uaccess_user.c
@@ -0,0 +1,64 @@
+/* 
+ * Copyright (C) 2001 Chris Emerson (cemerson@chiark.greenend.org.uk)
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <setjmp.h>
+#include <string.h>
+
+/* These are here rather than tt/uaccess.c because skas mode needs them in
+ * order to do SIGBUS recovery when a tmpfs mount runs out of room.
+ */
+
+unsigned long __do_user_copy(void *to, const void *from, int n,
+                             void **fault_addr, void **fault_catcher,
+                             void (*op)(void *to, const void *from,
+                                        int n), int *faulted_out)
+{
+        unsigned long *faddrp = (unsigned long *) fault_addr, ret;
+
+        sigjmp_buf jbuf;
+        *fault_catcher = &jbuf;
+        if(sigsetjmp(jbuf, 1) == 0){
+                (*op)(to, from, n);
+                ret = 0;
+                *faulted_out = 0;
+        } 
+        else {
+                ret = *faddrp;
+                *faulted_out = 1;
+        }
+        *fault_addr = NULL;
+        *fault_catcher = NULL;
+        return ret;
+}
+
+void __do_copy(void *to, const void *from, int n)
+{
+        memcpy(to, from, n);
+}       
+
+
+int __do_copy_to_user(void *to, const void *from, int n,
+                      void **fault_addr, void **fault_catcher)
+{
+        unsigned long fault;
+        int faulted;
+
+        fault = __do_user_copy(to, from, n, fault_addr, fault_catcher,
+                               __do_copy, &faulted);
+        if(!faulted) return(0);
+        else return(n - (fault - (unsigned long) to));
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/kernel/um_arch.c b/arch/um/kernel/um_arch.c
new file mode 100644
index 000000000000..5c49d88eed3d
--- /dev/null
+++ b/arch/um/kernel/um_arch.c
@@ -0,0 +1,467 @@
+/* 
+ * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/kernel.h"
+#include "linux/sched.h"
+#include "linux/notifier.h"
+#include "linux/mm.h"
+#include "linux/types.h"
+#include "linux/tty.h"
+#include "linux/init.h"
+#include "linux/bootmem.h"
+#include "linux/spinlock.h"
+#include "linux/utsname.h"
+#include "linux/sysrq.h"
+#include "linux/seq_file.h"
+#include "linux/delay.h"
+#include "linux/module.h"
+#include "asm/page.h"
+#include "asm/pgtable.h"
+#include "asm/ptrace.h"
+#include "asm/elf.h"
+#include "asm/user.h"
+#include "ubd_user.h"
+#include "asm/current.h"
+#include "asm/setup.h"
+#include "user_util.h"
+#include "kern_util.h"
+#include "kern.h"
+#include "mem_user.h"
+#include "mem.h"
+#include "umid.h"
+#include "initrd.h"
+#include "init.h"
+#include "os.h"
+#include "choose-mode.h"
+#include "mode_kern.h"
+#include "mode.h"
+
+#define DEFAULT_COMMAND_LINE "root=98:0"
+
+/* Changed in linux_main and setup_arch, which run before SMP is started */
+char command_line[COMMAND_LINE_SIZE] = { 0 };
+
+void add_arg(char *arg)
+{
+        if (strlen(command_line) + strlen(arg) + 1 > COMMAND_LINE_SIZE) {
+                printf("add_arg: Too many command line arguments!\n");
+                exit(1);
+        }
+        if(strlen(command_line) > 0)
+                strcat(command_line, " ");
+        strcat(command_line, arg);
+}
+
+struct cpuinfo_um boot_cpu_data = { 
+        .loops_per_jiffy        = 0,
+        .ipi_pipe               = { -1, -1 }
+};
+
+unsigned long thread_saved_pc(struct task_struct *task)
+{
+        return(os_process_pc(CHOOSE_MODE_PROC(thread_pid_tt, thread_pid_skas,
+                                              task)));
+}
+
+static int show_cpuinfo(struct seq_file *m, void *v)
+{
+        int index = 0;
+
+#ifdef CONFIG_SMP
+        index = (struct cpuinfo_um *) v - cpu_data;
+        if (!cpu_online(index))
+                return 0;
+#endif
+
+        seq_printf(m, "processor\t: %d\n", index);
+        seq_printf(m, "vendor_id\t: User Mode Linux\n");
+        seq_printf(m, "model name\t: UML\n");
+        seq_printf(m, "mode\t\t: %s\n", CHOOSE_MODE("tt", "skas"));
+        seq_printf(m, "host\t\t: %s\n", host_info);
+        seq_printf(m, "bogomips\t: %lu.%02lu\n\n",
+                   loops_per_jiffy/(500000/HZ),
+                   (loops_per_jiffy/(5000/HZ)) % 100);
+
+        return(0);
+}
+
+static void *c_start(struct seq_file *m, loff_t *pos)
+{
+        return *pos < NR_CPUS ? cpu_data + *pos : NULL;
+}
+
+static void *c_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        ++*pos;
+        return c_start(m, pos);
+}
+
+static void c_stop(struct seq_file *m, void *v)
+{
+}
+
+struct seq_operations cpuinfo_op = {
+        .start  = c_start,
+        .next   = c_next,
+        .stop   = c_stop,
+        .show   = show_cpuinfo,
+};
+
+pte_t * __bad_pagetable(void)
+{
+        panic("Someone should implement __bad_pagetable");
+        return(NULL);
+}
+
+/* Set in linux_main */
+unsigned long host_task_size;
+unsigned long task_size;
+
+unsigned long uml_start;
+
+/* Set in early boot */
+unsigned long uml_physmem;
+unsigned long uml_reserved;
+unsigned long start_vm;
+unsigned long end_vm;
+int ncpus = 1;
+
+#ifdef CONFIG_MODE_TT
+/* Pointer set in linux_main, the array itself is private to each thread,
+ * and changed at address space creation time so this poses no concurrency
+ * problems.
+ */
+static char *argv1_begin = NULL;
+static char *argv1_end = NULL;
+#endif
+
+/* Set in early boot */
+static int have_root __initdata = 0;
+long physmem_size = 32 * 1024 * 1024;
+
+void set_cmdline(char *cmd)
+{
+#ifdef CONFIG_MODE_TT
+        char *umid, *ptr;
+
+        if(CHOOSE_MODE(honeypot, 0)) return;
+
+        umid = get_umid(1);
+        if(umid != NULL){
+                snprintf(argv1_begin, 
+                         (argv1_end - argv1_begin) * sizeof(*ptr), 
+                         "(%s) ", umid);
+                ptr = &argv1_begin[strlen(argv1_begin)];
+        }
+        else ptr = argv1_begin;
+
+        snprintf(ptr, (argv1_end - ptr) * sizeof(*ptr), "[%s]", cmd);
+        memset(argv1_begin + strlen(argv1_begin), '\0', 
+               argv1_end - argv1_begin - strlen(argv1_begin));
+#endif
+}
+
+static char *usage_string = 
+"User Mode Linux v%s\n"
+"       available at http://user-mode-linux.sourceforge.net/\n\n";
+
+static int __init uml_version_setup(char *line, int *add)
+{
+        printf("%s\n", system_utsname.release);
+        exit(0);
+
+        return 0;
+}
+
+__uml_setup("--version", uml_version_setup,
+"--version\n"
+"    Prints the version number of the kernel.\n\n"
+);
+
+static int __init uml_root_setup(char *line, int *add)
+{
+        have_root = 1;
+        return 0;
+}
+
+__uml_setup("root=", uml_root_setup,
+"root=<file containing the root fs>\n"
+"    This is actually used by the generic kernel in exactly the same\n"
+"    way as in any other kernel. If you configure a number of block\n"
+"    devices and want to boot off something other than ubd0, you \n"
+"    would use something like:\n"
+"        root=/dev/ubd5\n\n"
+);
+
+#ifdef CONFIG_SMP
+static int __init uml_ncpus_setup(char *line, int *add)
+{
+       if (!sscanf(line, "%d", &ncpus)) {
+               printf("Couldn't parse [%s]\n", line);
+               return -1;
+       }
+
+       return 0;
+}
+
+__uml_setup("ncpus=", uml_ncpus_setup,
+"ncpus=<# of desired CPUs>\n"
+"    This tells an SMP kernel how many virtual processors to start.\n\n" 
+);
+#endif
+
+static int force_tt = 0;
+
+#if defined(CONFIG_MODE_TT) && defined(CONFIG_MODE_SKAS)
+#define DEFAULT_TT 0
+
+static int __init mode_tt_setup(char *line, int *add)
+{
+        force_tt = 1;
+        return(0);
+}
+
+#else
+#ifdef CONFIG_MODE_SKAS
+
+#define DEFAULT_TT 0
+
+static int __init mode_tt_setup(char *line, int *add)
+{
+        printf("CONFIG_MODE_TT disabled - 'mode=tt' ignored\n");
+        return(0);
+}
+
+#else
+#ifdef CONFIG_MODE_TT
+
+#define DEFAULT_TT 1
+
+static int __init mode_tt_setup(char *line, int *add)
+{
+        printf("CONFIG_MODE_SKAS disabled - 'mode=tt' redundant\n");
+        return(0);
+}
+
+#else
+
+#error Either CONFIG_MODE_TT or CONFIG_MODE_SKAS must be enabled
+
+#endif
+#endif
+#endif
+
+__uml_setup("mode=tt", mode_tt_setup,
+"mode=tt\n"
+"    When both CONFIG_MODE_TT and CONFIG_MODE_SKAS are enabled, this option\n"
+"    forces UML to run in tt (tracing thread) mode.  It is not the default\n"
+"    because it's slower and less secure than skas mode.\n\n"
+);
+
+int mode_tt = DEFAULT_TT;
+
+static int __init Usage(char *line, int *add)
+{
+        const char **p;
+
+        printf(usage_string, system_utsname.release);
+        p = &__uml_help_start;
+        while (p < &__uml_help_end) {
+                printf("%s", *p);
+                p++;
+        }
+        exit(0);
+
+        return 0;
+}
+
+__uml_setup("--help", Usage,
+"--help\n"
+"    Prints this message.\n\n"
+);
+
+static int __init uml_checksetup(char *line, int *add)
+{
+        struct uml_param *p;
+
+        p = &__uml_setup_start;
+        while(p < &__uml_setup_end) {
+                int n;
+
+                n = strlen(p->str);
+                if(!strncmp(line, p->str, n)){
+                        if (p->setup_func(line + n, add)) return 1;
+                }
+                p++;
+        }
+        return 0;
+}
+
+static void __init uml_postsetup(void)
+{
+        initcall_t *p;
+
+        p = &__uml_postsetup_start;
+        while(p < &__uml_postsetup_end){
+                (*p)();
+                p++;
+        }
+        return;
+}
+
+/* Set during early boot */
+unsigned long brk_start;
+unsigned long end_iomem;
+EXPORT_SYMBOL(end_iomem);
+
+#define MIN_VMALLOC (32 * 1024 * 1024)
+
+int linux_main(int argc, char **argv)
+{
+        unsigned long avail, diff;
+        unsigned long virtmem_size, max_physmem;
+        unsigned int i, add;
+
+        for (i = 1; i < argc; i++){
+                if((i == 1) && (argv[i][0] == ' ')) continue;
+                add = 1;
+                uml_checksetup(argv[i], &add);
+                if (add)
+                        add_arg(argv[i]);
+        }
+        if(have_root == 0)
+                add_arg(DEFAULT_COMMAND_LINE);
+
+        mode_tt = force_tt ? 1 : !can_do_skas();
+#ifndef CONFIG_MODE_TT
+        if (mode_tt) {
+                /*Since CONFIG_MODE_TT is #undef'ed, force_tt cannot be 1. So,
+                 * can_do_skas() returned 0, and the message is correct. */
+                printf("Support for TT mode is disabled, and no SKAS support is present on the host.\n");
+                exit(1);
+        }
+#endif
+        uml_start = CHOOSE_MODE_PROC(set_task_sizes_tt, set_task_sizes_skas, 0,
+                                     &host_task_size, &task_size);
+
+        /* Need to check this early because mmapping happens before the
+         * kernel is running.
+         */
+        check_tmpexec();
+
+        brk_start = (unsigned long) sbrk(0);
+        CHOOSE_MODE_PROC(before_mem_tt, before_mem_skas, brk_start);
+        /* Increase physical memory size for exec-shield users
+        so they actually get what they asked for. This should
+        add zero for non-exec shield users */
+
+        diff = UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
+        if(diff > 1024 * 1024){
+                printf("Adding %ld bytes to physical memory to account for "
+                       "exec-shield gap\n", diff);
+                physmem_size += UML_ROUND_UP(brk_start) - UML_ROUND_UP(&_end);
+        }
+
+        uml_physmem = uml_start;
+
+        /* Reserve up to 4M after the current brk */
+        uml_reserved = ROUND_4M(brk_start) + (1 << 22);
+
+        setup_machinename(system_utsname.machine);
+
+#ifdef CONFIG_MODE_TT
+        argv1_begin = argv[1];
+        argv1_end = &argv[1][strlen(argv[1])];
+#endif
+  
+        highmem = 0;
+        iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
+        max_physmem = get_kmem_end() - uml_physmem - iomem_size - MIN_VMALLOC;
+
+        /* Zones have to begin on a 1 << MAX_ORDER page boundary,
+         * so this makes sure that's true for highmem
+         */
+        max_physmem &= ~((1 << (PAGE_SHIFT + MAX_ORDER)) - 1);
+        if(physmem_size + iomem_size > max_physmem){
+                highmem = physmem_size + iomem_size - max_physmem;
+                physmem_size -= highmem;
+#ifndef CONFIG_HIGHMEM
+                highmem = 0;
+                printf("CONFIG_HIGHMEM not enabled - physical memory shrunk "
+                       "to %ld bytes\n", physmem_size);
+#endif
+        }
+
+        high_physmem = uml_physmem + physmem_size;
+        end_iomem = high_physmem + iomem_size;
+        high_memory = (void *) end_iomem;
+
+        start_vm = VMALLOC_START;
+
+        setup_physmem(uml_physmem, uml_reserved, physmem_size, highmem);
+        if(init_maps(physmem_size, iomem_size, highmem)){
+                printf("Failed to allocate mem_map for %ld bytes of physical "
+                       "memory and %ld bytes of highmem\n", physmem_size,
+                       highmem);
+                exit(1);
+        }
+
+        virtmem_size = physmem_size;
+        avail = get_kmem_end() - start_vm;
+        if(physmem_size > avail) virtmem_size = avail;
+        end_vm = start_vm + virtmem_size;
+
+        if(virtmem_size < physmem_size)
+                printf("Kernel virtual memory size shrunk to %ld bytes\n",
+                       virtmem_size);
+
+        uml_postsetup();
+
+        task_protections((unsigned long) &init_thread_info);
+        os_flush_stdout();
+
+        return(CHOOSE_MODE(start_uml_tt(), start_uml_skas()));
+}
+
+extern int uml_exitcode;
+
+static int panic_exit(struct notifier_block *self, unsigned long unused1,
+                      void *unused2)
+{
+        bust_spinlocks(1);
+        show_regs(&(current->thread.regs));
+        bust_spinlocks(0);
+        uml_exitcode = 1;
+        machine_halt();
+        return(0);
+}
+
+static struct notifier_block panic_exit_notifier = {
+        .notifier_call          = panic_exit,
+        .next                   = NULL,
+        .priority               = 0
+};
+
+void __init setup_arch(char **cmdline_p)
+{
+        notifier_chain_register(&panic_notifier_list, &panic_exit_notifier);
+        paging_init();
+        strlcpy(saved_command_line, command_line, COMMAND_LINE_SIZE);
+        *cmdline_p = command_line;
+        setup_hostinfo();
+}
+
+void __init check_bugs(void)
+{
+        arch_check_bugs();
+        check_ptrace();
+        check_sigio();
+        check_devanon();
+}
+
+void apply_alternatives(void *start, void *end)
+{
+}
diff --git a/arch/um/kernel/umid.c b/arch/um/kernel/umid.c
new file mode 100644
index 000000000000..186c28885016
--- /dev/null
+++ b/arch/um/kernel/umid.c
@@ -0,0 +1,325 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include "user.h"
+#include "umid.h"
+#include "init.h"
+#include "os.h"
+#include "user_util.h"
+#include "choose-mode.h"
+
+#define UMID_LEN 64
+#define UML_DIR "~/.uml/"
+
+/* Changed by set_umid and make_umid, which are run early in boot */
+static char umid[UMID_LEN] = { 0 };
+
+/* Changed by set_uml_dir and make_uml_dir, which are run early in boot */
+static char *uml_dir = UML_DIR;
+
+/* Changed by set_umid */
+static int umid_is_random = 1;
+static int umid_inited = 0;
+
+static int make_umid(int (*printer)(const char *fmt, ...));
+
+static int __init set_umid(char *name, int is_random,
+                           int (*printer)(const char *fmt, ...))
+{
+        if(umid_inited){
+                (*printer)("Unique machine name can't be set twice\n");
+                return(-1);
+        }
+
+        if(strlen(name) > UMID_LEN - 1)
+                (*printer)("Unique machine name is being truncated to %d "
+                           "characters\n", UMID_LEN);
+        strlcpy(umid, name, sizeof(umid));
+
+        umid_is_random = is_random;
+        umid_inited = 1;
+        return 0;
+}
+
+static int __init set_umid_arg(char *name, int *add)
+{
+        *add = 0;
+        return(set_umid(name, 0, printf));
+}
+
+__uml_setup("umid=", set_umid_arg,
+"umid=<name>\n"
+"    This is used to assign a unique identity to this UML machine and\n"
+"    is used for naming the pid file and management console socket.\n\n"
+);
+
+int __init umid_file_name(char *name, char *buf, int len)
+{
+        int n;
+
+        if(!umid_inited && make_umid(printk)) return(-1);
+
+        n = strlen(uml_dir) + strlen(umid) + strlen(name) + 1;
+        if(n > len){
+                printk("umid_file_name : buffer too short\n");
+                return(-1);
+        }
+
+        sprintf(buf, "%s%s/%s", uml_dir, umid, name);
+        return(0);
+}
+
+extern int tracing_pid;
+
+static int __init create_pid_file(void)
+{
+        char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
+        char pid[sizeof("nnnnn\0")];
+        int fd, n;
+
+        if(umid_file_name("pid", file, sizeof(file))) return 0;
+
+        fd = os_open_file(file, of_create(of_excl(of_rdwr(OPENFLAGS()))), 
+                          0644);
+        if(fd < 0){
+                printf("Open of machine pid file \"%s\" failed: %s\n",
+                       file, strerror(-fd));
+                return 0;
+        }
+
+        sprintf(pid, "%d\n", os_getpid());
+        n = os_write_file(fd, pid, strlen(pid));
+        if(n != strlen(pid))
+                printf("Write of pid file failed - err = %d\n", -n);
+        os_close_file(fd);
+        return 0;
+}
+
+static int actually_do_remove(char *dir)
+{
+        DIR *directory;
+        struct dirent *ent;
+        int len;
+        char file[256];
+
+        directory = opendir(dir);
+        if(directory == NULL){
+                printk("actually_do_remove : couldn't open directory '%s', "
+                       "errno = %d\n", dir, errno);
+                return(1);
+        }
+        while((ent = readdir(directory)) != NULL){
+                if(!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, ".."))
+                        continue;
+                len = strlen(dir) + sizeof("/") + strlen(ent->d_name) + 1;
+                if(len > sizeof(file)){
+                        printk("Not deleting '%s' from '%s' - name too long\n",
+                               ent->d_name, dir);
+                        continue;
+                }
+                sprintf(file, "%s/%s", dir, ent->d_name);
+                if(unlink(file) < 0){
+                        printk("actually_do_remove : couldn't remove '%s' "
+                               "from '%s', errno = %d\n", ent->d_name, dir, 
+                               errno);
+                        return(1);
+                }
+        }
+        if(rmdir(dir) < 0){
+                printk("actually_do_remove : couldn't rmdir '%s', "
+                       "errno = %d\n", dir, errno);
+                return(1);
+        }
+        return(0);
+}
+
+void remove_umid_dir(void)
+{
+        char dir[strlen(uml_dir) + UMID_LEN + 1];
+        if(!umid_inited) return;
+
+        sprintf(dir, "%s%s", uml_dir, umid);
+        actually_do_remove(dir);
+}
+
+char *get_umid(int only_if_set)
+{
+        if(only_if_set && umid_is_random) return(NULL);
+        return(umid);
+}
+
+int not_dead_yet(char *dir)
+{
+        char file[strlen(uml_dir) + UMID_LEN + sizeof("/pid\0")];
+        char pid[sizeof("nnnnn\0")], *end;
+        int dead, fd, p, n;
+
+        sprintf(file, "%s/pid", dir);
+        dead = 0;
+        fd = os_open_file(file, of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                if(fd != -ENOENT){
+                        printk("not_dead_yet : couldn't open pid file '%s', "
+                               "err = %d\n", file, -fd);
+                        return(1);
+                }
+                dead = 1;
+        }
+        if(fd > 0){
+                n = os_read_file(fd, pid, sizeof(pid));
+                if(n < 0){
+                        printk("not_dead_yet : couldn't read pid file '%s', "
+                               "err = %d\n", file, -n);
+                        return(1);
+                }
+                p = strtoul(pid, &end, 0);
+                if(end == pid){
+                        printk("not_dead_yet : couldn't parse pid file '%s', "
+                               "errno = %d\n", file, errno);
+                        dead = 1;
+                }
+                if(((kill(p, 0) < 0) && (errno == ESRCH)) ||
+                   (p == CHOOSE_MODE(tracing_pid, os_getpid())))
+                        dead = 1;
+        }
+        if(!dead) return(1);
+        return(actually_do_remove(dir));
+}
+
+static int __init set_uml_dir(char *name, int *add)
+{
+        if((strlen(name) > 0) && (name[strlen(name) - 1] != '/')){
+                uml_dir = malloc(strlen(name) + 2);
+                if(uml_dir == NULL){
+                        printf("Failed to malloc uml_dir - error = %d\n",
+                               errno);
+                        uml_dir = name;
+                        /* Return 0 here because do_initcalls doesn't look at
+                         * the return value.
+                         */
+                        return(0);
+                }
+                sprintf(uml_dir, "%s/", name);
+        }
+        else uml_dir = name;
+        return(0);
+}
+
+static int __init make_uml_dir(void)
+{
+        char dir[MAXPATHLEN + 1] = { '\0' };
+        int len;
+
+        if(*uml_dir == '~'){
+                char *home = getenv("HOME");
+
+                if(home == NULL){
+                        printf("make_uml_dir : no value in environment for "
+                               "$HOME\n");
+                        exit(1);
+                }
+                strlcpy(dir, home, sizeof(dir));
+                uml_dir++;
+        }
+        len = strlen(dir);
+        strncat(dir, uml_dir, sizeof(dir) - len);
+        len = strlen(dir);
+        if((len > 0) && (len < sizeof(dir) - 1) && (dir[len - 1] != '/')){
+                dir[len] = '/';
+                dir[len + 1] = '\0';
+        }
+
+        uml_dir = malloc(strlen(dir) + 1);
+        if(uml_dir == NULL){
+                printf("make_uml_dir : malloc failed, errno = %d\n", errno);
+                exit(1);
+        }
+        strcpy(uml_dir, dir);
+        
+        if((mkdir(uml_dir, 0777) < 0) && (errno != EEXIST)){
+                printf("Failed to mkdir %s: %s\n", uml_dir, strerror(errno));
+                return(-1);
+        }
+        return 0;
+}
+
+static int __init make_umid(int (*printer)(const char *fmt, ...))
+{
+        int fd, err;
+        char tmp[strlen(uml_dir) + UMID_LEN + 1];
+
+        strlcpy(tmp, uml_dir, sizeof(tmp));
+
+        if(!umid_inited){
+                strcat(tmp, "XXXXXX");
+                fd = mkstemp(tmp);
+                if(fd < 0){
+                        (*printer)("make_umid - mkstemp(%s) failed: %s\n",
+                                   tmp,strerror(errno));
+                        return(1);
+                }
+
+                os_close_file(fd);
+                /* There's a nice tiny little race between this unlink and
+                 * the mkdir below.  It'd be nice if there were a mkstemp
+                 * for directories.
+                 */
+                unlink(tmp);
+                set_umid(&tmp[strlen(uml_dir)], 1, printer);
+        }
+        
+        sprintf(tmp, "%s%s", uml_dir, umid);
+
+        err = mkdir(tmp, 0777);
+        if(err < 0){
+                if(errno == EEXIST){
+                        if(not_dead_yet(tmp)){
+                                (*printer)("umid '%s' is in use\n", umid);
+                                return(-1);
+                        }
+                        err = mkdir(tmp, 0777);
+                }
+        }
+        if(err < 0){
+                (*printer)("Failed to create %s - errno = %d\n", umid, errno);
+                return(-1);
+        }
+
+        return(0);
+}
+
+__uml_setup("uml_dir=", set_uml_dir,
+"uml_dir=<directory>\n"
+"    The location to place the pid and umid files.\n\n"
+);
+
+static int __init make_umid_setup(void)
+{
+        /* one function with the ordering we need ... */
+        make_uml_dir();
+        make_umid(printf);
+        return create_pid_file();
+}
+__uml_postsetup(make_umid_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 --git a/arch/um/kernel/uml.lds.S b/arch/um/kernel/uml.lds.S
new file mode 100644
index 000000000000..76eadb309189
--- /dev/null
+++ b/arch/um/kernel/uml.lds.S
@@ -0,0 +1,106 @@
+#include <asm-generic/vmlinux.lds.h>
+
+OUTPUT_FORMAT(ELF_FORMAT)
+OUTPUT_ARCH(ELF_ARCH)
+ENTRY(_start)
+jiffies = jiffies_64;
+
+SECTIONS
+{
+  /*This must contain the right address - not quite the default ELF one.*/
+  PROVIDE (__executable_start = START);
+  . = START + SIZEOF_HEADERS;
+
+  /* Used in arch/um/kernel/mem.c. Any memory between START and __binary_start
+   * is remapped.*/
+  __binary_start = .;
+#ifdef MODE_TT
+  .thread_private : {
+    __start_thread_private = .;
+    errno = .;
+    . += 4;
+    arch/um/kernel/tt/unmap_fin.o (.data)
+    __end_thread_private = .;
+  }
+  . = ALIGN(4096);
+  .remap : { arch/um/kernel/tt/unmap_fin.o (.text) }
+
+  /* We want it only if we are in MODE_TT. In both cases, however, when MODE_TT
+   * is off the resulting binary segfaults.*/
+
+  . = ALIGN(4096);              /* Init code and data */
+#endif
+
+  _stext = .;
+  __init_begin = .;
+  .init.text : {
+        _sinittext = .;
+        *(.init.text)
+        _einittext = .;
+  }
+  . = ALIGN(4096);
+  .text      :
+  {
+    *(.text)
+    SCHED_TEXT
+    LOCK_TEXT
+    *(.fixup)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+    *(.gnu.linkonce.t*)
+  }
+
+  #include "asm/common.lds.S"
+
+  init.data : { *(init.data) }
+  .data    :
+  {
+    . = ALIGN(KERNEL_STACK_SIZE);               /* init_task */
+    *(.data.init_task)
+    *(.data)
+    *(.gnu.linkonce.d*)
+    CONSTRUCTORS
+  }
+  .data1   : { *(.data1) }
+  .ctors         :
+  {
+    *(.ctors)
+  }
+  .dtors         :
+  {
+    *(.dtors)
+  }
+
+  .got           : { *(.got.plt) *(.got) }
+  .dynamic       : { *(.dynamic) }
+  /* We want the small data sections together, so single-instruction offsets
+     can access them all, and initialized data all before uninitialized, so
+     we can shorten the on-disk segment size.  */
+  .sdata     : { *(.sdata) }
+  _edata  =  .;
+  PROVIDE (edata = .);
+  . = ALIGN(0x1000);
+  .sbss      :
+  {
+   __bss_start = .;
+   PROVIDE(_bss_start = .);
+   *(.sbss)
+   *(.scommon)
+  }
+  .bss       :
+  {
+   *(.dynbss)
+   *(.bss)
+   *(COMMON)
+  }
+  _end = . ;
+  PROVIDE (end = .);
+  /* Stabs debugging sections.  */
+  .stab 0 : { *(.stab) }
+  .stabstr 0 : { *(.stabstr) }
+  .stab.excl 0 : { *(.stab.excl) }
+  .stab.exclstr 0 : { *(.stab.exclstr) }
+  .stab.index 0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment 0 : { *(.comment) }
+}
diff --git a/arch/um/kernel/user_util.c b/arch/um/kernel/user_util.c
new file mode 100644
index 000000000000..954ff67cc8b3
--- /dev/null
+++ b/arch/um/kernel/user_util.c
@@ -0,0 +1,173 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include "asm/types.h"
+#include <ctype.h>
+#include <signal.h>
+#include <wait.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <sched.h>
+#include <termios.h>
+#include <string.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "mem_user.h"
+#include "init.h"
+#include "helper.h"
+#include "ptrace_user.h"
+#include "uml-config.h"
+
+void stop(void)
+{
+        while(1) sleep(1000000);
+}
+
+void stack_protections(unsigned long address)
+{
+        int prot = PROT_READ | PROT_WRITE | PROT_EXEC;
+
+        if(mprotect((void *) address, page_size(), prot) < 0)
+                panic("protecting stack failed, errno = %d", errno);
+}
+
+void task_protections(unsigned long address)
+{
+        unsigned long guard = address + page_size();
+        unsigned long stack = guard + page_size();
+        int prot = 0, pages;
+
+#ifdef notdef
+        if(mprotect((void *) stack, page_size(), prot) < 0)
+                panic("protecting guard page failed, errno = %d", errno);
+#endif
+        pages = (1 << UML_CONFIG_KERNEL_STACK_ORDER) - 2;
+        prot = PROT_READ | PROT_WRITE | PROT_EXEC;
+        if(mprotect((void *) stack, pages * page_size(), prot) < 0)
+                panic("protecting stack failed, errno = %d", errno);
+}
+
+int wait_for_stop(int pid, int sig, int cont_type, void *relay)
+{
+        sigset_t *relay_signals = relay;
+        int status, ret;
+
+        while(1){
+                CATCH_EINTR(ret = waitpid(pid, &status, WUNTRACED));
+                if((ret < 0) ||
+                   !WIFSTOPPED(status) || (WSTOPSIG(status) != sig)){
+                        if(ret < 0){
+                                printk("wait failed, errno = %d\n",
+                                       errno);
+                        }
+                        else if(WIFEXITED(status)) 
+                                printk("process %d exited with status %d\n",
+                                       pid, WEXITSTATUS(status));
+                        else if(WIFSIGNALED(status))
+                                printk("process %d exited with signal %d\n",
+                                       pid, WTERMSIG(status));
+                        else if((WSTOPSIG(status) == SIGVTALRM) ||
+                                (WSTOPSIG(status) == SIGALRM) ||
+                                (WSTOPSIG(status) == SIGIO) ||
+                                (WSTOPSIG(status) == SIGPROF) ||
+                                (WSTOPSIG(status) == SIGCHLD) ||
+                                (WSTOPSIG(status) == SIGWINCH) ||
+                                (WSTOPSIG(status) == SIGINT)){
+                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
+                                continue;
+                        }
+                        else if((relay_signals != NULL) &&
+                                sigismember(relay_signals, WSTOPSIG(status))){
+                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
+                                continue;
+                        }
+                        else printk("process %d stopped with signal %d\n",
+                                    pid, WSTOPSIG(status));
+                        panic("wait_for_stop failed to wait for %d to stop "
+                              "with %d\n", pid, sig);
+                }
+                return(status);
+        }
+}
+
+int raw(int fd)
+{
+        struct termios tt;
+        int err;
+
+        CATCH_EINTR(err = tcgetattr(fd, &tt));
+        if (err < 0) {
+                        printk("tcgetattr failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        cfmakeraw(&tt);
+
+        CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
+        if (err < 0) {
+                        printk("tcsetattr failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        /* XXX tcsetattr could have applied only some changes
+         * (and cfmakeraw() is a set of changes) */
+        return(0);
+}
+
+void setup_machinename(char *machine_out)
+{
+        struct utsname host;
+
+        uname(&host);
+        strcpy(machine_out, host.machine);
+}
+
+char host_info[(_UTSNAME_LENGTH + 1) * 4 + _UTSNAME_NODENAME_LENGTH + 1];
+
+void setup_hostinfo(void)
+{
+        struct utsname host;
+
+        uname(&host);
+        sprintf(host_info, "%s %s %s %s %s", host.sysname, host.nodename,
+                host.release, host.version, host.machine);
+}
+
+int setjmp_wrapper(void (*proc)(void *, void *), ...)
+{
+        va_list args;
+        sigjmp_buf buf;
+        int n;
+
+        n = sigsetjmp(buf, 1);
+        if(n == 0){
+                va_start(args, proc);
+                (*proc)(&buf, &args);
+        }
+        va_end(args);
+        return(n);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
new file mode 100644
index 000000000000..4ddf540284ce
--- /dev/null
+++ b/arch/um/os-Linux/Makefile
@@ -0,0 +1,13 @@
+# 
+# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+obj-y = elf_aux.o file.o process.o signal.o time.o tty.o user_syms.o drivers/ \
+        sys-$(SUBARCH)/
+
+USER_OBJS := elf_aux.o file.o process.o signal.o time.o tty.o
+
+CFLAGS_user_syms.o += -DSUBARCH_$(SUBARCH)
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/drivers/Makefile b/arch/um/os-Linux/drivers/Makefile
new file mode 100644
index 000000000000..6c546dc9222b
--- /dev/null
+++ b/arch/um/os-Linux/drivers/Makefile
@@ -0,0 +1,13 @@
+# 
+# Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+ethertap-objs := ethertap_kern.o ethertap_user.o
+tuntap-objs := tuntap_kern.o tuntap_user.o
+
+obj-y = 
+obj-$(CONFIG_UML_NET_ETHERTAP) += ethertap.o
+obj-$(CONFIG_UML_NET_TUNTAP) += tuntap.o
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/drivers/etap.h b/arch/um/os-Linux/drivers/etap.h
new file mode 100644
index 000000000000..b84f6c4740f7
--- /dev/null
+++ b/arch/um/os-Linux/drivers/etap.h
@@ -0,0 +1,27 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "net_user.h"
+
+struct ethertap_data {
+        char *dev_name;
+        char *gate_addr;
+        int data_fd;
+        int control_fd;
+        void *dev;
+};
+
+extern struct net_user_info ethertap_user_info;
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/drivers/ethertap_kern.c b/arch/um/os-Linux/drivers/ethertap_kern.c
new file mode 100644
index 000000000000..6ae4b19d9f50
--- /dev/null
+++ b/arch/um/os-Linux/drivers/ethertap_kern.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include "linux/init.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "etap.h"
+
+struct ethertap_init {
+        char *dev_name;
+        char *gate_addr;
+};
+
+static void etap_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct ethertap_data *epri;
+        struct ethertap_init *init = data;
+
+        pri = dev->priv;
+        epri = (struct ethertap_data *) pri->user;
+        epri->dev_name = init->dev_name;
+        epri->gate_addr = init->gate_addr;
+        epri->data_fd = -1;
+        epri->control_fd = -1;
+        epri->dev = dev;
+
+        printk("ethertap backend - %s", epri->dev_name);
+        if (epri->gate_addr != NULL)
+                printk(", IP = %s", epri->gate_addr);
+        printk("\n");
+}
+
+static int etap_read(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        int len;
+
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_ETHERTAP);
+        if(*skb == NULL) return(-ENOMEM);
+        len = net_recvfrom(fd, (*skb)->mac.raw, 
+                           (*skb)->dev->mtu + 2 * ETH_HEADER_ETHERTAP);
+        if(len <= 0) return(len);
+        skb_pull(*skb, 2);
+        len -= 2;
+        return(len);
+}
+
+static int etap_write(int fd, struct sk_buff **skb, struct uml_net_private *lp)
+{
+        if(skb_headroom(*skb) < 2){
+                struct sk_buff *skb2;
+
+                skb2 = skb_realloc_headroom(*skb, 2);
+                dev_kfree_skb(*skb);
+                if (skb2 == NULL) return(-ENOMEM);
+                *skb = skb2;
+        }
+        skb_push(*skb, 2);
+        return(net_send(fd, (*skb)->data, (*skb)->len));
+}
+
+struct net_kern_info ethertap_kern_info = {
+        .init                   = etap_init,
+        .protocol               = eth_protocol,
+        .read                   = etap_read,
+        .write                  = etap_write,
+};
+
+int ethertap_setup(char *str, char **mac_out, void *data)
+{
+        struct ethertap_init *init = data;
+
+        *init = ((struct ethertap_init)
+                { .dev_name     = NULL,
+                  .gate_addr    = NULL });
+        if(tap_setup_common(str, "ethertap", &init->dev_name, mac_out,
+                            &init->gate_addr))
+                return(0);
+        if(init->dev_name == NULL){
+                printk("ethertap_setup : Missing tap device name\n");
+                return(0);
+        }
+
+        return(1);
+}
+
+static struct transport ethertap_transport = {
+        .list           = LIST_HEAD_INIT(ethertap_transport.list),
+        .name           = "ethertap",
+        .setup          = ethertap_setup,
+        .user           = &ethertap_user_info,
+        .kern           = &ethertap_kern_info,
+        .private_size   = sizeof(struct ethertap_data),
+};
+
+static int register_ethertap(void)
+{
+        register_transport(&ethertap_transport);
+        return(1);
+}
+
+__initcall(register_ethertap);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
new file mode 100644
index 000000000000..cd4d6544da71
--- /dev/null
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
+ * James Leu (jleu@mindspring.net).
+ * Copyright (C) 2001 by various other people who didn't put their name here.
+ * Licensed under the GPL.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <sys/errno.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <sys/un.h>
+#include <net/if.h>
+#include "user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "net_user.h"
+#include "etap.h"
+#include "helper.h"
+#include "os.h"
+
+#define MAX_PACKET ETH_MAX_PACKET
+
+void etap_user_init(void *data, void *dev)
+{
+        struct ethertap_data *pri = data;
+
+        pri->dev = dev;
+}
+
+struct addr_change {
+        enum { ADD_ADDR, DEL_ADDR } what;
+        unsigned char addr[4];
+        unsigned char netmask[4];
+};
+
+static void etap_change(int op, unsigned char *addr, unsigned char *netmask,
+                        int fd)
+{
+        struct addr_change change;
+        void *output;
+        int n;
+
+        change.what = op;
+        memcpy(change.addr, addr, sizeof(change.addr));
+        memcpy(change.netmask, netmask, sizeof(change.netmask));
+        n = os_write_file(fd, &change, sizeof(change));
+        if(n != sizeof(change))
+                printk("etap_change - request failed, err = %d\n", -n);
+        output = um_kmalloc(page_size());
+        if(output == NULL)
+                printk("etap_change : Failed to allocate output buffer\n");
+        read_output(fd, output, page_size());
+        if(output != NULL){
+                printk("%s", output);
+                kfree(output);
+        }
+}
+
+static void etap_open_addr(unsigned char *addr, unsigned char *netmask,
+                           void *arg)
+{
+        etap_change(ADD_ADDR, addr, netmask, *((int *) arg));
+}
+
+static void etap_close_addr(unsigned char *addr, unsigned char *netmask,
+                            void *arg)
+{
+        etap_change(DEL_ADDR, addr, netmask, *((int *) arg));
+}
+
+struct etap_pre_exec_data {
+        int control_remote;
+        int control_me;
+        int data_me;
+};
+
+static void etap_pre_exec(void *arg)
+{
+        struct etap_pre_exec_data *data = arg;
+
+        dup2(data->control_remote, 1);
+        os_close_file(data->data_me);
+        os_close_file(data->control_me);
+}
+
+static int etap_tramp(char *dev, char *gate, int control_me, 
+                      int control_remote, int data_me, int data_remote)
+{
+        struct etap_pre_exec_data pe_data;
+        int pid, status, err, n;
+        char version_buf[sizeof("nnnnn\0")];
+        char data_fd_buf[sizeof("nnnnnn\0")];
+        char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
+        char *setup_args[] = { "uml_net", version_buf, "ethertap", dev,
+                               data_fd_buf, gate_buf, NULL };
+        char *nosetup_args[] = { "uml_net", version_buf, "ethertap", 
+                                 dev, data_fd_buf, NULL };
+        char **args, c;
+
+        sprintf(data_fd_buf, "%d", data_remote);
+        sprintf(version_buf, "%d", UML_NET_VERSION);
+        if(gate != NULL){
+                strcpy(gate_buf, gate);
+                args = setup_args;
+        }
+        else args = nosetup_args;
+
+        err = 0;
+        pe_data.control_remote = control_remote;
+        pe_data.control_me = control_me;
+        pe_data.data_me = data_me;
+        pid = run_helper(etap_pre_exec, &pe_data, args, NULL);
+
+        if(pid < 0) err = pid;
+        os_close_file(data_remote);
+        os_close_file(control_remote);
+        n = os_read_file(control_me, &c, sizeof(c));
+        if(n != sizeof(c)){
+                printk("etap_tramp : read of status failed, err = %d\n", -n);
+                return(-EINVAL);
+        }
+        if(c != 1){
+                printk("etap_tramp : uml_net failed\n");
+                err = -EINVAL;
+                CATCH_EINTR(n = waitpid(pid, &status, 0));
+                if(n < 0)
+                        err = -errno;
+                else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 1))
+                        printk("uml_net didn't exit with status 1\n");
+        }
+        return(err);
+}
+
+static int etap_open(void *data)
+{
+        struct ethertap_data *pri = data;
+        char *output;
+        int data_fds[2], control_fds[2], err, output_len;
+
+        err = tap_open_common(pri->dev, pri->gate_addr);
+        if(err) return(err);
+
+        err = os_pipe(data_fds, 0, 0);
+        if(err < 0){
+                printk("data os_pipe failed - err = %d\n", -err);
+                return(err);
+        }
+
+        err = os_pipe(control_fds, 1, 0);
+        if(err < 0){
+                printk("control os_pipe failed - err = %d\n", -err);
+                return(err);
+        }
+        
+        err = etap_tramp(pri->dev_name, pri->gate_addr, control_fds[0], 
+                         control_fds[1], data_fds[0], data_fds[1]);
+        output_len = page_size();
+        output = um_kmalloc(output_len);
+        read_output(control_fds[0], output, output_len);
+
+        if(output == NULL)
+                printk("etap_open : failed to allocate output buffer\n");
+        else {
+                printk("%s", output);
+                kfree(output);
+        }
+
+        if(err < 0){
+                printk("etap_tramp failed - err = %d\n", -err);
+                return(err);
+        }
+
+        pri->data_fd = data_fds[0];
+        pri->control_fd = control_fds[0];
+        iter_addresses(pri->dev, etap_open_addr, &pri->control_fd);
+        return(data_fds[0]);
+}
+
+static void etap_close(int fd, void *data)
+{
+        struct ethertap_data *pri = data;
+
+        iter_addresses(pri->dev, etap_close_addr, &pri->control_fd);
+        os_close_file(fd);
+        os_shutdown_socket(pri->data_fd, 1, 1);
+        os_close_file(pri->data_fd);
+        pri->data_fd = -1;
+        os_close_file(pri->control_fd);
+        pri->control_fd = -1;
+}
+
+static int etap_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+static void etap_add_addr(unsigned char *addr, unsigned char *netmask,
+                          void *data)
+{
+        struct ethertap_data *pri = data;
+
+        tap_check_ips(pri->gate_addr, addr);
+        if(pri->control_fd == -1) return;
+        etap_open_addr(addr, netmask, &pri->control_fd);
+}
+
+static void etap_del_addr(unsigned char *addr, unsigned char *netmask, 
+                          void *data)
+{
+        struct ethertap_data *pri = data;
+
+        if(pri->control_fd == -1) return;
+        etap_close_addr(addr, netmask, &pri->control_fd);
+}
+
+struct net_user_info ethertap_user_info = {
+        .init           = etap_user_init,
+        .open           = etap_open,
+        .close          = etap_close,
+        .remove         = NULL,
+        .set_mtu        = etap_set_mtu,
+        .add_address    = etap_add_addr,
+        .delete_address = etap_del_addr,
+        .max_packet     = MAX_PACKET - ETH_HEADER_ETHERTAP
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/drivers/tuntap.h b/arch/um/os-Linux/drivers/tuntap.h
new file mode 100644
index 000000000000..25d4a2868814
--- /dev/null
+++ b/arch/um/os-Linux/drivers/tuntap.h
@@ -0,0 +1,32 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __UM_TUNTAP_H
+#define __UM_TUNTAP_H
+
+#include "net_user.h"
+
+struct tuntap_data {
+        char *dev_name;
+        int fixed_config;
+        char *gate_addr;
+        int fd;
+        void *dev;
+};
+
+extern struct net_user_info tuntap_user_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 --git a/arch/um/os-Linux/drivers/tuntap_kern.c b/arch/um/os-Linux/drivers/tuntap_kern.c
new file mode 100644
index 000000000000..4202b9ebad4c
--- /dev/null
+++ b/arch/um/os-Linux/drivers/tuntap_kern.c
@@ -0,0 +1,104 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/netdevice.h"
+#include "linux/etherdevice.h"
+#include "linux/skbuff.h"
+#include "linux/init.h"
+#include "asm/errno.h"
+#include "net_kern.h"
+#include "net_user.h"
+#include "tuntap.h"
+
+struct tuntap_init {
+        char *dev_name;
+        char *gate_addr;
+};
+
+static void tuntap_init(struct net_device *dev, void *data)
+{
+        struct uml_net_private *pri;
+        struct tuntap_data *tpri;
+        struct tuntap_init *init = data;
+
+        pri = dev->priv;
+        tpri = (struct tuntap_data *) pri->user;
+        tpri->dev_name = init->dev_name;
+        tpri->fixed_config = (init->dev_name != NULL);
+        tpri->gate_addr = init->gate_addr;
+        tpri->fd = -1;
+        tpri->dev = dev;
+
+        printk("TUN/TAP backend - ");
+        if (tpri->gate_addr != NULL)
+                printk("IP = %s", tpri->gate_addr);
+        printk("\n");
+}
+
+static int tuntap_read(int fd, struct sk_buff **skb, 
+                       struct uml_net_private *lp)
+{
+        *skb = ether_adjust_skb(*skb, ETH_HEADER_OTHER);
+        if(*skb == NULL) return(-ENOMEM);
+        return(net_read(fd, (*skb)->mac.raw, 
+                        (*skb)->dev->mtu + ETH_HEADER_OTHER));
+}
+
+static int tuntap_write(int fd, struct sk_buff **skb, 
+                        struct uml_net_private *lp)
+{
+        return(net_write(fd, (*skb)->data, (*skb)->len));
+}
+
+struct net_kern_info tuntap_kern_info = {
+        .init                   = tuntap_init,
+        .protocol               = eth_protocol,
+        .read                   = tuntap_read,
+        .write                  = tuntap_write,
+};
+
+int tuntap_setup(char *str, char **mac_out, void *data)
+{
+        struct tuntap_init *init = data;
+
+        *init = ((struct tuntap_init)
+                { .dev_name     = NULL,
+                  .gate_addr    = NULL });
+        if(tap_setup_common(str, "tuntap", &init->dev_name, mac_out,
+                            &init->gate_addr))
+                return(0);
+
+        return(1);
+}
+
+static struct transport tuntap_transport = {
+        .list           = LIST_HEAD_INIT(tuntap_transport.list),
+        .name           = "tuntap",
+        .setup          = tuntap_setup,
+        .user           = &tuntap_user_info,
+        .kern           = &tuntap_kern_info,
+        .private_size   = sizeof(struct tuntap_data),
+        .setup_size     = sizeof(struct tuntap_init),
+};
+
+static int register_tuntap(void)
+{
+        register_transport(&tuntap_transport);
+        return(1);
+}
+
+__initcall(register_tuntap);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
new file mode 100644
index 000000000000..4b83c6c3f48d
--- /dev/null
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -0,0 +1,225 @@
+/* 
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/uio.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <linux/if_tun.h>
+#include "net_user.h"
+#include "tuntap.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "user.h"
+#include "helper.h"
+#include "os.h"
+
+#define MAX_PACKET ETH_MAX_PACKET
+
+void tuntap_user_init(void *data, void *dev)
+{
+        struct tuntap_data *pri = data;
+
+        pri->dev = dev;
+}
+
+static void tuntap_add_addr(unsigned char *addr, unsigned char *netmask,
+                            void *data)
+{
+        struct tuntap_data *pri = data;
+
+        tap_check_ips(pri->gate_addr, addr);
+        if((pri->fd == -1) || pri->fixed_config) return;
+        open_addr(addr, netmask, pri->dev_name);
+}
+
+static void tuntap_del_addr(unsigned char *addr, unsigned char *netmask,
+                            void *data)
+{
+        struct tuntap_data *pri = data;
+
+        if((pri->fd == -1) || pri->fixed_config) return;
+        close_addr(addr, netmask, pri->dev_name);
+}
+
+struct tuntap_pre_exec_data {
+        int stdout;
+        int close_me;
+};
+
+static void tuntap_pre_exec(void *arg)
+{
+        struct tuntap_pre_exec_data *data = arg;
+        
+        dup2(data->stdout, 1);
+        os_close_file(data->close_me);
+}
+
+static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
+                             char *buffer, int buffer_len, int *used_out)
+{
+        struct tuntap_pre_exec_data data;
+        char version_buf[sizeof("nnnnn\0")];
+        char *argv[] = { "uml_net", version_buf, "tuntap", "up", gate,
+                         NULL };
+        char buf[CMSG_SPACE(sizeof(*fd_out))];
+        struct msghdr msg;
+        struct cmsghdr *cmsg;
+        struct iovec iov;
+        int pid, n;
+
+        sprintf(version_buf, "%d", UML_NET_VERSION);
+
+        data.stdout = remote;
+        data.close_me = me;
+
+        pid = run_helper(tuntap_pre_exec, &data, argv, NULL);
+
+        if(pid < 0) return(-pid);
+
+        os_close_file(remote);
+
+        msg.msg_name = NULL;
+        msg.msg_namelen = 0;
+        if(buffer != NULL){
+                iov = ((struct iovec) { buffer, buffer_len });
+                msg.msg_iov = &iov;
+                msg.msg_iovlen = 1;
+        }
+        else {
+                msg.msg_iov = NULL;
+                msg.msg_iovlen = 0;
+        }
+        msg.msg_control = buf;
+        msg.msg_controllen = sizeof(buf);
+        msg.msg_flags = 0;
+        n = recvmsg(me, &msg, 0);
+        *used_out = n;
+        if(n < 0){
+                printk("tuntap_open_tramp : recvmsg failed - errno = %d\n", 
+                       errno);
+                return(-errno);
+        }
+        CATCH_EINTR(waitpid(pid, NULL, 0));
+
+        cmsg = CMSG_FIRSTHDR(&msg);
+        if(cmsg == NULL){
+                printk("tuntap_open_tramp : didn't receive a message\n");
+                return(-EINVAL);
+        }
+        if((cmsg->cmsg_level != SOL_SOCKET) || 
+           (cmsg->cmsg_type != SCM_RIGHTS)){
+                printk("tuntap_open_tramp : didn't receive a descriptor\n");
+                return(-EINVAL);
+        }
+        *fd_out = ((int *) CMSG_DATA(cmsg))[0];
+        return(0);
+}
+
+static int tuntap_open(void *data)
+{
+        struct ifreq ifr;
+        struct tuntap_data *pri = data;
+        char *output, *buffer;
+        int err, fds[2], len, used;
+
+        err = tap_open_common(pri->dev, pri->gate_addr);
+        if(err < 0)
+                return(err);
+
+        if(pri->fixed_config){
+                pri->fd = os_open_file("/dev/net/tun", of_rdwr(OPENFLAGS()), 0);
+                if(pri->fd < 0){
+                        printk("Failed to open /dev/net/tun, err = %d\n",
+                               -pri->fd);
+                        return(pri->fd);
+                }
+                memset(&ifr, 0, sizeof(ifr));
+                ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
+                strlcpy(ifr.ifr_name, pri->dev_name, sizeof(ifr.ifr_name));
+                if(ioctl(pri->fd, TUNSETIFF, (void *) &ifr) < 0){
+                        printk("TUNSETIFF failed, errno = %d\n", errno);
+                        os_close_file(pri->fd);
+                        return(-errno);
+                }
+        }
+        else {
+                err = os_pipe(fds, 0, 0);
+                if(err < 0){
+                        printk("tuntap_open : os_pipe failed - err = %d\n",
+                               -err);
+                        return(err);
+                }
+
+                buffer = get_output_buffer(&len);
+                if(buffer != NULL) len--;
+                used = 0;
+
+                err = tuntap_open_tramp(pri->gate_addr, &pri->fd, fds[0],
+                                        fds[1], buffer, len, &used);
+
+                output = buffer;
+                if(err < 0) {
+                        printk("%s", output);
+                        free_output_buffer(buffer);
+                        printk("tuntap_open_tramp failed - err = %d\n", -err);
+                        return(err);
+                }
+
+                pri->dev_name = uml_strdup(buffer);
+                output += IFNAMSIZ;
+                printk("%s", output);
+                free_output_buffer(buffer);
+
+                os_close_file(fds[0]);
+                iter_addresses(pri->dev, open_addr, pri->dev_name);
+        }
+
+        return(pri->fd);
+}
+
+static void tuntap_close(int fd, void *data)
+{
+        struct tuntap_data *pri = data;
+
+        if(!pri->fixed_config) 
+                iter_addresses(pri->dev, close_addr, pri->dev_name);
+        os_close_file(fd);
+        pri->fd = -1;
+}
+
+static int tuntap_set_mtu(int mtu, void *data)
+{
+        return(mtu);
+}
+
+struct net_user_info tuntap_user_info = {
+        .init           = tuntap_user_init,
+        .open           = tuntap_open,
+        .close          = tuntap_close,
+        .remove         = NULL,
+        .set_mtu        = tuntap_set_mtu,
+        .add_address    = tuntap_add_addr,
+        .delete_address = tuntap_del_addr,
+        .max_packet     = MAX_PACKET
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/elf_aux.c b/arch/um/os-Linux/elf_aux.c
new file mode 100644
index 000000000000..9aee0b62ebca
--- /dev/null
+++ b/arch/um/os-Linux/elf_aux.c
@@ -0,0 +1,66 @@
+/*
+ *  arch/um/kernel/elf_aux.c
+ *
+ *  Scan the Elf auxiliary vector provided by the host to extract
+ *  information about vsyscall-page, etc.
+ *
+ *  Copyright (C) 2004 Fujitsu Siemens Computers GmbH
+ *  Author: Bodo Stroesser (bodo.stroesser@fujitsu-siemens.com)
+ */
+#include <elf.h>
+#include <stddef.h>
+#include "init.h"
+#include "elf_user.h"
+
+#if ELF_CLASS == ELFCLASS32
+typedef Elf32_auxv_t elf_auxv_t;
+#else
+typedef Elf64_auxv_t elf_auxv_t;
+#endif
+
+char * elf_aux_platform;
+long elf_aux_hwcap;
+
+unsigned long vsyscall_ehdr;
+unsigned long vsyscall_end;
+
+unsigned long __kernel_vsyscall;
+
+__init void scan_elf_aux( char **envp)
+{
+        long page_size = 0;
+        elf_auxv_t * auxv;
+
+        while ( *envp++ != NULL) ;
+
+        for ( auxv = (elf_auxv_t *)envp; auxv->a_type != AT_NULL; auxv++) {
+                switch ( auxv->a_type ) {
+                        case AT_SYSINFO:
+                                __kernel_vsyscall = auxv->a_un.a_val;
+                                break;
+                        case AT_SYSINFO_EHDR:
+                                vsyscall_ehdr = auxv->a_un.a_val;
+                                break;
+                        case AT_HWCAP:
+                                elf_aux_hwcap = auxv->a_un.a_val;
+                                break;
+                        case AT_PLATFORM:
+                                elf_aux_platform = auxv->a_un.a_ptr;
+                                break;
+                        case AT_PAGESZ:
+                                page_size = auxv->a_un.a_val;
+                                break;
+                }
+        }
+        if ( ! __kernel_vsyscall || ! vsyscall_ehdr ||
+             ! elf_aux_hwcap || ! elf_aux_platform ||
+             ! page_size || (vsyscall_ehdr % page_size) ) {
+                __kernel_vsyscall = 0;
+                vsyscall_ehdr = 0;
+                elf_aux_hwcap = 0;
+                elf_aux_platform = "i586";
+        }
+        else {
+                vsyscall_end = vsyscall_ehdr + page_size;
+        }
+}
diff --git a/arch/um/os-Linux/file.c b/arch/um/os-Linux/file.c
new file mode 100644
index 000000000000..77d4066d1af8
--- /dev/null
+++ b/arch/um/os-Linux/file.c
@@ -0,0 +1,680 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+#include <sys/uio.h>
+#include "os.h"
+#include "user.h"
+#include "kern_util.h"
+
+static void copy_stat(struct uml_stat *dst, struct stat64 *src)
+{
+        *dst = ((struct uml_stat) {
+                .ust_dev     = src->st_dev,     /* device */
+                .ust_ino     = src->st_ino,     /* inode */
+                .ust_mode    = src->st_mode,    /* protection */
+                .ust_nlink   = src->st_nlink,   /* number of hard links */
+                .ust_uid     = src->st_uid,     /* user ID of owner */
+                .ust_gid     = src->st_gid,     /* group ID of owner */
+                .ust_size    = src->st_size,    /* total size, in bytes */
+                .ust_blksize = src->st_blksize, /* blocksize for filesys I/O */
+                .ust_blocks  = src->st_blocks,  /* number of blocks allocated */
+                .ust_atime   = src->st_atime,   /* time of last access */
+                .ust_mtime   = src->st_mtime,   /* time of last modification */
+                .ust_ctime   = src->st_ctime,   /* time of last change */
+        });
+}
+
+int os_stat_fd(const int fd, struct uml_stat *ubuf)
+{
+        struct stat64 sbuf;
+        int err;
+
+        do {
+                err = fstat64(fd, &sbuf);
+        } while((err < 0) && (errno == EINTR)) ;
+
+        if(err < 0)
+                return(-errno);
+
+        if(ubuf != NULL)
+                copy_stat(ubuf, &sbuf);
+        return(err);
+}
+
+int os_stat_file(const char *file_name, struct uml_stat *ubuf)
+{
+        struct stat64 sbuf;
+        int err;
+
+        do {
+                err = stat64(file_name, &sbuf);
+        } while((err < 0) && (errno == EINTR)) ;
+
+        if(err < 0)
+                return(-errno);
+
+        if(ubuf != NULL)
+                copy_stat(ubuf, &sbuf);
+        return(err);
+}
+
+int os_access(const char* file, int mode)
+{
+        int amode, err;
+
+        amode=(mode&OS_ACC_R_OK ? R_OK : 0) | (mode&OS_ACC_W_OK ? W_OK : 0) |
+              (mode&OS_ACC_X_OK ? X_OK : 0) | (mode&OS_ACC_F_OK ? F_OK : 0) ;
+
+        err = access(file, amode);
+        if(err < 0)
+                return(-errno);
+
+        return(0);
+}
+
+void os_print_error(int error, const char* str)
+{
+        errno = error < 0 ? -error : error;
+
+        perror(str);
+}
+
+/* FIXME? required only by hostaudio (because it passes ioctls verbatim) */
+int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
+{
+        int err;
+
+        err = ioctl(fd, cmd, arg);
+        if(err < 0)
+                return(-errno);
+
+        return(err);
+}
+
+int os_window_size(int fd, int *rows, int *cols)
+{
+        struct winsize size;
+
+        if(ioctl(fd, TIOCGWINSZ, &size) < 0)
+                return(-errno);
+
+        *rows = size.ws_row;
+        *cols = size.ws_col;
+
+        return(0);
+}
+
+int os_new_tty_pgrp(int fd, int pid)
+{
+        if(ioctl(fd, TIOCSCTTY, 0) < 0){
+                printk("TIOCSCTTY failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        if(tcsetpgrp(fd, pid) < 0){
+                printk("tcsetpgrp failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        return(0);
+}
+
+/* FIXME: ensure namebuf in os_get_if_name is big enough */
+int os_get_ifname(int fd, char* namebuf)
+{
+        if(ioctl(fd, SIOCGIFNAME, namebuf) < 0)
+                return(-errno);
+
+        return(0);
+}
+
+int os_set_slip(int fd)
+{
+        int disc, sencap;
+
+        disc = N_SLIP;
+        if(ioctl(fd, TIOCSETD, &disc) < 0){
+                printk("Failed to set slip line discipline - "
+                       "errno = %d\n", errno);
+                return(-errno);
+        }
+
+        sencap = 0;
+        if(ioctl(fd, SIOCSIFENCAP, &sencap) < 0){
+                printk("Failed to set slip encapsulation - "
+                       "errno = %d\n", errno);
+                return(-errno);
+        }
+
+        return(0);
+}
+
+int os_set_owner(int fd, int pid)
+{
+        if(fcntl(fd, F_SETOWN, pid) < 0){
+                int save_errno = errno;
+
+                if(fcntl(fd, F_GETOWN, 0) != pid)
+                        return(-save_errno);
+        }
+
+        return(0);
+}
+
+/* FIXME? moved wholesale from sigio_user.c to get fcntls out of that file */
+int os_sigio_async(int master, int slave)
+{
+        int flags;
+
+        flags = fcntl(master, F_GETFL);
+        if(flags < 0) {
+                printk("fcntl F_GETFL failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
+           (fcntl(master, F_SETOWN, os_getpid()) < 0)){
+                printk("fcntl F_SETFL or F_SETOWN failed, errno = %d\n",
+                       errno);
+                return(-errno);
+        }
+
+        if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0)){
+                printk("fcntl F_SETFL failed, errno = %d\n", errno);
+                return(-errno);
+        }
+
+        return(0);
+}
+
+int os_mode_fd(int fd, int mode)
+{
+        int err;
+
+        do {
+                err = fchmod(fd, mode);
+        } while((err < 0) && (errno==EINTR)) ;
+
+        if(err < 0)
+                return(-errno);
+
+        return(0);
+}
+
+int os_file_type(char *file)
+{
+        struct uml_stat buf;
+        int err;
+
+        err = os_stat_file(file, &buf);
+        if(err < 0)
+                return(err);
+
+        if(S_ISDIR(buf.ust_mode)) return(OS_TYPE_DIR);
+        else if(S_ISLNK(buf.ust_mode)) return(OS_TYPE_SYMLINK);
+        else if(S_ISCHR(buf.ust_mode)) return(OS_TYPE_CHARDEV);
+        else if(S_ISBLK(buf.ust_mode)) return(OS_TYPE_BLOCKDEV);
+        else if(S_ISFIFO(buf.ust_mode)) return(OS_TYPE_FIFO);
+        else if(S_ISSOCK(buf.ust_mode)) return(OS_TYPE_SOCK);
+        else return(OS_TYPE_FILE);
+}
+
+int os_file_mode(char *file, struct openflags *mode_out)
+{
+        int err;
+
+        *mode_out = OPENFLAGS();
+
+        err = os_access(file, OS_ACC_W_OK);
+        if((err < 0) && (err != -EACCES))
+                return(err);
+
+        *mode_out = of_write(*mode_out);
+
+        err = os_access(file, OS_ACC_R_OK);
+        if((err < 0) && (err != -EACCES))
+                return(err);
+
+        *mode_out = of_read(*mode_out);
+
+        return(0);
+}
+
+int os_open_file(char *file, struct openflags flags, int mode)
+{
+        int fd, f = 0;
+
+        if(flags.r && flags.w) f = O_RDWR;
+        else if(flags.r) f = O_RDONLY;
+        else if(flags.w) f = O_WRONLY;
+        else f = 0;
+
+        if(flags.s) f |= O_SYNC;
+        if(flags.c) f |= O_CREAT;
+        if(flags.t) f |= O_TRUNC;
+        if(flags.e) f |= O_EXCL;
+
+        fd = open64(file, f, mode);
+        if(fd < 0)
+                return(-errno);
+
+        if(flags.cl && fcntl(fd, F_SETFD, 1)){
+                os_close_file(fd);
+                return(-errno);
+        }
+
+        return(fd);
+}
+
+int os_connect_socket(char *name)
+{
+        struct sockaddr_un sock;
+        int fd, err;
+
+        sock.sun_family = AF_UNIX;
+        snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
+
+        fd = socket(AF_UNIX, SOCK_STREAM, 0);
+        if(fd < 0)
+                return(fd);
+
+        err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
+        if(err)
+                return(-errno);
+
+        return(fd);
+}
+
+void os_close_file(int fd)
+{
+        close(fd);
+}
+
+int os_seek_file(int fd, __u64 offset)
+{
+        __u64 actual;
+
+        actual = lseek64(fd, offset, SEEK_SET);
+        if(actual != offset)
+                return(-errno);
+        return(0);
+}
+
+static int fault_buffer(void *start, int len,
+                        int (*copy_proc)(void *addr, void *buf, int len))
+{
+        int page = getpagesize(), i;
+        char c;
+
+        for(i = 0; i < len; i += page){
+                if((*copy_proc)(start + i, &c, sizeof(c)))
+                        return(-EFAULT);
+        }
+        if((len % page) != 0){
+                if((*copy_proc)(start + len - 1, &c, sizeof(c)))
+                        return(-EFAULT);
+        }
+        return(0);
+}
+
+static int file_io(int fd, void *buf, int len,
+                   int (*io_proc)(int fd, void *buf, int len),
+                   int (*copy_user_proc)(void *addr, void *buf, int len))
+{
+        int n, err;
+
+        do {
+                n = (*io_proc)(fd, buf, len);
+                if((n < 0) && (errno == EFAULT)){
+                        err = fault_buffer(buf, len, copy_user_proc);
+                        if(err)
+                                return(err);
+                        n = (*io_proc)(fd, buf, len);
+                }
+        } while((n < 0) && (errno == EINTR));
+
+        if(n < 0)
+                return(-errno);
+        return(n);
+}
+
+int os_read_file(int fd, void *buf, int len)
+{
+        return(file_io(fd, buf, len, (int (*)(int, void *, int)) read,
+                       copy_from_user_proc));
+}
+
+int os_write_file(int fd, const void *buf, int len)
+{
+        return(file_io(fd, (void *) buf, len,
+                       (int (*)(int, void *, int)) write, copy_to_user_proc));
+}
+
+int os_file_size(char *file, long long *size_out)
+{
+        struct uml_stat buf;
+        int err;
+
+        err = os_stat_file(file, &buf);
+        if(err < 0){
+                printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
+                return(err);
+        }
+
+        if(S_ISBLK(buf.ust_mode)){
+                int fd, blocks;
+
+                fd = os_open_file(file, of_read(OPENFLAGS()), 0);
+                if(fd < 0){
+                        printk("Couldn't open \"%s\", errno = %d\n", file, -fd);
+                        return(fd);
+                }
+                if(ioctl(fd, BLKGETSIZE, &blocks) < 0){
+                        printk("Couldn't get the block size of \"%s\", "
+                               "errno = %d\n", file, errno);
+                        err = -errno;
+                        os_close_file(fd);
+                        return(err);
+                }
+                *size_out = ((long long) blocks) * 512;
+                os_close_file(fd);
+                return(0);
+        }
+        *size_out = buf.ust_size;
+        return(0);
+}
+
+int os_file_modtime(char *file, unsigned long *modtime)
+{
+        struct uml_stat buf;
+        int err;
+
+        err = os_stat_file(file, &buf);
+        if(err < 0){
+                printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
+                return(err);
+        }
+
+        *modtime = buf.ust_mtime;
+        return(0);
+}
+
+int os_get_exec_close(int fd, int* close_on_exec)
+{
+        int ret;
+
+        do {
+                ret = fcntl(fd, F_GETFD);
+        } while((ret < 0) && (errno == EINTR)) ;
+
+        if(ret < 0)
+                return(-errno);
+
+        *close_on_exec = (ret&FD_CLOEXEC) ? 1 : 0;
+        return(ret);
+}
+
+int os_set_exec_close(int fd, int close_on_exec)
+{
+        int flag, err;
+
+        if(close_on_exec) flag = FD_CLOEXEC;
+        else flag = 0;
+
+        do {
+                err = fcntl(fd, F_SETFD, flag);
+        } while((err < 0) && (errno == EINTR)) ;
+
+        if(err < 0)
+                return(-errno);
+        return(err);
+}
+
+int os_pipe(int *fds, int stream, int close_on_exec)
+{
+        int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;
+
+        err = socketpair(AF_UNIX, type, 0, fds);
+        if(err < 0)
+                return(-errno);
+
+        if(!close_on_exec)
+                return(0);
+
+        err = os_set_exec_close(fds[0], 1);
+        if(err < 0)
+                goto error;
+
+        err = os_set_exec_close(fds[1], 1);
+        if(err < 0)
+                goto error;
+
+        return(0);
+
+ error:
+        printk("os_pipe : Setting FD_CLOEXEC failed, err = %d\n", -err);
+        os_close_file(fds[1]);
+        os_close_file(fds[0]);
+        return(err);
+}
+
+int os_set_fd_async(int fd, int owner)
+{
+        /* XXX This should do F_GETFL first */
+        if(fcntl(fd, F_SETFL, O_ASYNC | O_NONBLOCK) < 0){
+                printk("os_set_fd_async : failed to set O_ASYNC and "
+                       "O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
+                return(-errno);
+        }
+#ifdef notdef
+        if(fcntl(fd, F_SETFD, 1) < 0){
+                printk("os_set_fd_async : Setting FD_CLOEXEC failed, "
+                       "errno = %d\n", errno);
+        }
+#endif
+
+        if((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
+           (fcntl(fd, F_SETOWN, owner) < 0)){
+                printk("os_set_fd_async : Failed to fcntl F_SETOWN "
+                       "(or F_SETSIG) fd %d to pid %d, errno = %d\n", fd, 
+                       owner, errno);
+                return(-errno);
+        }
+
+        return(0);
+}
+
+int os_clear_fd_async(int fd)
+{
+        int flags = fcntl(fd, F_GETFL);
+
+        flags &= ~(O_ASYNC | O_NONBLOCK);
+        if(fcntl(fd, F_SETFL, flags) < 0)
+                return(-errno);
+        return(0);
+}
+
+int os_set_fd_block(int fd, int blocking)
+{
+        int flags;
+
+        flags = fcntl(fd, F_GETFL);
+
+        if(blocking) flags &= ~O_NONBLOCK;
+        else flags |= O_NONBLOCK;
+
+        if(fcntl(fd, F_SETFL, flags) < 0){
+                printk("Failed to change blocking on fd # %d, errno = %d\n",
+                       fd, errno);
+                return(-errno);
+        }
+        return(0);
+}
+
+int os_accept_connection(int fd)
+{
+        int new;
+
+        new = accept(fd, NULL, 0);
+        if(new < 0) 
+                return(-errno);
+        return(new);
+}
+
+#ifndef SHUT_RD
+#define SHUT_RD 0
+#endif
+
+#ifndef SHUT_WR
+#define SHUT_WR 1
+#endif
+
+#ifndef SHUT_RDWR
+#define SHUT_RDWR 2
+#endif
+
+int os_shutdown_socket(int fd, int r, int w)
+{
+        int what, err;
+
+        if(r && w) what = SHUT_RDWR;
+        else if(r) what = SHUT_RD;
+        else if(w) what = SHUT_WR;
+        else {
+                printk("os_shutdown_socket : neither r or w was set\n");
+                return(-EINVAL);
+        }
+        err = shutdown(fd, what);
+        if(err < 0)
+                return(-errno);
+        return(0);
+}
+
+int os_rcv_fd(int fd, int *helper_pid_out)
+{
+        int new, n;
+        char buf[CMSG_SPACE(sizeof(new))];
+        struct msghdr msg;
+        struct cmsghdr *cmsg;
+        struct iovec iov;
+
+        msg.msg_name = NULL;
+        msg.msg_namelen = 0;
+        iov = ((struct iovec) { .iov_base  = helper_pid_out,
+                                .iov_len   = sizeof(*helper_pid_out) });
+        msg.msg_iov = &iov;
+        msg.msg_iovlen = 1;
+        msg.msg_control = buf;
+        msg.msg_controllen = sizeof(buf);
+        msg.msg_flags = 0;
+
+        n = recvmsg(fd, &msg, 0);
+        if(n < 0)
+                return(-errno);
+
+        else if(n != sizeof(iov.iov_len))
+                *helper_pid_out = -1;
+
+        cmsg = CMSG_FIRSTHDR(&msg);
+        if(cmsg == NULL){
+                printk("rcv_fd didn't receive anything, error = %d\n", errno);
+                return(-1);
+        }
+        if((cmsg->cmsg_level != SOL_SOCKET) || 
+           (cmsg->cmsg_type != SCM_RIGHTS)){
+                printk("rcv_fd didn't receive a descriptor\n");
+                return(-1);
+        }
+
+        new = ((int *) CMSG_DATA(cmsg))[0];
+        return(new);
+}
+
+int os_create_unix_socket(char *file, int len, int close_on_exec)
+{
+        struct sockaddr_un addr;
+        int sock, err;
+
+        sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+        if (sock < 0){
+                printk("create_unix_socket - socket failed, errno = %d\n",
+                       errno);
+                return(-errno);
+        }
+
+        if(close_on_exec) {
+                err = os_set_exec_close(sock, 1);
+                if(err < 0)
+                        printk("create_unix_socket : close_on_exec failed, "
+                       "err = %d", -err);
+        }
+
+        addr.sun_family = AF_UNIX;
+
+        /* XXX Be more careful about overflow */
+        snprintf(addr.sun_path, len, "%s", file);
+
+        err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
+        if (err < 0){
+                printk("create_listening_socket at '%s' - bind failed, "
+                       "errno = %d\n", file, errno);
+                return(-errno);
+        }
+
+        return(sock);
+}
+
+void os_flush_stdout(void)
+{
+        fflush(stdout);
+}
+
+int os_lock_file(int fd, int excl)
+{
+        int type = excl ? F_WRLCK : F_RDLCK;
+        struct flock lock = ((struct flock) { .l_type   = type,
+                                              .l_whence = SEEK_SET,
+                                              .l_start  = 0,
+                                              .l_len    = 0 } );
+        int err, save;
+
+        err = fcntl(fd, F_SETLK, &lock);
+        if(!err)
+                goto out;
+
+        save = -errno;
+        err = fcntl(fd, F_GETLK, &lock);
+        if(err){
+                err = -errno;
+                goto out;
+        }
+
+        printk("F_SETLK failed, file already locked by pid %d\n", lock.l_pid);
+        err = save;
+ out:
+        return(err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/include/file.h b/arch/um/os-Linux/include/file.h
new file mode 100644
index 000000000000..d82711efacfa
--- /dev/null
+++ b/arch/um/os-Linux/include/file.h
@@ -0,0 +1,22 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __OS_FILE_H__
+#define __OS_FILE_H__
+
+#define DEV_NULL "/dev/null"
+
+#endif
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
new file mode 100644
index 000000000000..ba9ca1cc790a
--- /dev/null
+++ b/arch/um/os-Linux/process.c
@@ -0,0 +1,171 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+#include <linux/unistd.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include "ptrace_user.h"
+#include "os.h"
+#include "user.h"
+#include "user_util.h"
+
+#define ARBITRARY_ADDR -1
+#define FAILURE_PID    -1
+
+#define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
+#define COMM_SCANF "%*[^)])"
+
+unsigned long os_process_pc(int pid)
+{
+        char proc_stat[STAT_PATH_LEN], buf[256];
+        unsigned long pc;
+        int fd, err;
+
+        sprintf(proc_stat, "/proc/%d/stat", pid);
+        fd = os_open_file(proc_stat, of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("os_process_pc - couldn't open '%s', err = %d\n",
+                       proc_stat, -fd);
+                return(ARBITRARY_ADDR);
+        }
+        err = os_read_file(fd, buf, sizeof(buf));
+        if(err < 0){
+                printk("os_process_pc - couldn't read '%s', err = %d\n",
+                       proc_stat, -err);
+                os_close_file(fd);
+                return(ARBITRARY_ADDR);
+        }
+        os_close_file(fd);
+        pc = ARBITRARY_ADDR;
+        if(sscanf(buf, "%*d " COMM_SCANF " %*c %*d %*d %*d %*d %*d %*d %*d "
+                  "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
+                  "%*d %*d %*d %*d %*d %lu", &pc) != 1){
+                printk("os_process_pc - couldn't find pc in '%s'\n", buf);
+        }
+        return(pc);
+}
+
+int os_process_parent(int pid)
+{
+        char stat[STAT_PATH_LEN];
+        char data[256];
+        int parent, n, fd;
+
+        if(pid == -1) return(-1);
+
+        snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
+        fd = os_open_file(stat, of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("Couldn't open '%s', err = %d\n", stat, -fd);
+                return(FAILURE_PID);
+        }
+
+        n = os_read_file(fd, data, sizeof(data));
+        os_close_file(fd);
+
+        if(n < 0){
+                printk("Couldn't read '%s', err = %d\n", stat, -n);
+                return(FAILURE_PID);
+        }
+
+        parent = FAILURE_PID;
+        n = sscanf(data, "%*d " COMM_SCANF " %*c %d", &parent);
+        if(n != 1)
+                printk("Failed to scan '%s'\n", data);
+
+        return(parent);
+}
+
+void os_stop_process(int pid)
+{
+        kill(pid, SIGSTOP);
+}
+
+void os_kill_process(int pid, int reap_child)
+{
+        kill(pid, SIGKILL);
+        if(reap_child)
+                CATCH_EINTR(waitpid(pid, NULL, 0));
+                
+}
+
+/* Kill off a ptraced child by all means available.  kill it normally first,
+ * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
+ * which it can't exit directly.
+ */
+
+void os_kill_ptraced_process(int pid, int reap_child)
+{
+        kill(pid, SIGKILL);
+        ptrace(PTRACE_KILL, pid);
+        ptrace(PTRACE_CONT, pid);
+        if(reap_child)
+                CATCH_EINTR(waitpid(pid, NULL, 0));
+}
+
+void os_usr1_process(int pid)
+{
+        kill(pid, SIGUSR1);
+}
+
+/*Don't use the glibc version, which caches the result in TLS. It misses some
+ * syscalls, and also breaks with clone(), which does not unshare the TLS.*/
+inline _syscall0(pid_t, getpid)
+
+int os_getpid(void)
+{
+        return(getpid());
+}
+
+int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
+                  int r, int w, int x)
+{
+        void *loc;
+        int prot;
+
+        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
+                (x ? PROT_EXEC : 0);
+
+        loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
+                     fd, off);
+        if(loc == MAP_FAILED)
+                return(-errno);
+        return(0);
+}
+
+int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
+{
+        int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
+                    (x ? PROT_EXEC : 0));
+
+        if(mprotect(addr, len, prot) < 0)
+                return(-errno);
+        return(0);
+}
+
+int os_unmap_memory(void *addr, int len)
+{
+        int err;
+
+        err = munmap(addr, len);
+        if(err < 0)
+                return(-errno);
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
new file mode 100644
index 000000000000..7eac1baf5975
--- /dev/null
+++ b/arch/um/os-Linux/signal.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include "time_user.h"
+#include "mode.h"
+#include "sysdep/signal.h"
+
+void sig_handler(int sig)
+{
+        struct sigcontext *sc;
+
+        ARCH_GET_SIGCONTEXT(sc, sig);
+        CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
+                         sig, sc);
+}
+
+extern int timer_irq_inited;
+
+void alarm_handler(int sig)
+{
+        struct sigcontext *sc;
+
+        ARCH_GET_SIGCONTEXT(sc, sig);
+        if(!timer_irq_inited) return;
+
+        if(sig == SIGALRM)
+                switch_timers(0);
+
+        CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
+                         sig, sc);
+
+        if(sig == SIGALRM)
+                switch_timers(1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/sys-i386/Makefile b/arch/um/os-Linux/sys-i386/Makefile
new file mode 100644
index 000000000000..340ef26f5944
--- /dev/null
+++ b/arch/um/os-Linux/sys-i386/Makefile
@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+obj-$(CONFIG_MODE_SKAS) = registers.o
+
+USER_OBJS := $(obj-y)
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/sys-i386/registers.c b/arch/um/os-Linux/sys-i386/registers.c
new file mode 100644
index 000000000000..148645b14480
--- /dev/null
+++ b/arch/um/os-Linux/sys-i386/registers.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#include <errno.h>
+#include <string.h>
+#include "sysdep/ptrace_user.h"
+#include "sysdep/ptrace.h"
+#include "uml-config.h"
+#include "skas_ptregs.h"
+#include "registers.h"
+#include "user.h"
+
+/* These are set once at boot time and not changed thereafter */
+
+static unsigned long exec_regs[HOST_FRAME_SIZE];
+static unsigned long exec_fp_regs[HOST_FP_SIZE];
+static unsigned long exec_fpx_regs[HOST_XFP_SIZE];
+static int have_fpx_regs = 1;
+
+void init_thread_registers(union uml_pt_regs *to)
+{
+        memcpy(to->skas.regs, exec_regs, sizeof(to->skas.regs));
+        memcpy(to->skas.fp, exec_fp_regs, sizeof(to->skas.fp));
+        if(have_fpx_regs)
+                memcpy(to->skas.xfp, exec_fpx_regs, sizeof(to->skas.xfp));
+}
+
+/* XXX These need to use [GS]ETFPXREGS and copy_sc_{to,from}_user_skas needs
+ * to pass in a sufficiently large buffer
+ */
+int save_fp_registers(int pid, unsigned long *fp_regs)
+{
+        if(ptrace(PTRACE_GETFPREGS, pid, 0, fp_regs) < 0)
+                return(-errno);
+        return(0);
+}
+
+int restore_fp_registers(int pid, unsigned long *fp_regs)
+{
+        if(ptrace(PTRACE_SETFPREGS, pid, 0, fp_regs) < 0)
+                return(-errno);
+        return(0);
+}
+
+static int move_registers(int pid, int int_op, union uml_pt_regs *regs,
+                          int fp_op, unsigned long *fp_regs)
+{
+        if(ptrace(int_op, pid, 0, regs->skas.regs) < 0)
+                return(-errno);
+
+        if(ptrace(fp_op, pid, 0, fp_regs) < 0)
+                return(-errno);
+
+        return(0);
+}
+
+void save_registers(int pid, union uml_pt_regs *regs)
+{
+        unsigned long *fp_regs;
+        int err, fp_op;
+
+        if(have_fpx_regs){
+                fp_op = PTRACE_GETFPXREGS;
+                fp_regs = regs->skas.xfp;
+        }
+        else {
+                fp_op = PTRACE_GETFPREGS;
+                fp_regs = regs->skas.fp;
+        }
+
+        err = move_registers(pid, PTRACE_GETREGS, regs, fp_op, fp_regs);
+        if(err)
+                panic("save_registers - saving registers failed, errno = %d\n",
+                      -err);
+}
+
+void restore_registers(int pid, union uml_pt_regs *regs)
+{
+        unsigned long *fp_regs;
+        int err, fp_op;
+
+        if(have_fpx_regs){
+                fp_op = PTRACE_SETFPXREGS;
+                fp_regs = regs->skas.xfp;
+        }
+        else {
+                fp_op = PTRACE_SETFPREGS;
+                fp_regs = regs->skas.fp;
+        }
+
+        err = move_registers(pid, PTRACE_SETREGS, regs, fp_op, fp_regs);
+        if(err)
+                panic("restore_registers - saving registers failed, "
+                      "errno = %d\n", -err);
+}
+
+void init_registers(int pid)
+{
+        int err;
+
+        err = ptrace(PTRACE_GETREGS, pid, 0, exec_regs);
+        if(err)
+                panic("check_ptrace : PTRACE_GETREGS failed, errno = %d",
+                      err);
+
+        err = ptrace(PTRACE_GETFPXREGS, pid, 0, exec_fpx_regs);
+        if(!err)
+                return;
+
+        have_fpx_regs = 0;
+        if(err != EIO)
+                panic("check_ptrace : PTRACE_GETFPXREGS failed, errno = %d",
+                      err);
+
+        err = ptrace(PTRACE_GETFPREGS, pid, 0, exec_fp_regs);
+        if(err)
+                panic("check_ptrace : PTRACE_GETFPREGS failed, errno = %d",
+                      err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/sys-x86_64/Makefile b/arch/um/os-Linux/sys-x86_64/Makefile
new file mode 100644
index 000000000000..340ef26f5944
--- /dev/null
+++ b/arch/um/os-Linux/sys-x86_64/Makefile
@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+obj-$(CONFIG_MODE_SKAS) = registers.o
+
+USER_OBJS := $(obj-y)
+
+include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/sys-x86_64/registers.c b/arch/um/os-Linux/sys-x86_64/registers.c
new file mode 100644
index 000000000000..6286c974bbeb
--- /dev/null
+++ b/arch/um/os-Linux/sys-x86_64/registers.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2004 PathScale, Inc
+ * Licensed under the GPL
+ */
+
+#include <errno.h>
+#include <string.h>
+#include "ptrace_user.h"
+#include "uml-config.h"
+#include "skas_ptregs.h"
+#include "registers.h"
+#include "user.h"
+
+/* These are set once at boot time and not changed thereafter */
+
+static unsigned long exec_regs[HOST_FRAME_SIZE];
+static unsigned long exec_fp_regs[HOST_FP_SIZE];
+
+void init_thread_registers(union uml_pt_regs *to)
+{
+        memcpy(to->skas.regs, exec_regs, sizeof(to->skas.regs));
+        memcpy(to->skas.fp, exec_fp_regs, sizeof(to->skas.fp));
+}
+
+static int move_registers(int pid, int int_op, int fp_op,
+                          union uml_pt_regs *regs)
+{
+        if(ptrace(int_op, pid, 0, regs->skas.regs) < 0)
+                return(-errno);
+
+        if(ptrace(fp_op, pid, 0, regs->skas.fp) < 0)
+                return(-errno);
+
+        return(0);
+}
+
+void save_registers(int pid, union uml_pt_regs *regs)
+{
+        int err;
+
+        err = move_registers(pid, PTRACE_GETREGS, PTRACE_GETFPREGS, regs);
+        if(err)
+                panic("save_registers - saving registers failed, errno = %d\n",
+                      -err);
+}
+
+void restore_registers(int pid, union uml_pt_regs *regs)
+{
+        int err;
+
+        err = move_registers(pid, PTRACE_SETREGS, PTRACE_SETFPREGS, regs);
+        if(err)
+                panic("restore_registers - saving registers failed, "
+                      "errno = %d\n", -err);
+}
+
+void init_registers(int pid)
+{
+        int err;
+
+        err = ptrace(PTRACE_GETREGS, pid, 0, exec_regs);
+        if(err)
+                panic("check_ptrace : PTRACE_GETREGS failed, errno = %d",
+                      err);
+
+        err = ptrace(PTRACE_GETFPREGS, pid, 0, exec_fp_regs);
+        if(err)
+                panic("check_ptrace : PTRACE_GETFPREGS failed, errno = %d",
+                      err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
new file mode 100644
index 000000000000..cf30a39bc484
--- /dev/null
+++ b/arch/um/os-Linux/time.c
@@ -0,0 +1,21 @@
+#include <stdlib.h>
+#include <sys/time.h>
+
+unsigned long long os_usecs(void)
+{
+        struct timeval tv;
+
+        gettimeofday(&tv, NULL);
+        return((unsigned long long) tv.tv_sec * 1000000 + tv.tv_usec);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/tty.c b/arch/um/os-Linux/tty.c
new file mode 100644
index 000000000000..4cfdd18ea1ef
--- /dev/null
+++ b/arch/um/os-Linux/tty.c
@@ -0,0 +1,61 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include "os.h"
+#include "user.h"
+#include "kern_util.h"
+
+struct grantpt_info {
+        int fd;
+        int res;
+        int err;
+};
+
+static void grantpt_cb(void *arg)
+{
+        struct grantpt_info *info = arg;
+
+        info->res = grantpt(info->fd);
+        info->err = errno;
+}
+
+int get_pty(void)
+{
+        struct grantpt_info info;
+        int fd;
+
+        fd = os_open_file("/dev/ptmx", of_rdwr(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("get_pty : Couldn't open /dev/ptmx - err = %d\n", -fd);
+                return(fd);
+        }
+
+        info.fd = fd;
+        initial_thread_cb(grantpt_cb, &info);
+
+        if(info.res < 0){
+                printk("get_pty : Couldn't grant pty - errno = %d\n", 
+                       -info.err);
+                return(-1);
+        }
+        if(unlockpt(fd) < 0){
+                printk("get_pty : Couldn't unlock pty - errno = %d\n", errno);
+                return(-1);
+        }
+        return(fd);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/user_syms.c b/arch/um/os-Linux/user_syms.c
new file mode 100644
index 000000000000..75d7af9ae1d2
--- /dev/null
+++ b/arch/um/os-Linux/user_syms.c
@@ -0,0 +1,95 @@
+#include "linux/types.h"
+#include "linux/module.h"
+
+/* Some of this are builtin function (some are not but could in the future),
+ * so I *must* declare good prototypes for them and then EXPORT them.
+ * The kernel code uses the macro defined by include/linux/string.h,
+ * so I undef macros; the userspace code does not include that and I
+ * add an EXPORT for the glibc one.*/
+
+#undef strlen
+#undef strstr
+#undef memcpy
+#undef memset
+
+extern size_t strlen(const char *);
+extern void *memcpy(void *, const void *, size_t);
+extern void *memmove(void *, const void *, size_t);
+extern void *memset(void *, int, size_t);
+extern int printf(const char *, ...);
+
+EXPORT_SYMBOL(strlen);
+EXPORT_SYMBOL(memcpy);
+EXPORT_SYMBOL(memmove);
+EXPORT_SYMBOL(memset);
+EXPORT_SYMBOL(printf);
+
+EXPORT_SYMBOL(strstr);
+
+/* Here, instead, I can provide a fake prototype. Yes, someone cares: genksyms.
+ * However, the modules will use the CRC defined *here*, no matter if it is
+ * good; so the versions of these symbols will always match
+ */
+#define EXPORT_SYMBOL_PROTO(sym)       \
+       int sym(void);                  \
+       EXPORT_SYMBOL(sym);
+
+#ifdef SUBARCH_i386
+EXPORT_SYMBOL(vsyscall_ehdr);
+EXPORT_SYMBOL(vsyscall_end);
+#endif
+
+EXPORT_SYMBOL_PROTO(__errno_location);
+
+EXPORT_SYMBOL_PROTO(access);
+EXPORT_SYMBOL_PROTO(open);
+EXPORT_SYMBOL_PROTO(open64);
+EXPORT_SYMBOL_PROTO(close);
+EXPORT_SYMBOL_PROTO(read);
+EXPORT_SYMBOL_PROTO(write);
+EXPORT_SYMBOL_PROTO(dup2);
+EXPORT_SYMBOL_PROTO(__xstat);
+EXPORT_SYMBOL_PROTO(__lxstat);
+EXPORT_SYMBOL_PROTO(__lxstat64);
+EXPORT_SYMBOL_PROTO(lseek);
+EXPORT_SYMBOL_PROTO(lseek64);
+EXPORT_SYMBOL_PROTO(chown);
+EXPORT_SYMBOL_PROTO(truncate);
+EXPORT_SYMBOL_PROTO(utime);
+EXPORT_SYMBOL_PROTO(chmod);
+EXPORT_SYMBOL_PROTO(rename);
+EXPORT_SYMBOL_PROTO(__xmknod);
+
+EXPORT_SYMBOL_PROTO(symlink);
+EXPORT_SYMBOL_PROTO(link);
+EXPORT_SYMBOL_PROTO(unlink);
+EXPORT_SYMBOL_PROTO(readlink);
+
+EXPORT_SYMBOL_PROTO(mkdir);
+EXPORT_SYMBOL_PROTO(rmdir);
+EXPORT_SYMBOL_PROTO(opendir);
+EXPORT_SYMBOL_PROTO(readdir);
+EXPORT_SYMBOL_PROTO(closedir);
+EXPORT_SYMBOL_PROTO(seekdir);
+EXPORT_SYMBOL_PROTO(telldir);
+
+EXPORT_SYMBOL_PROTO(ioctl);
+
+EXPORT_SYMBOL_PROTO(pread64);
+EXPORT_SYMBOL_PROTO(pwrite64);
+
+EXPORT_SYMBOL_PROTO(statfs);
+EXPORT_SYMBOL_PROTO(statfs64);
+
+EXPORT_SYMBOL_PROTO(getuid);
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/os-Linux/util/Makefile b/arch/um/os-Linux/util/Makefile
new file mode 100644
index 000000000000..fb00ddf969bd
--- /dev/null
+++ b/arch/um/os-Linux/util/Makefile
@@ -0,0 +1,4 @@
+hostprogs-y             := mk_user_constants
+always                  := $(hostprogs-y)
+
+mk_user_constants-objs  := mk_user_constants.o
diff --git a/arch/um/os-Linux/util/mk_user_constants.c b/arch/um/os-Linux/util/mk_user_constants.c
new file mode 100644
index 000000000000..0933518aa8bd
--- /dev/null
+++ b/arch/um/os-Linux/util/mk_user_constants.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <asm/types.h>
+/* For some reason, x86_64 nowhere defines u64 and u32, even though they're
+ * used throughout the headers.
+ */
+typedef __u64 u64;
+typedef __u32 u32;
+#include <asm/user.h>
+
+int main(int argc, char **argv)
+{
+  printf("/*\n");
+  printf(" * Generated by mk_user_constants\n");
+  printf(" */\n");
+  printf("\n");
+  printf("#ifndef __UM_USER_CONSTANTS_H\n");
+  printf("#define __UM_USER_CONSTANTS_H\n");
+  printf("\n");
+  /* I'd like to use FRAME_SIZE from ptrace.h here, but that's wrong on
+   * x86_64 (216 vs 168 bytes).  user_regs_struct is the correct size on
+   * both x86_64 and i386.
+   */
+  printf("#define UM_FRAME_SIZE %d\n", (int) sizeof(struct user_regs_struct));
+
+  printf("\n");
+  printf("#endif\n");
+
+  return(0);
+}
diff --git a/arch/um/scripts/Makefile.rules b/arch/um/scripts/Makefile.rules
new file mode 100644
index 000000000000..143f6fea0763
--- /dev/null
+++ b/arch/um/scripts/Makefile.rules
@@ -0,0 +1,13 @@
+# ===========================================================================
+# arch/um: Generic definitions
+# ===========================================================================
+
+USER_SINGLE_OBJS = $(foreach f,$(patsubst %.o,%,$(obj-y) $(obj-m)),$($(f)-objs))
+USER_OBJS += $(filter %_user.o,$(obj-y) $(obj-m) $(USER_SINGLE_OBJS))
+
+USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
+
+$(USER_OBJS): c_flags = -Wp,-MD,$(depfile) $(USER_CFLAGS) $(CFLAGS_$(notdir $@))
+
+quiet_cmd_make_link = SYMLINK $@
+cmd_make_link       = rm -f $@; ln -sf $(srctree)/arch/$(SUBARCH)/$($(notdir $@)-dir)/$(notdir $@) $@
diff --git a/arch/um/sys-i386/Makefile b/arch/um/sys-i386/Makefile
new file mode 100644
index 000000000000..71b47e618605
--- /dev/null
+++ b/arch/um/sys-i386/Makefile
@@ -0,0 +1,29 @@
+obj-y = bitops.o bugs.o checksum.o delay.o fault.o ksyms.o ldt.o ptrace.o \
+        ptrace_user.o semaphore.o signal.o sigcontext.o syscalls.o sysrq.o
+
+obj-$(CONFIG_HIGHMEM) += highmem.o
+obj-$(CONFIG_MODULES) += module.o
+
+USER_OBJS := bugs.o ptrace_user.o sigcontext.o fault.o
+
+include arch/um/scripts/Makefile.rules
+
+SYMLINKS = bitops.c semaphore.c highmem.c module.c
+
+# this needs to be before the foreach, because clean-files does not accept
+# complete paths like $(src)/$f.
+clean-files := $(SYMLINKS)
+
+targets += $(SYMLINKS)
+
+SYMLINKS := $(foreach f,$(SYMLINKS),$(obj)/$f)
+
+bitops.c-dir = lib
+semaphore.c-dir = kernel
+highmem.c-dir = mm
+module.c-dir = kernel
+
+$(SYMLINKS): FORCE
+        $(call if_changed,make_link)
+
+subdir- := util
diff --git a/arch/um/sys-i386/bugs.c b/arch/um/sys-i386/bugs.c
new file mode 100644
index 000000000000..41b0ab2fe830
--- /dev/null
+++ b/arch/um/sys-i386/bugs.c
@@ -0,0 +1,222 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/signal.h>
+#include <asm/ldt.h>
+#include "kern_util.h"
+#include "user.h"
+#include "sysdep/ptrace.h"
+#include "task.h"
+#include "os.h"
+
+#define MAXTOKEN 64
+
+/* Set during early boot */
+int host_has_cmov = 1;
+int host_has_xmm = 0;
+
+static char token(int fd, char *buf, int len, char stop)
+{
+        int n;
+        char *ptr, *end, c;
+
+        ptr = buf;
+        end = &buf[len];
+        do {
+                n = os_read_file(fd, ptr, sizeof(*ptr));
+                c = *ptr++;
+                if(n != sizeof(*ptr)){
+                        if(n == 0) return(0);
+                        printk("Reading /proc/cpuinfo failed, err = %d\n", -n);
+                        if(n < 0)
+                                return(n);
+                        else
+                                return(-EIO);
+                }
+        } while((c != '\n') && (c != stop) && (ptr < end));
+
+        if(ptr == end){
+                printk("Failed to find '%c' in /proc/cpuinfo\n", stop);
+                return(-1);
+        }
+        *(ptr - 1) = '\0';
+        return(c);
+}
+
+static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
+{
+        int n;
+        char c;
+
+        scratch[len - 1] = '\0';
+        while(1){
+                c = token(fd, scratch, len - 1, ':');
+                if(c <= 0)
+                        return(0);
+                else if(c != ':'){
+                        printk("Failed to find ':' in /proc/cpuinfo\n");
+                        return(0);
+                }
+
+                if(!strncmp(scratch, key, strlen(key)))
+                        return(1);
+
+                do {
+                        n = os_read_file(fd, &c, sizeof(c));
+                        if(n != sizeof(c)){
+                                printk("Failed to find newline in "
+                                       "/proc/cpuinfo, err = %d\n", -n);
+                                return(0);
+                        }
+                } while(c != '\n');
+        }
+        return(0);
+}
+
+int cpu_feature(char *what, char *buf, int len)
+{
+        int fd, ret = 0;
+
+        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("Couldn't open /proc/cpuinfo, err = %d\n", -fd);
+                return(0);
+        }
+
+        if(!find_cpuinfo_line(fd, what, buf, len)){
+                printk("Couldn't find '%s' line in /proc/cpuinfo\n", what);
+                goto out_close;
+        }
+
+        token(fd, buf, len, '\n');
+        ret = 1;
+
+ out_close:
+        os_close_file(fd);
+        return(ret);
+}
+
+static int check_cpu_flag(char *feature, int *have_it)
+{
+        char buf[MAXTOKEN], c;
+        int fd, len = sizeof(buf)/sizeof(buf[0]);
+
+        printk("Checking for host processor %s support...", feature);
+        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("Couldn't open /proc/cpuinfo, err = %d\n", -fd);
+                return(0);
+        }
+
+        *have_it = 0;
+        if(!find_cpuinfo_line(fd, "flags", buf, sizeof(buf) / sizeof(buf[0])))
+                goto out;
+
+        c = token(fd, buf, len - 1, ' ');
+        if(c < 0) goto out;
+        else if(c != ' '){
+                printk("Failed to find ' ' in /proc/cpuinfo\n");
+                goto out;
+        }
+
+        while(1){
+                c = token(fd, buf, len - 1, ' ');
+                if(c < 0) goto out;
+                else if(c == '\n') break;
+
+                if(!strcmp(buf, feature)){
+                        *have_it = 1;
+                        goto out;
+                }
+        }
+ out:
+        if(*have_it == 0) printk("No\n");
+        else if(*have_it == 1) printk("Yes\n");
+        os_close_file(fd);
+        return(1);
+}
+
+#if 0 /* This doesn't work in tt mode, plus it's causing compilation problems
+       * for some people.
+       */
+static void disable_lcall(void)
+{
+        struct modify_ldt_ldt_s ldt;
+        int err;
+
+        bzero(&ldt, sizeof(ldt));
+        ldt.entry_number = 7;
+        ldt.base_addr = 0;
+        ldt.limit = 0;
+        err = modify_ldt(1, &ldt, sizeof(ldt));
+        if(err)
+                printk("Failed to disable lcall7 - errno = %d\n", errno);
+}
+#endif
+
+void arch_init_thread(void)
+{
+#if 0
+        disable_lcall();
+#endif
+}
+
+void arch_check_bugs(void)
+{
+        int have_it;
+
+        if(os_access("/proc/cpuinfo", OS_ACC_R_OK) < 0){
+                printk("/proc/cpuinfo not available - skipping CPU capability "
+                       "checks\n");
+                return;
+        }
+        if(check_cpu_flag("cmov", &have_it))
+                host_has_cmov = have_it;
+        if(check_cpu_flag("xmm", &have_it))
+                host_has_xmm = have_it;
+}
+
+int arch_handle_signal(int sig, union uml_pt_regs *regs)
+{
+        unsigned char tmp[2];
+
+        /* This is testing for a cmov (0x0f 0x4x) instruction causing a
+         * SIGILL in init.
+         */
+        if((sig != SIGILL) || (TASK_PID(get_current()) != 1)) return(0);
+
+        if (copy_from_user_proc(tmp, (void *) UPT_IP(regs), 2))
+                panic("SIGILL in init, could not read instructions!\n");
+        if((tmp[0] != 0x0f) || ((tmp[1] & 0xf0) != 0x40))
+                return(0);
+
+        if(host_has_cmov == 0)
+                panic("SIGILL caused by cmov, which this processor doesn't "
+                      "implement, boot a filesystem compiled for older "
+                      "processors");
+        else if(host_has_cmov == 1)
+                panic("SIGILL caused by cmov, which this processor claims to "
+                      "implement");
+        else if(host_has_cmov == -1)
+                panic("SIGILL caused by cmov, couldn't tell if this processor "
+                      "implements it, boot a filesystem compiled for older "
+                      "processors");
+        else panic("Bad value for host_has_cmov (%d)", host_has_cmov);
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/checksum.S b/arch/um/sys-i386/checksum.S
new file mode 100644
index 000000000000..a11171fb6223
--- /dev/null
+++ b/arch/um/sys-i386/checksum.S
@@ -0,0 +1,460 @@
+/*
+ * INET         An implementation of the TCP/IP protocol suite for the LINUX
+ *              operating system.  INET is implemented using the  BSD Socket
+ *              interface as the means of communication with the user level.
+ *
+ *              IP/TCP/UDP checksumming routines
+ *
+ * Authors:     Jorge Cwik, <jorge@laser.satlink.net>
+ *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
+ *              Tom May, <ftom@netcom.com>
+ *              Pentium Pro/II routines:
+ *              Alexander Kjeldaas <astor@guardian.no>
+ *              Finn Arne Gangstad <finnag@guardian.no>
+ *              Lots of code moved from tcp.c and ip.c; see those files
+ *              for more names.
+ *
+ * Changes:     Ingo Molnar, converted csum_partial_copy() to 2.1 exception
+ *                           handling.
+ *              Andi Kleen,  add zeroing on error
+ *                   converted to pure assembler
+ *
+ *              This program is free software; you can redistribute it and/or
+ *              modify it under the terms of the GNU General Public License
+ *              as published by the Free Software Foundation; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/config.h>
+#include <asm/errno.h>
+                                
+/*
+ * computes a partial checksum, e.g. for TCP/UDP fragments
+ */
+
+/*      
+unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
+ */
+                
+.text
+.align 4
+.globl arch_csum_partial                                                                
+                
+#ifndef CONFIG_X86_USE_PPRO_CHECKSUM
+
+          /*            
+           * Experiments with Ethernet and SLIP connections show that buff
+           * is aligned on either a 2-byte or 4-byte boundary.  We get at
+           * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
+           * Fortunately, it is easy to convert 2-byte alignment to 4-byte
+           * alignment for the unrolled loop.
+           */           
+arch_csum_partial:      
+        pushl %esi
+        pushl %ebx
+        movl 20(%esp),%eax      # Function arg: unsigned int sum
+        movl 16(%esp),%ecx      # Function arg: int len
+        movl 12(%esp),%esi      # Function arg: unsigned char *buff
+        testl $2, %esi          # Check alignment.
+        jz 2f                   # Jump if alignment is ok.
+        subl $2, %ecx           # Alignment uses up two bytes.
+        jae 1f                  # Jump if we had at least two bytes.
+        addl $2, %ecx           # ecx was < 2.  Deal with it.
+        jmp 4f
+1:      movw (%esi), %bx
+        addl $2, %esi
+        addw %bx, %ax
+        adcl $0, %eax
+2:
+        movl %ecx, %edx
+        shrl $5, %ecx
+        jz 2f
+        testl %esi, %esi
+1:      movl (%esi), %ebx
+        adcl %ebx, %eax
+        movl 4(%esi), %ebx
+        adcl %ebx, %eax
+        movl 8(%esi), %ebx
+        adcl %ebx, %eax
+        movl 12(%esi), %ebx
+        adcl %ebx, %eax
+        movl 16(%esi), %ebx
+        adcl %ebx, %eax
+        movl 20(%esi), %ebx
+        adcl %ebx, %eax
+        movl 24(%esi), %ebx
+        adcl %ebx, %eax
+        movl 28(%esi), %ebx
+        adcl %ebx, %eax
+        lea 32(%esi), %esi
+        dec %ecx
+        jne 1b
+        adcl $0, %eax
+2:      movl %edx, %ecx
+        andl $0x1c, %edx
+        je 4f
+        shrl $2, %edx           # This clears CF
+3:      adcl (%esi), %eax
+        lea 4(%esi), %esi
+        dec %edx
+        jne 3b
+        adcl $0, %eax
+4:      andl $3, %ecx
+        jz 7f
+        cmpl $2, %ecx
+        jb 5f
+        movw (%esi),%cx
+        leal 2(%esi),%esi
+        je 6f
+        shll $16,%ecx
+5:      movb (%esi),%cl
+6:      addl %ecx,%eax
+        adcl $0, %eax 
+7:      
+        popl %ebx
+        popl %esi
+        ret
+
+#else
+
+/* Version for PentiumII/PPro */
+
+arch_csum_partial:
+        pushl %esi
+        pushl %ebx
+        movl 20(%esp),%eax      # Function arg: unsigned int sum
+        movl 16(%esp),%ecx      # Function arg: int len
+        movl 12(%esp),%esi      # Function arg: const unsigned char *buf
+
+        testl $2, %esi         
+        jnz 30f                 
+10:
+        movl %ecx, %edx
+        movl %ecx, %ebx
+        andl $0x7c, %ebx
+        shrl $7, %ecx
+        addl %ebx,%esi
+        shrl $2, %ebx  
+        negl %ebx
+        lea 45f(%ebx,%ebx,2), %ebx
+        testl %esi, %esi
+        jmp *%ebx
+
+        # Handle 2-byte-aligned regions
+20:     addw (%esi), %ax
+        lea 2(%esi), %esi
+        adcl $0, %eax
+        jmp 10b
+
+30:     subl $2, %ecx          
+        ja 20b                 
+        je 32f
+        movzbl (%esi),%ebx      # csumming 1 byte, 2-aligned
+        addl %ebx, %eax
+        adcl $0, %eax
+        jmp 80f
+32:
+        addw (%esi), %ax        # csumming 2 bytes, 2-aligned
+        adcl $0, %eax
+        jmp 80f
+
+40: 
+        addl -128(%esi), %eax
+        adcl -124(%esi), %eax
+        adcl -120(%esi), %eax
+        adcl -116(%esi), %eax   
+        adcl -112(%esi), %eax   
+        adcl -108(%esi), %eax
+        adcl -104(%esi), %eax
+        adcl -100(%esi), %eax
+        adcl -96(%esi), %eax
+        adcl -92(%esi), %eax
+        adcl -88(%esi), %eax
+        adcl -84(%esi), %eax
+        adcl -80(%esi), %eax
+        adcl -76(%esi), %eax
+        adcl -72(%esi), %eax
+        adcl -68(%esi), %eax
+        adcl -64(%esi), %eax     
+        adcl -60(%esi), %eax     
+        adcl -56(%esi), %eax     
+        adcl -52(%esi), %eax   
+        adcl -48(%esi), %eax   
+        adcl -44(%esi), %eax
+        adcl -40(%esi), %eax
+        adcl -36(%esi), %eax
+        adcl -32(%esi), %eax
+        adcl -28(%esi), %eax
+        adcl -24(%esi), %eax
+        adcl -20(%esi), %eax
+        adcl -16(%esi), %eax
+        adcl -12(%esi), %eax
+        adcl -8(%esi), %eax
+        adcl -4(%esi), %eax
+45:
+        lea 128(%esi), %esi
+        adcl $0, %eax
+        dec %ecx
+        jge 40b
+        movl %edx, %ecx
+50:     andl $3, %ecx
+        jz 80f
+
+        # Handle the last 1-3 bytes without jumping
+        notl %ecx               # 1->2, 2->1, 3->0, higher bits are masked
+        movl $0xffffff,%ebx     # by the shll and shrl instructions
+        shll $3,%ecx
+        shrl %cl,%ebx
+        andl -128(%esi),%ebx    # esi is 4-aligned so should be ok
+        addl %ebx,%eax
+        adcl $0,%eax
+80: 
+        popl %ebx
+        popl %esi
+        ret
+                                
+#endif
+
+/*
+unsigned int csum_partial_copy_generic (const char *src, char *dst,
+                                  int len, int sum, int *src_err_ptr, int *dst_err_ptr)
+ */ 
+
+/*
+ * Copy from ds while checksumming, otherwise like csum_partial
+ *
+ * The macros SRC and DST specify the type of access for the instruction.
+ * thus we can call a custom exception handler for all access types.
+ *
+ * FIXME: could someone double-check whether I haven't mixed up some SRC and
+ *        DST definitions? It's damn hard to trigger all cases.  I hope I got
+ *        them all but there's no guarantee.
+ */
+
+#define SRC(y...)                       \
+        9999: y;                        \
+        .section __ex_table, "a";       \
+        .long 9999b, 6001f      ;       \
+        .previous
+
+#define DST(y...)                       \
+        9999: y;                        \
+        .section __ex_table, "a";       \
+        .long 9999b, 6002f      ;       \
+        .previous
+
+.align 4
+.globl csum_partial_copy_generic_i386
+                                
+#ifndef CONFIG_X86_USE_PPRO_CHECKSUM
+
+#define ARGBASE 16              
+#define FP              12
+                
+csum_partial_copy_generic_i386:
+        subl  $4,%esp   
+        pushl %edi
+        pushl %esi
+        pushl %ebx
+        movl ARGBASE+16(%esp),%eax      # sum
+        movl ARGBASE+12(%esp),%ecx      # len
+        movl ARGBASE+4(%esp),%esi       # src
+        movl ARGBASE+8(%esp),%edi       # dst
+
+        testl $2, %edi                  # Check alignment. 
+        jz 2f                           # Jump if alignment is ok.
+        subl $2, %ecx                   # Alignment uses up two bytes.
+        jae 1f                          # Jump if we had at least two bytes.
+        addl $2, %ecx                   # ecx was < 2.  Deal with it.
+        jmp 4f
+SRC(1:  movw (%esi), %bx        )
+        addl $2, %esi
+DST(    movw %bx, (%edi)        )
+        addl $2, %edi
+        addw %bx, %ax   
+        adcl $0, %eax
+2:
+        movl %ecx, FP(%esp)
+        shrl $5, %ecx
+        jz 2f
+        testl %esi, %esi
+SRC(1:  movl (%esi), %ebx       )
+SRC(    movl 4(%esi), %edx      )
+        adcl %ebx, %eax
+DST(    movl %ebx, (%edi)       )
+        adcl %edx, %eax
+DST(    movl %edx, 4(%edi)      )
+
+SRC(    movl 8(%esi), %ebx      )
+SRC(    movl 12(%esi), %edx     )
+        adcl %ebx, %eax
+DST(    movl %ebx, 8(%edi)      )
+        adcl %edx, %eax
+DST(    movl %edx, 12(%edi)     )
+
+SRC(    movl 16(%esi), %ebx     )
+SRC(    movl 20(%esi), %edx     )
+        adcl %ebx, %eax
+DST(    movl %ebx, 16(%edi)     )
+        adcl %edx, %eax
+DST(    movl %edx, 20(%edi)     )
+
+SRC(    movl 24(%esi), %ebx     )
+SRC(    movl 28(%esi), %edx     )
+        adcl %ebx, %eax
+DST(    movl %ebx, 24(%edi)     )
+        adcl %edx, %eax
+DST(    movl %edx, 28(%edi)     )
+
+        lea 32(%esi), %esi
+        lea 32(%edi), %edi
+        dec %ecx
+        jne 1b
+        adcl $0, %eax
+2:      movl FP(%esp), %edx
+        movl %edx, %ecx
+        andl $0x1c, %edx
+        je 4f
+        shrl $2, %edx                   # This clears CF
+SRC(3:  movl (%esi), %ebx       )
+        adcl %ebx, %eax
+DST(    movl %ebx, (%edi)       )
+        lea 4(%esi), %esi
+        lea 4(%edi), %edi
+        dec %edx
+        jne 3b
+        adcl $0, %eax
+4:      andl $3, %ecx
+        jz 7f
+        cmpl $2, %ecx
+        jb 5f
+SRC(    movw (%esi), %cx        )
+        leal 2(%esi), %esi
+DST(    movw %cx, (%edi)        )
+        leal 2(%edi), %edi
+        je 6f
+        shll $16,%ecx
+SRC(5:  movb (%esi), %cl        )
+DST(    movb %cl, (%edi)        )
+6:      addl %ecx, %eax
+        adcl $0, %eax
+7:
+5000:
+
+# Exception handler:
+.section .fixup, "ax"                                                   
+
+6001:
+        movl ARGBASE+20(%esp), %ebx     # src_err_ptr
+        movl $-EFAULT, (%ebx)
+
+        # zero the complete destination - computing the rest
+        # is too much work 
+        movl ARGBASE+8(%esp), %edi      # dst
+        movl ARGBASE+12(%esp), %ecx     # len
+        xorl %eax,%eax
+        rep ; stosb
+
+        jmp 5000b
+
+6002:
+        movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
+        movl $-EFAULT,(%ebx)
+        jmp 5000b
+
+.previous
+
+        popl %ebx
+        popl %esi
+        popl %edi
+        popl %ecx                       # equivalent to addl $4,%esp
+        ret     
+
+#else
+
+/* Version for PentiumII/PPro */
+
+#define ROUND1(x) \
+        SRC(movl x(%esi), %ebx  )       ;       \
+        addl %ebx, %eax                 ;       \
+        DST(movl %ebx, x(%edi)  )       ; 
+
+#define ROUND(x) \
+        SRC(movl x(%esi), %ebx  )       ;       \
+        adcl %ebx, %eax                 ;       \
+        DST(movl %ebx, x(%edi)  )       ;
+
+#define ARGBASE 12
+                
+csum_partial_copy_generic_i386:
+        pushl %ebx
+        pushl %edi
+        pushl %esi
+        movl ARGBASE+4(%esp),%esi       #src
+        movl ARGBASE+8(%esp),%edi       #dst    
+        movl ARGBASE+12(%esp),%ecx      #len
+        movl ARGBASE+16(%esp),%eax      #sum
+#       movl %ecx, %edx  
+        movl %ecx, %ebx  
+        movl %esi, %edx
+        shrl $6, %ecx     
+        andl $0x3c, %ebx  
+        negl %ebx
+        subl %ebx, %esi  
+        subl %ebx, %edi  
+        lea  -1(%esi),%edx
+        andl $-32,%edx
+        lea 3f(%ebx,%ebx), %ebx
+        testl %esi, %esi 
+        jmp *%ebx
+1:      addl $64,%esi
+        addl $64,%edi 
+        SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
+        ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52)    
+        ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36)    
+        ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20)    
+        ROUND (-16) ROUND(-12) ROUND(-8)  ROUND(-4)     
+3:      adcl $0,%eax
+        addl $64, %edx
+        dec %ecx
+        jge 1b
+4:      movl ARGBASE+12(%esp),%edx      #len
+        andl $3, %edx
+        jz 7f
+        cmpl $2, %edx
+        jb 5f
+SRC(    movw (%esi), %dx         )
+        leal 2(%esi), %esi
+DST(    movw %dx, (%edi)         )
+        leal 2(%edi), %edi
+        je 6f
+        shll $16,%edx
+5:
+SRC(    movb (%esi), %dl         )
+DST(    movb %dl, (%edi)         )
+6:      addl %edx, %eax
+        adcl $0, %eax
+7:
+.section .fixup, "ax"
+6001:   movl    ARGBASE+20(%esp), %ebx  # src_err_ptr   
+        movl $-EFAULT, (%ebx)
+        # zero the complete destination (computing the rest is too much work)
+        movl ARGBASE+8(%esp),%edi       # dst
+        movl ARGBASE+12(%esp),%ecx      # len
+        xorl %eax,%eax
+        rep; stosb
+        jmp 7b
+6002:   movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
+        movl $-EFAULT, (%ebx)
+        jmp  7b                 
+.previous                               
+
+        popl %esi
+        popl %edi
+        popl %ebx
+        ret
+                                
+#undef ROUND
+#undef ROUND1           
+                
+#endif
diff --git a/arch/um/sys-i386/delay.c b/arch/um/sys-i386/delay.c
new file mode 100644
index 000000000000..20d37dbbaf08
--- /dev/null
+++ b/arch/um/sys-i386/delay.c
@@ -0,0 +1,14 @@
+void __delay(unsigned long time)
+{
+        /* Stolen from the i386 __loop_delay */
+        int d0;
+        __asm__ __volatile__(
+                "\tjmp 1f\n"
+                ".align 16\n"
+                "1:\tjmp 2f\n"
+                ".align 16\n"
+                "2:\tdecl %0\n\tjns 2b"
+                :"=&a" (d0)
+                :"0" (time));
+}
+
diff --git a/arch/um/sys-i386/fault.c b/arch/um/sys-i386/fault.c
new file mode 100644
index 000000000000..d0bbcdfdb53f
--- /dev/null
+++ b/arch/um/sys-i386/fault.c
@@ -0,0 +1,42 @@
+/* 
+ * Copyright (C) 2002 - 2004 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include <signal.h>
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+
+/* These two are from asm-um/uaccess.h and linux/module.h, check them. */
+struct exception_table_entry
+{
+        unsigned long insn;
+        unsigned long fixup;
+};
+
+const struct exception_table_entry *search_exception_tables(unsigned long add);
+
+/* Compare this to arch/i386/mm/extable.c:fixup_exception() */
+int arch_fixup(unsigned long address, void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        const struct exception_table_entry *fixup;
+
+        fixup = search_exception_tables(address);
+        if(fixup != 0){
+                sc->eip = fixup->fixup;
+                return(1);
+        }
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/ksyms.c b/arch/um/sys-i386/ksyms.c
new file mode 100644
index 000000000000..74f70a120458
--- /dev/null
+++ b/arch/um/sys-i386/ksyms.c
@@ -0,0 +1,17 @@
+#include "linux/module.h"
+#include "linux/in6.h"
+#include "linux/rwsem.h"
+#include "asm/byteorder.h"
+#include "asm/semaphore.h"
+#include "asm/uaccess.h"
+#include "asm/checksum.h"
+#include "asm/errno.h"
+
+EXPORT_SYMBOL(__down_failed);
+EXPORT_SYMBOL(__down_failed_interruptible);
+EXPORT_SYMBOL(__down_failed_trylock);
+EXPORT_SYMBOL(__up_wakeup);
+
+/* Networking helper routines. */
+EXPORT_SYMBOL(csum_partial_copy_from);
+EXPORT_SYMBOL(csum_partial_copy_to);
diff --git a/arch/um/sys-i386/ldt.c b/arch/um/sys-i386/ldt.c
new file mode 100644
index 000000000000..31bcb2f997d4
--- /dev/null
+++ b/arch/um/sys-i386/ldt.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/config.h"
+#include "linux/slab.h"
+#include "asm/uaccess.h"
+#include "asm/ptrace.h"
+#include "choose-mode.h"
+#include "kern.h"
+
+#ifdef CONFIG_MODE_TT
+extern int modify_ldt(int func, void *ptr, unsigned long bytecount);
+
+/* XXX this needs copy_to_user and copy_from_user */
+
+int sys_modify_ldt_tt(int func, void __user *ptr, unsigned long bytecount)
+{
+        if (!access_ok(VERIFY_READ, ptr, bytecount))
+                return -EFAULT;
+
+        return modify_ldt(func, ptr, bytecount);
+}
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+extern int userspace_pid;
+
+#include "skas_ptrace.h"
+
+int sys_modify_ldt_skas(int func, void __user *ptr, unsigned long bytecount)
+{
+        struct ptrace_ldt ldt;
+        void *buf;
+        int res, n;
+
+        buf = kmalloc(bytecount, GFP_KERNEL);
+        if(buf == NULL)
+                return(-ENOMEM);
+
+        res = 0;
+
+        switch(func){
+        case 1:
+        case 0x11:
+                res = copy_from_user(buf, ptr, bytecount);
+                break;
+        }
+
+        if(res != 0){
+                res = -EFAULT;
+                goto out;
+        }
+
+        ldt = ((struct ptrace_ldt) { .func      = func,
+                                     .ptr       = buf,
+                                     .bytecount = bytecount });
+        res = ptrace(PTRACE_LDT, userspace_pid, 0, (unsigned long) &ldt);
+        if(res < 0)
+                goto out;
+
+        switch(func){
+        case 0:
+        case 2:
+                n = res;
+                res = copy_to_user(ptr, buf, n);
+                if(res != 0)
+                        res = -EFAULT;
+                else 
+                        res = n;
+                break;
+        }
+
+ out:
+        kfree(buf);
+        return(res);
+}
+#endif
+
+int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount)
+{
+        return(CHOOSE_MODE_PROC(sys_modify_ldt_tt, sys_modify_ldt_skas, func, 
+                                ptr, bytecount));
+}
+
+
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/ptrace.c b/arch/um/sys-i386/ptrace.c
new file mode 100644
index 000000000000..e470d28cdf84
--- /dev/null
+++ b/arch/um/sys-i386/ptrace.c
@@ -0,0 +1,369 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <linux/config.h>
+#include <linux/compiler.h>
+#include "linux/sched.h"
+#include "asm/elf.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+#include "asm/unistd.h"
+#include "sysdep/ptrace.h"
+#include "sysdep/sigcontext.h"
+#include "sysdep/sc.h"
+
+void arch_switch(void)
+{
+        update_debugregs(current->thread.arch.debugregs_seq);
+}
+
+int is_syscall(unsigned long addr)
+{
+        unsigned short instr;
+        int n;
+
+        n = copy_from_user(&instr, (void __user *) addr, sizeof(instr));
+        if(n){
+                printk("is_syscall : failed to read instruction from 0x%lx\n",
+                       addr);
+                return(0);
+        }
+        /* int 0x80 or sysenter */
+        return((instr == 0x80cd) || (instr == 0x340f));
+}
+
+/* determines which flags the user has access to. */
+/* 1 = access 0 = no access */
+#define FLAG_MASK 0x00044dd5
+
+int putreg(struct task_struct *child, int regno, unsigned long value)
+{
+        regno >>= 2;
+        switch (regno) {
+        case FS:
+                if (value && (value & 3) != 3)
+                        return -EIO;
+                PT_REGS_FS(&child->thread.regs) = value;
+                return 0;
+        case GS:
+                if (value && (value & 3) != 3)
+                        return -EIO;
+                PT_REGS_GS(&child->thread.regs) = value;
+                return 0;
+        case DS:
+        case ES:
+                if (value && (value & 3) != 3)
+                        return -EIO;
+                value &= 0xffff;
+                break;
+        case SS:
+        case CS:
+                if ((value & 3) != 3)
+                        return -EIO;
+                value &= 0xffff;
+                break;
+        case EFL:
+                value &= FLAG_MASK;
+                value |= PT_REGS_EFLAGS(&child->thread.regs);
+                break;
+        }
+        PT_REGS_SET(&child->thread.regs, regno, value);
+        return 0;
+}
+
+unsigned long getreg(struct task_struct *child, int regno)
+{
+        unsigned long retval = ~0UL;
+
+        regno >>= 2;
+        switch (regno) {
+        case FS:
+        case GS:
+        case DS:
+        case ES:
+        case SS:
+        case CS:
+                retval = 0xffff;
+                /* fall through */
+        default:
+                retval &= PT_REG(&child->thread.regs, regno);
+        }
+        return retval;
+}
+
+struct i387_fxsave_struct {
+        unsigned short  cwd;
+        unsigned short  swd;
+        unsigned short  twd;
+        unsigned short  fop;
+        long    fip;
+        long    fcs;
+        long    foo;
+        long    fos;
+        long    mxcsr;
+        long    reserved;
+        long    st_space[32];   /* 8*16 bytes for each FP-reg = 128 bytes */
+        long    xmm_space[32];  /* 8*16 bytes for each XMM-reg = 128 bytes */
+        long    padding[56];
+};
+
+/*
+ * FPU tag word conversions.
+ */
+
+static inline unsigned short twd_i387_to_fxsr( unsigned short twd )
+{
+        unsigned int tmp; /* to avoid 16 bit prefixes in the code */
+ 
+        /* Transform each pair of bits into 01 (valid) or 00 (empty) */
+        tmp = ~twd;
+        tmp = (tmp | (tmp>>1)) & 0x5555; /* 0V0V0V0V0V0V0V0V */
+        /* and move the valid bits to the lower byte. */
+        tmp = (tmp | (tmp >> 1)) & 0x3333; /* 00VV00VV00VV00VV */
+        tmp = (tmp | (tmp >> 2)) & 0x0f0f; /* 0000VVVV0000VVVV */
+        tmp = (tmp | (tmp >> 4)) & 0x00ff; /* 00000000VVVVVVVV */
+        return tmp;
+}
+
+static inline unsigned long twd_fxsr_to_i387( struct i387_fxsave_struct *fxsave )
+{
+        struct _fpxreg *st = NULL;
+        unsigned long twd = (unsigned long) fxsave->twd;
+        unsigned long tag;
+        unsigned long ret = 0xffff0000;
+        int i;
+
+#define FPREG_ADDR(f, n)        ((char *)&(f)->st_space + (n) * 16);
+
+        for ( i = 0 ; i < 8 ; i++ ) {
+                if ( twd & 0x1 ) {
+                        st = (struct _fpxreg *) FPREG_ADDR( fxsave, i );
+
+                        switch ( st->exponent & 0x7fff ) {
+                        case 0x7fff:
+                                tag = 2;                /* Special */
+                                break;
+                        case 0x0000:
+                                if ( !st->significand[0] &&
+                                     !st->significand[1] &&
+                                     !st->significand[2] &&
+                                     !st->significand[3] ) {
+                                        tag = 1;        /* Zero */
+                                } else {
+                                        tag = 2;        /* Special */
+                                }
+                                break;
+                        default:
+                                if ( st->significand[3] & 0x8000 ) {
+                                        tag = 0;        /* Valid */
+                                } else {
+                                        tag = 2;        /* Special */
+                                }
+                                break;
+                        }
+                } else {
+                        tag = 3;                        /* Empty */
+                }
+                ret |= (tag << (2 * i));
+                twd = twd >> 1;
+        }
+        return ret;
+}
+
+/*
+ * FXSR floating point environment conversions.
+ */
+
+#ifdef CONFIG_MODE_TT
+static inline int convert_fxsr_to_user_tt(struct _fpstate __user *buf,
+                                          struct pt_regs *regs)
+{
+        struct i387_fxsave_struct *fxsave = SC_FXSR_ENV(PT_REGS_SC(regs));
+        unsigned long env[7];
+        struct _fpreg __user *to;
+        struct _fpxreg *from;
+        int i;
+
+        env[0] = (unsigned long)fxsave->cwd | 0xffff0000;
+        env[1] = (unsigned long)fxsave->swd | 0xffff0000;
+        env[2] = twd_fxsr_to_i387(fxsave);
+        env[3] = fxsave->fip;
+        env[4] = fxsave->fcs | ((unsigned long)fxsave->fop << 16);
+        env[5] = fxsave->foo;
+        env[6] = fxsave->fos;
+
+        if ( __copy_to_user( buf, env, 7 * sizeof(unsigned long) ) )
+                return 1;
+
+        to = &buf->_st[0];
+        from = (struct _fpxreg *) &fxsave->st_space[0];
+        for ( i = 0 ; i < 8 ; i++, to++, from++ ) {
+                if ( __copy_to_user( to, from, sizeof(*to) ) )
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
+static inline int convert_fxsr_to_user(struct _fpstate __user *buf,
+                                       struct pt_regs *regs)
+{
+        return(CHOOSE_MODE(convert_fxsr_to_user_tt(buf, regs), 0));
+}
+
+#ifdef CONFIG_MODE_TT
+static inline int convert_fxsr_from_user_tt(struct pt_regs *regs,
+                                            struct _fpstate __user *buf)
+{
+        struct i387_fxsave_struct *fxsave = SC_FXSR_ENV(PT_REGS_SC(regs));
+        unsigned long env[7];
+        struct _fpxreg *to;
+        struct _fpreg __user *from;
+        int i;
+
+        if ( __copy_from_user( env, buf, 7 * sizeof(long) ) )
+                return 1;
+
+        fxsave->cwd = (unsigned short)(env[0] & 0xffff);
+        fxsave->swd = (unsigned short)(env[1] & 0xffff);
+        fxsave->twd = twd_i387_to_fxsr((unsigned short)(env[2] & 0xffff));
+        fxsave->fip = env[3];
+        fxsave->fop = (unsigned short)((env[4] & 0xffff0000) >> 16);
+        fxsave->fcs = (env[4] & 0xffff);
+        fxsave->foo = env[5];
+        fxsave->fos = env[6];
+
+        to = (struct _fpxreg *) &fxsave->st_space[0];
+        from = &buf->_st[0];
+        for ( i = 0 ; i < 8 ; i++, to++, from++ ) {
+                if ( __copy_from_user( to, from, sizeof(*from) ) )
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
+static inline int convert_fxsr_from_user(struct pt_regs *regs, 
+                                         struct _fpstate __user *buf)
+{
+        return(CHOOSE_MODE(convert_fxsr_from_user_tt(regs, buf), 0));
+}
+
+int get_fpregs(unsigned long buf, struct task_struct *child)
+{
+        int err;
+
+        err = convert_fxsr_to_user((struct _fpstate __user *) buf,
+                                   &child->thread.regs);
+        if(err) return(-EFAULT);
+        else return(0);
+}
+
+int set_fpregs(unsigned long buf, struct task_struct *child)
+{
+        int err;
+
+        err = convert_fxsr_from_user(&child->thread.regs, 
+                                     (struct _fpstate __user *) buf);
+        if(err) return(-EFAULT);
+        else return(0);
+}
+
+#ifdef CONFIG_MODE_TT
+int get_fpxregs_tt(unsigned long buf, struct task_struct *tsk)
+{
+        struct pt_regs *regs = &tsk->thread.regs;
+        struct i387_fxsave_struct *fxsave = SC_FXSR_ENV(PT_REGS_SC(regs));
+        int err;
+
+        err = __copy_to_user((void __user *) buf, fxsave,
+                             sizeof(struct user_fxsr_struct));
+        if(err) return -EFAULT;
+        else return 0;
+}
+#endif
+
+int get_fpxregs(unsigned long buf, struct task_struct *tsk)
+{
+        return(CHOOSE_MODE(get_fpxregs_tt(buf, tsk), 0));
+}
+
+#ifdef CONFIG_MODE_TT
+int set_fpxregs_tt(unsigned long buf, struct task_struct *tsk)
+{
+        struct pt_regs *regs = &tsk->thread.regs;
+        struct i387_fxsave_struct *fxsave = SC_FXSR_ENV(PT_REGS_SC(regs));
+        int err;
+
+        err = __copy_from_user(fxsave, (void __user *) buf,
+                               sizeof(struct user_fxsr_struct) );
+        if(err) return -EFAULT;
+        else return 0;
+}
+#endif
+
+int set_fpxregs(unsigned long buf, struct task_struct *tsk)
+{
+        return(CHOOSE_MODE(set_fpxregs_tt(buf, tsk), 0));
+}
+
+#ifdef notdef
+int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
+{
+        fpu->cwd = (((SC_FP_CW(PT_REGS_SC(regs)) & 0xffff) << 16) |
+                    (SC_FP_SW(PT_REGS_SC(regs)) & 0xffff));
+        fpu->swd = SC_FP_CSSEL(PT_REGS_SC(regs)) & 0xffff;
+        fpu->twd = SC_FP_IPOFF(PT_REGS_SC(regs));
+        fpu->fip = SC_FP_CSSEL(PT_REGS_SC(regs)) & 0xffff;
+        fpu->fcs = SC_FP_DATAOFF(PT_REGS_SC(regs));
+        fpu->foo = SC_FP_DATASEL(PT_REGS_SC(regs));
+        fpu->fos = 0;
+        memcpy(fpu->st_space, (void *) SC_FP_ST(PT_REGS_SC(regs)),
+               sizeof(fpu->st_space));
+        return(1);
+}
+#endif
+
+#ifdef CONFIG_MODE_TT
+static inline void copy_fpu_fxsave_tt(struct pt_regs *regs,
+                                      struct user_i387_struct *buf)
+{
+        struct i387_fxsave_struct *fpu = SC_FXSR_ENV(PT_REGS_SC(regs));
+        unsigned short *to;
+        unsigned short *from;
+        int i;
+
+        memcpy( buf, fpu, 7 * sizeof(long) );
+
+        to = (unsigned short *) &buf->st_space[0];
+        from = (unsigned short *) &fpu->st_space[0];
+        for ( i = 0 ; i < 8 ; i++, to += 5, from += 8 ) {
+                memcpy( to, from, 5 * sizeof(unsigned short) );
+        }
+}
+#endif
+
+static inline void copy_fpu_fxsave(struct pt_regs *regs,
+                                   struct user_i387_struct *buf)
+{
+        (void) CHOOSE_MODE(copy_fpu_fxsave_tt(regs, buf), 0);
+}
+
+int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu )
+{
+        copy_fpu_fxsave(regs, (struct user_i387_struct *) fpu);
+        return(1);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/ptrace_user.c b/arch/um/sys-i386/ptrace_user.c
new file mode 100644
index 000000000000..7c376c95de50
--- /dev/null
+++ b/arch/um/sys-i386/ptrace_user.c
@@ -0,0 +1,131 @@
+/* 
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <linux/stddef.h>
+#include "ptrace_user.h"
+/* Grr, asm/user.h includes asm/ptrace.h, so has to follow ptrace_user.h */
+#include <asm/user.h>
+#include "kern_util.h"
+#include "sysdep/thread.h"
+#include "user.h"
+#include "os.h"
+
+int ptrace_getregs(long pid, unsigned long *regs_out)
+{
+        if (ptrace(PTRACE_GETREGS, pid, 0, regs_out) < 0)
+                return -errno;
+        return 0;
+}
+
+int ptrace_setregs(long pid, unsigned long *regs)
+{
+        if (ptrace(PTRACE_SETREGS, pid, 0, regs) < 0)
+                return -errno;
+        return 0;
+}
+
+int ptrace_getfpregs(long pid, unsigned long *regs)
+{
+        if (ptrace(PTRACE_GETFPREGS, pid, 0, regs) < 0)
+                return -errno;
+        return 0;
+}
+
+int ptrace_setfpregs(long pid, unsigned long *regs)
+{
+        if (ptrace(PTRACE_SETFPREGS, pid, 0, regs) < 0)
+                return -errno;
+        return 0;
+}
+
+static void write_debugregs(int pid, unsigned long *regs)
+{
+        struct user *dummy;
+        int nregs, i;
+
+        dummy = NULL;
+        nregs = sizeof(dummy->u_debugreg)/sizeof(dummy->u_debugreg[0]);
+        for(i = 0; i < nregs; i++){
+                if((i == 4) || (i == 5)) continue;
+                if(ptrace(PTRACE_POKEUSR, pid, &dummy->u_debugreg[i],
+                          regs[i]) < 0)
+                        printk("write_debugregs - ptrace failed on "
+                               "register %d, value = 0x%x, errno = %d\n", i,
+                               regs[i], errno);
+        }
+}
+
+static void read_debugregs(int pid, unsigned long *regs)
+{
+        struct user *dummy;
+        int nregs, i;
+
+        dummy = NULL;
+        nregs = sizeof(dummy->u_debugreg)/sizeof(dummy->u_debugreg[0]);
+        for(i = 0; i < nregs; i++){
+                regs[i] = ptrace(PTRACE_PEEKUSR, pid,
+                                 &dummy->u_debugreg[i], 0);
+        }
+}
+
+/* Accessed only by the tracing thread */
+static unsigned long kernel_debugregs[8] = { [ 0 ... 7 ] = 0 };
+static int debugregs_seq = 0;
+
+void arch_enter_kernel(void *task, int pid)
+{
+        read_debugregs(pid, TASK_DEBUGREGS(task));
+        write_debugregs(pid, kernel_debugregs);
+}
+
+void arch_leave_kernel(void *task, int pid)
+{
+        read_debugregs(pid, kernel_debugregs);
+        write_debugregs(pid, TASK_DEBUGREGS(task));
+}
+
+void ptrace_pokeuser(unsigned long addr, unsigned long data)
+{
+        if((addr < offsetof(struct user, u_debugreg[0])) ||
+           (addr > offsetof(struct user, u_debugreg[7])))
+                return;
+        addr -= offsetof(struct user, u_debugreg[0]);
+        addr = addr >> 2;
+        if(kernel_debugregs[addr] == data) return;
+
+        kernel_debugregs[addr] = data;
+        debugregs_seq++;
+}
+
+static void update_debugregs_cb(void *arg)
+{
+        int pid = *((int *) arg);
+
+        write_debugregs(pid, kernel_debugregs);
+}
+
+void update_debugregs(int seq)
+{
+        int me;
+
+        if(seq == debugregs_seq) return;
+
+        me = os_getpid();
+        initial_thread_cb(update_debugregs_cb, &me);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/sigcontext.c b/arch/um/sys-i386/sigcontext.c
new file mode 100644
index 000000000000..467d489c31cd
--- /dev/null
+++ b/arch/um/sys-i386/sigcontext.c
@@ -0,0 +1,71 @@
+/* 
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <string.h>
+#include <asm/ptrace.h>
+#include <asm/sigcontext.h>
+#include "sysdep/ptrace.h"
+#include "kern_util.h"
+
+void sc_to_sc(void *to_ptr, void *from_ptr)
+{
+        struct sigcontext *to = to_ptr, *from = from_ptr;
+
+        memcpy(to, from, sizeof(*to) + sizeof(struct _fpstate));
+        if(from->fpstate != NULL)
+                to->fpstate = (struct _fpstate *) (to + 1);
+}
+
+unsigned long *sc_sigmask(void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        return &sc->oldmask;
+}
+
+int sc_get_fpregs(unsigned long buf, void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+        struct _fpstate *from = sc->fpstate, *to = (struct _fpstate *) buf;
+        int err = 0;
+
+        if(from == NULL){
+                err |= clear_user_proc(&to->cw, sizeof(to->cw));
+                err |= clear_user_proc(&to->sw, sizeof(to->sw));
+                err |= clear_user_proc(&to->tag, sizeof(to->tag));
+                err |= clear_user_proc(&to->ipoff, sizeof(to->ipoff));
+                err |= clear_user_proc(&to->cssel, sizeof(to->cssel));
+                err |= clear_user_proc(&to->dataoff, sizeof(to->dataoff));
+                err |= clear_user_proc(&to->datasel, sizeof(to->datasel));
+                err |= clear_user_proc(&to->_st, sizeof(to->_st));
+        }
+        else {
+                err |= copy_to_user_proc(&to->cw, &from->cw, sizeof(to->cw));
+                err |= copy_to_user_proc(&to->sw, &from->sw, sizeof(to->sw));
+                err |= copy_to_user_proc(&to->tag, &from->tag, 
+                                         sizeof(to->tag));
+                err |= copy_to_user_proc(&to->ipoff, &from->ipoff, 
+                                         sizeof(to->ipoff));
+                err |= copy_to_user_proc(&to->cssel,& from->cssel, 
+                                         sizeof(to->cssel));
+                err |= copy_to_user_proc(&to->dataoff, &from->dataoff, 
+                                    sizeof(to->dataoff));
+                err |= copy_to_user_proc(&to->datasel, &from->datasel, 
+                                    sizeof(to->datasel));
+                err |= copy_to_user_proc(to->_st, from->_st, sizeof(to->_st));
+        }
+        return(err);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/signal.c b/arch/um/sys-i386/signal.c
new file mode 100644
index 000000000000..76ba87254b25
--- /dev/null
+++ b/arch/um/sys-i386/signal.c
@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2004 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/signal.h"
+#include "linux/ptrace.h"
+#include "asm/current.h"
+#include "asm/ucontext.h"
+#include "asm/uaccess.h"
+#include "asm/unistd.h"
+#include "frame_kern.h"
+#include "signal_user.h"
+#include "sigcontext.h"
+#include "registers.h"
+#include "mode.h"
+
+#ifdef CONFIG_MODE_SKAS
+
+#include "skas.h"
+
+static int copy_sc_from_user_skas(struct pt_regs *regs,
+                                  struct sigcontext *from)
+{
+        struct sigcontext sc;
+        unsigned long fpregs[HOST_FP_SIZE];
+        int err;
+
+        err = copy_from_user(&sc, from, sizeof(sc));
+        err |= copy_from_user(fpregs, sc.fpstate, sizeof(fpregs));
+        if(err)
+                return(err);
+
+        REGS_GS(regs->regs.skas.regs) = sc.gs;
+        REGS_FS(regs->regs.skas.regs) = sc.fs;
+        REGS_ES(regs->regs.skas.regs) = sc.es;
+        REGS_DS(regs->regs.skas.regs) = sc.ds;
+        REGS_EDI(regs->regs.skas.regs) = sc.edi;
+        REGS_ESI(regs->regs.skas.regs) = sc.esi;
+        REGS_EBP(regs->regs.skas.regs) = sc.ebp;
+        REGS_SP(regs->regs.skas.regs) = sc.esp;
+        REGS_EBX(regs->regs.skas.regs) = sc.ebx;
+        REGS_EDX(regs->regs.skas.regs) = sc.edx;
+        REGS_ECX(regs->regs.skas.regs) = sc.ecx;
+        REGS_EAX(regs->regs.skas.regs) = sc.eax;
+        REGS_IP(regs->regs.skas.regs) = sc.eip;
+        REGS_CS(regs->regs.skas.regs) = sc.cs;
+        REGS_EFLAGS(regs->regs.skas.regs) = sc.eflags;
+        REGS_SS(regs->regs.skas.regs) = sc.ss;
+        regs->regs.skas.fault_addr = sc.cr2;
+        regs->regs.skas.fault_type = FAULT_WRITE(sc.err);
+        regs->regs.skas.trap_type = sc.trapno;
+
+        err = restore_fp_registers(userspace_pid[0], fpregs);
+        if(err < 0){
+                printk("copy_sc_from_user_skas - PTRACE_SETFPREGS failed, "
+                       "errno = %d\n", err);
+                return(1);
+        }
+
+        return(0);
+}
+
+int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
+                         struct pt_regs *regs, unsigned long fault_addr,
+                         int fault_type)
+{
+        struct sigcontext sc;
+        unsigned long fpregs[HOST_FP_SIZE];
+        int err;
+
+        sc.gs = REGS_GS(regs->regs.skas.regs);
+        sc.fs = REGS_FS(regs->regs.skas.regs);
+        sc.es = REGS_ES(regs->regs.skas.regs);
+        sc.ds = REGS_DS(regs->regs.skas.regs);
+        sc.edi = REGS_EDI(regs->regs.skas.regs);
+        sc.esi = REGS_ESI(regs->regs.skas.regs);
+        sc.ebp = REGS_EBP(regs->regs.skas.regs);
+        sc.esp = REGS_SP(regs->regs.skas.regs);
+        sc.ebx = REGS_EBX(regs->regs.skas.regs);
+        sc.edx = REGS_EDX(regs->regs.skas.regs);
+        sc.ecx = REGS_ECX(regs->regs.skas.regs);
+        sc.eax = REGS_EAX(regs->regs.skas.regs);
+        sc.eip = REGS_IP(regs->regs.skas.regs);
+        sc.cs = REGS_CS(regs->regs.skas.regs);
+        sc.eflags = REGS_EFLAGS(regs->regs.skas.regs);
+        sc.esp_at_signal = regs->regs.skas.regs[UESP];
+        sc.ss = regs->regs.skas.regs[SS];
+        sc.cr2 = fault_addr;
+        sc.err = TO_SC_ERR(fault_type);
+        sc.trapno = regs->regs.skas.trap_type;
+
+        err = save_fp_registers(userspace_pid[0], fpregs);
+        if(err < 0){
+                printk("copy_sc_to_user_skas - PTRACE_GETFPREGS failed, "
+                       "errno = %d\n", err);
+                return(1);
+        }
+        to_fp = (to_fp ? to_fp : (struct _fpstate *) (to + 1));
+        sc.fpstate = to_fp;
+
+        if(err)
+                return(err);
+
+        return(copy_to_user(to, &sc, sizeof(sc)) ||
+               copy_to_user(to_fp, fpregs, sizeof(fpregs)));
+}
+#endif
+
+#ifdef CONFIG_MODE_TT
+
+/* These copy a sigcontext to/from userspace.  They copy the fpstate pointer,
+ * blowing away the old, good one.  So, that value is saved, and then restored
+ * after the sigcontext copy.  In copy_from, the variable holding the saved
+ * fpstate pointer, and the sigcontext that it should be restored to are both
+ * in the kernel, so we can just restore using an assignment.  In copy_to, the
+ * saved pointer is in the kernel, but the sigcontext is in userspace, so we
+ * copy_to_user it.
+ */
+int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext *from,
+                         int fpsize)
+{
+        struct _fpstate *to_fp, *from_fp;
+        unsigned long sigs;
+        int err;
+
+        to_fp = to->fpstate;
+        from_fp = from->fpstate;
+        sigs = to->oldmask;
+        err = copy_from_user(to, from, sizeof(*to));
+        to->oldmask = sigs;
+        to->fpstate = to_fp;
+        if(to_fp != NULL)
+                err |= copy_from_user(to_fp, from_fp, fpsize);
+        return(err);
+}
+
+int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
+                       struct sigcontext *from, int fpsize)
+{
+        struct _fpstate *to_fp, *from_fp;
+        int err;
+
+        to_fp = (fp ? fp : (struct _fpstate *) (to + 1));
+        from_fp = from->fpstate;
+        err = copy_to_user(to, from, sizeof(*to));
+        if(from_fp != NULL){
+                err |= copy_to_user(&to->fpstate, &to_fp, sizeof(to->fpstate));
+                err |= copy_to_user(to_fp, from_fp, fpsize);
+        }
+        return(err);
+}
+#endif
+
+static int copy_sc_from_user(struct pt_regs *to, void __user *from)
+{
+        int ret;
+
+        ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from,
+                                               sizeof(struct _fpstate)),
+                          copy_sc_from_user_skas(to, from));
+        return(ret);
+}
+
+static int copy_sc_to_user(struct sigcontext *to, struct _fpstate *fp,
+                           struct pt_regs *from)
+{
+        return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
+                                              sizeof(*fp)),
+                           copy_sc_to_user_skas(to, fp, from,
+                                                current->thread.cr2,
+                                                current->thread.err)));
+}
+
+static int copy_ucontext_to_user(struct ucontext *uc, struct _fpstate *fp,
+                                 sigset_t *set, unsigned long sp)
+{
+        int err = 0;
+
+        err |= put_user(current->sas_ss_sp, &uc->uc_stack.ss_sp);
+        err |= put_user(sas_ss_flags(sp), &uc->uc_stack.ss_flags);
+        err |= put_user(current->sas_ss_size, &uc->uc_stack.ss_size);
+        err |= copy_sc_to_user(&uc->uc_mcontext, fp, &current->thread.regs);
+        err |= copy_to_user(&uc->uc_sigmask, set, sizeof(*set));
+        return(err);
+}
+
+struct sigframe
+{
+        char *pretcode;
+        int sig;
+        struct sigcontext sc;
+        struct _fpstate fpstate;
+        unsigned long extramask[_NSIG_WORDS-1];
+        char retcode[8];
+};
+
+struct rt_sigframe
+{
+        char *pretcode;
+        int sig;
+        struct siginfo *pinfo;
+        void *puc;
+        struct siginfo info;
+        struct ucontext uc;
+        struct _fpstate fpstate;
+        char retcode[8];
+};
+
+int setup_signal_stack_sc(unsigned long stack_top, int sig,
+                          struct k_sigaction *ka, struct pt_regs *regs,
+                          sigset_t *mask)
+{
+        struct sigframe __user *frame;
+        void *restorer;
+        int err = 0;
+
+        stack_top &= -8UL;
+        frame = (struct sigframe *) stack_top - 1;
+        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+                return 1;
+
+        restorer = (void *) frame->retcode;
+        if(ka->sa.sa_flags & SA_RESTORER)
+                restorer = ka->sa.sa_restorer;
+
+        err |= __put_user(restorer, &frame->pretcode);
+        err |= __put_user(sig, &frame->sig);
+        err |= copy_sc_to_user(&frame->sc, NULL, regs);
+        err |= __put_user(mask->sig[0], &frame->sc.oldmask);
+        if (_NSIG_WORDS > 1)
+                err |= __copy_to_user(&frame->extramask, &mask->sig[1],
+                                      sizeof(frame->extramask));
+
+        /*
+         * This is popl %eax ; movl $,%eax ; int $0x80
+         *
+         * WE DO NOT USE IT ANY MORE! It's only left here for historical
+         * reasons and because gdb uses it as a signature to notice
+         * signal handler stack frames.
+         */
+        err |= __put_user(0xb858, (short __user *)(frame->retcode+0));
+        err |= __put_user(__NR_sigreturn, (int __user *)(frame->retcode+2));
+        err |= __put_user(0x80cd, (short __user *)(frame->retcode+6));
+
+        if(err)
+                return(err);
+
+        PT_REGS_SP(regs) = (unsigned long) frame;
+        PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
+        PT_REGS_EAX(regs) = (unsigned long) sig;
+        PT_REGS_EDX(regs) = (unsigned long) 0;
+        PT_REGS_ECX(regs) = (unsigned long) 0;
+
+        if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
+                ptrace_notify(SIGTRAP);
+        return(0);
+}
+
+int setup_signal_stack_si(unsigned long stack_top, int sig,
+                          struct k_sigaction *ka, struct pt_regs *regs,
+                          siginfo_t *info, sigset_t *mask)
+{
+        struct rt_sigframe __user *frame;
+        void *restorer;
+        int err = 0;
+
+        stack_top &= -8UL;
+        frame = (struct rt_sigframe *) stack_top - 1;
+        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+                return 1;
+
+        restorer = (void *) frame->retcode;
+        if(ka->sa.sa_flags & SA_RESTORER)
+                restorer = ka->sa.sa_restorer;
+
+        err |= __put_user(restorer, &frame->pretcode);
+        err |= __put_user(sig, &frame->sig);
+        err |= __put_user(&frame->info, &frame->pinfo);
+        err |= __put_user(&frame->uc, &frame->puc);
+        err |= copy_siginfo_to_user(&frame->info, info);
+        err |= copy_ucontext_to_user(&frame->uc, &frame->fpstate, mask,
+                                     PT_REGS_SP(regs));
+
+        /*
+         * This is movl $,%eax ; int $0x80
+         *
+         * WE DO NOT USE IT ANY MORE! It's only left here for historical
+         * reasons and because gdb uses it as a signature to notice
+         * signal handler stack frames.
+         */
+        err |= __put_user(0xb8, (char __user *)(frame->retcode+0));
+        err |= __put_user(__NR_rt_sigreturn, (int __user *)(frame->retcode+1));
+        err |= __put_user(0x80cd, (short __user *)(frame->retcode+5));
+
+        if(err)
+                return(err);
+
+        PT_REGS_SP(regs) = (unsigned long) frame;
+        PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
+        PT_REGS_EAX(regs) = (unsigned long) sig;
+        PT_REGS_EDX(regs) = (unsigned long) &frame->info;
+        PT_REGS_ECX(regs) = (unsigned long) &frame->uc;
+
+        if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
+                ptrace_notify(SIGTRAP);
+        return(0);
+}
+
+long sys_sigreturn(struct pt_regs regs)
+{
+        unsigned long sp = PT_REGS_SP(&current->thread.regs);
+        struct sigframe __user *frame = (struct sigframe *)(sp - 8);
+        sigset_t set;
+        struct sigcontext __user *sc = &frame->sc;
+        unsigned long __user *oldmask = &sc->oldmask;
+        unsigned long __user *extramask = frame->extramask;
+        int sig_size = (_NSIG_WORDS - 1) * sizeof(unsigned long);
+
+        if(copy_from_user(&set.sig[0], oldmask, sizeof(&set.sig[0])) ||
+           copy_from_user(&set.sig[1], extramask, sig_size))
+                goto segfault;
+
+        sigdelsetmask(&set, ~_BLOCKABLE);
+
+        spin_lock_irq(&current->sighand->siglock);
+        current->blocked = set;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        if(copy_sc_from_user(&current->thread.regs, sc))
+                goto segfault;
+
+        /* Avoid ERESTART handling */
+        PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
+        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+
+ segfault:
+        force_sig(SIGSEGV, current);
+        return 0;
+}
+
+long sys_rt_sigreturn(struct pt_regs regs)
+{
+        unsigned long __user sp = PT_REGS_SP(&current->thread.regs);
+        struct rt_sigframe __user *frame = (struct rt_sigframe *) (sp - 4);
+        sigset_t set;
+        struct ucontext __user *uc = &frame->uc;
+        int sig_size = _NSIG_WORDS * sizeof(unsigned long);
+
+        if(copy_from_user(&set, &uc->uc_sigmask, sig_size))
+                goto segfault;
+
+        sigdelsetmask(&set, ~_BLOCKABLE);
+
+        spin_lock_irq(&current->sighand->siglock);
+        current->blocked = set;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        if(copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext))
+                goto segfault;
+
+        /* Avoid ERESTART handling */
+        PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
+        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+
+ segfault:
+        force_sig(SIGSEGV, current);
+        return 0;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/syscalls.c b/arch/um/sys-i386/syscalls.c
new file mode 100644
index 000000000000..335e2d89504d
--- /dev/null
+++ b/arch/um/sys-i386/syscalls.c
@@ -0,0 +1,210 @@
+/* 
+ * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/shm.h"
+#include "asm/ipc.h"
+#include "asm/mman.h"
+#include "asm/uaccess.h"
+#include "asm/unistd.h"
+
+/*
+ * Perform the select(nd, in, out, ex, tv) and mmap() system
+ * calls. Linux/i386 didn't use to be able to handle more than
+ * 4 system call parameters, so these system calls used a memory
+ * block for parameter passing..
+ */
+
+struct mmap_arg_struct {
+        unsigned long addr;
+        unsigned long len;
+        unsigned long prot;
+        unsigned long flags;
+        unsigned long fd;
+        unsigned long offset;
+};
+
+extern int old_mmap(unsigned long addr, unsigned long len,
+                    unsigned long prot, unsigned long flags,
+                    unsigned long fd, unsigned long offset);
+
+long old_mmap_i386(struct mmap_arg_struct __user *arg)
+{
+        struct mmap_arg_struct a;
+        int err = -EFAULT;
+
+        if (copy_from_user(&a, arg, sizeof(a)))
+                goto out;
+
+        err = old_mmap(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);
+ out:
+        return err;
+}
+
+struct sel_arg_struct {
+        unsigned long n;
+        fd_set __user *inp;
+        fd_set __user *outp;
+        fd_set __user *exp;
+        struct timeval __user *tvp;
+};
+
+long old_select(struct sel_arg_struct __user *arg)
+{
+        struct sel_arg_struct a;
+
+        if (copy_from_user(&a, arg, sizeof(a)))
+                return -EFAULT;
+        /* sys_select() does the appropriate kernel locking */
+        return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
+}
+
+/* The i386 version skips reading from %esi, the fourth argument. So we must do
+ * this, too.
+ */
+long sys_clone(unsigned long clone_flags, unsigned long newsp,
+               int __user *parent_tid, int unused, int __user *child_tid)
+{
+        long ret;
+
+        /* XXX: normal arch do here this pass, and also pass the regs to
+         * do_fork, instead of NULL. Currently the arch-independent code
+         * ignores these values, while the UML code (actually it's
+         * copy_thread) does the right thing. But this should change,
+         probably. */
+        /*if (!newsp)
+                newsp = UPT_SP(current->thread.regs);*/
+        current->thread.forking = 1;
+        ret = do_fork(clone_flags, newsp, NULL, 0, parent_tid, child_tid);
+        current->thread.forking = 0;
+        return(ret);
+}
+
+/*
+ * sys_ipc() is the de-multiplexer for the SysV IPC calls..
+ *
+ * This is really horribly ugly.
+ */
+long sys_ipc (uint call, int first, int second,
+             int third, void __user *ptr, long fifth)
+{
+        int version, ret;
+
+        version = call >> 16; /* hack for backward compatibility */
+        call &= 0xffff;
+
+        switch (call) {
+        case SEMOP:
+                return sys_semtimedop(first, (struct sembuf *) ptr, second,
+                                      NULL);
+        case SEMTIMEDOP:
+                return sys_semtimedop(first, (struct sembuf *) ptr, second,
+                                      (const struct timespec *) fifth);
+        case SEMGET:
+                return sys_semget (first, second, third);
+        case SEMCTL: {
+                union semun fourth;
+                if (!ptr)
+                        return -EINVAL;
+                if (get_user(fourth.__pad, (void **) ptr))
+                        return -EFAULT;
+                return sys_semctl (first, second, third, fourth);
+        }
+
+        case MSGSND:
+                return sys_msgsnd (first, (struct msgbuf *) ptr,
+                                   second, third);
+        case MSGRCV:
+                switch (version) {
+                case 0: {
+                        struct ipc_kludge tmp;
+                        if (!ptr)
+                                return -EINVAL;
+
+                        if (copy_from_user(&tmp,
+                                           (struct ipc_kludge *) ptr,
+                                           sizeof (tmp)))
+                                return -EFAULT;
+                        return sys_msgrcv (first, tmp.msgp, second,
+                                           tmp.msgtyp, third);
+                }
+                default:
+                        panic("msgrcv with version != 0");
+                        return sys_msgrcv (first,
+                                           (struct msgbuf *) ptr,
+                                           second, fifth, third);
+                }
+        case MSGGET:
+                return sys_msgget ((key_t) first, second);
+        case MSGCTL:
+                return sys_msgctl (first, second, (struct msqid_ds *) ptr);
+
+        case SHMAT:
+                switch (version) {
+                default: {
+                        ulong raddr;
+                        ret = do_shmat (first, (char *) ptr, second, &raddr);
+                        if (ret)
+                                return ret;
+                        return put_user (raddr, (ulong *) third);
+                }
+                case 1: /* iBCS2 emulator entry point */
+                        if (!segment_eq(get_fs(), get_ds()))
+                                return -EINVAL;
+                        return do_shmat (first, (char *) ptr, second, (ulong *) third);
+                }
+        case SHMDT:
+                return sys_shmdt ((char *)ptr);
+        case SHMGET:
+                return sys_shmget (first, second, third);
+        case SHMCTL:
+                return sys_shmctl (first, second,
+                                   (struct shmid_ds *) ptr);
+        default:
+                return -ENOSYS;
+        }
+}
+
+long 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 (!access_ok(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 (!access_ok(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;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-i386/sysrq.c b/arch/um/sys-i386/sysrq.c
new file mode 100644
index 000000000000..281fc7b8ca00
--- /dev/null
+++ b/arch/um/sys-i386/sysrq.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2001 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/smp.h"
+#include "linux/sched.h"
+#include "asm/ptrace.h"
+#include "sysrq.h"
+
+void show_regs(struct pt_regs *regs)
+{
+        printk("\n");
+        printk("EIP: %04lx:[<%08lx>] CPU: %d %s", 
+               0xffff & PT_REGS_CS(regs), PT_REGS_IP(regs),
+               smp_processor_id(), print_tainted());
+        if (PT_REGS_CS(regs) & 3)
+                printk(" ESP: %04lx:%08lx", 0xffff & PT_REGS_SS(regs),
+                       PT_REGS_SP(regs));
+        printk(" EFLAGS: %08lx\n    %s\n", PT_REGS_EFLAGS(regs),
+               print_tainted());
+        printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
+                PT_REGS_EAX(regs), PT_REGS_EBX(regs), 
+               PT_REGS_ECX(regs), 
+               PT_REGS_EDX(regs));
+        printk("ESI: %08lx EDI: %08lx EBP: %08lx",
+               PT_REGS_ESI(regs), PT_REGS_EDI(regs), 
+               PT_REGS_EBP(regs));
+        printk(" DS: %04lx ES: %04lx\n",
+               0xffff & PT_REGS_DS(regs), 
+               0xffff & PT_REGS_ES(regs));
+
+        show_trace((unsigned long *) &regs);
+}
diff --git a/arch/um/sys-i386/util/Makefile b/arch/um/sys-i386/util/Makefile
new file mode 100644
index 000000000000..34860f9ca7b0
--- /dev/null
+++ b/arch/um/sys-i386/util/Makefile
@@ -0,0 +1,8 @@
+
+hostprogs-y     := mk_sc mk_thread
+always          := $(hostprogs-y)
+
+mk_thread-objs  := mk_thread_kern.o mk_thread_user.o
+
+HOSTCFLAGS_mk_thread_kern.o     := $(CFLAGS) $(CPPFLAGS)
+HOSTCFLAGS_mk_thread_user.o     := $(USER_CFLAGS)
diff --git a/arch/um/sys-i386/util/mk_sc.c b/arch/um/sys-i386/util/mk_sc.c
new file mode 100644
index 000000000000..85cbd30396f7
--- /dev/null
+++ b/arch/um/sys-i386/util/mk_sc.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <signal.h>
+#include <linux/stddef.h>
+
+#define SC_OFFSET(name, field) \
+  printf("#define " name "(sc) *((unsigned long *) &(((char *) (sc))[%d]))\n",\
+         offsetof(struct sigcontext, field))
+
+#define SC_FP_OFFSET(name, field) \
+  printf("#define " name \
+         "(sc) *((unsigned long *) &(((char *) (SC_FPSTATE(sc)))[%d]))\n",\
+         offsetof(struct _fpstate, field))
+
+#define SC_FP_OFFSET_PTR(name, field, type) \
+  printf("#define " name \
+         "(sc) ((" type " *) &(((char *) (SC_FPSTATE(sc)))[%d]))\n",\
+         offsetof(struct _fpstate, field))
+
+int main(int argc, char **argv)
+{
+  SC_OFFSET("SC_IP", eip);
+  SC_OFFSET("SC_SP", esp);
+  SC_OFFSET("SC_FS", fs);
+  SC_OFFSET("SC_GS", gs);
+  SC_OFFSET("SC_DS", ds);
+  SC_OFFSET("SC_ES", es);
+  SC_OFFSET("SC_SS", ss);
+  SC_OFFSET("SC_CS", cs);
+  SC_OFFSET("SC_EFLAGS", eflags);
+  SC_OFFSET("SC_EAX", eax);
+  SC_OFFSET("SC_EBX", ebx);
+  SC_OFFSET("SC_ECX", ecx);
+  SC_OFFSET("SC_EDX", edx);
+  SC_OFFSET("SC_EDI", edi);
+  SC_OFFSET("SC_ESI", esi);
+  SC_OFFSET("SC_EBP", ebp);
+  SC_OFFSET("SC_TRAPNO", trapno);
+  SC_OFFSET("SC_ERR", err);
+  SC_OFFSET("SC_CR2", cr2);
+  SC_OFFSET("SC_FPSTATE", fpstate);
+  SC_OFFSET("SC_SIGMASK", oldmask);
+  SC_FP_OFFSET("SC_FP_CW", cw);
+  SC_FP_OFFSET("SC_FP_SW", sw);
+  SC_FP_OFFSET("SC_FP_TAG", tag);
+  SC_FP_OFFSET("SC_FP_IPOFF", ipoff);
+  SC_FP_OFFSET("SC_FP_CSSEL", cssel);
+  SC_FP_OFFSET("SC_FP_DATAOFF", dataoff);
+  SC_FP_OFFSET("SC_FP_DATASEL", datasel);
+  SC_FP_OFFSET_PTR("SC_FP_ST", _st, "struct _fpstate");
+  SC_FP_OFFSET_PTR("SC_FXSR_ENV", _fxsr_env, "void");
+  return(0);
+}
diff --git a/arch/um/sys-i386/util/mk_thread_kern.c b/arch/um/sys-i386/util/mk_thread_kern.c
new file mode 100644
index 000000000000..948b1ce85230
--- /dev/null
+++ b/arch/um/sys-i386/util/mk_thread_kern.c
@@ -0,0 +1,22 @@
+#include "linux/config.h"
+#include "linux/stddef.h"
+#include "linux/sched.h"
+
+extern void print_head(void);
+extern void print_constant_ptr(char *name, int value);
+extern void print_constant(char *name, char *type, int value);
+extern void print_tail(void);
+
+#define THREAD_OFFSET(field) offsetof(struct task_struct, thread.field)
+
+int main(int argc, char **argv)
+{
+  print_head();
+  print_constant_ptr("TASK_DEBUGREGS", THREAD_OFFSET(arch.debugregs));
+#ifdef CONFIG_MODE_TT
+  print_constant("TASK_EXTERN_PID", "int", THREAD_OFFSET(mode.tt.extern_pid));
+#endif
+  print_tail();
+  return(0);
+}
+
diff --git a/arch/um/sys-i386/util/mk_thread_user.c b/arch/um/sys-i386/util/mk_thread_user.c
new file mode 100644
index 000000000000..2620cd6aa1f1
--- /dev/null
+++ b/arch/um/sys-i386/util/mk_thread_user.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+void print_head(void)
+{
+  printf("/*\n");
+  printf(" * Generated by mk_thread\n");
+  printf(" */\n");
+  printf("\n");
+  printf("#ifndef __UM_THREAD_H\n");
+  printf("#define __UM_THREAD_H\n");
+  printf("\n");
+}
+
+void print_constant_ptr(char *name, int value)
+{
+  printf("#define %s(task) ((unsigned long *) "
+         "&(((char *) (task))[%d]))\n", name, value);
+}
+
+void print_constant(char *name, char *type, int value)
+{
+  printf("#define %s(task) *((%s *) &(((char *) (task))[%d]))\n", name, type, 
+         value);
+}
+
+void print_tail(void)
+{
+  printf("\n");
+  printf("#endif\n");
+}
diff --git a/arch/um/sys-ia64/Makefile b/arch/um/sys-ia64/Makefile
new file mode 100644
index 000000000000..d02f4c265232
--- /dev/null
+++ b/arch/um/sys-ia64/Makefile
@@ -0,0 +1,11 @@
+OBJ = built-in.o
+
+OBJS =
+
+all: $(OBJ)
+
+$(OBJ): $(OBJS)
+        rm -f $@
+        $(LD) $(LINKFLAGS) --start-group $^ --end-group -o $@
+
+clean-files := $(OBJS) link.ld
diff --git a/arch/um/sys-ppc/Makefile b/arch/um/sys-ppc/Makefile
new file mode 100644
index 000000000000..af200268fddb
--- /dev/null
+++ b/arch/um/sys-ppc/Makefile
@@ -0,0 +1,69 @@
+OBJ = built-in.o
+
+.S.o:
+        $(CC) $(AFLAGS) -D__ASSEMBLY__ -D__UM_PPC__ -c $< -o $*.o
+
+OBJS = ptrace.o sigcontext.o semaphore.o checksum.o miscthings.o misc.o \
+        ptrace_user.o sysrq.o
+
+EXTRA_AFLAGS := -DCONFIG_PPC32 -I. -I$(TOPDIR)/arch/ppc/kernel
+
+all: $(OBJ)
+
+$(OBJ): $(OBJS)
+        rm -f $@
+        $(LD) $(LINKFLAGS) --start-group $^ --end-group -o $@
+
+ptrace_user.o: ptrace_user.c
+        $(CC) -D__KERNEL__ $(USER_CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<
+
+sigcontext.o: sigcontext.c
+        $(CC) $(USER_CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<
+
+semaphore.c:
+        rm -f $@
+        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+
+checksum.S:
+        rm -f $@
+        ln -s $(TOPDIR)/arch/ppc/lib/$@ $@
+
+mk_defs.c:
+        rm -f $@
+        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+
+ppc_defs.head:
+        rm -f $@
+        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+
+ppc_defs.h: mk_defs.c ppc_defs.head \
+                $(TOPDIR)/include/asm-ppc/mmu.h \
+                $(TOPDIR)/include/asm-ppc/processor.h \
+                $(TOPDIR)/include/asm-ppc/pgtable.h \
+                $(TOPDIR)/include/asm-ppc/ptrace.h
+#       $(CC) $(CFLAGS) -S mk_defs.c
+        cp ppc_defs.head ppc_defs.h
+# for bk, this way we can write to the file even if it's not checked out
+        echo '#define THREAD 608' >> ppc_defs.h
+        echo '#define PT_REGS 8' >> ppc_defs.h
+        echo '#define CLONE_VM 256' >> ppc_defs.h
+#       chmod u+w ppc_defs.h
+#       grep '^#define' mk_defs.s >> ppc_defs.h
+#       rm mk_defs.s
+
+# the asm link is horrible, and breaks the other targets.  This is also
+# not going to work with parallel makes.
+
+checksum.o: checksum.S
+        rm -f asm
+        ln -s $(TOPDIR)/include/asm-ppc asm
+        $(CC) $(EXTRA_AFLAGS) $(AFLAGS) -D__ASSEMBLY__ -D__UM_PPC__ -c $< -o $*.o
+        rm -f asm
+
+misc.o: misc.S ppc_defs.h
+        rm -f asm
+        ln -s $(TOPDIR)/include/asm-ppc asm
+        $(CC) $(EXTRA_AFLAGS) $(AFLAGS) -D__ASSEMBLY__ -D__UM_PPC__ -c $< -o $*.o
+        rm -f asm
+
+clean-files := $(OBJS) ppc_defs.h checksum.S semaphore.c mk_defs.c
diff --git a/arch/um/sys-ppc/misc.S b/arch/um/sys-ppc/misc.S
new file mode 100644
index 000000000000..11b7bd768cfd
--- /dev/null
+++ b/arch/um/sys-ppc/misc.S
@@ -0,0 +1,116 @@
+/*
+ * This file contains miscellaneous low-level functions.
+ *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
+ *
+ * Largely rewritten by Cort Dougan (cort@cs.nmt.edu)
+ * and Paul Mackerras.
+ *
+ * A couple of functions stolen from arch/ppc/kernel/misc.S for UML
+ * by Chris Emerson.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <linux/config.h>
+#include <asm/processor.h>
+#include "ppc_asm.h"
+
+#if defined(CONFIG_4xx) || defined(CONFIG_8xx)
+#define CACHE_LINE_SIZE         16
+#define LG_CACHE_LINE_SIZE      4
+#define MAX_COPY_PREFETCH       1
+#elif !defined(CONFIG_PPC64BRIDGE)
+#define CACHE_LINE_SIZE         32
+#define LG_CACHE_LINE_SIZE      5
+#define MAX_COPY_PREFETCH       4
+#else
+#define CACHE_LINE_SIZE         128
+#define LG_CACHE_LINE_SIZE      7
+#define MAX_COPY_PREFETCH       1
+#endif /* CONFIG_4xx || CONFIG_8xx */
+
+        .text
+
+/*
+ * Clear a page using the dcbz instruction, which doesn't cause any
+ * memory traffic (except to write out any cache lines which get
+ * displaced).  This only works on cacheable memory.
+ */
+_GLOBAL(clear_page)
+        li      r0,4096/CACHE_LINE_SIZE
+        mtctr   r0
+#ifdef CONFIG_8xx
+        li      r4, 0
+1:      stw     r4, 0(r3)
+        stw     r4, 4(r3)
+        stw     r4, 8(r3)
+        stw     r4, 12(r3)
+#else
+1:      dcbz    0,r3
+#endif
+        addi    r3,r3,CACHE_LINE_SIZE
+        bdnz    1b
+        blr
+
+/*
+ * Copy a whole page.  We use the dcbz instruction on the destination
+ * to reduce memory traffic (it eliminates the unnecessary reads of
+ * the destination into cache).  This requires that the destination
+ * is cacheable.
+ */
+#define COPY_16_BYTES           \
+        lwz     r6,4(r4);       \
+        lwz     r7,8(r4);       \
+        lwz     r8,12(r4);      \
+        lwzu    r9,16(r4);      \
+        stw     r6,4(r3);       \
+        stw     r7,8(r3);       \
+        stw     r8,12(r3);      \
+        stwu    r9,16(r3)
+
+_GLOBAL(copy_page)
+        addi    r3,r3,-4
+        addi    r4,r4,-4
+        li      r5,4
+
+#ifndef CONFIG_8xx
+#if MAX_COPY_PREFETCH > 1
+        li      r0,MAX_COPY_PREFETCH
+        li      r11,4
+        mtctr   r0
+11:     dcbt    r11,r4
+        addi    r11,r11,CACHE_LINE_SIZE
+        bdnz    11b
+#else /* MAX_COPY_PREFETCH == 1 */
+        dcbt    r5,r4
+        li      r11,CACHE_LINE_SIZE+4
+#endif /* MAX_COPY_PREFETCH */
+#endif /* CONFIG_8xx */
+
+        li      r0,4096/CACHE_LINE_SIZE
+        mtctr   r0
+1:
+#ifndef CONFIG_8xx
+        dcbt    r11,r4
+        dcbz    r5,r3
+#endif
+        COPY_16_BYTES
+#if CACHE_LINE_SIZE >= 32
+        COPY_16_BYTES
+#if CACHE_LINE_SIZE >= 64
+        COPY_16_BYTES
+        COPY_16_BYTES
+#if CACHE_LINE_SIZE >= 128
+        COPY_16_BYTES
+        COPY_16_BYTES
+        COPY_16_BYTES
+        COPY_16_BYTES
+#endif
+#endif
+#endif
+        bdnz    1b
+        blr
diff --git a/arch/um/sys-ppc/miscthings.c b/arch/um/sys-ppc/miscthings.c
new file mode 100644
index 000000000000..373061c50129
--- /dev/null
+++ b/arch/um/sys-ppc/miscthings.c
@@ -0,0 +1,53 @@
+#include "linux/threads.h"
+#include "linux/stddef.h"  // for NULL
+#include "linux/elf.h"  // for AT_NULL
+
+/* The following function nicked from arch/ppc/kernel/process.c and
+ * adapted slightly */
+/*
+ * XXX ld.so expects the auxiliary table to start on
+ * a 16-byte boundary, so we have to find it and
+ * move it up. :-(
+ */
+void shove_aux_table(unsigned long sp)
+{
+        int argc;
+        char *p;
+        unsigned long e;
+        unsigned long aux_start, offset;
+
+        argc = *(int *)sp;
+        sp += sizeof(int) + (argc + 1) * sizeof(char *);
+        /* skip over the environment pointers */
+        do {
+                p = *(char **)sp;
+                sp += sizeof(char *);
+        } while (p != NULL);
+        aux_start = sp;
+        /* skip to the end of the auxiliary table */
+        do {
+                e = *(unsigned long *)sp;
+                sp += 2 * sizeof(unsigned long);
+        } while (e != AT_NULL);
+        offset = ((aux_start + 15) & ~15) - aux_start;
+        if (offset != 0) {
+                do {
+                        sp -= sizeof(unsigned long);
+                        e = *(unsigned long *)sp;
+                        *(unsigned long *)(sp + offset) = e;
+                } while (sp > aux_start);
+        }
+}
+/* END stuff taken from arch/ppc/kernel/process.c */
+
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-ppc/ptrace.c b/arch/um/sys-ppc/ptrace.c
new file mode 100644
index 000000000000..a971366d3277
--- /dev/null
+++ b/arch/um/sys-ppc/ptrace.c
@@ -0,0 +1,28 @@
+#include "linux/sched.h"
+#include "asm/ptrace.h"
+
+int putreg(struct task_struct *child, unsigned long regno, 
+                  unsigned long value)
+{
+        child->thread.process_regs.regs[regno >> 2] = value;
+        return 0;
+}
+
+unsigned long getreg(struct task_struct *child, unsigned long regno)
+{
+        unsigned long retval = ~0UL;
+
+        retval &= child->thread.process_regs.regs[regno >> 2];
+        return retval;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-ppc/ptrace_user.c b/arch/um/sys-ppc/ptrace_user.c
new file mode 100644
index 000000000000..ff0b9c077a13
--- /dev/null
+++ b/arch/um/sys-ppc/ptrace_user.c
@@ -0,0 +1,39 @@
+#include <errno.h>
+#include <asm/ptrace.h>
+#include "sysdep/ptrace.h"
+
+int ptrace_getregs(long pid, unsigned long *regs_out)
+{
+    int i;
+    for (i=0; i < sizeof(struct sys_pt_regs)/sizeof(PPC_REG); ++i) {
+        errno = 0;
+        regs_out->regs[i] = ptrace(PTRACE_PEEKUSR, pid, i*4, 0);
+        if (errno) {
+            return -errno;
+        }
+    }
+    return 0;
+}
+
+int ptrace_setregs(long pid, unsigned long *regs_in)
+{
+    int i;
+    for (i=0; i < sizeof(struct sys_pt_regs)/sizeof(PPC_REG); ++i) {
+        if (i != 34 /* FIXME: PT_ORIG_R3 */ && i <= PT_MQ) {
+            if (ptrace(PTRACE_POKEUSR, pid, i*4, regs_in->regs[i]) < 0) {
+                return -errno;
+            }
+        }
+    }
+    return 0;
+}
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-ppc/sigcontext.c b/arch/um/sys-ppc/sigcontext.c
new file mode 100644
index 000000000000..5d430fc994af
--- /dev/null
+++ b/arch/um/sys-ppc/sigcontext.c
@@ -0,0 +1,15 @@
+#include "asm/ptrace.h"
+#include "asm/sigcontext.h"
+#include "sysdep/ptrace.h"
+#include "user_util.h"
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-ppc/sysrq.c b/arch/um/sys-ppc/sysrq.c
new file mode 100644
index 000000000000..82d6e9335bb6
--- /dev/null
+++ b/arch/um/sys-ppc/sysrq.c
@@ -0,0 +1,43 @@
+/* 
+ * Copyright (C) 2001 Chris Emerson (cemerson@chiark.greenend.org.uk)
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/smp.h"
+#include "asm/ptrace.h"
+#include "sysrq.h"
+
+void show_regs(struct pt_regs_subarch *regs)
+{
+        printk("\n");
+        printk("show_regs(): insert regs here.\n");
+#if 0
+        printk("\n");
+        printk("EIP: %04x:[<%08lx>] CPU: %d",0xffff & regs->xcs, regs->eip,
+               smp_processor_id());
+        if (regs->xcs & 3)
+                printk(" ESP: %04x:%08lx",0xffff & regs->xss, regs->esp);
+        printk(" EFLAGS: %08lx\n", regs->eflags);
+        printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
+                regs->eax, regs->ebx, regs->ecx, regs->edx);
+        printk("ESI: %08lx EDI: %08lx EBP: %08lx",
+                regs->esi, regs->edi, regs->ebp);
+        printk(" DS: %04x ES: %04x\n",
+                0xffff & regs->xds, 0xffff & regs->xes);
+#endif
+
+        show_trace(&regs->gpr[1]);
+}
+
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/Makefile b/arch/um/sys-x86_64/Makefile
new file mode 100644
index 000000000000..2129e3143559
--- /dev/null
+++ b/arch/um/sys-x86_64/Makefile
@@ -0,0 +1,37 @@
+#
+# Copyright 2003 PathScale, Inc.
+#
+# Licensed under the GPL
+#
+
+lib-y = bitops.o bugs.o csum-partial.o delay.o fault.o mem.o memcpy.o \
+        ptrace.o ptrace_user.o semaphore.o sigcontext.o signal.o \
+        syscalls.o sysrq.o thunk.o
+
+USER_OBJS := ptrace_user.o sigcontext.o
+
+include arch/um/scripts/Makefile.rules
+
+SYMLINKS = bitops.c csum-copy.S csum-partial.c csum-wrappers.c memcpy.S \
+        semaphore.c thunk.S
+
+# this needs to be before the foreach, because clean-files does not accept
+# complete paths like $(src)/$f.
+clean-files := $(SYMLINKS)
+
+targets += $(SYMLINKS)
+
+SYMLINKS := $(foreach f,$(SYMLINKS),$(obj)/$f)
+
+bitops.c-dir = lib
+csum-copy.S-dir = lib
+csum-partial.c-dir = lib
+csum-wrappers.c-dir = lib
+memcpy.S-dir = lib
+semaphore.c-dir = kernel
+thunk.S-dir = lib
+
+$(SYMLINKS): FORCE
+        $(call if_changed,make_link)
+
+CFLAGS_csum-partial.o := -Dcsum_partial=arch_csum_partial
diff --git a/arch/um/sys-x86_64/bugs.c b/arch/um/sys-x86_64/bugs.c
new file mode 100644
index 000000000000..fdce7ea98ca7
--- /dev/null
+++ b/arch/um/sys-x86_64/bugs.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include "linux/sched.h"
+#include "linux/errno.h"
+#include "asm/system.h"
+#include "asm/pda.h"
+#include "sysdep/ptrace.h"
+#include "os.h"
+
+void arch_init_thread(void)
+{
+}
+
+void arch_check_bugs(void)
+{
+}
+
+int arch_handle_signal(int sig, union uml_pt_regs *regs)
+{
+        return(0);
+}
+
+#define MAXTOKEN 64
+
+/* Set during early boot */
+int host_has_cmov = 1;
+int host_has_xmm = 0;
+
+static char token(int fd, char *buf, int len, char stop)
+{
+        int n;
+        char *ptr, *end, c;
+
+        ptr = buf;
+        end = &buf[len];
+        do {
+                n = os_read_file(fd, ptr, sizeof(*ptr));
+                c = *ptr++;
+                if(n != sizeof(*ptr)){
+                        if(n == 0) return(0);
+                        printk("Reading /proc/cpuinfo failed, err = %d\n", -n);
+                        if(n < 0)
+                                return(n);
+                        else
+                                return(-EIO);
+                }
+        } while((c != '\n') && (c != stop) && (ptr < end));
+
+        if(ptr == end){
+                printk("Failed to find '%c' in /proc/cpuinfo\n", stop);
+                return(-1);
+        }
+        *(ptr - 1) = '\0';
+        return(c);
+}
+
+static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
+{
+        int n;
+        char c;
+
+        scratch[len - 1] = '\0';
+        while(1){
+                c = token(fd, scratch, len - 1, ':');
+                if(c <= 0)
+                        return(0);
+                else if(c != ':'){
+                        printk("Failed to find ':' in /proc/cpuinfo\n");
+                        return(0);
+                }
+
+                if(!strncmp(scratch, key, strlen(key)))
+                        return(1);
+
+                do {
+                        n = os_read_file(fd, &c, sizeof(c));
+                        if(n != sizeof(c)){
+                                printk("Failed to find newline in "
+                                       "/proc/cpuinfo, err = %d\n", -n);
+                                return(0);
+                        }
+                } while(c != '\n');
+        }
+        return(0);
+}
+
+int cpu_feature(char *what, char *buf, int len)
+{
+        int fd, ret = 0;
+
+        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
+        if(fd < 0){
+                printk("Couldn't open /proc/cpuinfo, err = %d\n", -fd);
+                return(0);
+        }
+
+        if(!find_cpuinfo_line(fd, what, buf, len)){
+                printk("Couldn't find '%s' line in /proc/cpuinfo\n", what);
+                goto out_close;
+        }
+
+        token(fd, buf, len, '\n');
+        ret = 1;
+
+ out_close:
+        os_close_file(fd);
+        return(ret);
+}
+
+/* Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/delay.c b/arch/um/sys-x86_64/delay.c
new file mode 100644
index 000000000000..f3b5187942b4
--- /dev/null
+++ b/arch/um/sys-x86_64/delay.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ * Copied from arch/x86_64
+ *
+ * Licensed under the GPL
+ */
+
+#include "asm/processor.h"
+
+void __delay(unsigned long loops)
+{
+        unsigned long i;
+
+        for(i = 0; i < loops; i++) ;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/fault.c b/arch/um/sys-x86_64/fault.c
new file mode 100644
index 000000000000..cee1513c5c31
--- /dev/null
+++ b/arch/um/sys-x86_64/fault.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include "user.h"
+
+int arch_fixup(unsigned long address, void *sc_ptr)
+{
+        /* XXX search_exception_tables() */
+        return(0);
+}
+
+/* Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/mem.c b/arch/um/sys-x86_64/mem.c
new file mode 100644
index 000000000000..3f59a0a4f156
--- /dev/null
+++ b/arch/um/sys-x86_64/mem.c
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include "linux/mm.h"
+#include "asm/page.h"
+#include "asm/mman.h"
+
+unsigned long vm_stack_flags = __VM_STACK_FLAGS;
+unsigned long vm_stack_flags32 = __VM_STACK_FLAGS;
+unsigned long vm_data_default_flags = __VM_DATA_DEFAULT_FLAGS;
+unsigned long vm_data_default_flags32 = __VM_DATA_DEFAULT_FLAGS;
+unsigned long vm_force_exec32 = PROT_EXEC;
+
+/* Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/ptrace.c b/arch/um/sys-x86_64/ptrace.c
new file mode 100644
index 000000000000..8c146b2a1e00
--- /dev/null
+++ b/arch/um/sys-x86_64/ptrace.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#define __FRAME_OFFSETS
+#include "asm/ptrace.h"
+#include "linux/sched.h"
+#include "linux/errno.h"
+#include "asm/elf.h"
+
+/* XXX x86_64 */
+unsigned long not_ss;
+unsigned long not_ds;
+unsigned long not_es;
+
+#define SC_SS(r) (not_ss)
+#define SC_DS(r) (not_ds)
+#define SC_ES(r) (not_es)
+
+/* determines which flags the user has access to. */
+/* 1 = access 0 = no access */
+#define FLAG_MASK 0x44dd5UL
+
+int putreg(struct task_struct *child, int regno, unsigned long value)
+{
+        unsigned long tmp;
+
+#ifdef TIF_IA32
+        /* Some code in the 64bit emulation may not be 64bit clean.
+           Don't take any chances. */
+        if (test_tsk_thread_flag(child, TIF_IA32))
+                value &= 0xffffffff;
+#endif
+        switch (regno){
+        case FS:
+        case GS:
+        case DS:
+        case ES:
+        case SS:
+        case CS:
+                if (value && (value & 3) != 3)
+                        return -EIO;
+                value &= 0xffff;
+                break;
+
+        case FS_BASE:
+        case GS_BASE:
+                if (!((value >> 48) == 0 || (value >> 48) == 0xffff))
+                        return -EIO;
+                break;
+
+        case EFLAGS:
+                value &= FLAG_MASK;
+                tmp = PT_REGS_EFLAGS(&child->thread.regs) & ~FLAG_MASK;
+                value |= tmp;
+                break;
+        }
+
+        PT_REGS_SET(&child->thread.regs, regno, value);
+        return 0;
+}
+
+unsigned long getreg(struct task_struct *child, int regno)
+{
+        unsigned long retval = ~0UL;
+        switch (regno) {
+        case FS:
+        case GS:
+        case DS:
+        case ES:
+        case SS:
+        case CS:
+                retval = 0xffff;
+                /* fall through */
+        default:
+                retval &= PT_REG(&child->thread.regs, regno);
+#ifdef TIF_IA32
+                if (test_tsk_thread_flag(child, TIF_IA32))
+                        retval &= 0xffffffff;
+#endif
+        }
+        return retval;
+}
+
+void arch_switch(void)
+{
+/* XXX
+        printk("arch_switch\n");
+*/
+}
+
+int is_syscall(unsigned long addr)
+{
+        panic("is_syscall");
+}
+
+int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu )
+{
+        panic("dump_fpu");
+        return(1);
+}
+
+int get_fpregs(unsigned long buf, struct task_struct *child)
+{
+        panic("get_fpregs");
+        return(0);
+}
+
+int set_fpregs(unsigned long buf, struct task_struct *child)
+{
+        panic("set_fpregs");
+        return(0);
+}
+
+int get_fpxregs(unsigned long buf, struct task_struct *tsk)
+{
+        panic("get_fpxregs");
+        return(0);
+}
+
+int set_fpxregs(unsigned long buf, struct task_struct *tsk)
+{
+        panic("set_fxpregs");
+        return(0);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/ptrace_user.c b/arch/um/sys-x86_64/ptrace_user.c
new file mode 100644
index 000000000000..12e404c6fa46
--- /dev/null
+++ b/arch/um/sys-x86_64/ptrace_user.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include <stddef.h>
+#include <errno.h>
+#include "ptrace_user.h"
+#include "user.h"
+#include "kern_constants.h"
+
+int ptrace_getregs(long pid, unsigned long *regs_out)
+{
+        if(ptrace(PTRACE_GETREGS, pid, 0, regs_out) < 0)
+                return(-errno);
+        return(0);
+}
+
+int ptrace_setregs(long pid, unsigned long *regs)
+{
+        if(ptrace(PTRACE_SETREGS, pid, 0, regs) < 0)
+                return(-errno);
+        return(0);
+}
+
+void ptrace_pokeuser(unsigned long addr, unsigned long data)
+{
+        panic("ptrace_pokeuser");
+}
+
+#define DS 184
+#define ES 192
+#define __USER_DS     0x2b
+
+void arch_enter_kernel(void *task, int pid)
+{
+}
+
+void arch_leave_kernel(void *task, int pid)
+{
+#ifdef UM_USER_CS
+        if(ptrace(PTRACE_POKEUSR, pid, CS, UM_USER_CS) < 0)
+                printk("POKEUSR CS failed");
+#endif
+
+        if(ptrace(PTRACE_POKEUSR, pid, DS, __USER_DS) < 0)
+                printk("POKEUSR DS failed");
+        if(ptrace(PTRACE_POKEUSR, pid, ES, __USER_DS) < 0)
+                printk("POKEUSR ES failed");
+}
diff --git a/arch/um/sys-x86_64/sigcontext.c b/arch/um/sys-x86_64/sigcontext.c
new file mode 100644
index 000000000000..c88e64def6f2
--- /dev/null
+++ b/arch/um/sys-x86_64/sigcontext.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include "user.h"
+
+void sc_to_sc(void *to_ptr, void *from_ptr)
+{
+        struct sigcontext *to = to_ptr, *from = from_ptr;
+        int size = sizeof(*to); /* + sizeof(struct _fpstate); */
+
+        memcpy(to, from, size);
+        if(from->fpstate != NULL)
+                to->fpstate = (struct _fpstate *) (to + 1);
+
+        to->fpstate = NULL;
+}
+
+unsigned long *sc_sigmask(void *sc_ptr)
+{
+        struct sigcontext *sc = sc_ptr;
+
+        return(&sc->oldmask);
+}
+
+/* Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/signal.c b/arch/um/sys-x86_64/signal.c
new file mode 100644
index 000000000000..5bc5a0d796e5
--- /dev/null
+++ b/arch/um/sys-x86_64/signal.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2003 PathScale, Inc.
+ * Licensed under the GPL
+ */
+
+#include "linux/stddef.h"
+#include "linux/errno.h"
+#include "linux/personality.h"
+#include "linux/ptrace.h"
+#include "asm/current.h"
+#include "asm/uaccess.h"
+#include "asm/sigcontext.h"
+#include "asm/ptrace.h"
+#include "asm/arch/ucontext.h"
+#include "choose-mode.h"
+#include "sysdep/ptrace.h"
+#include "frame_kern.h"
+
+#ifdef CONFIG_MODE_SKAS
+
+#include "skas.h"
+
+static int copy_sc_from_user_skas(struct pt_regs *regs,
+                                 struct sigcontext *from)
+{
+       int err = 0;
+
+#define GETREG(regs, regno, sc, regname) \
+       __get_user((regs)->regs.skas.regs[(regno) / sizeof(unsigned long)], \
+                  &(sc)->regname)
+
+       err |= GETREG(regs, R8, from, r8);
+       err |= GETREG(regs, R9, from, r9);
+       err |= GETREG(regs, R10, from, r10);
+       err |= GETREG(regs, R11, from, r11);
+       err |= GETREG(regs, R12, from, r12);
+       err |= GETREG(regs, R13, from, r13);
+       err |= GETREG(regs, R14, from, r14);
+       err |= GETREG(regs, R15, from, r15);
+       err |= GETREG(regs, RDI, from, rdi);
+       err |= GETREG(regs, RSI, from, rsi);
+       err |= GETREG(regs, RBP, from, rbp);
+       err |= GETREG(regs, RBX, from, rbx);
+       err |= GETREG(regs, RDX, from, rdx);
+       err |= GETREG(regs, RAX, from, rax);
+       err |= GETREG(regs, RCX, from, rcx);
+       err |= GETREG(regs, RSP, from, rsp);
+       err |= GETREG(regs, RIP, from, rip);
+       err |= GETREG(regs, EFLAGS, from, eflags);
+       err |= GETREG(regs, CS, from, cs);
+
+#undef GETREG
+
+       return(err);
+}
+
+int copy_sc_to_user_skas(struct sigcontext *to, struct _fpstate *to_fp,
+                        struct pt_regs *regs, unsigned long mask)
+{
+        unsigned long eflags;
+        int err = 0;
+
+        err |= __put_user(0, &to->gs);
+        err |= __put_user(0, &to->fs);
+
+#define PUTREG(regs, regno, sc, regname) \
+       __put_user((regs)->regs.skas.regs[(regno) / sizeof(unsigned long)], \
+                  &(sc)->regname)
+
+        err |= PUTREG(regs, RDI, to, rdi);
+        err |= PUTREG(regs, RSI, to, rsi);
+        err |= PUTREG(regs, RBP, to, rbp);
+        err |= PUTREG(regs, RSP, to, rsp);
+        err |= PUTREG(regs, RBX, to, rbx);
+        err |= PUTREG(regs, RDX, to, rdx);
+        err |= PUTREG(regs, RCX, to, rcx);
+        err |= PUTREG(regs, RAX, to, rax);
+        err |= PUTREG(regs, R8, to, r8);
+        err |= PUTREG(regs, R9, to, r9);
+        err |= PUTREG(regs, R10, to, r10);
+        err |= PUTREG(regs, R11, to, r11);
+        err |= PUTREG(regs, R12, to, r12);
+        err |= PUTREG(regs, R13, to, r13);
+        err |= PUTREG(regs, R14, to, r14);
+        err |= PUTREG(regs, R15, to, r15);
+        err |= PUTREG(regs, CS, to, cs); /* XXX x86_64 doesn't do this */
+        err |= __put_user(current->thread.err, &to->err);
+        err |= __put_user(current->thread.trap_no, &to->trapno);
+        err |= PUTREG(regs, RIP, to, rip);
+        err |= PUTREG(regs, EFLAGS, to, eflags);
+#undef PUTREG
+
+        err |= __put_user(mask, &to->oldmask);
+        err |= __put_user(current->thread.cr2, &to->cr2);
+
+        return(err);
+}
+
+#endif
+
+#ifdef CONFIG_MODE_TT
+int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext *from,
+                        int fpsize)
+{
+       struct _fpstate *to_fp, *from_fp;
+       unsigned long sigs;
+       int err;
+
+       to_fp = to->fpstate;
+       from_fp = from->fpstate;
+       sigs = to->oldmask;
+       err = copy_from_user(to, from, sizeof(*to));
+       to->oldmask = sigs;
+       return(err);
+}
+
+int copy_sc_to_user_tt(struct sigcontext *to, struct _fpstate *fp,
+                      struct sigcontext *from, int fpsize)
+{
+       struct _fpstate *to_fp, *from_fp;
+       int err;
+
+       to_fp = (fp ? fp : (struct _fpstate *) (to + 1));
+       from_fp = from->fpstate;
+       err = copy_to_user(to, from, sizeof(*to));
+       return(err);
+}
+
+#endif
+
+static int copy_sc_from_user(struct pt_regs *to, void __user *from)
+{
+       int ret;
+
+       ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from,
+                                              sizeof(struct _fpstate)),
+                         copy_sc_from_user_skas(to, from));
+       return(ret);
+}
+
+static int copy_sc_to_user(struct sigcontext *to, struct _fpstate *fp,
+                          struct pt_regs *from, unsigned long mask)
+{
+       return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs),
+                                             sizeof(*fp)),
+                          copy_sc_to_user_skas(to, fp, from, mask)));
+}
+
+struct rt_sigframe
+{
+       char *pretcode;
+       struct ucontext uc;
+       struct siginfo info;
+};
+
+#define round_down(m, n) (((m) / (n)) * (n))
+
+int setup_signal_stack_si(unsigned long stack_top, int sig,
+                          struct k_sigaction *ka, struct pt_regs * regs,
+                          siginfo_t *info, sigset_t *set)
+{
+        struct rt_sigframe __user *frame;
+        struct _fpstate __user *fp = NULL;
+        int err = 0;
+        struct task_struct *me = current;
+
+        frame = (struct rt_sigframe __user *)
+                round_down(stack_top - sizeof(struct rt_sigframe), 16) - 8;
+        frame -= 128;
+
+        if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate)))
+                goto out;
+
+#if 0 /* XXX */
+        if (save_i387(fp) < 0)
+                err |= -1;
+#endif
+        if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
+                goto out;
+
+        if (ka->sa.sa_flags & SA_SIGINFO) {
+                err |= copy_siginfo_to_user(&frame->info, info);
+                if (err)
+                        goto out;
+        }
+
+        /* Create the ucontext.  */
+        err |= __put_user(0, &frame->uc.uc_flags);
+        err |= __put_user(0, &frame->uc.uc_link);
+        err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
+        err |= __put_user(sas_ss_flags(PT_REGS_SP(regs)),
+                          &frame->uc.uc_stack.ss_flags);
+        err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
+        err |= copy_sc_to_user(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
+        err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate);
+        if (sizeof(*set) == 16) {
+                __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
+                __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]);
+        }
+        else
+                err |= __copy_to_user(&frame->uc.uc_sigmask, set,
+                                      sizeof(*set));
+
+        /* Set up to return from userspace.  If provided, use a stub
+           already in userspace.  */
+        /* x86-64 should always use SA_RESTORER. */
+        if (ka->sa.sa_flags & SA_RESTORER)
+                err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
+        else
+                /* could use a vstub here */
+                goto out;
+
+        if (err)
+                goto out;
+
+        /* Set up registers for signal handler */
+        {
+                struct exec_domain *ed = current_thread_info()->exec_domain;
+                if (unlikely(ed && ed->signal_invmap && sig < 32))
+                        sig = ed->signal_invmap[sig];
+        }
+
+        PT_REGS_RDI(regs) = sig;
+        /* In case the signal handler was declared without prototypes */
+        PT_REGS_RAX(regs) = 0;
+
+        /* This also works for non SA_SIGINFO handlers because they expect the
+           next argument after the signal number on the stack. */
+        PT_REGS_RSI(regs) = (unsigned long) &frame->info;
+        PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
+        PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
+
+        PT_REGS_RSP(regs) = (unsigned long) frame;
+ out:
+        return(err);
+}
+
+long sys_rt_sigreturn(struct pt_regs *regs)
+{
+        unsigned long sp = PT_REGS_SP(&current->thread.regs);
+        struct rt_sigframe __user *frame =
+                (struct rt_sigframe __user *)(sp - 8);
+        struct ucontext __user *uc = &frame->uc;
+        sigset_t set;
+
+        if(copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
+                goto segfault;
+
+        sigdelsetmask(&set, ~_BLOCKABLE);
+
+        spin_lock_irq(&current->sighand->siglock);
+        current->blocked = set;
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+
+        if(copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext))
+                goto segfault;
+
+        /* Avoid ERESTART handling */
+        PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
+        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
+
+ segfault:
+        force_sig(SIGSEGV, current);
+        return 0;
+}
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/syscalls.c b/arch/um/sys-x86_64/syscalls.c
new file mode 100644
index 000000000000..68205a03364c
--- /dev/null
+++ b/arch/um/sys-x86_64/syscalls.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include "linux/linkage.h"
+#include "linux/slab.h"
+#include "linux/shm.h"
+#include "asm/uaccess.h"
+#define __FRAME_OFFSETS
+#include "asm/ptrace.h"
+#include "asm/unistd.h"
+#include "asm/prctl.h" /* XXX This should get the constants from libc */
+#include "choose-mode.h"
+
+asmlinkage long wrap_sys_shmat(int shmid, char __user *shmaddr, int shmflg)
+{
+        unsigned long raddr;
+
+        return do_shmat(shmid, shmaddr, shmflg, &raddr) ?: (long) raddr;
+}
+
+#ifdef CONFIG_MODE_TT
+extern int modify_ldt(int func, void *ptr, unsigned long bytecount);
+
+long sys_modify_ldt_tt(int func, void *ptr, unsigned long bytecount)
+{
+        /* XXX This should check VERIFY_WRITE depending on func, check this
+         * in i386 as well.
+         */
+        if (!access_ok(VERIFY_READ, ptr, bytecount))
+                return -EFAULT;
+        return(modify_ldt(func, ptr, bytecount));
+}
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+extern int userspace_pid[];
+
+long sys_modify_ldt_skas(int func, void *ptr, unsigned long bytecount)
+{
+        struct ptrace_ldt ldt;
+        void *buf;
+        int res, n;
+
+        buf = kmalloc(bytecount, GFP_KERNEL);
+        if(buf == NULL)
+                return(-ENOMEM);
+
+        res = 0;
+
+        switch(func){
+        case 1:
+        case 0x11:
+                res = copy_from_user(buf, ptr, bytecount);
+                break;
+        }
+
+        if(res != 0){
+                res = -EFAULT;
+                goto out;
+        }
+
+        ldt = ((struct ptrace_ldt) { .func      = func,
+                                     .ptr       = buf,
+                                     .bytecount = bytecount });
+#warning Need to look up userspace_pid by cpu
+        res = ptrace(PTRACE_LDT, userspace_pid[0], 0, (unsigned long) &ldt);
+        if(res < 0)
+                goto out;
+
+        switch(func){
+        case 0:
+        case 2:
+                n = res;
+                res = copy_to_user(ptr, buf, n);
+                if(res != 0)
+                        res = -EFAULT;
+                else
+                        res = n;
+                break;
+        }
+
+ out:
+        kfree(buf);
+        return(res);
+}
+#endif
+
+long sys_modify_ldt(int func, void *ptr, unsigned long bytecount)
+{
+        return(CHOOSE_MODE_PROC(sys_modify_ldt_tt, sys_modify_ldt_skas, func,
+                                ptr, bytecount));
+}
+
+#ifdef CONFIG_MODE_TT
+extern long arch_prctl(int code, unsigned long addr);
+
+static long arch_prctl_tt(int code, unsigned long addr)
+{
+        unsigned long tmp;
+        long ret;
+
+        switch(code){
+        case ARCH_SET_GS:
+        case ARCH_SET_FS:
+                ret = arch_prctl(code, addr);
+                break;
+        case ARCH_GET_FS:
+        case ARCH_GET_GS:
+                ret = arch_prctl(code, (unsigned long) &tmp);
+                if(!ret)
+                        ret = put_user(tmp, &addr);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return(ret);
+}
+#endif
+
+#ifdef CONFIG_MODE_SKAS
+
+static long arch_prctl_skas(int code, unsigned long addr)
+{
+        long ret = 0;
+
+        switch(code){
+        case ARCH_SET_GS:
+                current->thread.regs.regs.skas.regs[GS_BASE / sizeof(unsigned long)] = addr;
+                break;
+        case ARCH_SET_FS:
+                current->thread.regs.regs.skas.regs[FS_BASE / sizeof(unsigned long)] = addr;
+                break;
+        case ARCH_GET_FS:
+                ret = put_user(current->thread.regs.regs.skas.regs[GS / sizeof(unsigned long)], &addr);
+                break;
+        case ARCH_GET_GS:
+                ret = put_user(current->thread.regs.regs.skas.regs[FS / sizeof(unsigned \
+long)], &addr);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return(ret);
+}
+#endif
+
+long sys_arch_prctl(int code, unsigned long addr)
+{
+        return(CHOOSE_MODE_PROC(arch_prctl_tt, arch_prctl_skas, code, addr));
+}
+
+long sys_clone(unsigned long clone_flags, unsigned long newsp,
+               void __user *parent_tid, void __user *child_tid)
+{
+        long ret;
+
+        /* XXX: normal arch do here this pass, and also pass the regs to
+         * do_fork, instead of NULL. Currently the arch-independent code
+         * ignores these values, while the UML code (actually it's
+         * copy_thread) does the right thing. But this should change,
+         probably. */
+        /*if (!newsp)
+                newsp = UPT_SP(current->thread.regs);*/
+        current->thread.forking = 1;
+        ret = do_fork(clone_flags, newsp, NULL, 0, parent_tid, child_tid);
+        current->thread.forking = 0;
+        return(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/sysrq.c b/arch/um/sys-x86_64/sysrq.c
new file mode 100644
index 000000000000..ddf74691a610
--- /dev/null
+++ b/arch/um/sys-x86_64/sysrq.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2003 PathScale, Inc.
+ *
+ * Licensed under the GPL
+ */
+
+#include "linux/kernel.h"
+#include "linux/utsname.h"
+#include "linux/module.h"
+#include "asm/current.h"
+#include "asm/ptrace.h"
+#include "sysrq.h"
+
+void __show_regs(struct pt_regs * regs)
+{
+        printk("\n");
+        print_modules();
+        printk("Pid: %d, comm: %.20s %s %s\n",
+               current->pid, current->comm, print_tainted(), system_utsname.release);
+        printk("RIP: %04lx:[<%016lx>] ", PT_REGS_CS(regs) & 0xffff,
+               PT_REGS_RIP(regs));
+        printk("\nRSP: %016lx  EFLAGS: %08lx\n", PT_REGS_RSP(regs),
+               PT_REGS_EFLAGS(regs));
+        printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
+               PT_REGS_RAX(regs), PT_REGS_RBX(regs), PT_REGS_RCX(regs));
+        printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
+               PT_REGS_RDX(regs), PT_REGS_RSI(regs), PT_REGS_RDI(regs));
+        printk("RBP: %016lx R08: %016lx R09: %016lx\n",
+               PT_REGS_RBP(regs), PT_REGS_R8(regs), PT_REGS_R9(regs));
+        printk("R10: %016lx R11: %016lx R12: %016lx\n",
+               PT_REGS_R10(regs), PT_REGS_R11(regs), PT_REGS_R12(regs));
+        printk("R13: %016lx R14: %016lx R15: %016lx\n",
+               PT_REGS_R13(regs), PT_REGS_R14(regs), PT_REGS_R15(regs));
+}
+
+void show_regs(struct pt_regs *regs)
+{
+        __show_regs(regs);
+        show_trace((unsigned long *) &regs);
+}
+
+/* Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff --git a/arch/um/sys-x86_64/util/Makefile b/arch/um/sys-x86_64/util/Makefile
new file mode 100644
index 000000000000..002607980864
--- /dev/null
+++ b/arch/um/sys-x86_64/util/Makefile
@@ -0,0 +1,10 @@
+# Copyright 2003 - 2004 Pathscale, Inc
+# Released under the GPL
+
+hostprogs-y     := mk_sc mk_thread
+always          := $(hostprogs-y)
+
+mk_thread-objs  := mk_thread_kern.o mk_thread_user.o
+
+HOSTCFLAGS_mk_thread_kern.o     := $(CFLAGS) $(CPPFLAGS)
+HOSTCFLAGS_mk_thread_user.o     := $(USER_CFLAGS)
diff --git a/arch/um/sys-x86_64/util/mk_sc.c b/arch/um/sys-x86_64/util/mk_sc.c
new file mode 100644
index 000000000000..c236e213918d
--- /dev/null
+++ b/arch/um/sys-x86_64/util/mk_sc.c
@@ -0,0 +1,58 @@
+/* Copyright (C) 2003 - 2004 PathScale, Inc
+ * Released under the GPL
+ */
+
+#include <stdio.h>
+#include <signal.h>
+#include <linux/stddef.h>
+
+#define SC_OFFSET(name, field) \
+  printf("#define " name \
+         "(sc) *((unsigned long *) &(((char *) (sc))[%ld]))\n",\
+         offsetof(struct sigcontext, field))
+
+#define SC_FP_OFFSET(name, field) \
+  printf("#define " name \
+         "(sc) *((unsigned long *) &(((char *) (SC_FPSTATE(sc)))[%ld]))\n",\
+         offsetof(struct _fpstate, field))
+
+#define SC_FP_OFFSET_PTR(name, field, type) \
+  printf("#define " name \
+         "(sc) ((" type " *) &(((char *) (SC_FPSTATE(sc)))[%d]))\n",\
+         offsetof(struct _fpstate, field))
+
+int main(int argc, char **argv)
+{
+  SC_OFFSET("SC_RBX", rbx);
+  SC_OFFSET("SC_RCX", rcx);
+  SC_OFFSET("SC_RDX", rdx);
+  SC_OFFSET("SC_RSI", rsi);
+  SC_OFFSET("SC_RDI", rdi);
+  SC_OFFSET("SC_RBP", rbp);
+  SC_OFFSET("SC_RAX", rax);
+  SC_OFFSET("SC_R8", r8);
+  SC_OFFSET("SC_R9", r9);
+  SC_OFFSET("SC_R10", r10);
+  SC_OFFSET("SC_R11", r11);
+  SC_OFFSET("SC_R12", r12);
+  SC_OFFSET("SC_R13", r13);
+  SC_OFFSET("SC_R14", r14);
+  SC_OFFSET("SC_R15", r15);
+  SC_OFFSET("SC_IP", rip);
+  SC_OFFSET("SC_SP", rsp);
+  SC_OFFSET("SC_CR2", cr2);
+  SC_OFFSET("SC_ERR", err);
+  SC_OFFSET("SC_TRAPNO", trapno);
+  SC_OFFSET("SC_CS", cs);
+  SC_OFFSET("SC_FS", fs);
+  SC_OFFSET("SC_GS", gs);
+  SC_OFFSET("SC_EFLAGS", eflags);
+  SC_OFFSET("SC_SIGMASK", oldmask);
+#if 0
+  SC_OFFSET("SC_ORIG_RAX", orig_rax);
+  SC_OFFSET("SC_DS", ds);
+  SC_OFFSET("SC_ES", es);
+  SC_OFFSET("SC_SS", ss);
+#endif
+  return(0);
+}
diff --git a/arch/um/sys-x86_64/util/mk_thread_kern.c b/arch/um/sys-x86_64/util/mk_thread_kern.c
new file mode 100644
index 000000000000..a281673f02b2
--- /dev/null
+++ b/arch/um/sys-x86_64/util/mk_thread_kern.c
@@ -0,0 +1,21 @@
+#include "linux/config.h"
+#include "linux/stddef.h"
+#include "linux/sched.h"
+
+extern void print_head(void);
+extern void print_constant_ptr(char *name, int value);
+extern void print_constant(char *name, char *type, int value);
+extern void print_tail(void);
+
+#define THREAD_OFFSET(field) offsetof(struct task_struct, thread.field)
+
+int main(int argc, char **argv)
+{
+  print_head();
+#ifdef CONFIG_MODE_TT
+  print_constant("TASK_EXTERN_PID", "int", THREAD_OFFSET(mode.tt.extern_pid));
+#endif
+  print_tail();
+  return(0);
+}
+
diff --git a/arch/um/sys-x86_64/util/mk_thread_user.c b/arch/um/sys-x86_64/util/mk_thread_user.c
new file mode 100644
index 000000000000..7989725568b8
--- /dev/null
+++ b/arch/um/sys-x86_64/util/mk_thread_user.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+void print_head(void)
+{
+  printf("/*\n");
+  printf(" * Generated by mk_thread\n");
+  printf(" */\n");
+  printf("\n");
+  printf("#ifndef __UM_THREAD_H\n");
+  printf("#define __UM_THREAD_H\n");
+  printf("\n");
+}
+
+void print_constant_ptr(char *name, int value)
+{
+  printf("#define %s(task) ((unsigned long *) "
+         "&(((char *) (task))[%d]))\n", name, value);
+}
+
+void print_constant(char *name, char *type, int value)
+{
+  printf("#define %s(task) *((%s *) &(((char *) (task))[%d]))\n", name, type,
+         value);
+}
+
+void print_tail(void)
+{
+  printf("\n");
+  printf("#endif\n");
+}
diff --git a/arch/um/util/Makefile b/arch/um/util/Makefile
new file mode 100644
index 000000000000..e2ab71209f3f
--- /dev/null
+++ b/arch/um/util/Makefile
@@ -0,0 +1,8 @@
+hostprogs-y             := mk_task mk_constants
+always                  := $(hostprogs-y)
+
+mk_task-objs            := mk_task_user.o mk_task_kern.o
+mk_constants-objs       := mk_constants_user.o mk_constants_kern.o
+
+HOSTCFLAGS_mk_task_kern.o       := $(CFLAGS) $(CPPFLAGS)
+HOSTCFLAGS_mk_constants_kern.o  := $(CFLAGS) $(CPPFLAGS)
diff --git a/arch/um/util/mk_constants_kern.c b/arch/um/util/mk_constants_kern.c
new file mode 100644
index 000000000000..cdcb1232a1ea
--- /dev/null
+++ b/arch/um/util/mk_constants_kern.c
@@ -0,0 +1,28 @@
+#include "linux/kernel.h"
+#include "linux/stringify.h"
+#include "linux/time.h"
+#include "asm/page.h"
+
+extern void print_head(void);
+extern void print_constant_str(char *name, char *value);
+extern void print_constant_int(char *name, int value);
+extern void print_tail(void);
+
+int main(int argc, char **argv)
+{
+  print_head();
+  print_constant_int("UM_KERN_PAGE_SIZE", PAGE_SIZE);
+
+  print_constant_str("UM_KERN_EMERG", KERN_EMERG);
+  print_constant_str("UM_KERN_ALERT", KERN_ALERT);
+  print_constant_str("UM_KERN_CRIT", KERN_CRIT);
+  print_constant_str("UM_KERN_ERR", KERN_ERR);
+  print_constant_str("UM_KERN_WARNING", KERN_WARNING);
+  print_constant_str("UM_KERN_NOTICE", KERN_NOTICE);
+  print_constant_str("UM_KERN_INFO", KERN_INFO);
+  print_constant_str("UM_KERN_DEBUG", KERN_DEBUG);
+
+  print_constant_int("UM_NSEC_PER_SEC", NSEC_PER_SEC);
+  print_tail();
+  return(0);
+}
diff --git a/arch/um/util/mk_constants_user.c b/arch/um/util/mk_constants_user.c
new file mode 100644
index 000000000000..8f4d7e50be7c
--- /dev/null
+++ b/arch/um/util/mk_constants_user.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+void print_head(void)
+{
+  printf("/*\n");
+  printf(" * Generated by mk_constants\n");
+  printf(" */\n");
+  printf("\n");
+  printf("#ifndef __UM_CONSTANTS_H\n");
+  printf("#define __UM_CONSTANTS_H\n");
+  printf("\n");
+}
+
+void print_constant_str(char *name, char *value)
+{
+  printf("#define %s \"%s\"\n", name, value);
+}
+
+void print_constant_int(char *name, int value)
+{
+  printf("#define %s %d\n", name, value);
+}
+
+void print_tail(void)
+{
+  printf("\n");
+  printf("#endif\n");
+}
diff --git a/arch/um/util/mk_task_kern.c b/arch/um/util/mk_task_kern.c
new file mode 100644
index 000000000000..c218103315ed
--- /dev/null
+++ b/arch/um/util/mk_task_kern.c
@@ -0,0 +1,17 @@
+#include "linux/sched.h"
+#include "linux/stddef.h"
+
+extern void print(char *name, char *type, int offset);
+extern void print_ptr(char *name, char *type, int offset);
+extern void print_head(void);
+extern void print_tail(void);
+
+int main(int argc, char **argv)
+{
+  print_head();
+  print_ptr("TASK_REGS", "union uml_pt_regs", 
+            offsetof(struct task_struct, thread.regs));
+  print("TASK_PID", "int", offsetof(struct task_struct, pid));
+  print_tail();
+  return(0);
+}
diff --git a/arch/um/util/mk_task_user.c b/arch/um/util/mk_task_user.c
new file mode 100644
index 000000000000..9db849f3f3ac
--- /dev/null
+++ b/arch/um/util/mk_task_user.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+void print(char *name, char *type, int offset)
+{
+  printf("#define %s(task) *((%s *) &(((char *) (task))[%d]))\n", name, type,
+         offset);
+}
+
+void print_ptr(char *name, char *type, int offset)
+{
+  printf("#define %s(task) ((%s *) &(((char *) (task))[%d]))\n", name, type,
+         offset);
+}
+
+void print_head(void)
+{
+  printf("/*\n");
+  printf(" * Generated by mk_task\n");
+  printf(" */\n");
+  printf("\n");
+  printf("#ifndef __TASK_H\n");
+  printf("#define __TASK_H\n");
+  printf("\n");
+}
+
+void print_tail(void)
+{
+  printf("\n");
+  printf("#endif\n");
+}