Merge http://jdike.stearns.org:5000/fixes-2.5

into home.transmeta.com:/home/torvalds/v2.5/linux

arch/um/Kconfig

@@ -30,40 +30,42 @@ config RWSEM_GENERIC_SPINLOCK
 	bool
 	default y
 
+menu "UML-specific options"
+
 config MODE_TT
-	bool
+	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
+	bool "Separate Kernel Address Space support"
 	default y
-
-config LOG_BUF_SHIFT
-	int
-	default 14
-
-menu "Code maturity level options"
-
-config EXPERIMENTAL
-	bool "Prompt for development and/or incomplete code/drivers"
-
-endmenu
-
-
-menu "General Setup"
+	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.
 
 config NET
 	bool "Networking support"
 
-config SYSVIPC
-	bool "System V IPC"
-
-config BSD_PROCESS_ACCT
-	bool "BSD Process Accounting"
-
-config SYSCTL
-	bool "Sysctl support"
-
 config BINFMT_AOUT
 	tristate "Kernel support for a.out binaries"
 
@@ -178,19 +180,7 @@ config KERNEL_STACK_ORDER
 
 endmenu
 
-
-menu "Loadable module support"
-
-config MODULES
-	bool "Enable loadable module support"
-
-# MODVERSIONS does not yet work in this architecture
-#   bool '  Set version information on all module symbols' CONFIG_MODVERSIONS
-config KMOD
-	bool "Kernel module loader"
-	depends on MODULES
-
-endmenu
+source "init/Kconfig"
 
 source "arch/um/Kconfig_char"
 
@@ -251,6 +241,10 @@ config DEBUGSYM
         If you're truly short on disk space or don't expect to report any
         bugs back to the UML developers, say N, otherwise say Y.
 
+config FRAME_POINTER
+	bool
+	default y if DEBUGSYM
+
 config PT_PROXY
 	bool "Enable ptrace proxy"
 	depends on XTERM_CHAN && DEBUGSYM

arch/um/Makefile

@@ -6,9 +6,6 @@
 ARCH_DIR = arch/um
 OS := $(shell uname -s)
 
-EXTRAVERSION := $(EXTRAVERSION)-1um
-include/linux/version.h: arch/$(ARCH)/Makefile
-
 # Recalculate MODLIB to reflect the EXTRAVERSION changes (via KERNELRELEASE)
 # The way the toplevel Makefile is written EXTRAVERSION is not supposed
 # to be changed outside the toplevel Makefile, but recalculating MODLIB is
@@ -21,17 +18,34 @@ CFLAGS := $(subst -fomit-frame-pointer,,$(CFLAGS))
 endif
 
 CFLAGS-$(CONFIG_DEBUGSYM) += -g
-CFLAGS-$(CONFIG_GCOV) += -fprofile-arcs -ftest-coverage
-CFLAGS-$(CONFIG_GPROF) += $(PROFILE)
-LINK-$(CONFIG_GPROF) += $(PROFILE) -Wl,--wrap,__monstartup
 
 core-y			+= $(ARCH_DIR)/kernel/		 \
 			   $(ARCH_DIR)/drivers/          \
 			   $(ARCH_DIR)/sys-$(SUBARCH)/
 
+# Have to precede the include because the included Makefiles reference them.
+SYMLINK_HEADERS = include/asm-um/archparam.h include/asm-um/system.h \
+	include/asm-um/sigcontext.h include/asm-um/processor.h \
+	include/asm-um/ptrace.h include/asm-um/arch-signal.h
+
+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
+
+include $(ARCH_DIR)/Makefile-$(SUBARCH)
+include $(ARCH_DIR)/Makefile-os-$(OS)
+
+MAKEFILE-$(CONFIG_MODE_TT) += Makefile-tt
+MAKEFILE-$(CONFIG_MODE_SKAS) += Makefile-skas
+
+ifneq ($(MAKEFILE-y),)
+  include $(addprefix $(ARCH_DIR)/,$(MAKEFILE-y))
+endif
+
+EXTRAVERSION := $(EXTRAVERSION)-1um
+
 ARCH_INCLUDE = -I$(ARCH_DIR)/include
-MODE_INCLUDE = -I$(ARCH_DIR)/kernel/tt/include \
-	-I$(ARCH_DIR)/kernel/skas/include
 
 # -Derrno=kernel_errno - This turns all kernel references to errno into
 # kernel_errno to separate them from the libc errno.  This allows -fno-common
@@ -46,23 +60,11 @@ LINK_WRAPS = -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc
 
 SIZE = (($(CONFIG_NEST_LEVEL) + $(CONFIG_KERNEL_HALF_GIGS)) * 0x20000000)
 
-SYMLINK_HEADERS = include/asm-um/archparam.h include/asm-um/system.h \
-	include/asm-um/sigcontext.h include/asm-um/processor.h \
-	include/asm-um/ptrace.h include/asm-um/arch-signal.h
-
-ARCH_SYMLINKS = include/asm-um/arch $(ARCH_DIR)/include/sysdep $(ARCH_DIR)/os \
-	$(SYMLINK_HEADERS) $(ARCH_DIR)/include/uml-config.h
-
 ifeq ($(CONFIG_MODE_SKAS), y)
-GEN_HEADERS = $(ARCH_DIR)/kernel/skas/include/skas_ptregs.h
-
 $(SYS_HEADERS) : $(ARCH_DIR)/kernel/skas/include/skas_ptregs.h
 endif
 
-GEN_HEADERS += $(ARCH_DIR)/include/task.h $(ARCH_DIR)/include/kern_constants.h
-
-include $(ARCH_DIR)/Makefile-$(SUBARCH)
-include $(ARCH_DIR)/Makefile-os-$(OS)
+include/linux/version.h: arch/$(ARCH)/Makefile
 
 $(ARCH_DIR)/vmlinux.lds.S :
 	touch $@
@@ -73,16 +75,46 @@ LDFLAGS_vmlinux = -r
 
 vmlinux: $(ARCH_DIR)/main.o 
 
-$(ARCH_DIR)/uml.lds.s : $(ARCH_DIR)/uml.lds.S scripts FORCE
-	$(call if_changed_dep,as_s_S)
+# These aren't in Makefile-tt because they are needed in the !CONFIG_MODE_TT +
+# CONFIG_MODE_SKAS + CONFIG_STATIC_LINK case.
+
+LINK_TT = -static
+LD_SCRIPT_TT := uml.lds.s
+
+ifeq ($(CONFIG_STATIC_LINK),y)
+  LINK-y += $(LINK_TT)
+  LD_SCRIPT-y := $(LD_SCRIPT_TT)
+else
+ifeq ($(CONFIG_MODE_TT),y)
+  LINK-y += $(LINK_TT)
+  LD_SCRIPT-y := $(LD_SCRIPT_TT)
+else
+ifeq ($(CONFIG_MODE_SKAS),y)
+  LINK-y += $(LINK_SKAS)
+  LD_SCRIPT-y := $(LD_SCRIPT_SKAS)
+endif
+endif
+endif
 
-AFLAGS_uml.lds.o = -U$(SUBARCH) -DSTART=$$(($(TOP_ADDR) - $(SIZE))) \
-	-DELF_ARCH=$(ELF_ARCH) -DELF_FORMAT=\"$(ELF_FORMAT)\" -P -C -Uum
+CPP_MODE_TT := $(shell [ "$(CONFIG_MODE_TT)" = "y" ] && echo -DMODE_TT)
+CONFIG_KERNEL_STACK_ORDER ?= 2
+STACK_SIZE := $(shell echo $$[ 4096 * (1 << $(CONFIG_KERNEL_STACK_ORDER)) ] )
 
-linux: $(ARCH_DIR)/uml.lds.s vmlinux
-	$(CC) -Wl,-T,$(ARCH_DIR)/uml.lds.s -static $(LINK-y) $(LINK_WRAPS) \
-		-o linux $(ARCH_DIR)/main.o vmlinux -L/usr/lib -lutil
+AFLAGS_vmlinux.lds.o = -U$(SUBARCH) \
+	-DSTART=$$(($(TOP_ADDR) - $(SIZE))) -DELF_ARCH=$(ELF_ARCH) \
+	-DELF_FORMAT=\"$(ELF_FORMAT)\" $(CPP_MODE_TT) \
+	-DKERNEL_STACK_SIZE=$(STACK_SIZE)
+
+AFLAGS_$(LD_SCRIPT-y:.s=).o = $(AFLAGS_vmlinux.lds.o) -P -C -Uum
 
+LD_SCRIPT-y := $(ARCH_DIR)/$(LD_SCRIPT-y)
+
+$(LD_SCRIPT-y) : $(LD_SCRIPT-y:.s=.S) scripts FORCE
+	$(call if_changed_dep,as_s_S)
+
+linux: vmlinux $(LD_SCRIPT-y)
+	$(CC) -Wl,-T,$(LD_SCRIPT-y) $(LINK-y) $(LINK_WRAPS) \
+		-o linux $(ARCH_DIR)/main.o vmlinux -L/usr/lib -lutil
 
 USER_CFLAGS := $(patsubst -I%,,$(CFLAGS))
 USER_CFLAGS := $(patsubst -Derrno=kernel_errno,,$(USER_CFLAGS))
@@ -92,7 +124,8 @@ USER_CFLAGS := $(patsubst -D__KERNEL__,,$(USER_CFLAGS)) $(ARCH_INCLUDE) \
 # To get a definition of F_SETSIG
 USER_CFLAGS += -D_GNU_SOURCE
 
-CLEAN_FILES += linux x.i gmon.out $(ARCH_DIR)/link.ld $(GEN_HEADERS)
+CLEAN_FILES += linux x.i gmon.out $(ARCH_DIR)/uml.lds.s \
+	$(ARCH_DIR)/dyn_link.ld.s $(GEN_HEADERS)
 
 $(ARCH_DIR)/main.o: $(ARCH_DIR)/main.c
 	$(CC) $(USER_CFLAGS) $(EXTRA_CFLAGS) -c -o $@ $<
@@ -102,8 +135,7 @@ archmrproper:
 	do \
 		$(MAKE) -C $$d archmrproper; \
 	done
-	rm -f $(SYMLINK_HEADERS) $(ARCH_SYMLINKS) include/asm \
-		$(ARCH_DIR)/link.ld \
+	rm -f $(CLEAN_FILES) $(SYMLINK_HEADERS) $(ARCH_SYMLINKS) include/asm \
 		$(addprefix $(ARCH_DIR)/kernel/,$(KERN_SYMLINKS))
 
 archclean: sysclean
@@ -132,7 +164,7 @@ $(ARCH_DIR)/os:
 	cd $(ARCH_DIR) && ln -sf os-$(OS) os
 
 $(ARCH_DIR)/include/uml-config.h :
-	ln -sf $(TOPDIR)/include/linux/autoconf.h $@
+	sed 's/ CONFIG/ UML_CONFIG/' $(TOPDIR)/include/linux/autoconf.h > $@
 
 $(ARCH_DIR)/include/task.h : $(ARCH_DIR)/util/mk_task
 	$< > $@
@@ -146,7 +178,4 @@ $(ARCH_DIR)/util/mk_task : $(ARCH_DIR)/kernel/skas/include/skas_ptregs.h \
 $(ARCH_DIR)/util: FORCE
 	@$(call descend,$@,)
 
-$(ARCH_DIR)/kernel/skas/include/skas_ptregs.h :
-	$(MAKE) -C $(ARCH_DIR)/kernel/skas include/skas_ptregs.h
-
 export SUBARCH USER_CFLAGS OS

arch/um/Makefile-skas

+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+PROFILE += -pg
+
+CFLAGS-$(CONFIG_GCOV) += -fprofile-arcs -ftest-coverage
+CFLAGS-$(CONFIG_GPROF) += $(PROFILE)
+LINK-$(CONFIG_GPROF) += $(PROFILE)
+
+MODE_INCLUDE += -I$(TOPDIR)/$(ARCH_DIR)/kernel/skas/include
+
+LINK_SKAS = -Wl,-rpath,/lib 
+LD_SCRIPT_SKAS = dyn.lds.s
+
+GEN_HEADERS += $(ARCH_DIR)/kernel/skas/include/skas_ptregs.h
+
+$(ARCH_DIR)/kernel/skas/include/skas_ptregs.h :
+	$(MAKE) -C $(ARCH_DIR)/kernel/skas include/skas_ptregs.h

arch/um/Makefile-tt

+# 
+# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+# Licensed under the GPL
+#
+
+MODE_INCLUDE += -I$(TOPDIR)/$(ARCH_DIR)/kernel/tt/include
+

arch/um/drivers/daemon_user.c

@@ -7,6 +7,7 @@
 
 #include <errno.h>
 #include <unistd.h>
+#include <stdint.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/time.h>
@@ -24,8 +25,8 @@ enum request_type { REQ_NEW_CONTROL };
 #define SWITCH_MAGIC 0xfeedface
 
 struct request_v3 {
-	unsigned long magic;
-	int version;
+	uint32_t magic;
+	uint32_t version;
 	enum request_type type;
 	struct sockaddr_un sock;
 };

arch/um/drivers/line.c

@@ -35,7 +35,7 @@ void line_timer_cb(void *arg)
 	line_interrupt(dev->driver->read_irq, dev, NULL);
 }
 
-void buffer_data(struct line *line, const char *buf, int len)
+static void buffer_data(struct line *line, const char *buf, int len)
 {
 	int end;
 
@@ -452,11 +452,19 @@ void line_register_devfs(struct lines *set, struct line_driver *line_driver,
 
 void lines_init(struct line *lines, int nlines)
 {
+	struct line *line;
 	int i;
 
 	for(i = 0; i < nlines; i++){
-		INIT_LIST_HEAD(&lines[i].chan_list);
-		sema_init(&lines[i].sem, 1);
+		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");
+		}
 	}
 }
 
@@ -533,7 +541,8 @@ static void winch_cleanup(void)
 	list_for_each(ele, &winch_handlers){
 		winch = list_entry(ele, struct winch, list);
 		close(winch->fd);
-		if(winch->pid != -1) os_kill_process(winch->pid, 0);
+		if(winch->pid != -1) 
+			os_kill_process(winch->pid, 1);
 	}
 }
 

arch/um/drivers/port_kern.c

@@ -31,7 +31,6 @@ struct port_list {
 
 struct port_dev {
 	struct port_list *port;
-	int fd;
 	int helper_pid;
 	int telnetd_pid;
 };
@@ -55,7 +54,8 @@ static void pipe_interrupt(int irq, void *data, struct pt_regs *regs)
 		if(fd == -EAGAIN)
 			return;
 
-		printk("os_rcv_fd returned %d\n", -fd);
+		printk(KERN_ERR "pipe_interrupt : os_rcv_fd returned %d\n", 
+		       -fd);
 		os_close_file(conn->fd);
 	}
 
@@ -75,13 +75,15 @@ static int port_accept(struct port_list *port)
 	fd = port_connection(port->fd, socket, &pid);
 	if(fd < 0){
 		if(fd != -EAGAIN)
-			printk("port_connection returned %d\n", -fd);
+			printk(KERN_ERR "port_accept : port_connection "
+			       "returned %d\n", -fd);
 		goto out;
 	}
 
 	conn = kmalloc(sizeof(*conn), GFP_ATOMIC);
 	if(conn == NULL){
-		printk("port_interrupt : failed to allocate connection\n");
+		printk(KERN_ERR "port_accept : failed to allocate "
+		       "connection\n");
 		goto out_close;
 	}
 	*conn = ((struct connection) 
@@ -94,7 +96,8 @@ static int port_accept(struct port_list *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 "Failed to get IRQ for telnetd\n");
+		printk(KERN_ERR "port_accept : failed to get IRQ for "
+		       "telnetd\n");
 		goto out_free;
 	}
 
@@ -106,7 +109,8 @@ static int port_accept(struct port_list *port)
 	kfree(conn);
  out_close:
 	os_close_file(fd);
-	if(pid != -1) os_kill_process(pid, 0);
+	if(pid != -1) 
+		os_kill_process(pid, 1);
  out:
 	return(ret);
 } 
@@ -206,38 +210,16 @@ void *port_data(int port_num)
 	return(dev);
 }
 
-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, 0);
- 	dev->helper_pid = -1;
-}
-
-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);
-		os_close_file(port->fd);
-	}
-}
-
-__uml_exitcall(free_port);
-
 int port_wait(void *data)
 {
 	struct port_dev *dev = data;
 	struct connection *conn;
 	struct port_list *port = dev->port;
+	int fd;
 
 	while(1){
-		if(down_interruptible(&port->sem)) return(-ERESTARTSYS);
+		if(down_interruptible(&port->sem))
+			return(-ERESTARTSYS);
 
 		spin_lock(&port->lock);
 
@@ -264,21 +246,48 @@ int port_wait(void *data)
 		kfree(conn);
 	}
 
-	dev->fd = conn->fd;
+	fd = conn->fd;
 	dev->helper_pid = conn->helper_pid;
 	dev->telnetd_pid = conn->telnetd_pid;
 	kfree(conn);
 
-	return(dev->fd);
+	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);
+
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically

arch/um/drivers/port_user.c

@@ -47,14 +47,28 @@ void *port_init(char *str, int device, struct chan_opts *opts)
 		return(NULL);
 	}
 
-	if((kern_data = port_data(port)) == NULL) return(NULL);
+	if((kern_data = port_data(port)) == NULL) 
+		return(NULL);
+
+	if((data = um_kmalloc(sizeof(*data))) == NULL) 
+		goto err;
 
-	if((data = um_kmalloc(sizeof(*data))) == NULL) return(NULL);
-	*data = ((struct port_chan) { raw : 		opts->raw,
-				      kernel_data :	kern_data });
+	*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);
+}
+
+void port_free(void *d)
+{
+	struct port_chan *data = d;
+
+	port_kern_free(data->kernel_data);
+	kfree(data);
 }
 
 int port_open(int input, int output, int primary, void *d, char **dev_out)
@@ -86,25 +100,17 @@ int port_console_write(int fd, const char *buf, int n, void *d)
 	return(generic_console_write(fd, buf, n, &data->tt));
 }
 
-void port_free(void *d)
-{
-	struct port_chan *data = d;
-
-	port_kern_free(data->kernel_data);
-	kfree(data);
-}
-
 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,
+	.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)
@@ -113,7 +119,8 @@ int port_listen_fd(int port)
 	int fd, err;
 
 	fd = socket(PF_INET, SOCK_STREAM, 0);
-	if(fd == -1) return(-errno);
+	if(fd == -1) 
+		return(-errno);
 
 	addr.sin_family = AF_INET;
 	addr.sin_port = htons(port);
@@ -163,14 +170,16 @@ int port_connection(int fd, int *socket, int *pid_out)
 		return(-errno);
 
 	err = os_pipe(socket, 0, 0);
-	if(err) goto out_close;
+	if(err) 
+		goto out_close;
 
 	data = ((struct port_pre_exec_data)
-		{ sock_fd : 		new,
-		  pipe_fd :		socket[1] });
+		{ .sock_fd  		= new,
+		  .pipe_fd 		= socket[1] });
 
 	err = run_helper(port_pre_exec, &data, argv, NULL);
-	if(err < 0) goto out_shutdown;
+	if(err < 0) 
+		goto out_shutdown;
 
 	*pid_out = err;
 	return(new);

arch/um/drivers/pty.c

 /* 
- * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 
@@ -86,34 +86,15 @@ int getmaster(char *line)
 	return(-1);
 }
 
-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 pty_open(int input, int output, int primary, void *d, char **dev_out)
 {
 	struct pty_chan *data = d;
 	int fd;
 	char dev[sizeof("/dev/ptyxx\0")] = "/dev/ptyxx";
-	struct grantpt_info info;
 
 	fd = getmaster(dev);
 	if(fd < 0) return(-errno);
 	
-	info.fd = fd;
-	initial_thread_cb(grantpt_cb, &info);
-	unlockpt(fd);
-
 	if(data->raw) raw(fd, 0);
 	if(data->announce) (*data->announce)(dev, data->dev);
 

arch/um/drivers/ubd_kern.c

@@ -77,9 +77,11 @@ 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 })
+#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 })
+#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
@@ -177,6 +179,8 @@ static void make_ide_entries(char *dev_name)
 	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;
@@ -405,7 +409,8 @@ static int io_pid = -1;
 
 void kill_io_thread(void)
 {
-	if(io_pid != -1) kill(io_pid, SIGKILL);
+	if(io_pid != -1) 
+		os_kill_process(io_pid, 1);
 }
 
 __uml_exitcall(kill_io_thread);

arch/um/drivers/xterm.c

@@ -137,7 +137,7 @@ int xterm_open(int input, int output, int primary, void *d, char **dev_out)
 	}
 	if(new < 0){
 		printk("xterm_open : os_rcv_fd failed, errno = %d\n", -new);
-		return(new);
+		goto out;
 	}
 
 	tcgetattr(new, &data->tt);
@@ -145,6 +145,8 @@ int xterm_open(int input, int output, int primary, void *d, char **dev_out)
 
 	data->pid = pid;
 	*dev_out = NULL;
+ out:
+	unlink(file);
 	return(new);
 }
 
@@ -152,9 +154,11 @@ void xterm_close(int fd, void *d)
 {
 	struct xterm_chan *data = d;
 	
-	if(data->pid != -1) kill(data->pid, SIGKILL);
+	if(data->pid != -1) 
+		os_kill_process(data->pid, 1);
 	data->pid = -1;
-	if(data->helper_pid != -1) kill(data->helper_pid, SIGKILL);
+	if(data->helper_pid != -1) 
+		os_kill_process(data->helper_pid, 0);
 	data->helper_pid = -1;
 	close(fd);
 }

arch/um/dyn.lds.S

+OUTPUT_FORMAT(ELF_FORMAT)
+OUTPUT_ARCH(ELF_ARCH)
+ENTRY(_start)
+jiffies = jiffies_64;
+
+SEARCH_DIR("/usr/local/i686-pc-linux-gnu/lib"); SEARCH_DIR("/usr/local/lib"); SEARCH_DIR("/lib"); SEARCH_DIR("/usr/lib");
+/* Do we need any of these for elf?
+   __DYNAMIC = 0;    */
+SECTIONS
+{
+  . = START + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  . = ALIGN(4096);
+  __binary_start = .;
+  . = ALIGN(4096);		/* Init code and data */
+  _stext = .;
+  __init_begin = .;
+  .text.init : { *(.text.init) }
+
+  . = 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 .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"
+
+  .data.init : { *(.data.init) }
+
+  /* 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) }
+}

arch/um/include/choose-mode.h

@@ -8,13 +8,13 @@
 
 #include "uml-config.h"
 
-#if defined(CONFIG_MODE_TT) && defined(CONFIG_MODE_SKAS)
+#if defined(UML_CONFIG_MODE_TT) && defined(UML_CONFIG_MODE_SKAS)
 #define CHOOSE_MODE(tt, skas) (mode_tt ? (tt) : (skas))
 
-#elif defined(CONFIG_MODE_SKAS)
+#elif defined(UML_CONFIG_MODE_SKAS)
 #define CHOOSE_MODE(tt, skas) (skas)
 
-#elif defined(CONFIG_MODE_TT)
+#elif defined(UML_CONFIG_MODE_TT)
 #define CHOOSE_MODE(tt, skas) (tt)
 #endif
 

arch/um/include/frame.h

@@ -15,12 +15,12 @@ struct frame_common {
 	int sr_index;
 	int sr_relative;
 	int sp_index;
+	struct arch_frame_data arch;
 };
 
 struct sc_frame {
 	struct frame_common common;
 	int sc_index;
-	struct arch_frame_data arch;
 };
 
 extern struct sc_frame signal_frame_sc;
@@ -31,6 +31,8 @@ struct si_frame {
 	struct frame_common common;
 	int sip_index;
 	int si_index;
+	int ucp_index;
+	int uc_index;
 };
 
 extern struct si_frame signal_frame_si;

arch/um/include/irq_user.h

@@ -8,7 +8,7 @@
 
 enum { IRQ_READ, IRQ_WRITE };
 
-extern void sigio_handler(int sig, struct uml_pt_regs *regs);
+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(int irq, void *dev_id);
 extern void free_irq_by_fd(int fd);

arch/um/include/kern_util.h

@@ -47,7 +47,7 @@ extern void free_stack(unsigned long stack, int order);
 extern void add_input_request(int op, void (*proc)(int), void *arg);
 extern int sys_execve(char *file, char **argv, char **env);
 extern char *current_cmd(void);
-extern void timer_handler(int sig, struct uml_pt_regs *regs);
+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);
@@ -64,7 +64,7 @@ extern void *syscall_sp(void *t);
 extern void syscall_trace(void);
 extern int hz(void);
 extern void idle_timer(void);
-extern unsigned int do_IRQ(int irq, struct uml_pt_regs *regs);
+extern unsigned int do_IRQ(int irq, union uml_pt_regs *regs);
 extern int external_pid(void *t);
 extern int pid_to_processor_id(int pid);
 extern void boot_timer_handler(int sig);
@@ -77,10 +77,10 @@ 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, struct uml_pt_regs *regs);
+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(struct uml_pt_regs *regs);
+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);
@@ -101,7 +101,7 @@ 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 void bus_handler(int sig, struct uml_pt_regs *regs);
+extern void bus_handler(int sig, union uml_pt_regs *regs);
 extern long execute_syscall(void *r);
 extern int smp_sigio_handler(void);
 extern void *get_current(void);

arch/um/include/mconsole.h

@@ -7,30 +7,35 @@
 #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 {
-	unsigned long magic;
-	int version;
-	int len;
+	u32 magic;
+	u32 version;
+	u32 len;
 	char data[MCONSOLE_MAX_DATA];
 };
 
 struct mconsole_reply {
-	int err;
-	int more;
-	int len;
+	u32 err;
+	u32 more;
+	u32 len;
 	char data[MCONSOLE_MAX_DATA];
 };
 
 struct mconsole_notify {
-	unsigned long magic;
-	int version;	
+	u32 magic;
+	u32 version;	
 	enum { MCONSOLE_SOCKET, MCONSOLE_PANIC, MCONSOLE_HANG,
 	       MCONSOLE_USER_NOTIFY } type;
-	int len;
+	u32 len;
 	char data[MCONSOLE_MAX_DATA];
 };
 

arch/um/include/mode.h

@@ -8,11 +8,11 @@
 
 #include "uml-config.h"
 
-#ifdef CONFIG_MODE_TT
+#ifdef UML_CONFIG_MODE_TT
 #include "../kernel/tt/include/mode.h"
 #endif
 
-#ifdef CONFIG_MODE_SKAS
+#ifdef UML_CONFIG_MODE_SKAS
 #include "../kernel/skas/include/mode.h"
 #endif
 

arch/um/include/os.h

@@ -25,9 +25,11 @@ struct openflags {
 	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, c : 0, s : 0 })
+#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)
 {
@@ -83,9 +85,16 @@ static inline struct openflags of_excl(struct openflags flags)
 	return(flags); 
 }
  
+static inline struct openflags of_cloexec(struct openflags flags)
+{ 
+	flags.cl = 1; 
+	return(flags); 
+}
+  
 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, char *buf, int len);
+extern int os_read_file(int fd, void *buf, int len);
+extern int os_write_file(int fd, void *buf, int count);
 extern int os_file_size(char *file, long long *size_out);
 extern int os_pipe(int *fd, int stream, int close_on_exec);
 extern int os_set_fd_async(int fd, int owner);
@@ -98,7 +107,6 @@ extern int create_unix_socket(char *file, int len);
 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_write_file(int fd, char *buf, int count);
 
 extern unsigned long os_process_pc(int pid);
 extern int os_process_parent(int pid);

arch/um/include/signal_kern.h

 /* 
- * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 
 #ifndef __SIGNAL_KERN_H__
 #define __SIGNAL_KERN_H__
 
-#include "sysdep/ptrace.h"
-
-extern void signal_deliverer(int sig);
-extern int probe_stack(unsigned long sp, int delta);
 extern int have_signals(void *t);
 
 #endif

arch/um/include/sysdep-i386/frame.h

@@ -7,7 +7,8 @@
 #define __FRAME_I386_H
 
 struct arch_frame_data_raw {
-	unsigned long sc_end;
+	unsigned long fp_start;
+	unsigned long sr;
 };
 
 struct arch_frame_data {

arch/um/include/sysdep-i386/frame_kern.h

@@ -16,6 +16,15 @@ static inline void *sp_to_sc(unsigned long sp)
 	return((void *) sp);
 }
 
+static inline void *sp_to_uc(unsigned long sp)
+{
+	unsigned long uc;
+
+	uc = sp + signal_frame_si.uc_index - 
+		signal_frame_si.common.sp_index - 4;
+	return((void *) uc);
+}
+
 static inline void *sp_to_rt_sc(unsigned long sp)
 {
 	unsigned long sc;
@@ -42,7 +51,7 @@ static inline void *sp_to_rt_mask(unsigned long sp)
 
 	mask = sp - signal_frame_si.common.sp_index + 
 		signal_frame_si.common.len + 
-		sc_size(&signal_frame_sc.arch) - 4;
+		sc_size(&signal_frame_si.common.arch) - 4;
 	return((void *) mask);
 }
 

arch/um/include/sysdep-i386/frame_user.h

@@ -18,26 +18,35 @@
  * setup_arch_frame uses that data to figure out what 
  * arch_frame_data.fpstate_size should be.  It really has no idea, since it's
  * not allowed to do sizeof(struct fpstate) but it's safe to consider that it's
- * everything from the end of the sgcontext up to the top of the stack.  So,
+ * everything from the end of the sigcontext up to the top of the stack.  So,
  * it masks off the page number to get the offset within the page and subtracts
  * that from the page size, and that's how big the fpstate struct will be
  * considered to be.
  */
 
 static inline void setup_arch_frame_raw(struct arch_frame_data_raw *data,
-					struct sigcontext *sc)
+					void *end, unsigned long srp)
 {
-	data->sc_end = (unsigned long) sc;
-	data->sc_end += sizeof(*sc);
+	unsigned long sr = *((unsigned long *) srp);
+
+	data->fp_start = (unsigned long) end;
+	if((sr & PAGE_MASK) == ((unsigned long) end & PAGE_MASK))
+		data->sr = sr;
+	else data->sr = 0;
 }
 
 static inline void setup_arch_frame(struct arch_frame_data_raw *in, 
 				    struct arch_frame_data *out)
 {
-	unsigned long fpstate_start = in->sc_end;
+	unsigned long fpstate_start = in->fp_start;
 
+	if(in->sr == 0){
 		fpstate_start &= ~PAGE_MASK;
 		out->fpstate_size = PAGE_SIZE - fpstate_start;
+	}
+	else {
+		out->fpstate_size = in->sr - fpstate_start;
+	}
 }
 
 /* This figures out where on the stack the SA_RESTORER function address

arch/um/include/sysdep-i386/ptrace.h

@@ -7,72 +7,101 @@
 #define __SYSDEP_I386_PTRACE_H
 
 #include "uml-config.h"
+
+#ifdef UML_CONFIG_MODE_TT
 #include "ptrace-tt.h"
+#endif
+
+#ifdef UML_CONFIG_MODE_SKAS
 #include "ptrace-skas.h"
+#endif
+
 #include "choose-mode.h"
 
-struct uml_pt_regs {
-	unsigned long args[6];
+union uml_pt_regs {
+#ifdef UML_CONFIG_MODE_TT
+	struct tt_regs {
 		long syscall;
-	int is_user;
-	union {
-#ifdef CONFIG_MODE_TT
-		void *tt;
+		void *sc;
+	} tt;
 #endif
-#ifdef CONFIG_MODE_SKAS
-		struct {
+#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
-	} mode;
 };
 
-#define EMPTY_UML_PT_REGS { \
-	syscall : 	-1, \
-	args : 		{ [0 ... 5] = 0 }, \
-	is_user :	0 }
+#define EMPTY_UML_PT_REGS { }
 
 extern int mode_tt;
 
+#define UPT_SC(r) ((r)->tt.sc)
 #define UPT_IP(r) \
-	CHOOSE_MODE(SC_IP((r)->mode.tt), REGS_IP((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_IP(UPT_SC(r)), REGS_IP((r)->skas.regs))
 #define UPT_SP(r) \
-	CHOOSE_MODE(SC_SP((r)->mode.tt), REGS_SP((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_SP(UPT_SC(r)), REGS_SP((r)->skas.regs))
 #define UPT_EFLAGS(r) \
-	CHOOSE_MODE(SC_EFLAGS((r)->mode.tt), REGS_EFLAGS((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_EFLAGS(UPT_SC(r)), REGS_EFLAGS((r)->skas.regs))
 #define UPT_EAX(r) \
-	CHOOSE_MODE(SC_EAX((r)->mode.tt), REGS_EAX((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_EAX(UPT_SC(r)), REGS_EAX((r)->skas.regs))
 #define UPT_EBX(r) \
-	CHOOSE_MODE(SC_EBX((r)->mode.tt), REGS_EBX((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_EBX(UPT_SC(r)), REGS_EBX((r)->skas.regs))
 #define UPT_ECX(r) \
-	CHOOSE_MODE(SC_ECX((r)->mode.tt), REGS_ECX((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_ECX(UPT_SC(r)), REGS_ECX((r)->skas.regs))
 #define UPT_EDX(r) \
-	CHOOSE_MODE(SC_EDX((r)->mode.tt), REGS_EDX((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_EDX(UPT_SC(r)), REGS_EDX((r)->skas.regs))
 #define UPT_ESI(r) \
-	CHOOSE_MODE(SC_ESI((r)->mode.tt), REGS_ESI((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_ESI(UPT_SC(r)), REGS_ESI((r)->skas.regs))
 #define UPT_EDI(r) \
-	CHOOSE_MODE(SC_EDI((r)->mode.tt), REGS_EDI((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_EDI(UPT_SC(r)), REGS_EDI((r)->skas.regs))
 #define UPT_EBP(r) \
-	CHOOSE_MODE(SC_EBP((r)->mode.tt), REGS_EBP((r)->mode.skas.regs))
-#define UPT_ORIG_EAX(r) ((r)->syscall)
+	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((r)->mode.tt), REGS_CS((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_CS(UPT_SC(r)), REGS_CS((r)->skas.regs))
 #define UPT_SS(r) \
-	CHOOSE_MODE(SC_SS((r)->mode.tt), REGS_SS((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_SS(UPT_SC(r)), REGS_SS((r)->skas.regs))
 #define UPT_DS(r) \
-	CHOOSE_MODE(SC_DS((r)->mode.tt), REGS_DS((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_DS(UPT_SC(r)), REGS_DS((r)->skas.regs))
 #define UPT_ES(r) \
-	CHOOSE_MODE(SC_ES((r)->mode.tt), REGS_ES((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_ES(UPT_SC(r)), REGS_ES((r)->skas.regs))
 #define UPT_FS(r) \
-	CHOOSE_MODE(SC_FS((r)->mode.tt), REGS_FS((r)->mode.skas.regs))
+	CHOOSE_MODE(SC_FS(UPT_SC(r)), REGS_FS((r)->skas.regs))
 #define UPT_GS(r) \
-	CHOOSE_MODE(SC_GS((r)->mode.tt), REGS_GS((r)->mode.skas.regs))
-#define UPT_SC(r) ((r)->mode.tt)
+	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; \
@@ -129,28 +158,26 @@ extern int mode_tt;
 	} while (0)
 
 #define UPT_SET_SYSCALL_RETURN(r, res) \
-	CHOOSE_MODE(SC_SET_SYSCALL_RETURN((r)->mode.tt, (res)), \
-                    REGS_SET_SYSCALL_RETURN((r)->mode.skas.regs, (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((r)->mode.tt), \
-		    REGS_RESTART_SYSCALL((r)->mode.skas.regs))
+	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) ((r)->syscall)
+#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(r->mode.tt), \
-		    REGS_SEGV_IS_FIXABLE(&r->mode.skas))
+	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(r->mode.tt), \
-		    REGS_FAULT_ADDR(&r->mode.skas))
+	CHOOSE_MODE(SC_FAULT_ADDR(UPT_SC(r)), REGS_FAULT_ADDR(&r->skas))
 
 #define UPT_FAULT_WRITE(r) \
-	CHOOSE_MODE(SC_FAULT_WRITE(r->mode.tt), \
-		    REGS_FAULT_WRITE(&r->mode.skas))
+	CHOOSE_MODE(SC_FAULT_WRITE(UPT_SC(r)), REGS_FAULT_WRITE(&r->skas))
 
 #endif
 

arch/um/include/sysdep-i386/sigcontext.h

@@ -33,34 +33,6 @@
 
 #define SC_SEGV_IS_FIXABLE(sc) (SEGV_IS_FIXABLE(SC_TRAPNO(sc)))
 
-#ifdef CONFIG_MODE_TT
-/* XXX struct sigcontext needs declaring by now */
-static inline void sc_to_regs(struct uml_pt_regs *regs, struct sigcontext *sc,
-			      unsigned long syscall)
-{
-	regs->syscall = syscall;
-	regs->args[0] = SC_EBX(sc);
-	regs->args[1] = SC_ECX(sc);
-	regs->args[2] = SC_EDX(sc);
-	regs->args[3] = SC_ESI(sc);
-	regs->args[4] = SC_EDI(sc);
-	regs->args[5] = SC_EBP(sc);
-}
-#endif
-
-#ifdef CONFIG_MODE_SKAS
-static inline void host_to_regs(struct uml_pt_regs *regs)
-{
-	regs->syscall = UPT_ORIG_EAX(regs);
-	regs->args[0] = UPT_EBX(regs);
-	regs->args[1] = UPT_ECX(regs);
-	regs->args[2] = UPT_EDX(regs);
-	regs->args[3] = UPT_ESI(regs);
-	regs->args[4] = UPT_EDI(regs);
-	regs->args[5] = UPT_EBP(regs);
-}
-#endif
-
 extern unsigned long *sc_sigmask(void *sc_ptr);
 extern int sc_get_fpregs(unsigned long buf, void *sc_ptr);
 

arch/um/include/sysdep-i386/syscalls.h

@@ -4,10 +4,12 @@
  */
 
 #include "asm/unistd.h"
+#include "sysdep/ptrace.h"
 
 typedef long syscall_handler_t(struct pt_regs);
 
-#define EXECUTE_SYSCALL(syscall, regs) (*sys_call_table[syscall])(*regs);
+#define EXECUTE_SYSCALL(syscall, regs) \
+	((long (*)(struct syscall_args)) (*sys_call_table[syscall]))(SYSCALL_ARGS(&regs->regs))
 
 extern syscall_handler_t sys_modify_ldt;
 extern syscall_handler_t old_mmap_i386;

arch/um/include/time_user.h

@@ -11,7 +11,7 @@ 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 time_lock(void);
-extern void time_unlock(void);
+extern unsigned long time_lock(void);
+extern void time_unlock(unsigned long);
 
 #endif

arch/um/include/umid.h

@@ -3,8 +3,13 @@
  * 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

arch/um/include/uml_uaccess.h

+/*
+ * 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:
+ */

arch/um/include/user_util.h

@@ -24,7 +24,7 @@ struct cpu_task {
 extern struct cpu_task cpu_tasks[];
 
 struct signal_info {
-	void (*handler)(int, struct uml_pt_regs *);
+	void (*handler)(int, union uml_pt_regs *);
 	int is_irq;
 };
 
@@ -61,7 +61,6 @@ extern int start_fork_tramp(void *arg, unsigned long temp_stack,
 			    int clone_flags, int (*tramp)(void *));
 extern int clone_and_wait(int (*fn)(void *), void *arg, void *sp, int flags);
 extern int linux_main(int argc, char **argv);
-extern void remap_data(void *segment_start, void *segment_end, int w);
 extern void set_cmdline(char *cmd);
 extern void input_cb(void (*proc)(void *), void *arg, int arg_len);
 extern int get_pty(void);
@@ -87,7 +86,7 @@ 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 arch_handle_signal(int sig, struct uml_pt_regs *regs);
+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);

arch/um/kernel/Makefile

@@ -3,15 +3,13 @@
 # Licensed under the GPL
 #
 
-EXTRA_TARGETS	:= unmap_fin.o
-
 obj-y = checksum.o config.o exec_kern.o exitcode.o frame_kern.o frame.o \
 	helper.o init_task.o irq.o irq_user.o ksyms.o mem.o mem_user.o \
 	process.o process_kern.o ptrace.o reboot.o resource.o sigio_user.o \
 	sigio_kern.o signal_kern.o signal_user.o smp.o syscall_kern.o \
 	syscall_user.o sysrq.o sys_call_table.o tempfile.o time.o \
-	time_kern.o tlb.o trap_kern.o trap_user.o um_arch.o \
-	umid.o user_util.o
+	time_kern.o tlb.o trap_kern.o trap_user.o uaccess_user.o um_arch.o \
+	umid.o user_syms.o user_util.o
 
 obj-$(CONFIG_BLK_DEV_INITRD) += initrd_kern.o initrd_user.o
 obj-$(CONFIG_GPROF)	+= gprof_syms.o
@@ -23,16 +21,10 @@ obj-$(CONFIG_MODE_SKAS) += skas/
 
 user-objs-$(CONFIG_TTY_LOG) += tty_log.o
 
-# user_syms.o not included here because Rules.make has its own ideas about
-# building anything in export-objs
-
 USER_OBJS := $(filter %_user.o,$(obj-y))  $(user-objs-y) config.o helper.o \
 	process.o tempfile.o time.o tty_log.o umid.o user_util.o user_syms.o
 USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
 
-UNMAP_CFLAGS := $(patsubst -pg -DPROFILING,,$(USER_CFLAGS))
-UNMAP_CFLAGS := $(patsubst -fprofile-arcs -ftest-coverage,,$(UNMAP_CFLAGS))
-
 DMODULES-$(CONFIG_MODULES) = -D__CONFIG_MODULES__
 DMODVERSIONS-$(CONFIG_MODVERSIONS) = -D__CONFIG_MODVERSIONS__
 
@@ -43,13 +35,7 @@ CFLAGS_user_syms.o = -D__AUTOCONF_INCLUDED__ $(DMODULES-y) $(DMODVERSIONS-y) \
 CFLAGS_frame.o := $(patsubst -fomit-frame-pointer,,$(USER_CFLAGS))
 
 $(USER_OBJS) : %.o: %.c
-	$(CC) $(CFLAGS_$@) $(USER_CFLAGS) -c -o $@ $<
-
-$(obj)/unmap.o: $(src)/unmap.c
-	$(CC) $(UNMAP_CFLAGS) -c -o $@ $<
-
-$(obj)/unmap_fin.o : $(src)/unmap.o
-	ld -r -o $@ $< -lc -L/usr/lib
+	$(CC) $(CFLAGS_$(notdir $@)) $(USER_CFLAGS) -c -o $@ $<
 
 # This has to be separate because it needs be compiled with frame pointers
 # regardless of how the rest of the kernel is built.

arch/um/kernel/frame.c

@@ -78,7 +78,8 @@ static int capture_stack(int (*child)(void *arg), void *arg, void *sp,
 
 	/* It has outlived its usefulness, so continue it so it can exit */
 	if(ptrace(PTRACE_CONT, pid, 0, 0) < 0){
-		printf("capture_stack : mmap failed - errno = %d\n", errno);
+		printf("capture_stack : PTRACE_CONT failed - errno = %d\n", 
+		       errno);
 		exit(1);
 	}
 	if(waitpid(pid, &status, 0) < 0){
@@ -110,6 +111,7 @@ struct common_raw {
 	unsigned long sig;
 	unsigned long sr;
 	unsigned long sp;	
+	struct arch_frame_data_raw arch;
 };
 
 #define SA_RESTORER (0x04000000)
@@ -173,7 +175,6 @@ struct sc_frame_raw {
 	struct common_raw common;
 	unsigned long sc;
 	int restorer;
-	struct arch_frame_data_raw arch;
 };
 
 /* Changed only during early boot */
@@ -185,7 +186,8 @@ static void sc_handler(int sig, struct sigcontext sc)
 	raw_sc->common.sr = frame_restorer();
 	raw_sc->common.sp = frame_sp();
 	raw_sc->sc = (unsigned long) &sc;
-	setup_arch_frame_raw(&raw_sc->arch, &sc);
+	setup_arch_frame_raw(&raw_sc->common.arch, &sc + 1, raw_sc->common.sr);
+
 	os_stop_process(os_getpid());
 	kill(getpid(), SIGKILL);
 }
@@ -205,18 +207,25 @@ struct si_frame_raw {
 	struct common_raw common;
 	unsigned long sip;
 	unsigned long si;
+	unsigned long ucp;
+	unsigned long uc;
 };
 
 /* Changed only during early boot */
 static struct si_frame_raw *raw_si = NULL;
 
-static void si_handler(int sig, siginfo_t *si)
+static void si_handler(int sig, siginfo_t *si, struct ucontext *ucontext)
 {
 	raw_si->common.sig = (unsigned long) &sig;
 	raw_si->common.sr = frame_restorer();
 	raw_si->common.sp = frame_sp();
 	raw_si->sip = (unsigned long) &si;
 	raw_si->si = (unsigned long) si;
+	raw_si->ucp = (unsigned long) &ucontext;
+	raw_si->uc = (unsigned long) ucontext;
+	setup_arch_frame_raw(&raw_si->common.arch, 
+			     ucontext->uc_mcontext.fpregs, raw_si->common.sr);
+	
 	os_stop_process(os_getpid());
 	kill(getpid(), SIGKILL);
 }
@@ -292,7 +301,7 @@ void capture_signal_stack(void)
 				    &signal_frame_sc.common);
 
 	signal_frame_sc.sc_index = raw_sc.sc - base;
-	setup_arch_frame(&raw_sc.arch, &signal_frame_sc.arch);
+	setup_arch_frame(&raw_sc.common.arch, &signal_frame_sc.common.arch);
 
 	/* Ditto for the sigcontext, sigrestorer layout */
 	raw_sc.restorer = 1;
@@ -300,6 +309,7 @@ void capture_signal_stack(void)
 				    (void *) top, sigstack, PAGE_SIZE, 
 				    &signal_frame_sc_sr.common);
 	signal_frame_sc_sr.sc_index = raw_sc.sc - base;
+	setup_arch_frame(&raw_sc.common.arch, &signal_frame_sc_sr.common.arch);
 
 	/* And the siginfo layout */
 
@@ -308,6 +318,9 @@ void capture_signal_stack(void)
 				    &signal_frame_si.common);
 	signal_frame_si.sip_index = raw_si.sip - base;
 	signal_frame_si.si_index = raw_si.si - base;
+	signal_frame_si.ucp_index = raw_si.ucp - base;
+	signal_frame_si.uc_index = raw_si.uc - base;
+	setup_arch_frame(&raw_si.common.arch, &signal_frame_si.common.arch);
 
 	if((munmap(stack, PAGE_SIZE) < 0) || 
 	   (munmap(sigstack, PAGE_SIZE) < 0)){

arch/um/kernel/frame_kern.c

@@ -6,6 +6,8 @@
 #include "asm/ptrace.h"
 #include "asm/uaccess.h"
 #include "asm/signal.h"
+#include "asm/uaccess.h"
+#include "asm/ucontext.h"
 #include "frame_kern.h"
 #include "sigcontext.h"
 #include "sysdep/ptrace.h"
@@ -27,48 +29,62 @@ static int copy_restorer(void (*restorer)(void), unsigned long start,
 			    sizeof(restorer)));
 }
 
-static int copy_sc_to_user(void *to, struct pt_regs *from)
+static int copy_sc_to_user(void *to, void *fp, struct pt_regs *from, 
+			   struct arch_frame_data *arch)
 {
-	return(CHOOSE_MODE(copy_sc_to_user_tt(to, from->regs.mode.tt, 
-					      &signal_frame_sc_sr.arch),
-			   copy_sc_to_user_skas(to, &from->regs,
+	return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs), 
+					      arch),
+			   copy_sc_to_user_skas(to, fp, &from->regs,
 						current->thread.cr2,
 						current->thread.err)));
 }
 
+static int copy_ucontext_to_user(struct ucontext *uc, void *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,
+			       &signal_frame_si.common.arch);
+	err |= copy_to_user(&uc->uc_sigmask, set, sizeof(*set));
+	return(err);
+}
+
 int setup_signal_stack_si(unsigned long stack_top, int sig, 
 			  unsigned long handler, void (*restorer)(void), 
 			  struct pt_regs *regs, siginfo_t *info, 
 			  sigset_t *mask)
 {
-	unsigned long start, sc, sigs;
-	void *sip;
-	int sig_size = _NSIG_WORDS * sizeof(unsigned long);
+	unsigned long start;
+	void *sip, *ucp, *fp;
 
-	start = stack_top - signal_frame_si.common.len - 
-		sc_size(&signal_frame_sc.arch) - sig_size;
+	start = stack_top - signal_frame_si.common.len;
 	sip = (void *) (start + signal_frame_si.si_index);
-	sc = start + signal_frame_si.common.len;
-	sigs = sc + sc_size(&signal_frame_sc.arch);
+	ucp = (void *) (start + signal_frame_si.uc_index);
+	fp = (void *) (((unsigned long) ucp) + sizeof(struct ucontext));
 
 	if(restorer == NULL)
 		panic("setup_signal_stack_si - no restorer");
 
-	if(copy_sc_to_user((void *) sc, regs) ||
-	   copy_to_user((void *) start, signal_frame_si.common.data,
+	if(copy_to_user((void *) start, signal_frame_si.common.data,
 			signal_frame_si.common.len) ||
 	   copy_to_user((void *) (start + signal_frame_si.common.sig_index), 
 			&sig, sizeof(sig)) ||
 	   copy_siginfo_to_user(sip, info) ||
 	   copy_to_user((void *) (start + signal_frame_si.sip_index), &sip,
 			sizeof(sip)) ||
-	   copy_to_user((void *) sigs, mask, sig_size) ||
+	   copy_ucontext_to_user(ucp, fp, mask, PT_REGS_SP(regs)) ||
+	   copy_to_user((void *) (start + signal_frame_si.ucp_index), &ucp,
+			sizeof(ucp)) ||
 	   copy_restorer(restorer, start, signal_frame_si.common.sr_index,
 			 signal_frame_si.common.sr_relative))
 		return(1);
 	
 	PT_REGS_IP(regs) = handler;
-	PT_REGS_SP(regs) = start + signal_frame_sc.common.sp_index;
+	PT_REGS_SP(regs) = start + signal_frame_si.common.sp_index;
 	return(0);
 }
 
@@ -96,7 +112,8 @@ int setup_signal_stack_sc(unsigned long stack_top, int sig,
 	if(copy_to_user((void *) start, frame->data, frame->len) ||
 	   copy_to_user((void *) (start + frame->sig_index), &sig, 
 			sizeof(sig)) ||
-	   copy_sc_to_user(user_sc, regs) ||
+	   copy_sc_to_user(user_sc, NULL, regs, 
+			   &signal_frame_sc.common.arch) ||
 	   copy_to_user(sc_sigmask(user_sc), mask, sizeof(mask->sig[0])) ||
 	   copy_to_user((void *) sigs, &mask->sig[1], sig_size) ||
 	   copy_restorer(restorer, start, frame->sr_index, frame->sr_relative))

arch/um/kernel/irq.c

@@ -271,7 +271,7 @@ void enable_irq(unsigned int irq)
  * SMP cross-CPU interrupts have their own specific
  * handlers).
  */
-unsigned int do_IRQ(int irq, struct uml_pt_regs *regs)
+unsigned int do_IRQ(int irq, union uml_pt_regs *regs)
 {	
 	/* 
 	 * 0 return value means that this irq is already being

arch/um/kernel/irq_user.c

@@ -42,7 +42,7 @@ static int pollfds_size = 0;
 
 extern int io_count, intr_count;
 
-void sigio_handler(int sig, struct uml_pt_regs *regs)
+void sigio_handler(int sig, union uml_pt_regs *regs)
 {
 	struct irq_fd *irq_fd, *next;
 	int i, n;

arch/um/kernel/ksyms.c

@@ -14,6 +14,7 @@
 #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"
@@ -42,7 +43,11 @@ 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(mode_tt);
+EXPORT_SYMBOL(handle_page_fault);
 
+EXPORT_SYMBOL(os_getpid);
 EXPORT_SYMBOL(os_open_file);
 EXPORT_SYMBOL(os_read_file);
 EXPORT_SYMBOL(os_write_file);

arch/um/kernel/mem.c

@@ -27,6 +27,7 @@
 #include "init.h"
 #include "os.h"
 #include "mode_kern.h"
+#include "uml_uaccess.h"
 
 /* Changed during early boot */
 pgd_t swapper_pg_dir[1024];
@@ -414,8 +415,28 @@ __uml_setup("mem=", uml_mem_setup,
 
 struct page *arch_validate(struct page *page, int mask, int order)
 {
-	return(CHOOSE_MODE_PROC(arch_validate_tt, arch_validate_skas, page, 
-				mask, order));
+	unsigned long addr, zero = 0;
+	int i;
+
+ again:
+	if(page == NULL) return(page);
+	if(PageHighMem(page)) return(page);
+
+	addr = (unsigned long) page_address(page);
+	for(i = 0; i < (1 << order); i++){
+		current->thread.fault_addr = (void *) addr;
+		if(__do_copy_to_user((void *) addr, &zero, 
+				     sizeof(zero),
+				     &current->thread.fault_addr,
+				     &current->thread.fault_catcher)){
+			if(!(mask & __GFP_WAIT)) return(NULL);
+			else break;
+		}
+		addr += PAGE_SIZE;
+	}
+	if(i == (1 << order)) return(page);
+	page = alloc_pages(mask, order);
+	goto again;
 }
 
 DECLARE_MUTEX(vm_reserved_sem);

arch/um/kernel/process_kern.c

@@ -169,8 +169,12 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 
 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)

arch/um/kernel/ptrace.c

@@ -9,7 +9,9 @@
 #include "linux/smp_lock.h"
 #include "linux/security.h"
 #include "linux/ptrace.h"
+#ifdef CONFIG_PROC_MM
 #include "linux/proc_mm.h"
+#endif
 #include "asm/ptrace.h"
 #include "asm/uaccess.h"
 #include "kern_util.h"

arch/um/kernel/sigio_user.c

@@ -111,6 +111,7 @@ static void tty_output(int master, int slave)
 
 	printk("Checking that host ptys support output SIGIO...");
 
+	memset(buf, 0, sizeof(buf));
 	while(write(master, buf, sizeof(buf)) > 0) ;
 	if(errno != EAGAIN)
 		panic("check_sigio : write failed, errno = %d\n", errno);
@@ -267,7 +268,8 @@ static void update_thread(void)
 	return;
  fail:
 	sigio_lock();
-	if(write_sigio_pid != -1) kill(write_sigio_pid, SIGKILL);
+	if(write_sigio_pid != -1) 
+		os_kill_process(write_sigio_pid, 1);
 	write_sigio_pid = -1;
 	close(sigio_private[0]);
 	close(sigio_private[1]);	
@@ -394,7 +396,7 @@ void write_sigio_workaround(void)
 	return;
 
  out_kill:
-	kill(write_sigio_pid, SIGKILL);
+	os_kill_process(write_sigio_pid, 1);
 	write_sigio_pid = -1;
  out_close2:
 	close(sigio_private[0]);
@@ -420,7 +422,8 @@ int read_sigio_fd(int fd)
 
 static void sigio_cleanup(void)
 {
-	if(write_sigio_pid != -1) kill(write_sigio_pid, SIGKILL);
+	if(write_sigio_pid != -1)
+		os_kill_process(write_sigio_pid, 1);
 }
 
 __uml_exitcall(sigio_cleanup);

arch/um/kernel/signal_kern.c

@@ -18,6 +18,7 @@
 #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"
@@ -29,18 +30,6 @@
 EXPORT_SYMBOL(block_signals);
 EXPORT_SYMBOL(unblock_signals);
 
-int probe_stack(unsigned long sp, int delta)
-{
-	int n;
-
-	if((get_user(n, (int *) sp) != 0) ||
-	   (put_user(n, (int *) sp) != 0) ||
-	   (get_user(n, (int *) (sp - delta)) != 0) ||
-	   (put_user(n, (int *) (sp - delta)) != 0))
-		return(-EFAULT);
-	return(0);
-}
-
 static void force_segv(int sig)
 {
 	if(sig == SIGSEGV){
@@ -237,20 +226,20 @@ int sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize)
 	}
 }
 
-static int copy_sc_from_user(struct pt_regs *to, void *from)
+static int copy_sc_from_user(struct pt_regs *to, void *from, 
+			     struct arch_frame_data *arch)
 {
 	int ret;
 
-	ret = CHOOSE_MODE(copy_sc_from_user_tt(to->regs.mode.tt, from, 
-					       &signal_frame_sc.arch),
+	ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from, arch),
 			  copy_sc_from_user_skas(&to->regs, from));
 	return(ret);
 }
 
 int sys_sigreturn(struct pt_regs regs)
 {
-	void *sc = sp_to_sc(PT_REGS_SP(&regs));
-	void *mask = sp_to_mask(PT_REGS_SP(&regs));
+	void *sc = sp_to_sc(PT_REGS_SP(&current->thread.regs));
+	void *mask = sp_to_mask(PT_REGS_SP(&current->thread.regs));
 	int sig_size = (_NSIG_WORDS - 1) * sizeof(unsigned long);
 
 	spin_lock_irq(&current->sig->siglock);
@@ -260,22 +249,25 @@ int sys_sigreturn(struct pt_regs regs)
 	sigdelsetmask(&current->blocked, ~_BLOCKABLE);
 	recalc_sigpending();
 	spin_unlock_irq(&current->sig->siglock);
-	copy_sc_from_user(&current->thread.regs, sc);
+	copy_sc_from_user(&current->thread.regs, sc, 
+			  &signal_frame_sc.common.arch);
 	return(PT_REGS_SYSCALL_RET(&current->thread.regs));
 }
 
 int sys_rt_sigreturn(struct pt_regs regs)
 {
-	void *sc = sp_to_rt_sc(PT_REGS_SP(&regs));
-	void *mask = sp_to_rt_mask(PT_REGS_SP(&regs));
+	struct ucontext *uc = sp_to_uc(PT_REGS_SP(&current->thread.regs));
+	void *fp;
 	int sig_size = _NSIG_WORDS * sizeof(unsigned long);
 
 	spin_lock_irq(&current->sig->siglock);
-	copy_from_user(&current->blocked, mask, sig_size);
+	copy_from_user(&current->blocked, &uc->uc_sigmask, sig_size);
 	sigdelsetmask(&current->blocked, ~_BLOCKABLE);
 	recalc_sigpending();
 	spin_unlock_irq(&current->sig->siglock);
-	copy_sc_from_user(&current->thread.regs, sc);
+	fp = (void *) (((unsigned long) uc) + sizeof(struct ucontext));
+	copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext,
+			  &signal_frame_si.common.arch);
 	return(PT_REGS_SYSCALL_RET(&current->thread.regs));
 }
 

arch/um/kernel/skas/include/mode.h

@@ -12,10 +12,11 @@ extern unsigned long exec_fpx_regs[];
 extern int have_fpx_regs;
 
 extern void user_time_init_skas(void);
-extern int copy_sc_from_user_skas(struct uml_pt_regs *regs, void *from_ptr);
-extern int copy_sc_to_user_skas(void *to_ptr, struct uml_pt_regs *regs, 
+extern int copy_sc_from_user_skas(union uml_pt_regs *regs, void *from_ptr);
+extern int copy_sc_to_user_skas(void *to_ptr, void *fp, 
+				union uml_pt_regs *regs, 
 				unsigned long fault_addr, int fault_type);
-extern void sig_handler_common_skas(int sig, struct sigcontext *sc);
+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);

arch/um/kernel/skas/include/mode_kern.h

@@ -21,6 +21,8 @@ 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, 
@@ -32,11 +34,10 @@ 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 struct page *arch_validate_skas(struct page *page, int mask, int order);
 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)
+#define kmem_end_skas (host_task_size - 1024 * 1024)
 
 #endif
 

arch/um/kernel/skas/include/ptrace-skas.h

@@ -8,7 +8,7 @@
 
 #include "uml-config.h"
 
-#ifdef CONFIG_MODE_SKAS
+#ifdef UML_CONFIG_MODE_SKAS
 
 #include "skas_ptregs.h"
 

arch/um/kernel/skas/include/skas.h

@@ -17,21 +17,21 @@ extern void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
 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(struct uml_pt_regs *regs);
+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(struct uml_pt_regs *regs);
+extern void handle_syscall(union uml_pt_regs *regs);
 extern void map(int fd, unsigned long virt, unsigned long phys, 
 		unsigned long len, int r, int w, int x);
 extern int unmap(int fd, void *addr, int len);
 extern int protect(int fd, unsigned long addr, unsigned long len, 
 		   int r, int w, int x, int must_succeed);
-extern void user_signal(int sig, struct uml_pt_regs *regs);
+extern void user_signal(int sig, union uml_pt_regs *regs);
 extern int singlestepping_skas(void);
 extern int new_mm(int from);
-extern void save_registers(struct uml_pt_regs *regs);
-extern void restore_registers(struct uml_pt_regs *regs);
+extern void save_registers(union uml_pt_regs *regs);
+extern void restore_registers(union uml_pt_regs *regs);
 extern void start_userspace(void);
 extern void init_registers(int pid);
 

arch/um/kernel/skas/include/uaccess.h

@@ -27,9 +27,6 @@ static inline int verify_area_skas(int type, const void * addr,
 	return(access_ok_skas(type, addr, size) ? 0 : -EFAULT);
 }
 
-extern void *um_virt_to_phys(struct task_struct *task, unsigned long virt,
-			     pte_t *pte_out);
-
 static inline unsigned long maybe_map(unsigned long virt, int is_write)
 {
 	pte_t pte;

arch/um/kernel/skas/mem.c

@@ -18,11 +18,6 @@ unsigned long set_task_sizes_skas(int arg, unsigned long *host_size_out,
 	return(((unsigned long) set_task_sizes_skas) & ~0xffffff);
 }
 
-struct page *arch_validate_skas(struct page *page, int mask, int order)
-{
-	return(page);
-}
-
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically

arch/um/kernel/skas/mem_user.c

@@ -33,7 +33,7 @@ void map(int fd, unsigned long virt, unsigned long phys, unsigned long len,
 					 .fd		= region->fd,
 					 .offset	= phys_offset(phys)
 				       } } } );
-	n = os_write_file(fd, (char *) &map, sizeof(map));
+	n = os_write_file(fd, &map, sizeof(map));
 	if(n != sizeof(map)) 
 		printk("map : /proc/mm map failed, errno = %d\n", errno);
 }
@@ -48,7 +48,7 @@ int unmap(int fd, void *addr, int len)
 				       { .munmap	= 
 					 { .addr 	= (unsigned long) addr,
 					   .len		= len } } } );
-	n = os_write_file(fd, (char *) &unmap, sizeof(unmap));
+	n = os_write_file(fd, &unmap, sizeof(unmap));
 	if((n != 0) && (n != sizeof(unmap)))
 		return(-errno);
 	return(0);
@@ -70,7 +70,7 @@ int protect(int fd, unsigned long addr, unsigned long len, int r, int w,
 					   .len		= len,
 					   .prot	= prot } } } );
 
-	n = os_write_file(fd, (char *) &protect, sizeof(protect));
+	n = os_write_file(fd, &protect, sizeof(protect));
 	if((n != 0) && (n != sizeof(protect))){
 		if(must_succeed)
 			panic("protect failed, errno = %d", errno);

arch/um/kernel/skas/process.c

@@ -20,10 +20,10 @@
 #include "user_util.h"
 #include "kern_util.h"
 #include "skas.h"
-#include "skas_ptrace.h"
 #include "sysdep/sigcontext.h"
 #include "os.h"
 #include "proc_mm.h"
+#include "skas_ptrace.h"
 
 unsigned long exec_regs[FRAME_SIZE];
 unsigned long exec_fp_regs[HOST_FP_SIZE];
@@ -39,14 +39,15 @@ static void handle_segv(int pid)
 	if(err)
 		panic("handle_segv - PTRACE_FAULTINFO failed, errno = %d\n",
 		      errno);
+
 	segv(fault.addr, 0, FAULT_WRITE(fault.is_write), 1, NULL);
 }
 
-static void handle_trap(int pid, struct uml_pt_regs *regs)
+static void handle_trap(int pid, union uml_pt_regs *regs)
 {
 	int err, syscall_nr, status;
 
-	syscall_nr = PT_SYSCALL_NR(regs->mode.skas.regs);
+	syscall_nr = PT_SYSCALL_NR(regs->skas.regs);
 	if(syscall_nr < 1){
 		relay_signal(SIGTRAP, regs);
 		return;
@@ -79,6 +80,7 @@ static int userspace_tramp(void *arg)
 	enable_timer();
 	ptrace(PTRACE_TRACEME, 0, 0, 0);
 	os_stop_process(os_getpid());
+	return(0);
 }
 
 void start_userspace(void)
@@ -115,7 +117,7 @@ void start_userspace(void)
 	userspace_pid = pid;
 }
 
-void userspace(struct uml_pt_regs *regs)
+void userspace(union uml_pt_regs *regs)
 {
 	int err, status, op;
 
@@ -131,7 +133,7 @@ void userspace(struct uml_pt_regs *regs)
 			panic("userspace - waitpid failed, errno = %d\n", 
 			      errno);
 
-		regs->is_user = 1;
+		regs->skas.is_user = 1;
 		save_registers(regs);
 
 		if(WIFSTOPPED(status)){
@@ -191,28 +193,28 @@ void thread_wait(void *sw, void *fb)
 		longjmp(*fork_buf, 1);
 }
 
-static int move_registers(int int_op, int fp_op, struct uml_pt_regs *regs,
+static int move_registers(int int_op, int fp_op, union uml_pt_regs *regs,
 			  unsigned long *fp_regs)
 {
-	if(ptrace(int_op, userspace_pid, 0, regs->mode.skas.regs) < 0)
+	if(ptrace(int_op, userspace_pid, 0, regs->skas.regs) < 0)
 		return(-errno);
 	if(ptrace(fp_op, userspace_pid, 0, fp_regs) < 0)
 		return(-errno);
 	return(0);
 }
 
-void save_registers(struct uml_pt_regs *regs)
+void save_registers(union uml_pt_regs *regs)
 {
 	unsigned long *fp_regs;
 	int err, fp_op;
 
 	if(have_fpx_regs){
 		fp_op = PTRACE_GETFPXREGS;
-		fp_regs = regs->mode.skas.xfp;
+		fp_regs = regs->skas.xfp;
 	}
 	else {
 		fp_op = PTRACE_GETFPREGS;
-		fp_regs = regs->mode.skas.fp;
+		fp_regs = regs->skas.fp;
 	}
 
 	err = move_registers(PTRACE_GETREGS, fp_op, regs, fp_regs);
@@ -221,18 +223,18 @@ void save_registers(struct uml_pt_regs *regs)
 		      err);
 }
 
-void restore_registers(struct uml_pt_regs *regs)
+void restore_registers(union uml_pt_regs *regs)
 {
 	unsigned long *fp_regs;
 	int err, fp_op;
 
 	if(have_fpx_regs){
 		fp_op = PTRACE_SETFPXREGS;
-		fp_regs = regs->mode.skas.xfp;
+		fp_regs = regs->skas.xfp;
 	}
 	else {
 		fp_op = PTRACE_SETFPREGS;
-		fp_regs = regs->mode.skas.fp;
+		fp_regs = regs->skas.fp;
 	}
 
 	err = move_registers(PTRACE_SETREGS, fp_op, regs, fp_regs);
@@ -272,10 +274,14 @@ int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
 		(*cb_proc)(cb_arg);
 		longjmp(*cb_back, 1);
 	}
-	else if(n == 3)
+	else if(n == 3){
+		kmalloc_ok = 0;
 		return(0);
-	else if(n == 4)
+	}
+	else if(n == 4){
+		kmalloc_ok = 0;
 		return(1);
+	}
 	longjmp(**switch_buf, 1);
 }
 
@@ -296,8 +302,11 @@ void initial_thread_cb_skas(void (*proc)(void *), void *arg)
 	cb_proc = proc;
 	cb_arg = arg;
 	cb_back = &here;
+
+	block_signals();
 	if(setjmp(here) == 0)
 		longjmp(initial_jmpbuf, 2);
+	unblock_signals();
 
 	cb_proc = NULL;
 	cb_arg = NULL;
@@ -328,7 +337,7 @@ int new_mm(int from)
 		copy = ((struct proc_mm_op) { .op 	= MM_COPY_SEGMENTS,
 					      .u 	= 
 					      { .copy_segments	= from } } );
-		n = os_write_file(fd, (char *) &copy, sizeof(copy));
+		n = os_write_file(fd, &copy, sizeof(copy));
 		if(n != sizeof(copy)) 
 			printk("new_mm : /proc/mm copy_segments failed, "
 			       "errno = %d\n", errno);

arch/um/kernel/skas/process_kern.c

@@ -68,8 +68,7 @@ void new_thread_handler(int sig)
 	n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
 	if(n == 1)
 		userspace(&current->thread.regs.regs);
-	else if(n == 2)
-		do_exit(0);
+	else do_exit(0);
 }
 
 void new_thread_proc(void *stack, void (*handler)(int sig))
@@ -109,21 +108,21 @@ int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
   	void (*handler)(int);
 
 	if(current->thread.forking){
-	  	memcpy(&p->thread.regs.regs.mode.skas, 
-		       &current->thread.regs.regs.mode.skas, 
-		       sizeof(p->thread.regs.regs.mode.skas));
-		REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.mode.skas.regs, 0);
-		if(sp != 0) REGS_SP(p->thread.regs.regs.mode.skas.regs) = sp;
+	  	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 {
-	  	memcpy(p->thread.regs.regs.mode.skas.regs, exec_regs, 
-		       sizeof(p->thread.regs.regs.mode.skas.regs));
-		memcpy(p->thread.regs.regs.mode.skas.fp, exec_fp_regs, 
-		       sizeof(p->thread.regs.regs.mode.skas.fp));
-	  	memcpy(p->thread.regs.regs.mode.skas.xfp, exec_fpx_regs, 
-		       sizeof(p->thread.regs.regs.mode.skas.xfp));
+	  	memcpy(p->thread.regs.regs.skas.regs, exec_regs, 
+		       sizeof(p->thread.regs.regs.skas.regs));
+		memcpy(p->thread.regs.regs.skas.fp, exec_fp_regs, 
+		       sizeof(p->thread.regs.regs.skas.fp));
+	  	memcpy(p->thread.regs.regs.skas.xfp, exec_fpx_regs, 
+		       sizeof(p->thread.regs.regs.skas.xfp));
                 p->thread.request.u.thread = current->thread.request.u.thread;
 		handler = new_thread_handler;
 	}

arch/um/kernel/skas/sys-i386/sigcontext.c

@@ -15,7 +15,7 @@
 
 extern int userspace_pid;
 
-int copy_sc_from_user_skas(struct uml_pt_regs *regs, void *from_ptr)
+int copy_sc_from_user_skas(union uml_pt_regs *regs, void *from_ptr)
 {
   	struct sigcontext sc, *from = from_ptr;
 	unsigned long fpregs[FP_FRAME_SIZE];
@@ -26,26 +26,26 @@ int copy_sc_from_user_skas(struct uml_pt_regs *regs, void *from_ptr)
 	if(err)
 		return(err);
 
-	regs->mode.skas.regs[GS] = sc.gs;
-	regs->mode.skas.regs[FS] = sc.fs;
-	regs->mode.skas.regs[ES] = sc.es;
-	regs->mode.skas.regs[DS] = sc.ds;
-	regs->mode.skas.regs[EDI] = sc.edi;
-	regs->mode.skas.regs[ESI] = sc.esi;
-	regs->mode.skas.regs[EBP] = sc.ebp;
-	regs->mode.skas.regs[UESP] = sc.esp;
-	regs->mode.skas.regs[EBX] = sc.ebx;
-	regs->mode.skas.regs[EDX] = sc.edx;
-	regs->mode.skas.regs[ECX] = sc.ecx;
-	regs->mode.skas.regs[EAX] = sc.eax;
-	regs->mode.skas.regs[EIP] = sc.eip;
-	regs->mode.skas.regs[CS] = sc.cs;
-	regs->mode.skas.regs[EFL] = sc.eflags;
-	regs->mode.skas.regs[UESP] = sc.esp_at_signal;
-	regs->mode.skas.regs[SS] = sc.ss;
-	regs->mode.skas.fault_addr = sc.cr2;
-	regs->mode.skas.fault_type = FAULT_WRITE(sc.err);
-	regs->mode.skas.trap_type = sc.trapno;
+	regs->skas.regs[GS] = sc.gs;
+	regs->skas.regs[FS] = sc.fs;
+	regs->skas.regs[ES] = sc.es;
+	regs->skas.regs[DS] = sc.ds;
+	regs->skas.regs[EDI] = sc.edi;
+	regs->skas.regs[ESI] = sc.esi;
+	regs->skas.regs[EBP] = sc.ebp;
+	regs->skas.regs[UESP] = sc.esp;
+	regs->skas.regs[EBX] = sc.ebx;
+	regs->skas.regs[EDX] = sc.edx;
+	regs->skas.regs[ECX] = sc.ecx;
+	regs->skas.regs[EAX] = sc.eax;
+	regs->skas.regs[EIP] = sc.eip;
+	regs->skas.regs[CS] = sc.cs;
+	regs->skas.regs[EFL] = sc.eflags;
+	regs->skas.regs[UESP] = sc.esp_at_signal;
+	regs->skas.regs[SS] = sc.ss;
+	regs->skas.fault_addr = sc.cr2;
+	regs->skas.fault_type = FAULT_WRITE(sc.err);
+	regs->skas.trap_type = sc.trapno;
 
 	err = ptrace(PTRACE_SETFPREGS, userspace_pid, 0, fpregs);
 	if(err < 0){
@@ -57,7 +57,7 @@ int copy_sc_from_user_skas(struct uml_pt_regs *regs, void *from_ptr)
 	return(0);
 }
 
-int copy_sc_to_user_skas(void *to_ptr, struct uml_pt_regs *regs, 
+int copy_sc_to_user_skas(void *to_ptr, void *fp, union uml_pt_regs *regs, 
 			 unsigned long fault_addr, int fault_type)
 {
   	struct sigcontext sc, *to = to_ptr;
@@ -65,26 +65,26 @@ int copy_sc_to_user_skas(void *to_ptr, struct uml_pt_regs *regs,
 	unsigned long fpregs[FP_FRAME_SIZE];
 	int err;
 
-	sc.gs = regs->mode.skas.regs[GS];
-	sc.fs = regs->mode.skas.regs[FS];
-	sc.es = regs->mode.skas.regs[ES];
-	sc.ds = regs->mode.skas.regs[DS];
-	sc.edi = regs->mode.skas.regs[EDI];
-	sc.esi = regs->mode.skas.regs[ESI];
-	sc.ebp = regs->mode.skas.regs[EBP];
-	sc.esp = regs->mode.skas.regs[UESP];
-	sc.ebx = regs->mode.skas.regs[EBX];
-	sc.edx = regs->mode.skas.regs[EDX];
-	sc.ecx = regs->mode.skas.regs[ECX];
-	sc.eax = regs->mode.skas.regs[EAX];
-	sc.eip = regs->mode.skas.regs[EIP];
-	sc.cs = regs->mode.skas.regs[CS];
-	sc.eflags = regs->mode.skas.regs[EFL];
-	sc.esp_at_signal = regs->mode.skas.regs[UESP];
-	sc.ss = regs->mode.skas.regs[SS];
+	sc.gs = regs->skas.regs[GS];
+	sc.fs = regs->skas.regs[FS];
+	sc.es = regs->skas.regs[ES];
+	sc.ds = regs->skas.regs[DS];
+	sc.edi = regs->skas.regs[EDI];
+	sc.esi = regs->skas.regs[ESI];
+	sc.ebp = regs->skas.regs[EBP];
+	sc.esp = regs->skas.regs[UESP];
+	sc.ebx = regs->skas.regs[EBX];
+	sc.edx = regs->skas.regs[EDX];
+	sc.ecx = regs->skas.regs[ECX];
+	sc.eax = regs->skas.regs[EAX];
+	sc.eip = regs->skas.regs[EIP];
+	sc.cs = regs->skas.regs[CS];
+	sc.eflags = regs->skas.regs[EFL];
+	sc.esp_at_signal = regs->skas.regs[UESP];
+	sc.ss = regs->skas.regs[SS];
 	sc.cr2 = fault_addr;
 	sc.err = TO_SC_ERR(fault_type);
-	sc.trapno = regs->mode.skas.trap_type;
+	sc.trapno = regs->skas.trap_type;
 
 	err = ptrace(PTRACE_GETFPREGS, userspace_pid, 0, fpregs);
 	if(err < 0){
@@ -92,7 +92,8 @@ int copy_sc_to_user_skas(void *to_ptr, struct uml_pt_regs *regs,
 		       "errno = %d\n", errno);
 		return(1);
 	}
-	to_fp = (struct _fpstate *)((unsigned long) to + sizeof(*to));
+	to_fp = (struct _fpstate *) 
+		(fp ? (unsigned long) fp : ((unsigned long) to + sizeof(*to)));
 	sc.fpstate = to_fp;
 
 	if(err)

arch/um/kernel/skas/syscall_kern.c

@@ -21,7 +21,7 @@ long execute_syscall_skas(void *r)
 
 	current->thread.nsyscalls++;
 	nsyscalls++;
-	syscall = regs->regs.syscall;
+	syscall = UPT_SYSCALL_NR(&regs->regs);
 
 	if((syscall >= NR_syscalls) || (syscall < 0))
 		res = -ENOSYS;

arch/um/kernel/skas/syscall_user.c

@@ -15,18 +15,17 @@
 #define ERESTARTNOINTR	513
 #define ERESTARTNOHAND	514
 
-void handle_syscall(struct uml_pt_regs *regs)
+void handle_syscall(union uml_pt_regs *regs)
 {
 	long result;
 	int index;
 
-	host_to_regs(regs);
 	index = record_syscall_start(UPT_SYSCALL_NR(regs));
 
 	syscall_trace();
 	result = execute_syscall(regs);
 
-	REGS_SET_SYSCALL_RETURN(regs->mode.skas.regs, result);
+	REGS_SET_SYSCALL_RETURN(regs->skas.regs, result);
 	if((result == -ERESTARTNOHAND) || (result == -ERESTARTSYS) || 
 	   (result == -ERESTARTNOINTR))
 		do_signal(result);

arch/um/kernel/skas/tlb.c

@@ -67,7 +67,7 @@ static void fix_range(struct mm_struct *mm, unsigned long start_addr,
 	}
 }
 
-static void flush_kernel_vm_range(unsigned long start, unsigned long end)
+void flush_tlb_kernel_range_skas(unsigned long start, unsigned long end)
 {
 	struct mm_struct *mm;
 	pgd_t *pgd;
@@ -99,7 +99,6 @@ static void flush_kernel_vm_range(unsigned long start, unsigned long end)
 				protect_memory(addr, PAGE_SIZE, 1, 1, 1, 1);
 			}
 			addr += PAGE_SIZE;
-
 		}
 		else {
 			if(pmd_newpage(*pmd)){
@@ -116,27 +115,26 @@ static void flush_kernel_vm_range(unsigned long start, unsigned long end)
 
 void flush_tlb_kernel_vm_skas(void)
 {
-	flush_kernel_vm_range(start_vm, end_vm);
+	flush_tlb_kernel_range_skas(start_vm, end_vm);
 }
 
 void __flush_tlb_one_skas(unsigned long addr)
 {
-	flush_kernel_vm_range(addr, addr + PAGE_SIZE);
+	flush_tlb_kernel_range_skas(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_kernel_vm_range(start, end);
+		flush_tlb_kernel_range_skas(start, end);
 	else fix_range(vma->vm_mm, start, end, 0);
 }
 
 void flush_tlb_mm_skas(struct mm_struct *mm)
 {
-	if(mm == NULL)
 	flush_tlb_kernel_vm_skas();
-	else fix_range(mm, 0, host_task_size, 0);
+	fix_range(mm, 0, host_task_size, 0);
 }
 
 void force_flush_all_skas(void)

arch/um/kernel/skas/trap_user.c

@@ -13,41 +13,40 @@
 #include "task.h"
 #include "sigcontext.h"
 
-void sig_handler_common_skas(int sig, struct sigcontext *sc)
+void sig_handler_common_skas(int sig, void *sc_ptr)
 {
-	struct uml_pt_regs save_regs, *r;
+	struct sigcontext *sc = sc_ptr;
+	struct skas_regs *r;
 	struct signal_info *info;
 	int save_errno = errno;
 
-	r = (struct uml_pt_regs *) TASK_REGS(get_current());
-	save_regs = *r;
+	r = &TASK_REGS(get_current())->skas;
 	r->is_user = 0;
-	r->mode.skas.fault_addr = SC_FAULT_ADDR(sc);
-	r->mode.skas.fault_type = SC_FAULT_TYPE(sc);
-	r->mode.skas.trap_type = SC_TRAP_TYPE(sc);
+	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, r);
+	(*info->handler)(sig, (union uml_pt_regs *) r);
 
-	*r = save_regs;
 	errno = save_errno;
 }
 
 extern int missed_ticks[];
 
-void user_signal(int sig, struct uml_pt_regs *regs)
+void user_signal(int sig, union uml_pt_regs *regs)
 {
 	struct signal_info *info;
 
 	if(sig == SIGVTALRM)
 		missed_ticks[cpu()]++;
-	regs->is_user = 1;
-	regs->mode.skas.fault_addr = 0;
-	regs->mode.skas.fault_type = 0;
-	regs->mode.skas.trap_type = 0;
+	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);
 

arch/um/kernel/tempfile.c

@@ -23,11 +23,11 @@ static void __init find_tempdir(void)
 	if(tempdir != NULL) return;	/* We've already been called */
 	for(i = 0; dirs[i]; i++){
 		dir = getenv(dirs[i]);
-		if(dir != NULL) break;
+		if((dir != NULL) && (*dir != '\0'))
+			break;
 	}
-	if(dir == NULL) dir = "/tmp";
-	else if(*dir == '\0') dir = NULL;
-	if(dir != NULL) {
+	if((dir == NULL) || (*dir == '\0')) 
+		dir = "/tmp";
 	tempdir = malloc(strlen(dir) + 2);
 	if(tempdir == NULL){
 		fprintf(stderr, "Failed to malloc tempdir, "
@@ -36,7 +36,6 @@ static void __init find_tempdir(void)
 	}
 	strcpy(tempdir, dir);
 	strcat(tempdir, "/");
-	}
 }
 
 int make_tempfile(const char *template, char **out_tempname, int do_unlink)

arch/um/kernel/time.c

@@ -86,20 +86,23 @@ struct timeval local_offset = { 0, 0 };
 
 void do_gettimeofday(struct timeval *tv)
 {
-	time_lock();
+	unsigned long flags;
+
+	flags = time_lock();
 	gettimeofday(tv, NULL);
 	timeradd(tv, &local_offset, tv);
-	time_unlock();
+	time_unlock(flags);
 }
 
 void do_settimeofday(struct timeval *tv)
 {
 	struct timeval now;
+	unsigned long flags;
 
-	time_lock();
+	flags = time_lock();
 	gettimeofday(&now, NULL);
 	timersub(tv, &now, &local_offset);
-	time_unlock();
+	time_unlock(flags);
 }
 
 void idle_sleep(int secs)
@@ -108,7 +111,7 @@ void idle_sleep(int secs)
 
 	ts.tv_sec = secs;
 	ts.tv_nsec = 0;
-	nanosleep(&ts, &ts);
+	nanosleep(&ts, NULL);
 }
 
 /*

arch/um/kernel/time_kern.c

@@ -36,7 +36,7 @@ int timer_irq_inited = 0;
  */
 int __attribute__ ((__section__ (".unprotected"))) missed_ticks[NR_CPUS];
 
-void timer_irq(struct uml_pt_regs *regs)
+void timer_irq(union uml_pt_regs *regs)
 {
 	int cpu = current->thread_info->cpu, ticks = missed_ticks[cpu];
 
@@ -49,7 +49,9 @@ void boot_timer_handler(int sig)
 {
 	struct pt_regs regs;
 
-	regs.regs.is_user = 0;
+	CHOOSE_MODE((void) 
+		    (UPT_SC(&regs.regs) = (struct sigcontext *) (&sig + 1)),
+		    (void) (regs.regs.skas.is_user = 0));
 	do_timer(&regs);
 }
 
@@ -117,7 +119,7 @@ void __const_udelay(um_udelay_t usecs)
 	for(i=0;i<n;i++) ;
 }
 
-void timer_handler(int sig, struct uml_pt_regs *regs)
+void timer_handler(int sig, union uml_pt_regs *regs)
 {
 #ifdef CONFIG_SMP
 	update_process_times(user_context(UPT_SP(regs)));
@@ -128,14 +130,16 @@ void timer_handler(int sig, struct uml_pt_regs *regs)
 
 static spinlock_t timer_spinlock = SPIN_LOCK_UNLOCKED;
 
-void time_lock(void)
+unsigned long time_lock(void)
 {
-	spin_lock(&timer_spinlock);
+	unsigned long flags;
+	spin_lock_irqsave(&timer_spinlock, flags);
+	return(flags);
 }
 
-void time_unlock(void)
+void time_unlock(unsigned long flags)
 {
-	spin_unlock(&timer_spinlock);
+	spin_unlock_irqrestore(&timer_spinlock, flags);
 }
 
 int __init timer_init(void)

arch/um/kernel/tlb.c

@@ -21,6 +21,12 @@ 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_skas, start, end);
+}
+
 void flush_tlb_kernel_vm(void)
 {
 	CHOOSE_MODE(flush_tlb_kernel_vm_tt(), flush_tlb_kernel_vm_skas());

arch/um/kernel/trap_kern.c

@@ -109,7 +109,8 @@ unsigned long segv(unsigned long address, unsigned long ip, int is_write,
                 flush_tlb_kernel_vm();
                 return(0);
         }
-        if(current->mm == NULL) panic("Segfault with no mm");
+        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;
@@ -164,14 +165,15 @@ void bad_segv(unsigned long address, unsigned long ip, int is_write)
 	force_sig_info(SIGSEGV, &si, current);
 }
 
-void relay_signal(int sig, struct uml_pt_regs *regs)
+void relay_signal(int sig, union uml_pt_regs *regs)
 {
 	if(arch_handle_signal(sig, regs)) return;
-	if(!regs->is_user) panic("Kernel mode signal %d", sig);
+	if(!UPT_IS_USER(regs))
+		panic("Kernel mode signal %d", sig);
 	force_sig(sig, current);
 }
 
-void bus_handler(int sig, struct uml_pt_regs *regs)
+void bus_handler(int sig, union uml_pt_regs *regs)
 {
 	if(current->thread.fault_catcher != NULL)
 		do_longjmp(current->thread.fault_catcher, 1);

arch/um/kernel/trap_user.c

@@ -48,11 +48,11 @@ struct {
 	int is_user;
 } segfault_record[1024];
 
-void segv_handler(int sig, struct uml_pt_regs *regs)
+void segv_handler(int sig, union uml_pt_regs *regs)
 {
 	int index, max;
 
-	if(regs->is_user && !UPT_SEGV_IS_FIXABLE(regs)){
+	if(UPT_IS_USER(regs) && !UPT_SEGV_IS_FIXABLE(regs)){
 		bad_segv(UPT_FAULT_ADDR(regs), UPT_IP(regs), 
 			 UPT_FAULT_WRITE(regs));
 		return;
@@ -65,35 +65,35 @@ void segv_handler(int sig, struct uml_pt_regs *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 = regs->is_user;
+	segfault_record[index].is_user = UPT_IS_USER(regs);
 	segv(UPT_FAULT_ADDR(regs), UPT_IP(regs), UPT_FAULT_WRITE(regs),
-	     regs->is_user, regs);
+	     UPT_IS_USER(regs), regs);
 }
 
-void usr2_handler(int sig, struct uml_pt_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 },
-	[ 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 },
+	[ SIGTRAP ] { .handler 		= relay_signal,
+		      .is_irq 		= 0 },
+	[ SIGFPE ] { .handler 		= relay_signal,
+		     .is_irq 		= 0 },
+	[ SIGILL ] { .handler 		= relay_signal,
+		     .is_irq 		= 0 },
+	[ 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 sig_handler(int sig, struct sigcontext sc)

arch/um/kernel/tt/Makefile

@@ -3,16 +3,29 @@
 # Licensed under the GPL
 #
 
-obj-y = exec_kern.o exec_user.o gdb.o gdb_kern.o ksyms.o mem.o process_kern.o \
+EXTRA_TARGETS := unmap_fin.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_user.o sys-$(SUBARCH)/
 
-obj-$(CONFIG_PT_PROXY) += ptproxy/
+obj-$(CONFIG_PT_PROXY) += gdb_kern.o ptproxy/
 
 USER_OBJS := $(filter %_user.o,$(obj-y)) gdb.o time.o tracer.o
 USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
 
+UNMAP_CFLAGS := $(patsubst -pg -DPROFILING,,$(USER_CFLAGS))
+UNMAP_CFLAGS := $(patsubst -fprofile-arcs -ftest-coverage,,$(UNMAP_CFLAGS))
+
 $(USER_OBJS) : %.o: %.c
 	$(CC) $(CFLAGS_$(notdir $@)) $(USER_CFLAGS) -c -o $@ $<
 
+$(O_TARGET) : $(obj)/unmap_fin.o
+
+$(obj)/unmap.o: $(src)/unmap.c
+	$(CC) $(UNMAP_CFLAGS) -c -o $@ $<
+
+$(obj)/unmap_fin.o : $(src)/unmap.o
+	ld -r -o $@ $< -lc -L/usr/lib
+
 clean :

arch/um/kernel/tt/gdb.c

@@ -44,7 +44,7 @@ int cont(int pid)
 	return(ptrace(PTRACE_CONT, pid, 0, 0));
 }
 
-#ifdef CONFIG_PT_PROXY
+#ifdef UML_CONFIG_PT_PROXY
 
 int debugger_signal(int status, pid_t pid)
 {
@@ -74,16 +74,16 @@ 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 *);
+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];
+	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);
+	xterm_fd = xterm_open(1, 1, 1, xterm_data, &dummy);
 	return(xterm_fd);
 }
 

arch/um/kernel/tt/gdb_kern.c

@@ -13,9 +13,9 @@ 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,
+	.name		= "gdb",
+	.config		= gdb_config,
+	.remove		= gdb_remove,
 };
 
 int gdb_mc_init(void)

arch/um/kernel/tt/include/mode.h

@@ -13,9 +13,10 @@ extern int tracing_pid;
 extern int tracer(int (*init_proc)(void *), void *sp);
 extern void user_time_init_tt(void);
 extern int copy_sc_from_user_tt(void *to_ptr, void *from_ptr, void *data);
-extern int copy_sc_to_user_tt(void *to_ptr, void *from_ptr, void *data);
-extern void sig_handler_common_tt(int sig, struct sigcontext *sc);
-extern void syscall_handler_tt(int sig, struct uml_pt_regs *regs);
+extern int copy_sc_to_user_tt(void *to_ptr, void *fp, void *from_ptr, 
+			      void *data);
+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);

arch/um/kernel/tt/include/mode_kern.h

@@ -22,6 +22,7 @@ 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, 
@@ -33,7 +34,6 @@ 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 struct page *arch_validate_tt(struct page *page, int mask, int order);
 extern int external_pid_tt(struct task_struct *task);
 extern int thread_pid_tt(struct task_struct *task);
 

arch/um/kernel/tt/include/ptrace-tt.h

@@ -8,7 +8,7 @@
 
 #include "uml-config.h"
 
-#ifdef CONFIG_MODE_TT
+#ifdef UML_CONFIG_MODE_TT
 #include "sysdep/sc.h"
 #endif
 

arch/um/kernel/tt/include/tt.h

@@ -26,10 +26,11 @@ extern void set_tracing(void *t, int tracing);
 extern int is_tracing(void *task);
 extern int singlestepping_tt(void *t);
 extern void clear_singlestep(void *t);
-extern void syscall_handler(int sig, struct uml_pt_regs *regs);
+extern void syscall_handler(int sig, union uml_pt_regs *regs);
 extern void exit_kernel(int pid, void *task);
 extern int do_syscall(void *task, int pid);
 extern int is_valid_pid(int pid);
+extern void remap_data(void *segment_start, void *segment_end, int w);
 
 #endif
 

arch/um/kernel/tt/include/uaccess.h

@@ -12,6 +12,7 @@
 #include "asm/errno.h"
 #include "asm/current.h"
 #include "asm/a.out.h"
+#include "uml_uaccess.h"
 
 #define ABOVE_KMEM (16 * 1024 * 1024)
 
@@ -51,9 +52,6 @@ static inline int copy_from_user_tt(void *to, const void *from, int n)
 				   &current->thread.fault_catcher) : n);
 }
 
-extern int __do_copy_to_user(void *to, const void *from, int n,
-				  void **fault_addr, void **fault_catcher);
-
 static inline int copy_to_user_tt(void *to, const void *from, int n)
 {
 	return(access_ok_tt(VERIFY_WRITE, to, n) ?

arch/um/kernel/tt/mem.c

@@ -39,32 +39,6 @@ unsigned long set_task_sizes_tt(int arg, unsigned long *host_size_out,
 	return(START);
 }
 
-struct page *arch_validate_tt(struct page *page, int mask, int order)
-{
-        unsigned long addr, zero = 0;
-        int i;
-
- again:
-        if(page == NULL) return(page);
-        if(PageHighMem(page)) return(page);
-
-        addr = (unsigned long) page_address(page);
-        for(i = 0; i < (1 << order); i++){
-                current->thread.fault_addr = (void *) addr;
-                if(__do_copy_to_user((void *) addr, &zero, 
-                                     sizeof(zero),
-                                     &current->thread.fault_addr,
-                                     &current->thread.fault_catcher)){
-                        if(!(mask & __GFP_WAIT)) return(NULL);
-                        else break;
-                }
-                addr += PAGE_SIZE;
-        }
-        if(i == (1 << order)) return(page);
-        page = alloc_pages(mask, order);
-        goto again;
-}
-
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically

arch/um/kernel/tt/mem_user.c

+/* 
+ * 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);
+	if((addr = mmap(NULL, size, PROT_WRITE | PROT_READ, 
+			MAP_SHARED, data, 0)) == 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:
+ */

arch/um/kernel/tt/process_kern.c

@@ -6,6 +6,7 @@
 #include "linux/sched.h"
 #include "linux/signal.h"
 #include "linux/kernel.h"
+#include "linux/interrupt.h"
 #include "asm/system.h"
 #include "asm/pgalloc.h"
 #include "asm/ptrace.h"
@@ -111,7 +112,7 @@ void exit_thread_tt(void)
 	close(current->thread.mode.tt.switch_pipe[1]);
 }
 
-extern void schedule_tail(struct task_struct *prev);
+void schedule_tail(task_t *prev);
 
 static void new_thread_handler(int sig)
 {
@@ -120,13 +121,13 @@ static void new_thread_handler(int sig)
 
 	fn = current->thread.request.u.thread.proc;
 	arg = current->thread.request.u.thread.arg;
-	current->thread.regs.regs.mode.tt = (void *) (&sig + 1);
+	UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
 	suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
 
 	block_signals();
 	init_new_thread_signals(1);
 #ifdef CONFIG_SMP
-	schedule_tail(NULL);
+	schedule_tail(current->thread.prev_sched);
 #endif
 	enable_timer();
 	free_page(current->thread.temp_stack);
@@ -160,7 +161,7 @@ static int new_thread_proc(void *stack)
 
 void finish_fork_handler(int sig)
 {
-	current->thread.regs.regs.mode.tt = (void *) (&sig + 1);
+ 	UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
 	suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
 
 #ifdef CONFIG_SMP	
@@ -168,6 +169,7 @@ void finish_fork_handler(int sig)
 #endif
 	enable_timer();
 	change_sig(SIGVTALRM, 1);
+	local_irq_enable();
 	force_flush_all();
 	if(current->mm != current->parent->mm)
 		protect_memory(uml_reserved, high_physmem - uml_reserved, 1, 
@@ -187,6 +189,7 @@ int fork_tramp(void *stack)
 {
 	int sig = sigusr1;
 
+	local_irq_disable();
 	init_new_thread_stack(stack, finish_fork_handler);
 
 	kill(os_getpid(), sig);
@@ -232,10 +235,10 @@ int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
 	}
 
 	if(current->thread.forking){
-		sc_to_sc(p->thread.regs.regs.mode.tt, 
-			 current->thread.regs.regs.mode.tt);
-		SC_SET_SYSCALL_RETURN(p->thread.regs.regs.mode.tt, 0);
-		if(sp != 0) SC_SP(p->thread.regs.regs.mode.tt) = sp;
+		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;
 

arch/um/kernel/tt/sys-i386/sigcontext.c

@@ -29,14 +29,15 @@ int copy_sc_from_user_tt(void *to_ptr, void *from_ptr, void *data)
 	return(err);
 }
 
-int copy_sc_to_user_tt(void *to_ptr, void *from_ptr, void *data)
+int copy_sc_to_user_tt(void *to_ptr, void *fp, void *from_ptr, void *data)
 {
 	struct arch_frame_data *arch = data;
 	struct sigcontext *to = to_ptr, *from = from_ptr;
 	struct _fpstate *to_fp, *from_fp;
 	int err;
 
-	to_fp = (struct _fpstate *)((unsigned long) to + sizeof(*to));
+	to_fp = (struct _fpstate *) 
+		(fp ? (unsigned long) fp : ((unsigned long) to + sizeof(*to)));
 	from_fp = from->fpstate;
 	err = copy_to_user_proc(to, from, sizeof(*to));
 	if(from_fp != NULL){

arch/um/kernel/tt/syscall_kern.c

@@ -20,29 +20,32 @@ static inline int check_area(void *ptr, int size)
 
 static int check_readlink(struct pt_regs *regs)
 {
-	return(check_area((void *) regs->regs.args[1], regs->regs.args[2]));
+	return(check_area((void *) UPT_SYSCALL_ARG1(&regs->regs),
+			  UPT_SYSCALL_ARG2(&regs->regs)));
 }
 
 static int check_utime(struct pt_regs *regs)
 {
-	return(check_area((void *) regs->regs.args[1],
+	return(check_area((void *) UPT_SYSCALL_ARG1(&regs->regs),
 			  sizeof(struct utimbuf)));
 }
 
 static int check_oldstat(struct pt_regs *regs)
 {
-	return(check_area((void *) regs->regs.args[1], 
+	return(check_area((void *) UPT_SYSCALL_ARG1(&regs->regs), 
 			  sizeof(struct __old_kernel_stat)));
 }
 
 static int check_stat(struct pt_regs *regs)
 {
-	return(check_area((void *) regs->regs.args[1], sizeof(struct stat)));
+	return(check_area((void *) UPT_SYSCALL_ARG1(&regs->regs), 
+			  sizeof(struct stat)));
 }
 
 static int check_stat64(struct pt_regs *regs)
 {
-	return(check_area((void *) regs->regs.args[1], sizeof(struct stat64)));
+	return(check_area((void *) UPT_SYSCALL_ARG1(&regs->regs), 
+			  sizeof(struct stat64)));
 }
 
 struct bogus {
@@ -90,7 +93,7 @@ struct bogus this_is_bogus[256] = {
 
 static int check_bogosity(struct pt_regs *regs)
 {
-	struct bogus *bogon = &this_is_bogus[regs->regs.syscall];
+	struct bogus *bogon = &this_is_bogus[UPT_SYSCALL_NR(&regs->regs)];
 
 	if(!bogon->kernel_ds) return(0);
 	if(bogon->check_params && (*bogon->check_params)(regs))
@@ -109,7 +112,7 @@ long execute_syscall_tt(void *r)
 
 	current->thread.nsyscalls++;
 	nsyscalls++;
-	syscall = regs->regs.syscall;
+	syscall = UPT_SYSCALL_NR(&regs->regs);
 
 	if((syscall >= NR_syscalls) || (syscall < 0))
 		res = -ENOSYS;

arch/um/kernel/tt/syscall_user.c

@@ -22,15 +22,14 @@
 #define ERESTARTNOINTR	513
 #define ERESTARTNOHAND	514
 
-void syscall_handler_tt(int sig, struct uml_pt_regs *regs)
+void syscall_handler_tt(int sig, union uml_pt_regs *regs)
 {
 	void *sc;
 	long result;
 	int index, syscall;
 
-	syscall = regs->syscall;
-	sc = regs->mode.tt;
-	sc_to_regs(regs, sc, syscall);
+	syscall = UPT_SYSCALL_NR(regs);
+	sc = UPT_SC(regs);
 	SC_START_SYSCALL(sc);
 
 	index = record_syscall_start(syscall);
@@ -40,7 +39,7 @@ void syscall_handler_tt(int sig, struct uml_pt_regs *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.
 	 */
-	regs->mode.tt = sc;
+	UPT_SC(regs) = sc;
 
 	SC_SET_SYSCALL_RETURN(sc, result);
 	if((result == -ERESTARTNOHAND) || (result == -ERESTARTSYS) || 
@@ -54,7 +53,7 @@ void syscall_handler_tt(int sig, struct uml_pt_regs *regs)
 int do_syscall(void *task, int pid)
 {
 	unsigned long proc_regs[FRAME_SIZE];
-	struct uml_pt_regs *regs;
+	union uml_pt_regs *regs;
 	int syscall;
 
 	if(ptrace_getregs(pid, proc_regs) < 0)

arch/um/kernel/tt/tlb.c

@@ -132,7 +132,7 @@ static void flush_kernel_vm_range(unsigned long start, unsigned long end,
 	if(updated && update_seq) atomic_inc(&vmchange_seq);
 }
 
-void flush_tlb_kernel_range(unsigned long start, unsigned long end)
+void flush_tlb_kernel_range_tt(unsigned long start, unsigned long end)
 {
         flush_kernel_vm_range(start, end, 1);
 }

arch/um/kernel/tt/trap_user.c

@@ -14,26 +14,27 @@
 #include "task.h"
 #include "tt.h"
 
-void sig_handler_common_tt(int sig, struct sigcontext *sc)
+void sig_handler_common_tt(int sig, void *sc_ptr)
 {
-	struct uml_pt_regs save_regs, *r;
+	struct sigcontext *sc = sc_ptr;
+	struct tt_regs save_regs, *r;
 	struct signal_info *info;
 	int save_errno = errno, is_user;
 
 	unprotect_kernel_mem();
 
-	r = (struct uml_pt_regs *) TASK_REGS(get_current());
+	r = &TASK_REGS(get_current())->tt;
 	save_regs = *r;
 	is_user = user_context(SC_SP(sc));
-	r->is_user = is_user;
-	r->mode.tt = sc;
-	if(sig != SIGUSR2) r->syscall = -1;
+	r->sc = sc;
+	if(sig != SIGUSR2) 
+		r->syscall = -1;
 
 	change_sig(SIGUSR1, 1);
 	info = &sig_info[sig];
 	if(!info->is_irq) unblock_signals();
 
-	(*info->handler)(sig, r);
+	(*info->handler)(sig, (union uml_pt_regs *) r);
 
 	if(is_user){
 		interrupt_end();

arch/um/kernel/tt/uaccess_user.c

@@ -7,34 +7,7 @@
 #include <setjmp.h>
 #include <string.h>
 #include "user_util.h"
-
-static 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;
-
-	jmp_buf jbuf;
-	*fault_catcher = &jbuf;
-	if(setjmp(jbuf) == 0){
-		(*op)(to, from, n);
-		ret = 0;
-		*faulted_out = 0;
-	} 
-	else {
-		ret = *faddrp;
-		*faulted_out = 1;
-	}
-	*fault_addr = NULL;
-	*fault_catcher = NULL;
-	return ret;
-}
-
-static void __do_copy(void *to, const void *from, int n)
-{
-	memcpy(to, from, n);
-}	
+#include "uml_uaccess.h"
 
 int __do_copy_from_user(void *to, const void *from, int n,
 			void **fault_addr, void **fault_catcher)
@@ -48,19 +21,6 @@ int __do_copy_from_user(void *to, const void *from, int n,
 	else return(n - (fault - (unsigned long) from));
 }
 
-
-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));
-}
-
 static void __do_strncpy(void *dst, const void *src, int count)
 {
 	strncpy(dst, src, count);

arch/um/kernel/uaccess_user.c

+/* 
+ * 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;
+
+	jmp_buf jbuf;
+	*fault_catcher = &jbuf;
+	if(setjmp(jbuf) == 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:
+ */

arch/um/kernel/um_arch.c

@@ -335,6 +335,11 @@ int linux_main(int argc, char **argv)
 	if(physmem_size > max_physmem){
 		highmem = physmem_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;

arch/um/kernel/umid.c

@@ -35,7 +35,7 @@ static int umid_inited = 0;
 
 static int make_umid(void);
 
-static int __init set_umid(char *name, int *add)
+static int __init set_umid(char *name, int is_random)
 {
 	if(umid_inited){
 		printk("Unique machine name can't be set twice\n");
@@ -48,12 +48,17 @@ static int __init set_umid(char *name, int *add)
 	strncpy(umid, name, UMID_LEN - 1);
 	umid[UMID_LEN - 1] = '\0';
 
-	umid_is_random = 0;
+	umid_is_random = is_random;
 	umid_inited = 1;
 	return 0;
 }
 
-__uml_setup("umid=", set_umid,
+static int __init set_umid_arg(char *name, int *add)
+{
+	return(set_umid(name, 0));
+}
+
+__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"
@@ -186,7 +191,6 @@ int not_dead_yet(char *dir)
 	}
 	if(!dead) return(1);
 	return(actually_do_remove(dir));
-	return(0);
 }
 
 static int __init set_uml_dir(char *name, int *add)
@@ -254,7 +258,7 @@ static int __init make_umid(void)
 		strcat(tmp, "XXXXXX");
 		fd = mkstemp(tmp);
 		if(fd < 0){
-			printk("set_umid - mkstemp failed, errno = %d\n",
+			printk("make_umid - mkstemp failed, errno = %d\n",
 			       errno);
 			return(1);
 		}
@@ -265,7 +269,7 @@ static int __init make_umid(void)
 		 * for directories.
 		 */
 		unlink(tmp);
-		strcpy(umid, &tmp[strlen(uml_dir)]);
+		set_umid(&tmp[strlen(uml_dir)], 1);
 	}
 	
 	sprintf(tmp, "%s%s", uml_dir, umid);

arch/um/kernel/user_syms.c

@@ -10,10 +10,7 @@
 #include <sys/ioctl.h>
 #include "user_util.h"
 #include "mem_user.h"
-
-/* XXX All the __CONFIG_* stuff is broken because this file can't include
- * config.h
- */
+#include "uml-config.h"
 
 /* Had to steal this from linux/module.h because that file can't be included
  * since this includes various user-level headers.
@@ -36,7 +33,7 @@ struct module_symbol
 #define EXPORT_SYMBOL(var)	   error config_must_be_included_before_module
 #define EXPORT_SYMBOL_NOVERS(var)  error config_must_be_included_before_module
 
-#elif !defined(__CONFIG_MODULES__)
+#elif !defined(UML_CONFIG_MODULES)
 
 #define __EXPORT_SYMBOL(sym,str)
 #define EXPORT_SYMBOL(var)
@@ -51,7 +48,7 @@ const struct module_symbol __ksymtab_##sym 		\
 __attribute__((section("__ksymtab"))) =			\
 { (unsigned long)&sym, __kstrtab_##sym }
 
-#if defined(__MODVERSIONS__) || !defined(__CONFIG_MODVERSIONS__)
+#if defined(__MODVERSIONS__) || !defined(UML_CONFIG_MODVERSIONS)
 #define EXPORT_SYMBOL(var)  __EXPORT_SYMBOL(var, __MODULE_STRING(var))
 #else
 #define EXPORT_SYMBOL(var)  __EXPORT_SYMBOL(var, __MODULE_STRING(__VERSIONED_SYMBOL(var)))

arch/um/kernel/user_util.c

@@ -47,31 +47,6 @@ void add_arg(char *cmd_line, char *arg)
 	strcat(cmd_line, arg);
 }
 
-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);
-	if((addr = mmap(NULL, size, PROT_WRITE | PROT_READ, 
-			MAP_SHARED, data, 0)) < 0){
-		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);
-	}
-}
-
 void stop(void)
 {
 	while(1) sleep(1000000);

arch/um/os-Linux/file.c

@@ -28,8 +28,8 @@ int os_file_type(char *file)
 	else if(S_ISLNK(buf.st_mode)) return(OS_TYPE_SYMLINK);
 	else if(S_ISCHR(buf.st_mode)) return(OS_TYPE_CHARDEV);
 	else if(S_ISBLK(buf.st_mode)) return(OS_TYPE_BLOCKDEV);
-	else if(S_ISFIFO(buf.st_mode))return(OS_TYPE_FIFO);
-	else if(S_ISSOCK(buf.st_mode))return(OS_TYPE_SOCK);
+	else if(S_ISFIFO(buf.st_mode)) return(OS_TYPE_FIFO);
+	else if(S_ISSOCK(buf.st_mode)) return(OS_TYPE_SOCK);
 	else return(OS_TYPE_FILE);
 }
 
@@ -64,6 +64,15 @@ int os_open_file(char *file, struct openflags flags, int mode)
 
 	fd = open64(file, f, mode);
 	if(fd < 0) return(-errno);
+	
+	if(flags.cl){
+		if(fcntl(fd, F_SETFD, 1)){
+			close(fd);
+			return(-errno);
+		}
+	}
+
+ 	return(fd);
 	return(fd);
 }
 
@@ -100,7 +109,7 @@ int os_seek_file(int fd, __u64 offset)
 	return(0);
 }
 
-int os_read_file(int fd, char *buf, int len)
+int os_read_file(int fd, void *buf, int len)
 {
 	int n;
 
@@ -118,7 +127,7 @@ int os_read_file(int fd, char *buf, int len)
 	return(n);
 }
 
-int os_write_file(int fd, char *buf, int count)
+int os_write_file(int fd, void *buf, int count)
 {
 	int n;
 

arch/um/os-Linux/process.c

@@ -106,7 +106,7 @@ int os_map_memory(void *virt, int fd, unsigned long off, unsigned long len,
 
 	loc = mmap((void *) virt, len, prot, MAP_SHARED | MAP_FIXED, 
 		   fd, off);
-	if(loc < 0)
+	if(loc == MAP_FAILED)
 		return(-errno);
 	return(0);
 }

arch/um/sys-i386/Makefile

@@ -7,6 +7,7 @@ USER_OBJS := bugs.o ptrace_user.o sigcontext.o fault.o
 USER_OBJS := $(foreach file,$(USER_OBJS),$(obj)/$(file))
 
 SYMLINKS = semaphore.c highmem.c module.c
+SYMLINKS := $(foreach f,$(SYMLINKS),$(src)/$f)
 
 semaphore.c-dir = kernel
 highmem.c-dir = mm
@@ -20,7 +21,7 @@ endef
 $(USER_OBJS) : %.o: %.c
 	$(CC) $(CFLAGS_$(notdir $@)) $(USER_CFLAGS) -c -o $@ $<
 
-$(foreach f,$(SYMLINKS),$(src)/$f): 
+$(SYMLINKS): 
 	$(call make_link,$@)
 
 clean:

arch/um/sys-i386/bugs.c

@@ -117,7 +117,7 @@ void arch_check_bugs(void)
 	if(check_cpu_feature("xmm", &have_it)) cpu_has_xmm = have_it;
 }
 
-int arch_handle_signal(int sig, struct uml_pt_regs *regs)
+int arch_handle_signal(int sig, union uml_pt_regs *regs)
 {
 	unsigned long ip;
 

arch/um/sys-i386/sigcontext.c

@@ -21,7 +21,7 @@ int sc_size(void *data)
 void sc_to_sc(void *to_ptr, void *from_ptr)
 {
 	struct sigcontext *to = to_ptr, *from = from_ptr;
-	int size = sizeof(*to) + signal_frame_sc.arch.fpstate_size;
+	int size = sizeof(*to) + signal_frame_sc.common.arch.fpstate_size;
 
 	memcpy(to, from, size);
 	if(from->fpstate != NULL) to->fpstate = (struct _fpstate *) (to + 1);

arch/um/sys-i386/util/mk_thread_kern.c

+#include "linux/config.h"
 #include "linux/stddef.h"
 #include "linux/sched.h"
 
@@ -12,7 +13,9 @@ 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);
 }

arch/um/uml.lds.S

@@ -11,15 +11,17 @@ SECTIONS
 
   . = ALIGN(4096);
   __binary_start = .;
+#ifdef MODE_TT
   .thread_private : {
     __start_thread_private = .;
     errno = .;
     . += 4;
-    arch/um/kernel/unmap_fin.o (.data)
+    arch/um/kernel/tt/unmap_fin.o (.data)
     __end_thread_private = .;
   }
   . = ALIGN(4096);
-  .remap : { arch/um/kernel/unmap_fin.o (.text) }
+  .remap : { arch/um/kernel/tt/unmap_fin.o (.text) }
+#endif
 
   . = ALIGN(4096);		/* Init code and data */
   _stext = .;
@@ -34,80 +36,12 @@ SECTIONS
     *(.gnu.linkonce.t*)
   }
 
-  . = ALIGN(16);		/* Exception table */
-  __start___ex_table = .;
-  __ex_table : { *(__ex_table) }
-  __stop___ex_table = .;
-
-  RODATA
-
-  .fini      : { *(.fini)    } =0x9090
-  _etext = .;
-  PROVIDE (etext = .);
-
-  . = ALIGN(4096);
-  PROVIDE (_sdata = .);
-
-  .unprotected : { *(.unprotected) }
-  . = ALIGN(4096);
-  PROVIDE (_unprotected_end = .);
-
-  . = ALIGN(4096);
-  __uml_setup_start = .;
-  .uml.setup.init : { *(.uml.setup.init) }
-  __uml_setup_end = .;
-	
-  __uml_help_start = .;
-  .uml.help.init : { *(.uml.help.init) }
-  __uml_help_end = .;
-	
-  __uml_postsetup_start = .;
-  .uml.postsetup.init : { *(.uml.postsetup.init) }
-  __uml_postsetup_end = .;
-	
-  __setup_start = .;
-  .init.setup : { *(.init.setup) }
-  __setup_end = .;
-
-  __start___param = .;
-  __param : { *(__param) }
-  __stop___param = .;
-
-  __per_cpu_start = . ; 
-  .data.percpu : { *(.data.percpu) }
-  __per_cpu_end = . ;
-	
-  __initcall_start = .;
-  .initcall.init : {
-	*(.initcall1.init) 
-	*(.initcall2.init) 
-	*(.initcall3.init) 
-	*(.initcall4.init) 
-	*(.initcall5.init) 
-	*(.initcall6.init) 
-	*(.initcall7.init)
-  }
-  __initcall_end = .;
-  __uml_initcall_start = .;
-  .uml.initcall.init : { *(.uml.initcall.init) }
-  __uml_initcall_end = .;
-  __init_end = .;
-  __exitcall_begin = .;
-  .exitcall : { *(.exitcall.exit) }
-  __exitcall_end = .;
-  __uml_exitcall_begin = .;
-  .uml.exitcall : { *(.uml.exitcall.exit) }
-  __uml_exitcall_end = .;
-
-   . = ALIGN(4096);
-   __initramfs_start = .;
-   .init.ramfs : { *(.init.ramfs) }
-   __initramfs_end = .;
+  #include "asm/common.lds.S"
 
   .data.init : { *(.data.init) }
   .data    :
   {
-    . = ALIGN(16384);		/* init_task */
+    . = ALIGN(KERNEL_STACK_SIZE);		/* init_task */
     *(.data.init_task)
     *(.data)
     *(.gnu.linkonce.d*)

arch/um/util/mk_task_kern.c

@@ -9,7 +9,7 @@ extern void print_tail(void);
 int main(int argc, char **argv)
 {
   print_head();
-  print_ptr("TASK_REGS", "struct uml_pt_regs", 
+  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();

include/asm-um/archparam-i386.h

@@ -48,7 +48,7 @@ typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 	/* fake once used fs and gs selectors? */	\
 	pr_reg[9] = PT_REGS_DS(regs);		\
 	pr_reg[10] = PT_REGS_DS(regs);		\
-	pr_reg[11] = regs->regs.syscall;	\
+	pr_reg[11] = PT_REGS_SYSCALL_NR(regs);	\
 	pr_reg[12] = PT_REGS_IP(regs);		\
 	pr_reg[13] = PT_REGS_CS(regs);		\
 	pr_reg[14] = PT_REGS_EFLAGS(regs);	\

include/asm-um/common.lds.S

+  .fini      : { *(.fini)    } =0x9090
+  _etext = .;
+  PROVIDE (etext = .);
+
+  . = ALIGN(4096);
+  _sdata = .;
+  PROVIDE (sdata = .);
+
+  . = ALIGN(16);		/* Exception table */
+  __start___ex_table = .;
+  __ex_table : { *(__ex_table) }
+  __stop___ex_table = .;
+
+  RODATA
+
+  __start___ksymtab = .;	/* Kernel symbol table */
+  __ksymtab : { *(__ksymtab) }
+  __stop___ksymtab = .;
+
+  __start___gpl_ksymtab = .;	/* Kernel symbol table:	GPL-only symbols */
+  __gpl_ksymtab : { *(__gpl_ksymtab) }
+  __stop___gpl_ksymtab = .;
+
+  __start___kallsyms = .;       /* All kernel symbols */
+  __kallsyms : { *(__kallsyms) }
+  __stop___kallsyms = .;
+
+  .unprotected : { *(.unprotected) }
+  . = ALIGN(4096);
+  PROVIDE (_unprotected_end = .);
+
+  . = ALIGN(4096);
+  __uml_setup_start = .;
+  .uml.setup.init : { *(.uml.setup.init) }
+  __uml_setup_end = .;
+	
+  __uml_help_start = .;
+  .uml.help.init : { *(.uml.help.init) }
+  __uml_help_end = .;
+	
+  __uml_postsetup_start = .;
+  .uml.postsetup.init : { *(.uml.postsetup.init) }
+  __uml_postsetup_end = .;
+	
+  __setup_start = .;
+  .init.setup : { *(.init.setup) }
+  __setup_end = .;
+
+  __start___param = .;
+  __param : { *(__param) }
+  __stop___param = .;
+
+  . = ALIGN(32);
+  __per_cpu_start = . ; 
+  .data.percpu : { *(.data.percpu) }
+  __per_cpu_end = . ;
+	
+  __initcall_start = .;
+  .initcall.init : {
+	*(.initcall1.init) 
+	*(.initcall2.init) 
+	*(.initcall3.init) 
+	*(.initcall4.init) 
+	*(.initcall5.init) 
+	*(.initcall6.init) 
+	*(.initcall7.init)
+  }
+  __initcall_end = .;
+
+  __uml_initcall_start = .;
+  .uml.initcall.init : { *(.uml.initcall.init) }
+  __uml_initcall_end = .;
+  __init_end = .;
+
+  __exitcall_begin = .;
+  .exitcall : { *(.exitcall.exit) }
+  __exitcall_end = .;
+
+  __uml_exitcall_begin = .;
+  .uml.exitcall : { *(.uml.exitcall.exit) }
+  __uml_exitcall_end = .;
+
+  . = ALIGN(4096);
+  __initramfs_start = .;
+  .init.ramfs : { *(.init.ramfs) }
+  __initramfs_end = .;

include/asm-um/pgtable.h

@@ -14,6 +14,9 @@
 
 extern pgd_t swapper_pg_dir[1024];
 
+extern void *um_virt_to_phys(struct task_struct *task, unsigned long virt,
+			     pte_t *pte_out);
+
 /* zero page used for uninitialized stuff */
 extern unsigned long *empty_zero_page;
 

include/asm-um/ptrace-generic.h

@@ -9,7 +9,7 @@
 #ifndef __ASSEMBLY__
 
 #include "linux/config.h"
-#include "skas_ptrace.h"
+
 #include "asm/current.h"
 
 #define pt_regs pt_regs_subarch
@@ -23,9 +23,10 @@
 #undef instruction_pointer
 
 #include "sysdep/ptrace.h"
+#include "skas_ptrace.h"
 
 struct pt_regs {
-	struct uml_pt_regs regs;
+	union uml_pt_regs regs;
 };
 
 #define EMPTY_REGS { regs : EMPTY_UML_PT_REGS }

include/asm-um/ptrace-i386.h

@@ -6,6 +6,7 @@
 #ifndef __UM_PTRACE_I386_H
 #define __UM_PTRACE_I386_H
 
+#include "sysdep/ptrace.h"
 #include "asm/ptrace-generic.h"
 
 #define PT_REGS_EAX(r) UPT_EAX(&(r)->regs)
@@ -29,7 +30,7 @@
 #define PT_REGS_SYSCALL_RET(r) PT_REGS_EAX(r)
 #define PT_FIX_EXEC_STACK(sp) do ; while(0)
 
-#define user_mode(r) ((r)->regs.is_user)
+#define user_mode(r) UPT_IS_USER(&(r)->regs)
 
 #endif
 

include/asm-um/ucontext.h

+#ifndef _ASM_UM_UCONTEXT_H
+#define _ASM_UM_UCONTEXT_H
+
+#include "asm/arch/ucontext.h"
+
+#endif