Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal

Pull third pile of kernel_execve() patches from Al Viro:
 "The last bits of infrastructure for kernel_thread() et.al., with
  alpha/arm/x86 use of those.  Plus sanitizing the asm glue and
  do_notify_resume() on alpha, fixing the "disabled irq while running
  task_work stuff" breakage there.

  At that point the rest of kernel_thread/kernel_execve/sys_execve work
  can be done independently for different architectures.  The only
  pending bits that do depend on having all architectures converted are
  restrictred to fs/* and kernel/* - that'll obviously have to wait for
  the next cycle.

  I thought we'd have to wait for all of them done before we start
  eliminating the longjump-style insanity in kernel_execve(), but it
  turned out there's a very simple way to do that without flagday-style
  changes."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal:
  alpha: switch to saner kernel_execve() semantics
  arm: switch to saner kernel_execve() semantics
  x86, um: convert to saner kernel_execve() semantics
  infrastructure for saner ret_from_kernel_thread semantics
  make sure that kernel_thread() callbacks call do_exit() themselves
  make sure that we always have a return path from kernel_execve()
  ppc: eeh_event should just use kthread_run()
  don't bother with kernel_thread/kernel_execve for launching linuxrc
  alpha: get rid of switch_stack argument of do_work_pending()
  alpha: don't bother passing switch_stack separately from regs
  alpha: take SIGPENDING/NOTIFY_RESUME loop into signal.c
  alpha: simplify TIF_NEED_RESCHED handling

2 files changed, 33 insertions, 41 deletions

diff --git a/init/do_mounts_initrd.c b/init/do_mounts_initrd.c
index 135959a276b..5e4ded51788 100644
--- a/init/do_mounts_initrd.c
+++ b/init/do_mounts_initrd.c
@@ -16,13 +16,13 @@
 #include <linux/initrd.h>
 #include <linux/sched.h>
 #include <linux/freezer.h>
+#include <linux/kmod.h>
 
 #include "do_mounts.h"
 
 unsigned long initrd_start, initrd_end;
 int initrd_below_start_ok;
 unsigned int real_root_dev;     /* do_proc_dointvec cannot handle kdev_t */
-static int __initdata old_fd, root_fd;
 static int __initdata mount_initrd = 1;
 
 static int __init no_initrd(char *str)
@@ -33,33 +33,29 @@ static int __init no_initrd(char *str)
 
 __setup("noinitrd", no_initrd);
 
-static int __init do_linuxrc(void *_shell)
+static int init_linuxrc(struct subprocess_info *info, struct cred *new)
 {
-        static const char *argv[] = { "linuxrc", NULL, };
-        extern const char *envp_init[];
-        const char *shell = _shell;
-
-        sys_close(old_fd);sys_close(root_fd);
+        sys_unshare(CLONE_FS | CLONE_FILES);
+        /* move initrd over / and chdir/chroot in initrd root */
+        sys_chdir("/root");
+        sys_mount(".", "/", NULL, MS_MOVE, NULL);
+        sys_chroot(".");
         sys_setsid();
-        return kernel_execve(shell, argv, envp_init);
+        return 0;
 }
 
 static void __init handle_initrd(void)
 {
+        static char *argv[] = { "linuxrc", NULL, };
+        extern char *envp_init[];
         int error;
-        int pid;
 
         real_root_dev = new_encode_dev(ROOT_DEV);
         create_dev("/dev/root.old", Root_RAM0);
         /* mount initrd on rootfs' /root */
         mount_block_root("/dev/root.old", root_mountflags & ~MS_RDONLY);
         sys_mkdir("/old", 0700);
-        root_fd = sys_open("/", 0, 0);
-        old_fd = sys_open("/old", 0, 0);
-        /* move initrd over / and chdir/chroot in initrd root */
-        sys_chdir("/root");
-        sys_mount(".", "/", NULL, MS_MOVE, NULL);
-        sys_chroot(".");
+        sys_chdir("/old");
 
         /*
          * In case that a resume from disk is carried out by linuxrc or one of
@@ -67,27 +63,22 @@ static void __init handle_initrd(void)
          */
         current->flags |= PF_FREEZER_SKIP;
 
-        pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
-        if (pid > 0)
-                while (pid != sys_wait4(-1, NULL, 0, NULL))
-                        yield();
+        call_usermodehelper_fns("/linuxrc", argv, envp_init, UMH_WAIT_PROC,
+                        init_linuxrc, NULL, NULL);
 
         current->flags &= ~PF_FREEZER_SKIP;
 
         /* move initrd to rootfs' /old */
-        sys_fchdir(old_fd);
-        sys_mount("/", ".", NULL, MS_MOVE, NULL);
+        sys_mount("..", ".", NULL, MS_MOVE, NULL);
         /* switch root and cwd back to / of rootfs */
-        sys_fchdir(root_fd);
-        sys_chroot(".");
-        sys_close(old_fd);
-        sys_close(root_fd);
+        sys_chroot("..");
 
         if (new_decode_dev(real_root_dev) == Root_RAM0) {
                 sys_chdir("/old");
                 return;
         }
 
+        sys_chdir("/");
         ROOT_DEV = new_decode_dev(real_root_dev);
         mount_root();
 
diff --git a/init/main.c b/init/main.c
index 313360fe111..9cf77ab138a 100644
--- a/init/main.c
+++ b/init/main.c
@@ -69,6 +69,7 @@
 #include <linux/slab.h>
 #include <linux/perf_event.h>
 #include <linux/file.h>
+#include <linux/ptrace.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -791,17 +792,17 @@ static void __init do_pre_smp_initcalls(void)
                 do_one_initcall(*fn);
 }
 
-static void run_init_process(const char *init_filename)
+static int run_init_process(const char *init_filename)
 {
         argv_init[0] = init_filename;
-        kernel_execve(init_filename, argv_init, envp_init);
+        return kernel_execve(init_filename, argv_init, envp_init);
 }
 
-/* This is a non __init function. Force it to be noinline otherwise gcc
- * makes it inline to init() and it becomes part of init.text section
- */
-static noinline int init_post(void)
+static void __init kernel_init_freeable(void);
+
+static int __ref kernel_init(void *unused)
 {
+        kernel_init_freeable();
         /* need to finish all async __init code before freeing the memory */
         async_synchronize_full();
         free_initmem();
@@ -813,7 +814,8 @@ static noinline int init_post(void)
         flush_delayed_fput();
 
         if (ramdisk_execute_command) {
-                run_init_process(ramdisk_execute_command);
+                if (!run_init_process(ramdisk_execute_command))
+                        return 0;
                 printk(KERN_WARNING "Failed to execute %s\n",
                                 ramdisk_execute_command);
         }
@@ -825,20 +827,22 @@ static noinline int init_post(void)
          * trying to recover a really broken machine.
          */
         if (execute_command) {
-                run_init_process(execute_command);
+                if (!run_init_process(execute_command))
+                        return 0;
                 printk(KERN_WARNING "Failed to execute %s.  Attempting "
                                         "defaults...\n", execute_command);
         }
-        run_init_process("/sbin/init");
-        run_init_process("/etc/init");
-        run_init_process("/bin/init");
-        run_init_process("/bin/sh");
+        if (!run_init_process("/sbin/init") ||
+            !run_init_process("/etc/init") ||
+            !run_init_process("/bin/init") ||
+            !run_init_process("/bin/sh"))
+                return 0;
 
         panic("No init found.  Try passing init= option to kernel. "
               "See Linux Documentation/init.txt for guidance.");
 }
 
-static int __init kernel_init(void * unused)
+static void __init kernel_init_freeable(void)
 {
         /*
          * Wait until kthreadd is all set-up.
@@ -893,7 +897,4 @@ static int __init kernel_init(void * unused)
          * we're essentially up and running. Get rid of the
          * initmem segments and start the user-mode stuff..
          */
-
-        init_post();
-        return 0;
 }