source: src/linux/universal/linux-4.9/init/main.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 2 months ago

kernel update

File size: 24.8 KB
Line 
1/*
2 *  linux/init/main.c
3 *
4 *  Copyright (C) 1991, 1992  Linus Torvalds
5 *
6 *  GK 2/5/95  -  Changed to support mounting root fs via NFS
7 *  Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96
8 *  Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96
9 *  Simplified starting of init:  Michael A. Griffith <grif@acm.org>
10 */
11
12#define DEBUG           /* Enable initcall_debug */
13
14#include <linux/types.h>
15#include <linux/module.h>
16#include <linux/proc_fs.h>
17#include <linux/kernel.h>
18#include <linux/syscalls.h>
19#include <linux/stackprotector.h>
20#include <linux/string.h>
21#include <linux/ctype.h>
22#include <linux/delay.h>
23#include <linux/ioport.h>
24#include <linux/init.h>
25#include <linux/initrd.h>
26#include <linux/bootmem.h>
27#include <linux/acpi.h>
28#include <linux/tty.h>
29#include <linux/percpu.h>
30#include <linux/kmod.h>
31#include <linux/vmalloc.h>
32#include <linux/kernel_stat.h>
33#include <linux/start_kernel.h>
34#include <linux/security.h>
35#include <linux/smp.h>
36#include <linux/profile.h>
37#include <linux/rcupdate.h>
38#include <linux/moduleparam.h>
39#include <linux/kallsyms.h>
40#include <linux/writeback.h>
41#include <linux/cpu.h>
42#include <linux/cpuset.h>
43#include <linux/cgroup.h>
44#include <linux/efi.h>
45#include <linux/tick.h>
46#include <linux/interrupt.h>
47#include <linux/taskstats_kern.h>
48#include <linux/delayacct.h>
49#include <linux/unistd.h>
50#include <linux/rmap.h>
51#include <linux/mempolicy.h>
52#include <linux/key.h>
53#include <linux/buffer_head.h>
54#include <linux/page_ext.h>
55#include <linux/debug_locks.h>
56#include <linux/debugobjects.h>
57#include <linux/lockdep.h>
58#include <linux/kmemleak.h>
59#include <linux/pid_namespace.h>
60#include <linux/device.h>
61#include <linux/kthread.h>
62#include <linux/sched.h>
63#include <linux/signal.h>
64#include <linux/idr.h>
65#include <linux/kgdb.h>
66#include <linux/ftrace.h>
67#include <linux/async.h>
68#include <linux/kmemcheck.h>
69#include <linux/sfi.h>
70#include <linux/shmem_fs.h>
71#include <linux/slab.h>
72#include <linux/perf_event.h>
73#include <linux/file.h>
74#include <linux/ptrace.h>
75#include <linux/blkdev.h>
76#include <linux/elevator.h>
77#include <linux/sched_clock.h>
78#include <linux/context_tracking.h>
79#include <linux/random.h>
80#include <linux/list.h>
81#include <linux/integrity.h>
82#include <linux/proc_ns.h>
83#include <linux/io.h>
84
85#include <asm/io.h>
86#include <asm/bugs.h>
87#include <asm/setup.h>
88#include <asm/sections.h>
89#include <asm/cacheflush.h>
90
91static int kernel_init(void *);
92
93extern void init_IRQ(void);
94extern void fork_init(void);
95extern void radix_tree_init(void);
96
97/*
98 * Debug helper: via this flag we know that we are in 'early bootup code'
99 * where only the boot processor is running with IRQ disabled.  This means
100 * two things - IRQ must not be enabled before the flag is cleared and some
101 * operations which are not allowed with IRQ disabled are allowed while the
102 * flag is set.
103 */
104bool early_boot_irqs_disabled __read_mostly;
105
106enum system_states system_state __read_mostly;
107EXPORT_SYMBOL(system_state);
108
109/*
110 * Boot command-line arguments
111 */
112#define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT
113#define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT
114
115extern void time_init(void);
116/* Default late time init is NULL. archs can override this later. */
117void (*__initdata late_time_init)(void);
118
119/* Untouched command line saved by arch-specific code. */
120char __initdata boot_command_line[COMMAND_LINE_SIZE];
121/* Untouched saved command line (eg. for /proc) */
122char *saved_command_line;
123EXPORT_SYMBOL(saved_command_line);
124/* Command line for parameter parsing */
125static char *static_command_line;
126/* Command line for per-initcall parameter parsing */
127static char *initcall_command_line;
128
129static char *execute_command;
130static char *ramdisk_execute_command;
131
132/*
133 * Used to generate warnings if static_key manipulation functions are used
134 * before jump_label_init is called.
135 */
136bool static_key_initialized __read_mostly;
137EXPORT_SYMBOL_GPL(static_key_initialized);
138
139/*
140 * If set, this is an indication to the drivers that reset the underlying
141 * device before going ahead with the initialization otherwise driver might
142 * rely on the BIOS and skip the reset operation.
143 *
144 * This is useful if kernel is booting in an unreliable environment.
145 * For ex. kdump situation where previous kernel has crashed, BIOS has been
146 * skipped and devices will be in unknown state.
147 */
148unsigned int reset_devices;
149EXPORT_SYMBOL(reset_devices);
150
151static int __init set_reset_devices(char *str)
152{
153        reset_devices = 1;
154        return 1;
155}
156
157__setup("reset_devices", set_reset_devices);
158
159static const char *argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
160const char *envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
161static const char *panic_later, *panic_param;
162
163extern const struct obs_kernel_param __setup_start[], __setup_end[];
164
165static bool __init obsolete_checksetup(char *line)
166{
167        const struct obs_kernel_param *p;
168        bool had_early_param = false;
169
170        p = __setup_start;
171        do {
172                int n = strlen(p->str);
173                if (parameqn(line, p->str, n)) {
174                        if (p->early) {
175                                /* Already done in parse_early_param?
176                                 * (Needs exact match on param part).
177                                 * Keep iterating, as we can have early
178                                 * params and __setups of same names 8( */
179                                if (line[n] == '\0' || line[n] == '=')
180                                        had_early_param = true;
181                        } else if (!p->setup_func) {
182                                pr_warn("Parameter %s is obsolete, ignored\n",
183                                        p->str);
184                                return true;
185                        } else if (p->setup_func(line + n))
186                                return true;
187                }
188                p++;
189        } while (p < __setup_end);
190
191        return had_early_param;
192}
193
194/*
195 * This should be approx 2 Bo*oMips to start (note initial shift), and will
196 * still work even if initially too large, it will just take slightly longer
197 */
198unsigned long loops_per_jiffy = (1<<12);
199EXPORT_SYMBOL(loops_per_jiffy);
200
201static int __init debug_kernel(char *str)
202{
203        console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
204        return 0;
205}
206
207static int __init quiet_kernel(char *str)
208{
209        console_loglevel = CONSOLE_LOGLEVEL_QUIET;
210        return 0;
211}
212
213early_param("debug", debug_kernel);
214early_param("quiet", quiet_kernel);
215
216static int __init loglevel(char *str)
217{
218        int newlevel;
219
220        /*
221         * Only update loglevel value when a correct setting was passed,
222         * to prevent blind crashes (when loglevel being set to 0) that
223         * are quite hard to debug
224         */
225        if (get_option(&str, &newlevel)) {
226                console_loglevel = newlevel;
227                return 0;
228        }
229
230        return -EINVAL;
231}
232
233early_param("loglevel", loglevel);
234
235/* Change NUL term back to "=", to make "param" the whole string. */
236static int __init repair_env_string(char *param, char *val,
237                                    const char *unused, void *arg)
238{
239        if (val) {
240                /* param=val or param="val"? */
241                if (val == param+strlen(param)+1)
242                        val[-1] = '=';
243                else if (val == param+strlen(param)+2) {
244                        val[-2] = '=';
245                        memmove(val-1, val, strlen(val)+1);
246                        val--;
247                } else
248                        BUG();
249        }
250        return 0;
251}
252
253/* Anything after -- gets handed straight to init. */
254static int __init set_init_arg(char *param, char *val,
255                               const char *unused, void *arg)
256{
257        unsigned int i;
258
259        if (panic_later)
260                return 0;
261
262        repair_env_string(param, val, unused, NULL);
263
264        for (i = 0; argv_init[i]; i++) {
265                if (i == MAX_INIT_ARGS) {
266                        panic_later = "init";
267                        panic_param = param;
268                        return 0;
269                }
270        }
271        argv_init[i] = param;
272        return 0;
273}
274
275/*
276 * Unknown boot options get handed to init, unless they look like
277 * unused parameters (modprobe will find them in /proc/cmdline).
278 */
279static int __init unknown_bootoption(char *param, char *val,
280                                     const char *unused, void *arg)
281{
282        repair_env_string(param, val, unused, NULL);
283
284        /* Handle obsolete-style parameters */
285        if (obsolete_checksetup(param))
286                return 0;
287
288        /* Unused module parameter. */
289        if (strchr(param, '.') && (!val || strchr(param, '.') < val))
290                return 0;
291
292        if (panic_later)
293                return 0;
294
295        if (val) {
296                /* Environment option */
297                unsigned int i;
298                for (i = 0; envp_init[i]; i++) {
299                        if (i == MAX_INIT_ENVS) {
300                                panic_later = "env";
301                                panic_param = param;
302                        }
303                        if (!strncmp(param, envp_init[i], val - param))
304                                break;
305                }
306                envp_init[i] = param;
307        } else {
308                /* Command line option */
309                unsigned int i;
310                for (i = 0; argv_init[i]; i++) {
311                        if (i == MAX_INIT_ARGS) {
312                                panic_later = "init";
313                                panic_param = param;
314                        }
315                }
316                argv_init[i] = param;
317        }
318        return 0;
319}
320
321static int __init init_setup(char *str)
322{
323        unsigned int i;
324
325        execute_command = str;
326        /*
327         * In case LILO is going to boot us with default command line,
328         * it prepends "auto" before the whole cmdline which makes
329         * the shell think it should execute a script with such name.
330         * So we ignore all arguments entered _before_ init=... [MJ]
331         */
332        for (i = 1; i < MAX_INIT_ARGS; i++)
333                argv_init[i] = NULL;
334        return 1;
335}
336__setup("init=", init_setup);
337
338static int __init rdinit_setup(char *str)
339{
340        unsigned int i;
341
342        ramdisk_execute_command = str;
343        /* See "auto" comment in init_setup */
344        for (i = 1; i < MAX_INIT_ARGS; i++)
345                argv_init[i] = NULL;
346        return 1;
347}
348__setup("rdinit=", rdinit_setup);
349
350#ifndef CONFIG_SMP
351static const unsigned int setup_max_cpus = NR_CPUS;
352static inline void setup_nr_cpu_ids(void) { }
353static inline void smp_prepare_cpus(unsigned int maxcpus) { }
354#endif
355
356/*
357 * We need to store the untouched command line for future reference.
358 * We also need to store the touched command line since the parameter
359 * parsing is performed in place, and we should allow a component to
360 * store reference of name/value for future reference.
361 */
362static void __init setup_command_line(char *command_line)
363{
364        saved_command_line =
365                memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
366        initcall_command_line =
367                memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
368        static_command_line = memblock_virt_alloc(strlen(command_line) + 1, 0);
369        strcpy(saved_command_line, boot_command_line);
370        strcpy(static_command_line, command_line);
371}
372
373/*
374 * We need to finalize in a non-__init function or else race conditions
375 * between the root thread and the init thread may cause start_kernel to
376 * be reaped by free_initmem before the root thread has proceeded to
377 * cpu_idle.
378 *
379 * gcc-3.4 accidentally inlines this function, so use noinline.
380 */
381
382static __initdata DECLARE_COMPLETION(kthreadd_done);
383
384static noinline void __ref rest_init(void)
385{
386        int pid;
387
388        rcu_scheduler_starting();
389        /*
390         * We need to spawn init first so that it obtains pid 1, however
391         * the init task will end up wanting to create kthreads, which, if
392         * we schedule it before we create kthreadd, will OOPS.
393         */
394        kernel_thread(kernel_init, NULL, CLONE_FS);
395        numa_default_policy();
396        pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
397        rcu_read_lock();
398        kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
399        rcu_read_unlock();
400        complete(&kthreadd_done);
401
402        /*
403         * The boot idle thread must execute schedule()
404         * at least once to get things moving:
405         */
406        init_idle_bootup_task(current);
407        schedule_preempt_disabled();
408        /* Call into cpu_idle with preempt disabled */
409        cpu_startup_entry(CPUHP_ONLINE);
410}
411
412/* Check for early params. */
413static int __init do_early_param(char *param, char *val,
414                                 const char *unused, void *arg)
415{
416        const struct obs_kernel_param *p;
417
418        for (p = __setup_start; p < __setup_end; p++) {
419                if ((p->early && parameq(param, p->str)) ||
420                    (strcmp(param, "console") == 0 &&
421                     strcmp(p->str, "earlycon") == 0)
422                ) {
423                        if (p->setup_func(val) != 0)
424                                pr_warn("Malformed early option '%s'\n", param);
425                }
426        }
427        /* We accept everything at this stage. */
428        return 0;
429}
430
431void __init parse_early_options(char *cmdline)
432{
433        parse_args("early options", cmdline, NULL, 0, 0, 0, NULL,
434                   do_early_param);
435}
436
437/* Arch code calls this early on, or if not, just before other parsing. */
438void __init parse_early_param(void)
439{
440        static int done __initdata;
441        static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
442
443        if (done)
444                return;
445
446        /* All fall through to do_early_param. */
447        strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
448        parse_early_options(tmp_cmdline);
449        done = 1;
450}
451
452void __init __weak smp_setup_processor_id(void)
453{
454}
455
456# if THREAD_SIZE >= PAGE_SIZE
457void __init __weak thread_stack_cache_init(void)
458{
459}
460#endif
461
462/*
463 * Set up kernel memory allocators
464 */
465static void __init mm_init(void)
466{
467        /*
468         * page_ext requires contiguous pages,
469         * bigger than MAX_ORDER unless SPARSEMEM.
470         */
471        page_ext_init_flatmem();
472        mem_init();
473        kmem_cache_init();
474        percpu_init_late();
475        pgtable_init();
476        vmalloc_init();
477        ioremap_huge_init();
478}
479
480asmlinkage __visible void __init start_kernel(void)
481{
482        char *command_line;
483        char *after_dashes;
484
485        set_task_stack_end_magic(&init_task);
486        smp_setup_processor_id();
487        debug_objects_early_init();
488
489        /*
490         * Set up the the initial canary ASAP:
491         */
492        boot_init_stack_canary();
493
494        cgroup_init_early();
495
496        local_irq_disable();
497        early_boot_irqs_disabled = true;
498
499/*
500 * Interrupts are still disabled. Do necessary setups, then
501 * enable them
502 */
503        boot_cpu_init();
504        page_address_init();
505        pr_notice("%s", linux_banner);
506        setup_arch(&command_line);
507        mm_init_cpumask(&init_mm);
508        setup_command_line(command_line);
509        setup_nr_cpu_ids();
510        setup_per_cpu_areas();
511        boot_cpu_state_init();
512        smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
513
514        build_all_zonelists(NULL, NULL);
515        page_alloc_init();
516
517        pr_notice("Kernel command line: %s\n", boot_command_line);
518        parse_early_param();
519        after_dashes = parse_args("Booting kernel",
520                                  static_command_line, __start___param,
521                                  __stop___param - __start___param,
522                                  -1, -1, NULL, &unknown_bootoption);
523        if (!IS_ERR_OR_NULL(after_dashes))
524                parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
525                           NULL, set_init_arg);
526
527        jump_label_init();
528
529        /*
530         * These use large bootmem allocations and must precede
531         * kmem_cache_init()
532         */
533        setup_log_buf(0);
534        pidhash_init();
535        vfs_caches_init_early();
536        sort_main_extable();
537        trap_init();
538        mm_init();
539
540        /*
541         * Set up the scheduler prior starting any interrupts (such as the
542         * timer interrupt). Full topology setup happens at smp_init()
543         * time - but meanwhile we still have a functioning scheduler.
544         */
545        sched_init();
546        /*
547         * Disable preemption - early bootup scheduling is extremely
548         * fragile until we cpu_idle() for the first time.
549         */
550        preempt_disable();
551        if (WARN(!irqs_disabled(),
552                 "Interrupts were enabled *very* early, fixing it\n"))
553                local_irq_disable();
554        idr_init_cache();
555        rcu_init();
556
557        /* trace_printk() and trace points may be used after this */
558        trace_init();
559
560        context_tracking_init();
561        radix_tree_init();
562        /* init some links before init_ISA_irqs() */
563        early_irq_init();
564        init_IRQ();
565        tick_init();
566        rcu_init_nohz();
567        init_timers();
568        hrtimers_init();
569        softirq_init();
570        timekeeping_init();
571        time_init();
572        sched_clock_postinit();
573        printk_nmi_init();
574        perf_event_init();
575        profile_init();
576        call_function_init();
577        WARN(!irqs_disabled(), "Interrupts were enabled early\n");
578        early_boot_irqs_disabled = false;
579        local_irq_enable();
580
581        kmem_cache_init_late();
582
583        /*
584         * HACK ALERT! This is early. We're enabling the console before
585         * we've done PCI setups etc, and console_init() must be aware of
586         * this. But we do want output early, in case something goes wrong.
587         */
588        console_init();
589        if (panic_later)
590                panic("Too many boot %s vars at `%s'", panic_later,
591                      panic_param);
592
593        lockdep_info();
594
595        /*
596         * Need to run this when irqs are enabled, because it wants
597         * to self-test [hard/soft]-irqs on/off lock inversion bugs
598         * too:
599         */
600        locking_selftest();
601
602#ifdef CONFIG_BLK_DEV_INITRD
603        if (initrd_start && !initrd_below_start_ok &&
604            page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
605                pr_crit("initrd overwritten (0x%08lx < 0x%08lx) - disabling it.\n",
606                    page_to_pfn(virt_to_page((void *)initrd_start)),
607                    min_low_pfn);
608                initrd_start = 0;
609        }
610#endif
611        page_ext_init();
612        debug_objects_mem_init();
613        kmemleak_init();
614        setup_per_cpu_pageset();
615        numa_policy_init();
616        if (late_time_init)
617                late_time_init();
618        sched_clock_init();
619        calibrate_delay();
620        pidmap_init();
621        anon_vma_init();
622        acpi_early_init();
623#ifdef CONFIG_X86
624        if (efi_enabled(EFI_RUNTIME_SERVICES))
625                efi_enter_virtual_mode();
626#endif
627#ifdef CONFIG_X86_ESPFIX64
628        /* Should be run before the first non-init thread is created */
629        init_espfix_bsp();
630#endif
631        thread_stack_cache_init();
632        cred_init();
633        fork_init();
634        proc_caches_init();
635        buffer_init();
636        key_init();
637        security_init();
638        dbg_late_init();
639        vfs_caches_init();
640        signals_init();
641        /* rootfs populating might need page-writeback */
642        page_writeback_init();
643        proc_root_init();
644        nsfs_init();
645        cpuset_init();
646        cgroup_init();
647        taskstats_init_early();
648        delayacct_init();
649
650        check_bugs();
651
652        acpi_subsystem_init();
653        sfi_init_late();
654
655        if (efi_enabled(EFI_RUNTIME_SERVICES)) {
656                efi_late_init();
657                efi_free_boot_services();
658        }
659
660        ftrace_init();
661
662        /* Do the rest non-__init'ed, we're now alive */
663        rest_init();
664}
665
666/* Call all constructor functions linked into the kernel. */
667static void __init do_ctors(void)
668{
669#ifdef CONFIG_CONSTRUCTORS
670        ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
671
672        for (; fn < (ctor_fn_t *) __ctors_end; fn++)
673                (*fn)();
674#endif
675}
676
677bool initcall_debug;
678core_param(initcall_debug, initcall_debug, bool, 0644);
679
680#ifdef CONFIG_KALLSYMS
681struct blacklist_entry {
682        struct list_head next;
683        char *buf;
684};
685
686static __initdata_or_module LIST_HEAD(blacklisted_initcalls);
687
688static int __init initcall_blacklist(char *str)
689{
690        char *str_entry;
691        struct blacklist_entry *entry;
692
693        /* str argument is a comma-separated list of functions */
694        do {
695                str_entry = strsep(&str, ",");
696                if (str_entry) {
697                        pr_debug("blacklisting initcall %s\n", str_entry);
698                        entry = alloc_bootmem(sizeof(*entry));
699                        entry->buf = alloc_bootmem(strlen(str_entry) + 1);
700                        strcpy(entry->buf, str_entry);
701                        list_add(&entry->next, &blacklisted_initcalls);
702                }
703        } while (str_entry);
704
705        return 0;
706}
707
708static bool __init_or_module initcall_blacklisted(initcall_t fn)
709{
710        struct blacklist_entry *entry;
711        char fn_name[KSYM_SYMBOL_LEN];
712        unsigned long addr;
713
714        if (list_empty(&blacklisted_initcalls))
715                return false;
716
717        addr = (unsigned long) dereference_function_descriptor(fn);
718        sprint_symbol_no_offset(fn_name, addr);
719
720        /*
721         * fn will be "function_name [module_name]" where [module_name] is not
722         * displayed for built-in init functions.  Strip off the [module_name].
723         */
724        strreplace(fn_name, ' ', '\0');
725
726        list_for_each_entry(entry, &blacklisted_initcalls, next) {
727                if (!strcmp(fn_name, entry->buf)) {
728                        pr_debug("initcall %s blacklisted\n", fn_name);
729                        return true;
730                }
731        }
732
733        return false;
734}
735#else
736static int __init initcall_blacklist(char *str)
737{
738        pr_warn("initcall_blacklist requires CONFIG_KALLSYMS\n");
739        return 0;
740}
741
742static bool __init_or_module initcall_blacklisted(initcall_t fn)
743{
744        return false;
745}
746#endif
747__setup("initcall_blacklist=", initcall_blacklist);
748
749static int __init_or_module do_one_initcall_debug(initcall_t fn)
750{
751        ktime_t calltime, delta, rettime;
752        unsigned long long duration;
753        int ret;
754
755        printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
756        calltime = ktime_get();
757        ret = fn();
758        rettime = ktime_get();
759        delta = ktime_sub(rettime, calltime);
760        duration = (unsigned long long) ktime_to_ns(delta) >> 10;
761        printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n",
762                 fn, ret, duration);
763
764        return ret;
765}
766
767int __init_or_module do_one_initcall(initcall_t fn)
768{
769        int count = preempt_count();
770        int ret;
771        char msgbuf[64];
772
773        if (initcall_blacklisted(fn))
774                return -EPERM;
775
776        if (initcall_debug)
777                ret = do_one_initcall_debug(fn);
778        else
779                ret = fn();
780
781        msgbuf[0] = 0;
782
783        if (preempt_count() != count) {
784                sprintf(msgbuf, "preemption imbalance ");
785                preempt_count_set(count);
786        }
787        if (irqs_disabled()) {
788                strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
789                local_irq_enable();
790        }
791        WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
792
793        add_latent_entropy();
794        return ret;
795}
796
797
798extern initcall_t __initcall_start[];
799extern initcall_t __initcall0_start[];
800extern initcall_t __initcall1_start[];
801extern initcall_t __initcall2_start[];
802extern initcall_t __initcall3_start[];
803extern initcall_t __initcall4_start[];
804extern initcall_t __initcall5_start[];
805extern initcall_t __initcall6_start[];
806extern initcall_t __initcall7_start[];
807extern initcall_t __initcall_end[];
808
809static initcall_t *initcall_levels[] __initdata = {
810        __initcall0_start,
811        __initcall1_start,
812        __initcall2_start,
813        __initcall3_start,
814        __initcall4_start,
815        __initcall5_start,
816        __initcall6_start,
817        __initcall7_start,
818        __initcall_end,
819};
820
821/* Keep these in sync with initcalls in include/linux/init.h */
822static char *initcall_level_names[] __initdata = {
823        "early",
824        "core",
825        "postcore",
826        "arch",
827        "subsys",
828        "fs",
829        "device",
830        "late",
831};
832
833static void __init do_initcall_level(int level)
834{
835        initcall_t *fn;
836
837        strcpy(initcall_command_line, saved_command_line);
838        parse_args(initcall_level_names[level],
839                   initcall_command_line, __start___param,
840                   __stop___param - __start___param,
841                   level, level,
842                   NULL, &repair_env_string);
843
844        for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
845                do_one_initcall(*fn);
846}
847
848static void __init do_initcalls(void)
849{
850        int level;
851
852        for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
853                do_initcall_level(level);
854}
855
856/*
857 * Ok, the machine is now initialized. None of the devices
858 * have been touched yet, but the CPU subsystem is up and
859 * running, and memory and process management works.
860 *
861 * Now we can finally start doing some real work..
862 */
863static void __init do_basic_setup(void)
864{
865        cpuset_init_smp();
866        shmem_init();
867        driver_init();
868        init_irq_proc();
869        do_ctors();
870        usermodehelper_enable();
871        do_initcalls();
872}
873
874static void __init do_pre_smp_initcalls(void)
875{
876        initcall_t *fn;
877
878        for (fn = __initcall_start; fn < __initcall0_start; fn++)
879                do_one_initcall(*fn);
880}
881
882/*
883 * This function requests modules which should be loaded by default and is
884 * called twice right after initrd is mounted and right before init is
885 * exec'd.  If such modules are on either initrd or rootfs, they will be
886 * loaded before control is passed to userland.
887 */
888void __init load_default_modules(void)
889{
890        load_default_elevator_module();
891}
892
893static int run_init_process(const char *init_filename)
894{
895        argv_init[0] = init_filename;
896        return do_execve(getname_kernel(init_filename),
897                (const char __user *const __user *)argv_init,
898                (const char __user *const __user *)envp_init);
899}
900
901static int try_to_run_init_process(const char *init_filename)
902{
903        int ret;
904
905        ret = run_init_process(init_filename);
906
907        if (ret && ret != -ENOENT) {
908                pr_err("Starting init: %s exists but couldn't execute it (error %d)\n",
909                       init_filename, ret);
910        }
911
912        return ret;
913}
914
915static noinline void __init kernel_init_freeable(void);
916
917#ifdef CONFIG_DEBUG_RODATA
918static bool rodata_enabled = true;
919static int __init set_debug_rodata(char *str)
920{
921        return strtobool(str, &rodata_enabled);
922}
923__setup("rodata=", set_debug_rodata);
924
925static void mark_readonly(void)
926{
927        if (rodata_enabled)
928                mark_rodata_ro();
929        else
930                pr_info("Kernel memory protection disabled.\n");
931}
932#else
933static inline void mark_readonly(void)
934{
935        pr_warn("This architecture does not have kernel memory protection.\n");
936}
937#endif
938
939static int __ref kernel_init(void *unused)
940{
941        int ret;
942
943        kernel_init_freeable();
944        /* need to finish all async __init code before freeing the memory */
945        async_synchronize_full();
946        free_initmem();
947        mark_readonly();
948        system_state = SYSTEM_RUNNING;
949        numa_default_policy();
950
951        flush_delayed_fput();
952
953        rcu_end_inkernel_boot();
954
955        if (ramdisk_execute_command) {
956                if (!run_init_process(execute_command))
957                        return 0;
958                pr_err("Failed to execute %s\n", ramdisk_execute_command);
959        }
960
961        /*
962         * We try each of these until one succeeds.
963         *
964         * The Bourne shell can be used instead of init if we are
965         * trying to recover a really broken machine.
966         */
967/*      if (execute_command) {
968                ret = run_init_process(execute_command);
969                if (!ret)
970                        return 0;
971                panic("Requested init %s failed (error %d).",
972                      execute_command, ret);
973        }*/
974        if (!run_init_process("/sbin/init"))
975                return 0;
976
977        panic("No init found.  Try passing init= option to kernel. "
978              "See Linux Documentation/init.txt for guidance.");
979}
980
981static noinline void __init kernel_init_freeable(void)
982{
983        /*
984         * Wait until kthreadd is all set-up.
985         */
986        wait_for_completion(&kthreadd_done);
987
988        /* Now the scheduler is fully set up and can do blocking allocations */
989        gfp_allowed_mask = __GFP_BITS_MASK;
990
991        /*
992         * init can allocate pages on any node
993         */
994        set_mems_allowed(node_states[N_MEMORY]);
995        /*
996         * init can run on any cpu.
997         */
998        set_cpus_allowed_ptr(current, cpu_all_mask);
999
1000        cad_pid = task_pid(current);
1001
1002        smp_prepare_cpus(setup_max_cpus);
1003
1004        do_pre_smp_initcalls();
1005        lockup_detector_init();
1006
1007        smp_init();
1008        sched_init_smp();
1009
1010        page_alloc_init_late();
1011
1012        do_basic_setup();
1013
1014        /* Open the /dev/console on the rootfs, this should never fail */
1015        if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
1016                printk(KERN_WARNING "Please be patient, while System loads ...\n");
1017
1018        (void) sys_dup(0);
1019        (void) sys_dup(0);
1020        /*
1021         * check if there is an early userspace init.  If yes, let it do all
1022         * the work
1023         */
1024
1025        if (!ramdisk_execute_command)
1026                ramdisk_execute_command = "/init";
1027
1028        if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
1029                ramdisk_execute_command = NULL;
1030                prepare_namespace();
1031        }
1032
1033        /*
1034         * Ok, we have completed the initial bootup, and
1035         * we're essentially up and running. Get rid of the
1036         * initmem segments and start the user-mode stuff..
1037         *
1038         * rootfs is available now, try loading the public keys
1039         * and default modules
1040         */
1041
1042        integrity_load_keys();
1043        load_default_modules();
1044}
Note: See TracBrowser for help on using the repository browser.