Merge ../linux-2.6

9 files changed, 535 insertions, 16 deletions

diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index d15ec2af6a22..b83ac8e21c35 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -3,11 +3,12 @@
 # Licensed under the GPL
 #
 
-obj-y = aio.o elf_aux.o file.o mem.o process.o signal.o start_up.o time.o \
-        tt.o tty.o user_syms.o drivers/ sys-$(SUBARCH)/
+obj-y = aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
+        start_up.o time.o tt.o tty.o uaccess.o user_syms.o drivers/ \
+        sys-$(SUBARCH)/
 
-USER_OBJS := aio.o elf_aux.o file.o mem.o process.o signal.o start_up.o \
-        time.o tt.o tty.o
+USER_OBJS := aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
+        start_up.o time.o tt.o tty.o uaccess.o
 
 elf_aux.o: $(ARCH_DIR)/kernel-offsets.h
 CFLAGS_elf_aux.o += -I$(objtree)/arch/um
diff --git a/arch/um/os-Linux/aio.c b/arch/um/os-Linux/aio.c
index 41cfb0944201..ffa759addd3c 100644
--- a/arch/um/os-Linux/aio.c
+++ b/arch/um/os-Linux/aio.c
@@ -10,7 +10,6 @@
 #include <sched.h>
 #include <sys/syscall.h>
 #include "os.h"
-#include "helper.h"
 #include "aio.h"
 #include "init.h"
 #include "user.h"
diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
index cd4d6544da71..901b85e8a1c6 100644
--- a/arch/um/os-Linux/drivers/ethertap_user.c
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -19,7 +19,6 @@
 #include "user_util.h"
 #include "net_user.h"
 #include "etap.h"
-#include "helper.h"
 #include "os.h"
 
 #define MAX_PACKET ETH_MAX_PACKET
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
index 4ba9b17adf13..52945338b64d 100644
--- a/arch/um/os-Linux/drivers/tuntap_user.c
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -20,7 +20,6 @@
 #include "kern_util.h"
 #include "user_util.h"
 #include "user.h"
-#include "helper.h"
 #include "os.h"
 
 #define MAX_PACKET ETH_MAX_PACKET
diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
new file mode 100644
index 000000000000..36cc8475bcda
--- /dev/null
+++ b/arch/um/os-Linux/helper.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sched.h>
+#include <sys/signal.h>
+#include <sys/wait.h>
+#include "user.h"
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+
+struct helper_data {
+        void (*pre_exec)(void*);
+        void *pre_data;
+        char **argv;
+        int fd;
+};
+
+/* Debugging aid, changed only from gdb */
+int helper_pause = 0;
+
+static void helper_hup(int sig)
+{
+}
+
+static int helper_child(void *arg)
+{
+        struct helper_data *data = arg;
+        char **argv = data->argv;
+        int errval;
+
+        if(helper_pause){
+                signal(SIGHUP, helper_hup);
+                pause();
+        }
+        if(data->pre_exec != NULL)
+                (*data->pre_exec)(data->pre_data);
+        execvp(argv[0], argv);
+        errval = errno;
+        printk("execvp of '%s' failed - errno = %d\n", argv[0], errno);
+        os_write_file(data->fd, &errval, sizeof(errval));
+        kill(os_getpid(), SIGKILL);
+        return(0);
+}
+
+/* Returns either the pid of the child process we run or -E* on failure.
+ * XXX The alloc_stack here breaks if this is called in the tracing thread */
+int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
+               unsigned long *stack_out)
+{
+        struct helper_data data;
+        unsigned long stack, sp;
+        int pid, fds[2], ret, n;
+
+        if((stack_out != NULL) && (*stack_out != 0))
+                stack = *stack_out;
+        else stack = alloc_stack(0, um_in_interrupt());
+        if(stack == 0)
+                return(-ENOMEM);
+
+        ret = os_pipe(fds, 1, 0);
+        if(ret < 0){
+                printk("run_helper : pipe failed, ret = %d\n", -ret);
+                goto out_free;
+        }
+
+        ret = os_set_exec_close(fds[1], 1);
+        if(ret < 0){
+                printk("run_helper : setting FD_CLOEXEC failed, ret = %d\n",
+                       -ret);
+                goto out_close;
+        }
+
+        sp = stack + page_size() - sizeof(void *);
+        data.pre_exec = pre_exec;
+        data.pre_data = pre_data;
+        data.argv = argv;
+        data.fd = fds[1];
+        pid = clone(helper_child, (void *) sp, CLONE_VM | SIGCHLD, &data);
+        if(pid < 0){
+                ret = -errno;
+                printk("run_helper : clone failed, errno = %d\n", errno);
+                goto out_close;
+        }
+
+        close(fds[1]);
+        fds[1] = -1;
+
+        /*Read the errno value from the child.*/
+        n = os_read_file(fds[0], &ret, sizeof(ret));
+        if(n < 0){
+                printk("run_helper : read on pipe failed, ret = %d\n", -n);
+                ret = n;
+                kill(pid, SIGKILL);
+                CATCH_EINTR(waitpid(pid, NULL, 0));
+        }
+        else if(n != 0){
+                CATCH_EINTR(n = waitpid(pid, NULL, 0));
+                ret = -errno;
+        } else {
+                ret = pid;
+        }
+
+out_close:
+        if (fds[1] != -1)
+                close(fds[1]);
+        close(fds[0]);
+out_free:
+        if(stack_out == NULL)
+                free_stack(stack, 0);
+        else *stack_out = stack;
+        return(ret);
+}
+
+int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags,
+                      unsigned long *stack_out, int stack_order)
+{
+        unsigned long stack, sp;
+        int pid, status, err;
+
+        stack = alloc_stack(stack_order, um_in_interrupt());
+        if(stack == 0) return(-ENOMEM);
+
+        sp = stack + (page_size() << stack_order) - sizeof(void *);
+        pid = clone(proc, (void *) sp, flags | SIGCHLD, arg);
+        if(pid < 0){
+                err = -errno;
+                printk("run_helper_thread : clone failed, errno = %d\n",
+                       errno);
+                return err;
+        }
+        if(stack_out == NULL){
+                CATCH_EINTR(pid = waitpid(pid, &status, 0));
+                if(pid < 0){
+                        err = -errno;
+                        printk("run_helper_thread - wait failed, errno = %d\n",
+                               errno);
+                        pid = err;
+                }
+                if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
+                        printk("run_helper_thread - thread returned status "
+                               "0x%x\n", status);
+                free_stack(stack, stack_order);
+        }
+        else *stack_out = stack;
+        return(pid);
+}
+
+int helper_wait(int pid)
+{
+        int ret;
+
+        CATCH_EINTR(ret = waitpid(pid, NULL, WNOHANG));
+        if(ret < 0){
+                ret = -errno;
+                printk("helper_wait : waitpid failed, errno = %d\n", errno);
+        }
+        return(ret);
+}
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
new file mode 100644
index 000000000000..23da27d22569
--- /dev/null
+++ b/arch/um/os-Linux/main.c
@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/resource.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <asm/page.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "mem_user.h"
+#include "signal_user.h"
+#include "time_user.h"
+#include "irq_user.h"
+#include "user.h"
+#include "init.h"
+#include "mode.h"
+#include "choose-mode.h"
+#include "uml-config.h"
+#include "os.h"
+
+/* Set in set_stklim, which is called from main and __wrap_malloc.
+ * __wrap_malloc only calls it if main hasn't started.
+ */
+unsigned long stacksizelim;
+
+/* Set in main */
+char *linux_prog;
+
+#define PGD_BOUND (4 * 1024 * 1024)
+#define STACKSIZE (8 * 1024 * 1024)
+#define THREAD_NAME_LEN (256)
+
+static void set_stklim(void)
+{
+        struct rlimit lim;
+
+        if(getrlimit(RLIMIT_STACK, &lim) < 0){
+                perror("getrlimit");
+                exit(1);
+        }
+        if((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)){
+                lim.rlim_cur = STACKSIZE;
+                if(setrlimit(RLIMIT_STACK, &lim) < 0){
+                        perror("setrlimit");
+                        exit(1);
+                }
+        }
+        stacksizelim = (lim.rlim_cur + PGD_BOUND - 1) & ~(PGD_BOUND - 1);
+}
+
+static __init void do_uml_initcalls(void)
+{
+        initcall_t *call;
+
+        call = &__uml_initcall_start;
+        while (call < &__uml_initcall_end){;
+                (*call)();
+                call++;
+        }
+}
+
+static void last_ditch_exit(int sig)
+{
+        signal(SIGINT, SIG_DFL);
+        signal(SIGTERM, SIG_DFL);
+        signal(SIGHUP, SIG_DFL);
+        uml_cleanup();
+        exit(1);
+}
+
+extern int uml_exitcode;
+
+extern void scan_elf_aux( char **envp);
+
+int main(int argc, char **argv, char **envp)
+{
+        char **new_argv;
+        sigset_t mask;
+        int ret, i, err;
+
+        /* Enable all signals except SIGIO - in some environments, we can
+         * enter with some signals blocked
+         */
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGIO);
+        if(sigprocmask(SIG_SETMASK, &mask, NULL) < 0){
+                perror("sigprocmask");
+                exit(1);
+        }
+
+#ifdef UML_CONFIG_CMDLINE_ON_HOST
+        /* Allocate memory for thread command lines */
+        if(argc < 2 || strlen(argv[1]) < THREAD_NAME_LEN - 1){
+
+                char padding[THREAD_NAME_LEN] = {
+                        [ 0 ...  THREAD_NAME_LEN - 2] = ' ', '\0'
+                };
+
+                new_argv = malloc((argc + 2) * sizeof(char*));
+                if(!new_argv) {
+                        perror("Allocating extended argv");
+                        exit(1);
+                }
+
+                new_argv[0] = argv[0];
+                new_argv[1] = padding;
+
+                for(i = 2; i <= argc; i++)
+                        new_argv[i] = argv[i - 1];
+                new_argv[argc + 1] = NULL;
+
+                execvp(new_argv[0], new_argv);
+                perror("execing with extended args");
+                exit(1);
+        }
+#endif
+
+        linux_prog = argv[0];
+
+        set_stklim();
+
+        new_argv = malloc((argc + 1) * sizeof(char *));
+        if(new_argv == NULL){
+                perror("Mallocing argv");
+                exit(1);
+        }
+        for(i=0;i<argc;i++){
+                new_argv[i] = strdup(argv[i]);
+                if(new_argv[i] == NULL){
+                        perror("Mallocing an arg");
+                        exit(1);
+                }
+        }
+        new_argv[argc] = NULL;
+
+        set_handler(SIGINT, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+        set_handler(SIGTERM, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+        set_handler(SIGHUP, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
+
+        scan_elf_aux( envp);
+
+        do_uml_initcalls();
+        ret = linux_main(argc, argv);
+
+        /* Disable SIGPROF - I have no idea why libc doesn't do this or turn
+         * off the profiling time, but UML dies with a SIGPROF just before
+         * exiting when profiling is active.
+         */
+        change_sig(SIGPROF, 0);
+
+        /* This signal stuff used to be in the reboot case.  However,
+         * sometimes a SIGVTALRM can come in when we're halting (reproducably
+         * when writing out gcov information, presumably because that takes
+         * some time) and cause a segfault.
+         */
+
+        /* stop timers and set SIG*ALRM to be ignored */
+        disable_timer();
+
+        /* disable SIGIO for the fds and set SIGIO to be ignored */
+        err = deactivate_all_fds();
+        if(err)
+                printf("deactivate_all_fds failed, errno = %d\n", -err);
+
+        /* Let any pending signals fire now.  This ensures
+         * that they won't be delivered after the exec, when
+         * they are definitely not expected.
+         */
+        unblock_signals();
+
+        /* Reboot */
+        if(ret){
+                printf("\n");
+                execvp(new_argv[0], new_argv);
+                perror("Failed to exec kernel");
+                ret = 1;
+        }
+        printf("\n");
+        return(uml_exitcode);
+}
+
+#define CAN_KMALLOC() \
+        (kmalloc_ok && CHOOSE_MODE((os_getpid() != tracing_pid), 1))
+
+extern void *__real_malloc(int);
+
+void *__wrap_malloc(int size)
+{
+        void *ret;
+
+        if(!CAN_KMALLOC())
+                return(__real_malloc(size));
+        else if(size <= PAGE_SIZE) /* finding contiguos pages can be hard*/
+                ret = um_kmalloc(size);
+        else ret = um_vmalloc(size);
+
+        /* glibc people insist that if malloc fails, errno should be
+         * set by malloc as well. So we do.
+         */
+        if(ret == NULL)
+                errno = ENOMEM;
+
+        return(ret);
+}
+
+void *__wrap_calloc(int n, int size)
+{
+        void *ptr = __wrap_malloc(n * size);
+
+        if(ptr == NULL) return(NULL);
+        memset(ptr, 0, n * size);
+        return(ptr);
+}
+
+extern void __real_free(void *);
+
+extern unsigned long high_physmem;
+
+void __wrap_free(void *ptr)
+{
+        unsigned long addr = (unsigned long) ptr;
+
+        /* We need to know how the allocation happened, so it can be correctly
+         * freed.  This is done by seeing what region of memory the pointer is
+         * in -
+         *      physical memory - kmalloc/kfree
+         *      kernel virtual memory - vmalloc/vfree
+         *      anywhere else - malloc/free
+         * If kmalloc is not yet possible, then either high_physmem and/or
+         * end_vm are still 0 (as at startup), in which case we call free, or
+         * we have set them, but anyway addr has not been allocated from those
+         * areas. So, in both cases __real_free is called.
+         *
+         * CAN_KMALLOC is checked because it would be bad to free a buffer
+         * with kmalloc/vmalloc after they have been turned off during
+         * shutdown.
+         * XXX: However, we sometimes shutdown CAN_KMALLOC temporarily, so
+         * there is a possibility for memory leaks.
+         */
+
+        if((addr >= uml_physmem) && (addr < high_physmem)){
+                if(CAN_KMALLOC())
+                        kfree(ptr);
+        }
+        else if((addr >= start_vm) && (addr < end_vm)){
+                if(CAN_KMALLOC())
+                        vfree(ptr);
+        }
+        else __real_free(ptr);
+}
diff --git a/arch/um/os-Linux/mem.c b/arch/um/os-Linux/mem.c
index 8e71edaaf80b..9d7d69a523bb 100644
--- a/arch/um/os-Linux/mem.c
+++ b/arch/um/os-Linux/mem.c
@@ -88,7 +88,7 @@ int make_tempfile(const char *template, char **out_tempname, int do_unlink)
  * This proc is used in start_up.c
  * So it isn't 'static'.
  */
-int create_tmp_file(unsigned long len)
+int create_tmp_file(unsigned long long len)
 {
         int fd, err;
         char zero;
@@ -121,7 +121,7 @@ int create_tmp_file(unsigned long len)
         return(fd);
 }
 
-static int create_anon_file(unsigned long len)
+static int create_anon_file(unsigned long long len)
 {
         void *addr;
         int fd;
@@ -144,7 +144,7 @@ static int create_anon_file(unsigned long len)
 
 extern int have_devanon;
 
-int create_mem_file(unsigned long len)
+int create_mem_file(unsigned long long len)
 {
         int err, fd;
 
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index b99ab414542f..37517d49c4ae 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -135,7 +135,9 @@ static int stop_ptraced_child(int pid, void *stack, int exitcode,
 }
 
 int ptrace_faultinfo = 1;
+int ptrace_ldt = 1;
 int proc_mm = 1;
+int skas_needs_stub = 0;
 
 static int __init skas0_cmd_param(char *str, int* add)
 {
@@ -294,7 +296,7 @@ static void __init check_ptrace(void)
         check_sysemu();
 }
 
-extern int create_tmp_file(unsigned long len);
+extern int create_tmp_file(unsigned long long len);
 
 static void check_tmpexec(void)
 {
@@ -352,14 +354,26 @@ __uml_setup("noptracefaultinfo", noptracefaultinfo_cmd_param,
 "    it. To support PTRACE_FAULTINFO, the host needs to be patched\n"
 "    using the current skas3 patch.\n\n");
 
+static int __init noptraceldt_cmd_param(char *str, int* add)
+{
+        ptrace_ldt = 0;
+        return 0;
+}
+
+__uml_setup("noptraceldt", noptraceldt_cmd_param,
+"noptraceldt\n"
+"    Turns off usage of PTRACE_LDT, even if host supports it.\n"
+"    To support PTRACE_LDT, the host needs to be patched using\n"
+"    the current skas3 patch.\n\n");
+
 #ifdef UML_CONFIG_MODE_SKAS
-static inline void check_skas3_ptrace_support(void)
+static inline void check_skas3_ptrace_faultinfo(void)
 {
         struct ptrace_faultinfo fi;
         void *stack;
         int pid, n;
 
-        printf("Checking for the skas3 patch in the host...");
+        printf("  - PTRACE_FAULTINFO...");
         pid = start_ptraced_child(&stack);
 
         n = ptrace(PTRACE_FAULTINFO, pid, 0, &fi);
@@ -381,9 +395,49 @@ static inline void check_skas3_ptrace_support(void)
         stop_ptraced_child(pid, stack, 1, 1);
 }
 
-int can_do_skas(void)
+static inline void check_skas3_ptrace_ldt(void)
+{
+#ifdef PTRACE_LDT
+        void *stack;
+        int pid, n;
+        unsigned char ldtbuf[40];
+        struct ptrace_ldt ldt_op = (struct ptrace_ldt) {
+                .func = 2, /* read default ldt */
+                .ptr = ldtbuf,
+                .bytecount = sizeof(ldtbuf)};
+
+        printf("  - PTRACE_LDT...");
+        pid = start_ptraced_child(&stack);
+
+        n = ptrace(PTRACE_LDT, pid, 0, (unsigned long) &ldt_op);
+        if (n < 0) {
+                if(errno == EIO)
+                        printf("not found\n");
+                else {
+                        perror("not found");
+                }
+                ptrace_ldt = 0;
+        }
+        else {
+                if(ptrace_ldt)
+                        printf("found\n");
+                else
+                        printf("found, but use is disabled\n");
+        }
+
+        stop_ptraced_child(pid, stack, 1, 1);
+#else
+        /* PTRACE_LDT might be disabled via cmdline option.
+         * We want to override this, else we might use the stub
+         * without real need
+         */
+        ptrace_ldt = 1;
+#endif
+}
+
+static inline void check_skas3_proc_mm(void)
 {
-        printf("Checking for /proc/mm...");
+        printf("  - /proc/mm...");
         if (os_access("/proc/mm", OS_ACC_W_OK) < 0) {
                 proc_mm = 0;
                 printf("not found\n");
@@ -394,8 +448,19 @@ int can_do_skas(void)
                 else
                         printf("found\n");
         }
+}
+
+int can_do_skas(void)
+{
+        printf("Checking for the skas3 patch in the host:\n");
+
+        check_skas3_proc_mm();
+        check_skas3_ptrace_faultinfo();
+        check_skas3_ptrace_ldt();
+
+        if(!proc_mm || !ptrace_faultinfo || !ptrace_ldt)
+                skas_needs_stub = 1;
 
-        check_skas3_ptrace_support();
         return 1;
 }
 #else
diff --git a/arch/um/os-Linux/uaccess.c b/arch/um/os-Linux/uaccess.c
new file mode 100644
index 000000000000..38d710158c3d
--- /dev/null
+++ b/arch/um/os-Linux/uaccess.c
@@ -0,0 +1,32 @@
+/*
+ * 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>
+
+unsigned long __do_user_copy(void *to, const void *from, int n,
+                             void **fault_addr, void **fault_catcher,
+                             void (*op)(void *to, const void *from,
+                                        int n), int *faulted_out)
+{
+        unsigned long *faddrp = (unsigned long *) fault_addr, ret;
+
+        sigjmp_buf jbuf;
+        *fault_catcher = &jbuf;
+        if(sigsetjmp(jbuf, 1) == 0){
+                (*op)(to, from, n);
+                ret = 0;
+                *faulted_out = 0;
+        }
+        else {
+                ret = *faddrp;
+                *faulted_out = 1;
+        }
+        *fault_addr = NULL;
+        *fault_catcher = NULL;
+        return ret;
+}
+