Merge branch 'linus' into sched/core
[linux-2.6.git] / init / main.c
index 5988deb..8646401 100644 (file)
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/initrd.h>
 #include <linux/bootmem.h>
 #include <linux/acpi.h>
 #include <linux/tty.h>
-#include <linux/gfp.h>
 #include <linux/percpu.h>
 #include <linux/kmod.h>
 #include <linux/vmalloc.h>
@@ -33,7 +31,6 @@
 #include <linux/start_kernel.h>
 #include <linux/security.h>
 #include <linux/smp.h>
-#include <linux/workqueue.h>
 #include <linux/profile.h>
 #include <linux/rcupdate.h>
 #include <linux/moduleparam.h>
 #include <linux/sched.h>
 #include <linux/signal.h>
 #include <linux/idr.h>
+#include <linux/kgdb.h>
 #include <linux/ftrace.h>
 #include <linux/async.h>
 #include <linux/kmemcheck.h>
-#include <linux/kmemtrace.h>
 #include <linux/sfi.h>
 #include <linux/shmem_fs.h>
-#include <trace/boot.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -124,7 +121,9 @@ static char *ramdisk_execute_command;
 
 #ifdef CONFIG_SMP
 /* Setup configured maximum number of CPUs to activate */
-unsigned int __initdata setup_max_cpus = NR_CPUS;
+unsigned int setup_max_cpus = NR_CPUS;
+EXPORT_SYMBOL(setup_max_cpus);
+
 
 /*
  * Setup routine for controlling SMP activation
@@ -149,6 +148,20 @@ static int __init nosmp(char *str)
 
 early_param("nosmp", nosmp);
 
+/* this is hard limit */
+static int __init nrcpus(char *str)
+{
+       int nr_cpus;
+
+       get_option(&str, &nr_cpus);
+       if (nr_cpus > 0 && nr_cpus < nr_cpu_ids)
+               nr_cpu_ids = nr_cpus;
+
+       return 0;
+}
+
+early_param("nr_cpus", nrcpus);
+
 static int __init maxcpus(char *str)
 {
        get_option(&str, &setup_max_cpus);
@@ -160,7 +173,7 @@ static int __init maxcpus(char *str)
 
 early_param("maxcpus", maxcpus);
 #else
-const unsigned int setup_max_cpus = NR_CPUS;
+static const unsigned int setup_max_cpus = NR_CPUS;
 #endif
 
 /*
@@ -183,15 +196,15 @@ static int __init set_reset_devices(char *str)
 
 __setup("reset_devices", set_reset_devices);
 
-static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
-char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
+static const char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
+const char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
 static const char *panic_later, *panic_param;
 
-extern struct obs_kernel_param __setup_start[], __setup_end[];
+extern const struct obs_kernel_param __setup_start[], __setup_end[];
 
 static int __init obsolete_checksetup(char *line)
 {
-       struct obs_kernel_param *p;
+       const struct obs_kernel_param *p;
        int had_early_param = 0;
 
        p = __setup_start;
@@ -251,7 +264,7 @@ early_param("loglevel", loglevel);
 
 /*
  * Unknown boot options get handed to init, unless they look like
- * failed parameters
+ * unused parameters (modprobe will find them in /proc/cmdline).
  */
 static int __init unknown_bootoption(char *param, char *val)
 {
@@ -272,14 +285,9 @@ static int __init unknown_bootoption(char *param, char *val)
        if (obsolete_checksetup(param))
                return 0;
 
-       /*
-        * Preemptive maintenance for "why didn't my misspelled command
-        * line work?"
-        */
-       if (strchr(param, '.') && (!val || strchr(param, '.') < val)) {
-               printk(KERN_ERR "Unknown boot option `%s': ignoring\n", param);
+       /* Unused module parameter. */
+       if (strchr(param, '.') && (!val || strchr(param, '.') < val))
                return 0;
-       }
 
        if (panic_later)
                return 0;
@@ -374,12 +382,6 @@ static void __init smp_init(void)
 {
        unsigned int cpu;
 
-       /*
-        * Set up the current CPU as possible to migrate to.
-        * The other ones will be done by cpu_up/cpu_down()
-        */
-       set_cpu_active(smp_processor_id(), true);
-
        /* FIXME: This should be done in userspace --RR */
        for_each_present_cpu(cpu) {
                if (num_online_cpus() >= setup_max_cpus)
@@ -418,17 +420,25 @@ static void __init setup_command_line(char *command_line)
  * gcc-3.4 accidentally inlines this function, so use noinline.
  */
 
+static __initdata DECLARE_COMPLETION(kthreadd_done);
+
 static noinline void __init_refok rest_init(void)
-       __releases(kernel_lock)
 {
        int pid;
 
        rcu_scheduler_starting();
+       /*
+        * We need to spawn init first so that it obtains pid 1, however
+        * the init task will end up wanting to create kthreads, which, if
+        * we schedule it before we create kthreadd, will OOPS.
+        */
        kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
        numa_default_policy();
        pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
+       rcu_read_lock();
        kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
-       unlock_kernel();
+       rcu_read_unlock();
+       complete(&kthreadd_done);
 
        /*
         * The boot idle thread must execute schedule()
@@ -446,7 +456,7 @@ static noinline void __init_refok rest_init(void)
 /* Check for early params. */
 static int __init do_early_param(char *param, char *val)
 {
-       struct obs_kernel_param *p;
+       const struct obs_kernel_param *p;
 
        for (p = __setup_start; p < __setup_end; p++) {
                if ((p->early && strcmp(param, p->str) == 0) ||
@@ -491,6 +501,7 @@ static void __init boot_cpu_init(void)
        int cpu = smp_processor_id();
        /* Mark the boot cpu "present", "online" etc for SMP and UP case */
        set_cpu_online(cpu, true);
+       set_cpu_active(cpu, true);
        set_cpu_present(cpu, true);
        set_cpu_possible(cpu, true);
 }
@@ -515,6 +526,7 @@ static void __init mm_init(void)
        page_cgroup_init_flatmem();
        mem_init();
        kmem_cache_init();
+       percpu_init_late();
        pgtable_cache_init();
        vmalloc_init();
 }
@@ -522,7 +534,7 @@ static void __init mm_init(void)
 asmlinkage void __init start_kernel(void)
 {
        char * command_line;
-       extern struct kernel_param __start___param[], __stop___param[];
+       extern const struct kernel_param __start___param[], __stop___param[];
 
        smp_setup_processor_id();
 
@@ -542,13 +554,11 @@ asmlinkage void __init start_kernel(void)
 
        local_irq_disable();
        early_boot_irqs_off();
-       early_init_irq_lock_class();
 
 /*
  * Interrupts are still disabled. Do necessary setups, then
  * enable them
  */
-       lock_kernel();
        tick_init();
        boot_cpu_init();
        page_address_init();
@@ -560,7 +570,7 @@ asmlinkage void __init start_kernel(void)
        setup_per_cpu_areas();
        smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
 
-       build_all_zonelists();
+       build_all_zonelists(NULL);
        page_alloc_init();
 
        printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
@@ -594,6 +604,7 @@ asmlinkage void __init start_kernel(void)
                local_irq_disable();
        }
        rcu_init();
+       radix_tree_init();
        /* init some links before init_ISA_irqs() */
        early_irq_init();
        init_IRQ();
@@ -611,7 +622,7 @@ asmlinkage void __init start_kernel(void)
        local_irq_enable();
 
        /* Interrupts are enabled now so all GFP allocations are safe. */
-       set_gfp_allowed_mask(__GFP_BITS_MASK);
+       gfp_allowed_mask = __GFP_BITS_MASK;
 
        kmem_cache_init_late();
 
@@ -645,7 +656,6 @@ asmlinkage void __init start_kernel(void)
 #endif
        page_cgroup_init();
        enable_debug_pagealloc();
-       kmemtrace_init();
        kmemleak_init();
        debug_objects_mem_init();
        idr_init_cache();
@@ -668,8 +678,8 @@ asmlinkage void __init start_kernel(void)
        buffer_init();
        key_init();
        security_init();
+       dbg_late_init();
        vfs_caches_init(totalram_pages);
-       radix_tree_init();
        signals_init();
        /* rootfs populating might need page-writeback */
        page_writeback_init();
@@ -696,10 +706,10 @@ asmlinkage void __init start_kernel(void)
 static void __init do_ctors(void)
 {
 #ifdef CONFIG_CONSTRUCTORS
-       ctor_fn_t *call = (ctor_fn_t *) __ctors_start;
+       ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
 
-       for (; call < (ctor_fn_t *) __ctors_end; call++)
-               (*call)();
+       for (; fn < (ctor_fn_t *) __ctors_end; fn++)
+               (*fn)();
 #endif
 }
 
@@ -707,38 +717,39 @@ int initcall_debug;
 core_param(initcall_debug, initcall_debug, bool, 0644);
 
 static char msgbuf[64];
-static struct boot_trace_call call;
-static struct boot_trace_ret ret;
 
-int do_one_initcall(initcall_t fn)
+static int __init_or_module do_one_initcall_debug(initcall_t fn)
 {
-       int count = preempt_count();
        ktime_t calltime, delta, rettime;
+       unsigned long long duration;
+       int ret;
+
+       printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
+       calltime = ktime_get();
+       ret = fn();
+       rettime = ktime_get();
+       delta = ktime_sub(rettime, calltime);
+       duration = (unsigned long long) ktime_to_ns(delta) >> 10;
+       printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n", fn,
+               ret, duration);
+
+       return ret;
+}
 
-       if (initcall_debug) {
-               call.caller = task_pid_nr(current);
-               printk("calling  %pF @ %i\n", fn, call.caller);
-               calltime = ktime_get();
-               trace_boot_call(&call, fn);
-               enable_boot_trace();
-       }
-
-       ret.result = fn();
+int __init_or_module do_one_initcall(initcall_t fn)
+{
+       int count = preempt_count();
+       int ret;
 
-       if (initcall_debug) {
-               disable_boot_trace();
-               rettime = ktime_get();
-               delta = ktime_sub(rettime, calltime);
-               ret.duration = (unsigned long long) ktime_to_ns(delta) >> 10;
-               trace_boot_ret(&ret, fn);
-               printk("initcall %pF returned %d after %Ld usecs\n", fn,
-                       ret.result, ret.duration);
-       }
+       if (initcall_debug)
+               ret = do_one_initcall_debug(fn);
+       else
+               ret = fn();
 
        msgbuf[0] = 0;
 
-       if (ret.result && ret.result != -ENODEV && initcall_debug)
-               sprintf(msgbuf, "error code %d ", ret.result);
+       if (ret && ret != -ENODEV && initcall_debug)
+               sprintf(msgbuf, "error code %d ", ret);
 
        if (preempt_count() != count) {
                strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
@@ -752,7 +763,7 @@ int do_one_initcall(initcall_t fn)
                printk("initcall %pF returned with %s\n", fn, msgbuf);
        }
 
-       return ret.result;
+       return ret;
 }
 
 
@@ -760,10 +771,10 @@ extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
 
 static void __init do_initcalls(void)
 {
-       initcall_t *call;
+       initcall_t *fn;
 
-       for (call = __early_initcall_end; call < __initcall_end; call++)
-               do_one_initcall(*call);
+       for (fn = __early_initcall_end; fn < __initcall_end; fn++)
+               do_one_initcall(*fn);
 
        /* Make sure there is no pending stuff from the initcall sequence */
        flush_scheduled_work();
@@ -778,7 +789,6 @@ static void __init do_initcalls(void)
  */
 static void __init do_basic_setup(void)
 {
-       init_workqueues();
        cpuset_init_smp();
        usermodehelper_init();
        init_tmpfs();
@@ -790,13 +800,13 @@ static void __init do_basic_setup(void)
 
 static void __init do_pre_smp_initcalls(void)
 {
-       initcall_t *call;
+       initcall_t *fn;
 
-       for (call = __initcall_start; call < __early_initcall_end; call++)
-               do_one_initcall(*call);
+       for (fn = __initcall_start; fn < __early_initcall_end; fn++)
+               do_one_initcall(*fn);
 }
 
-static void run_init_process(char *init_filename)
+static void run_init_process(const char *init_filename)
 {
        argv_init[0] = init_filename;
        kernel_execve(init_filename, argv_init, envp_init);
@@ -806,21 +816,14 @@ static void run_init_process(char *init_filename)
  * makes it inline to init() and it becomes part of init.text section
  */
 static noinline int init_post(void)
-       __releases(kernel_lock)
 {
        /* need to finish all async __init code before freeing the memory */
        async_synchronize_full();
        free_initmem();
-       unlock_kernel();
        mark_rodata_ro();
        system_state = SYSTEM_RUNNING;
        numa_default_policy();
 
-       if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
-               printk(KERN_WARNING "Warning: unable to open an initial console.\n");
-
-       (void) sys_dup(0);
-       (void) sys_dup(0);
 
        current->signal->flags |= SIGNAL_UNKILLABLE;
 
@@ -846,17 +849,20 @@ static noinline int init_post(void)
        run_init_process("/bin/init");
        run_init_process("/bin/sh");
 
-       panic("No init found.  Try passing init= option to kernel.");
+       panic("No init found.  Try passing init= option to kernel. "
+             "See Linux Documentation/init.txt for guidance.");
 }
 
 static int __init kernel_init(void * unused)
 {
-       lock_kernel();
-
+       /*
+        * Wait until kthreadd is all set-up.
+        */
+       wait_for_completion(&kthreadd_done);
        /*
         * init can allocate pages on any node
         */
-       set_mems_allowed(node_possible_map);
+       set_mems_allowed(node_states[N_HIGH_MEMORY]);
        /*
         * init can run on any cpu.
         */
@@ -876,13 +882,18 @@ static int __init kernel_init(void * unused)
        smp_prepare_cpus(setup_max_cpus);
 
        do_pre_smp_initcalls();
-       start_boot_trace();
 
        smp_init();
        sched_init_smp();
 
        do_basic_setup();
 
+       /* Open the /dev/console on the rootfs, this should never fail */
+       if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
+               printk(KERN_WARNING "Warning: unable to open an initial console.\n");
+
+       (void) sys_dup(0);
+       (void) sys_dup(0);
        /*
         * check if there is an early userspace init.  If yes, let it do all
         * the work