1
2
3
4
5
6
7
8
9
10
11
12#define 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#ifndef CONFIG_DEBUG_RODATA
97static inline void mark_rodata_ro(void) { }
98#endif
99
100
101
102
103
104
105
106
107bool early_boot_irqs_disabled __read_mostly;
108
109enum system_states system_state __read_mostly;
110EXPORT_SYMBOL(system_state);
111
112
113
114
115#define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT
116#define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT
117
118extern void time_init(void);
119
120void (*__initdata late_time_init)(void);
121
122
123char __initdata boot_command_line[COMMAND_LINE_SIZE];
124
125char *saved_command_line;
126
127static char *static_command_line;
128
129static char *initcall_command_line;
130
131static char *execute_command;
132static char *ramdisk_execute_command;
133
134
135
136
137
138bool static_key_initialized __read_mostly;
139EXPORT_SYMBOL_GPL(static_key_initialized);
140
141
142
143
144
145
146
147
148
149
150unsigned int reset_devices;
151EXPORT_SYMBOL(reset_devices);
152
153static int __init set_reset_devices(char *str)
154{
155 reset_devices = 1;
156 return 1;
157}
158
159__setup("reset_devices", set_reset_devices);
160
161static const char *argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
162const char *envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
163static const char *panic_later, *panic_param;
164
165extern const struct obs_kernel_param __setup_start[], __setup_end[];
166
167static int __init obsolete_checksetup(char *line)
168{
169 const struct obs_kernel_param *p;
170 int had_early_param = 0;
171
172 p = __setup_start;
173 do {
174 int n = strlen(p->str);
175 if (parameqn(line, p->str, n)) {
176 if (p->early) {
177
178
179
180
181 if (line[n] == '\0' || line[n] == '=')
182 had_early_param = 1;
183 } else if (!p->setup_func) {
184 pr_warn("Parameter %s is obsolete, ignored\n",
185 p->str);
186 return 1;
187 } else if (p->setup_func(line + n))
188 return 1;
189 }
190 p++;
191 } while (p < __setup_end);
192
193 return had_early_param;
194}
195
196
197
198
199
200unsigned long loops_per_jiffy = (1<<12);
201EXPORT_SYMBOL(loops_per_jiffy);
202
203static int __init debug_kernel(char *str)
204{
205 console_loglevel = CONSOLE_LOGLEVEL_DEBUG;
206 return 0;
207}
208
209static int __init quiet_kernel(char *str)
210{
211 console_loglevel = CONSOLE_LOGLEVEL_QUIET;
212 return 0;
213}
214
215early_param("debug", debug_kernel);
216early_param("quiet", quiet_kernel);
217
218static int __init loglevel(char *str)
219{
220 int newlevel;
221
222
223
224
225
226
227 if (get_option(&str, &newlevel)) {
228 console_loglevel = newlevel;
229 return 0;
230 }
231
232 return -EINVAL;
233}
234
235early_param("loglevel", loglevel);
236
237
238static int __init repair_env_string(char *param, char *val,
239 const char *unused, void *arg)
240{
241 if (val) {
242
243 if (val == param+strlen(param)+1)
244 val[-1] = '=';
245 else if (val == param+strlen(param)+2) {
246 val[-2] = '=';
247 memmove(val-1, val, strlen(val)+1);
248 val--;
249 } else
250 BUG();
251 }
252 return 0;
253}
254
255
256static int __init set_init_arg(char *param, char *val,
257 const char *unused, void *arg)
258{
259 unsigned int i;
260
261 if (panic_later)
262 return 0;
263
264 repair_env_string(param, val, unused, NULL);
265
266 for (i = 0; argv_init[i]; i++) {
267 if (i == MAX_INIT_ARGS) {
268 panic_later = "init";
269 panic_param = param;
270 return 0;
271 }
272 }
273 argv_init[i] = param;
274 return 0;
275}
276
277
278
279
280
281static int __init unknown_bootoption(char *param, char *val,
282 const char *unused, void *arg)
283{
284 repair_env_string(param, val, unused, NULL);
285
286
287 if (obsolete_checksetup(param))
288 return 0;
289
290
291 if (strchr(param, '.') && (!val || strchr(param, '.') < val))
292 return 0;
293
294 if (panic_later)
295 return 0;
296
297 if (val) {
298
299 unsigned int i;
300 for (i = 0; envp_init[i]; i++) {
301 if (i == MAX_INIT_ENVS) {
302 panic_later = "env";
303 panic_param = param;
304 }
305 if (!strncmp(param, envp_init[i], val - param))
306 break;
307 }
308 envp_init[i] = param;
309 } else {
310
311 unsigned int i;
312 for (i = 0; argv_init[i]; i++) {
313 if (i == MAX_INIT_ARGS) {
314 panic_later = "init";
315 panic_param = param;
316 }
317 }
318 argv_init[i] = param;
319 }
320 return 0;
321}
322
323static int __init init_setup(char *str)
324{
325 unsigned int i;
326
327 execute_command = str;
328
329
330
331
332
333
334 for (i = 1; i < MAX_INIT_ARGS; i++)
335 argv_init[i] = NULL;
336 return 1;
337}
338__setup("init=", init_setup);
339
340static int __init rdinit_setup(char *str)
341{
342 unsigned int i;
343
344 ramdisk_execute_command = str;
345
346 for (i = 1; i < MAX_INIT_ARGS; i++)
347 argv_init[i] = NULL;
348 return 1;
349}
350__setup("rdinit=", rdinit_setup);
351
352#ifndef CONFIG_SMP
353static const unsigned int setup_max_cpus = NR_CPUS;
354static inline void setup_nr_cpu_ids(void) { }
355static inline void smp_prepare_cpus(unsigned int maxcpus) { }
356#endif
357
358
359
360
361
362
363
364static void __init setup_command_line(char *command_line)
365{
366 saved_command_line =
367 memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
368 initcall_command_line =
369 memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
370 static_command_line = memblock_virt_alloc(strlen(command_line) + 1, 0);
371 strcpy(saved_command_line, boot_command_line);
372 strcpy(static_command_line, command_line);
373}
374
375
376
377
378
379
380
381
382
383
384static __initdata DECLARE_COMPLETION(kthreadd_done);
385
386static noinline void __init_refok rest_init(void)
387{
388 int pid;
389
390 rcu_scheduler_starting();
391 smpboot_thread_init();
392
393
394
395
396
397 kernel_thread(kernel_init, NULL, CLONE_FS);
398 numa_default_policy();
399 pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
400 rcu_read_lock();
401 kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
402 rcu_read_unlock();
403 complete(&kthreadd_done);
404
405
406
407
408
409 init_idle_bootup_task(current);
410 schedule_preempt_disabled();
411
412 cpu_startup_entry(CPUHP_ONLINE);
413}
414
415
416static int __init do_early_param(char *param, char *val,
417 const char *unused, void *arg)
418{
419 const struct obs_kernel_param *p;
420
421 for (p = __setup_start; p < __setup_end; p++) {
422 if ((p->early && parameq(param, p->str)) ||
423 (strcmp(param, "console") == 0 &&
424 strcmp(p->str, "earlycon") == 0)
425 ) {
426 if (p->setup_func(val) != 0)
427 pr_warn("Malformed early option '%s'\n", param);
428 }
429 }
430
431 return 0;
432}
433
434void __init parse_early_options(char *cmdline)
435{
436 parse_args("early options", cmdline, NULL, 0, 0, 0, NULL,
437 do_early_param);
438}
439
440
441void __init parse_early_param(void)
442{
443 static int done __initdata;
444 static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
445
446 if (done)
447 return;
448
449
450 strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
451 parse_early_options(tmp_cmdline);
452 done = 1;
453}
454
455
456
457
458
459static void __init boot_cpu_init(void)
460{
461 int cpu = smp_processor_id();
462
463 set_cpu_online(cpu, true);
464 set_cpu_active(cpu, true);
465 set_cpu_present(cpu, true);
466 set_cpu_possible(cpu, true);
467}
468
469void __init __weak smp_setup_processor_id(void)
470{
471}
472
473# if THREAD_SIZE >= PAGE_SIZE
474void __init __weak thread_info_cache_init(void)
475{
476}
477#endif
478
479
480
481
482static void __init mm_init(void)
483{
484
485
486
487
488 page_ext_init_flatmem();
489 mem_init();
490 kmem_cache_init();
491 percpu_init_late();
492 pgtable_init();
493 vmalloc_init();
494 ioremap_huge_init();
495}
496
497asmlinkage __visible void __init start_kernel(void)
498{
499 char *command_line;
500 char *after_dashes;
501
502
503
504
505
506 lockdep_init();
507 set_task_stack_end_magic(&init_task);
508 smp_setup_processor_id();
509 debug_objects_early_init();
510
511
512
513
514 boot_init_stack_canary();
515
516 cgroup_init_early();
517
518 local_irq_disable();
519 early_boot_irqs_disabled = true;
520
521
522
523
524
525 boot_cpu_init();
526 page_address_init();
527 pr_notice("%s", linux_banner);
528 setup_arch(&command_line);
529 mm_init_cpumask(&init_mm);
530 setup_command_line(command_line);
531 setup_nr_cpu_ids();
532 setup_per_cpu_areas();
533 smp_prepare_boot_cpu();
534
535 build_all_zonelists(NULL, NULL);
536 page_alloc_init();
537
538 pr_notice("Kernel command line: %s\n", boot_command_line);
539 parse_early_param();
540 after_dashes = parse_args("Booting kernel",
541 static_command_line, __start___param,
542 __stop___param - __start___param,
543 -1, -1, NULL, &unknown_bootoption);
544 if (!IS_ERR_OR_NULL(after_dashes))
545 parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
546 NULL, set_init_arg);
547
548 jump_label_init();
549
550
551
552
553
554 setup_log_buf(0);
555 pidhash_init();
556 vfs_caches_init_early();
557 sort_main_extable();
558 trap_init();
559 mm_init();
560
561
562
563
564
565
566 sched_init();
567
568
569
570
571 preempt_disable();
572 if (WARN(!irqs_disabled(),
573 "Interrupts were enabled *very* early, fixing it\n"))
574 local_irq_disable();
575 idr_init_cache();
576 rcu_init();
577
578
579 trace_init();
580
581 context_tracking_init();
582 radix_tree_init();
583
584 early_irq_init();
585 init_IRQ();
586 tick_init();
587 rcu_init_nohz();
588 init_timers();
589 hrtimers_init();
590 softirq_init();
591 timekeeping_init();
592 time_init();
593 sched_clock_postinit();
594 perf_event_init();
595 profile_init();
596 call_function_init();
597 WARN(!irqs_disabled(), "Interrupts were enabled early\n");
598 early_boot_irqs_disabled = false;
599 local_irq_enable();
600
601 kmem_cache_init_late();
602
603
604
605
606
607
608 console_init();
609 if (panic_later)
610 panic("Too many boot %s vars at `%s'", panic_later,
611 panic_param);
612
613 lockdep_info();
614
615
616
617
618
619
620 locking_selftest();
621
622#ifdef CONFIG_BLK_DEV_INITRD
623 if (initrd_start && !initrd_below_start_ok &&
624 page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
625 pr_crit("initrd overwritten (0x%08lx < 0x%08lx) - disabling it.\n",
626 page_to_pfn(virt_to_page((void *)initrd_start)),
627 min_low_pfn);
628 initrd_start = 0;
629 }
630#endif
631 page_ext_init();
632 debug_objects_mem_init();
633 kmemleak_init();
634 setup_per_cpu_pageset();
635 numa_policy_init();
636 if (late_time_init)
637 late_time_init();
638 sched_clock_init();
639 calibrate_delay();
640 pidmap_init();
641 anon_vma_init();
642 acpi_early_init();
643#ifdef CONFIG_X86
644 if (efi_enabled(EFI_RUNTIME_SERVICES))
645 efi_enter_virtual_mode();
646#endif
647#ifdef CONFIG_X86_ESPFIX64
648
649 init_espfix_bsp();
650#endif
651 thread_info_cache_init();
652 cred_init();
653 fork_init();
654 proc_caches_init();
655 buffer_init();
656 key_init();
657 security_init();
658 dbg_late_init();
659 vfs_caches_init();
660 signals_init();
661
662 page_writeback_init();
663 proc_root_init();
664 nsfs_init();
665 cpuset_init();
666 cgroup_init();
667 taskstats_init_early();
668 delayacct_init();
669
670 check_bugs();
671
672 acpi_subsystem_init();
673 sfi_init_late();
674
675 if (efi_enabled(EFI_RUNTIME_SERVICES)) {
676 efi_late_init();
677 efi_free_boot_services();
678 }
679
680 ftrace_init();
681
682
683 rest_init();
684}
685
686
687static void __init do_ctors(void)
688{
689#ifdef CONFIG_CONSTRUCTORS
690 ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
691
692 for (; fn < (ctor_fn_t *) __ctors_end; fn++)
693 (*fn)();
694#endif
695}
696
697bool initcall_debug;
698core_param(initcall_debug, initcall_debug, bool, 0644);
699
700#ifdef CONFIG_KALLSYMS
701struct blacklist_entry {
702 struct list_head next;
703 char *buf;
704};
705
706static __initdata_or_module LIST_HEAD(blacklisted_initcalls);
707
708static int __init initcall_blacklist(char *str)
709{
710 char *str_entry;
711 struct blacklist_entry *entry;
712
713
714 do {
715 str_entry = strsep(&str, ",");
716 if (str_entry) {
717 pr_debug("blacklisting initcall %s\n", str_entry);
718 entry = alloc_bootmem(sizeof(*entry));
719 entry->buf = alloc_bootmem(strlen(str_entry) + 1);
720 strcpy(entry->buf, str_entry);
721 list_add(&entry->next, &blacklisted_initcalls);
722 }
723 } while (str_entry);
724
725 return 0;
726}
727
728static bool __init_or_module initcall_blacklisted(initcall_t fn)
729{
730 struct list_head *tmp;
731 struct blacklist_entry *entry;
732 char *fn_name;
733
734 fn_name = kasprintf(GFP_KERNEL, "%pf", fn);
735 if (!fn_name)
736 return false;
737
738 list_for_each(tmp, &blacklisted_initcalls) {
739 entry = list_entry(tmp, struct blacklist_entry, next);
740 if (!strcmp(fn_name, entry->buf)) {
741 pr_debug("initcall %s blacklisted\n", fn_name);
742 kfree(fn_name);
743 return true;
744 }
745 }
746
747 kfree(fn_name);
748 return false;
749}
750#else
751static int __init initcall_blacklist(char *str)
752{
753 pr_warn("initcall_blacklist requires CONFIG_KALLSYMS\n");
754 return 0;
755}
756
757static bool __init_or_module initcall_blacklisted(initcall_t fn)
758{
759 return false;
760}
761#endif
762__setup("initcall_blacklist=", initcall_blacklist);
763
764static int __init_or_module do_one_initcall_debug(initcall_t fn)
765{
766 ktime_t calltime, delta, rettime;
767 unsigned long long duration;
768 int ret;
769
770 printk(KERN_DEBUG "calling %pF @ %i\n", fn, task_pid_nr(current));
771 calltime = ktime_get();
772 ret = fn();
773 rettime = ktime_get();
774 delta = ktime_sub(rettime, calltime);
775 duration = (unsigned long long) ktime_to_ns(delta) >> 10;
776 printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n",
777 fn, ret, duration);
778
779 return ret;
780}
781
782int __init_or_module do_one_initcall(initcall_t fn)
783{
784 int count = preempt_count();
785 int ret;
786 char msgbuf[64];
787
788 if (initcall_blacklisted(fn))
789 return -EPERM;
790
791 if (initcall_debug)
792 ret = do_one_initcall_debug(fn);
793 else
794 ret = fn();
795
796 msgbuf[0] = 0;
797
798 if (preempt_count() != count) {
799 sprintf(msgbuf, "preemption imbalance ");
800 preempt_count_set(count);
801 }
802 if (irqs_disabled()) {
803 strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
804 local_irq_enable();
805 }
806 WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
807
808 return ret;
809}
810
811
812extern initcall_t __initcall_start[];
813extern initcall_t __initcall0_start[];
814extern initcall_t __initcall1_start[];
815extern initcall_t __initcall2_start[];
816extern initcall_t __initcall3_start[];
817extern initcall_t __initcall4_start[];
818extern initcall_t __initcall5_start[];
819extern initcall_t __initcall6_start[];
820extern initcall_t __initcall7_start[];
821extern initcall_t __initcall_end[];
822
823static initcall_t *initcall_levels[] __initdata = {
824 __initcall0_start,
825 __initcall1_start,
826 __initcall2_start,
827 __initcall3_start,
828 __initcall4_start,
829 __initcall5_start,
830 __initcall6_start,
831 __initcall7_start,
832 __initcall_end,
833};
834
835
836static char *initcall_level_names[] __initdata = {
837 "early",
838 "core",
839 "postcore",
840 "arch",
841 "subsys",
842 "fs",
843 "device",
844 "late",
845};
846
847static void __init do_initcall_level(int level)
848{
849 initcall_t *fn;
850
851 strcpy(initcall_command_line, saved_command_line);
852 parse_args(initcall_level_names[level],
853 initcall_command_line, __start___param,
854 __stop___param - __start___param,
855 level, level,
856 NULL, &repair_env_string);
857
858 for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
859 do_one_initcall(*fn);
860}
861
862static void __init do_initcalls(void)
863{
864 int level;
865
866 for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
867 do_initcall_level(level);
868}
869
870
871
872
873
874
875
876
877static void __init do_basic_setup(void)
878{
879 cpuset_init_smp();
880 usermodehelper_init();
881 shmem_init();
882 driver_init();
883 init_irq_proc();
884 do_ctors();
885 usermodehelper_enable();
886 do_initcalls();
887 random_int_secret_init();
888}
889
890static void __init do_pre_smp_initcalls(void)
891{
892 initcall_t *fn;
893
894 for (fn = __initcall_start; fn < __initcall0_start; fn++)
895 do_one_initcall(*fn);
896}
897
898
899
900
901
902
903
904void __init load_default_modules(void)
905{
906 load_default_elevator_module();
907}
908
909static int run_init_process(const char *init_filename)
910{
911 argv_init[0] = init_filename;
912 return do_execve(getname_kernel(init_filename),
913 (const char __user *const __user *)argv_init,
914 (const char __user *const __user *)envp_init);
915}
916
917static int try_to_run_init_process(const char *init_filename)
918{
919 int ret;
920
921 ret = run_init_process(init_filename);
922
923 if (ret && ret != -ENOENT) {
924 pr_err("Starting init: %s exists but couldn't execute it (error %d)\n",
925 init_filename, ret);
926 }
927
928 return ret;
929}
930
931static noinline void __init kernel_init_freeable(void);
932
933static int __ref kernel_init(void *unused)
934{
935 int ret;
936
937 kernel_init_freeable();
938
939 async_synchronize_full();
940 free_initmem();
941 mark_rodata_ro();
942 system_state = SYSTEM_RUNNING;
943 numa_default_policy();
944
945 flush_delayed_fput();
946
947 if (ramdisk_execute_command) {
948 ret = run_init_process(ramdisk_execute_command);
949 if (!ret)
950 return 0;
951 pr_err("Failed to execute %s (error %d)\n",
952 ramdisk_execute_command, ret);
953 }
954
955
956
957
958
959
960
961 if (execute_command) {
962 ret = run_init_process(execute_command);
963 if (!ret)
964 return 0;
965 panic("Requested init %s failed (error %d).",
966 execute_command, ret);
967 }
968 if (!try_to_run_init_process("/sbin/init") ||
969 !try_to_run_init_process("/etc/init") ||
970 !try_to_run_init_process("/bin/init") ||
971 !try_to_run_init_process("/bin/sh"))
972 return 0;
973
974 panic("No working init found. Try passing init= option to kernel. "
975 "See Linux Documentation/init.txt for guidance.");
976}
977
978static noinline void __init kernel_init_freeable(void)
979{
980
981
982
983 wait_for_completion(&kthreadd_done);
984
985
986 gfp_allowed_mask = __GFP_BITS_MASK;
987
988
989
990
991 set_mems_allowed(node_states[N_MEMORY]);
992
993
994
995 set_cpus_allowed_ptr(current, cpu_all_mask);
996
997 cad_pid = task_pid(current);
998
999 smp_prepare_cpus(setup_max_cpus);
1000
1001 do_pre_smp_initcalls();
1002 lockup_detector_init();
1003
1004 smp_init();
1005 sched_init_smp();
1006
1007 page_alloc_init_late();
1008
1009 do_basic_setup();
1010
1011
1012 if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
1013 pr_err("Warning: unable to open an initial console.\n");
1014
1015 (void) sys_dup(0);
1016 (void) sys_dup(0);
1017
1018
1019
1020
1021
1022 if (!ramdisk_execute_command)
1023 ramdisk_execute_command = "/init";
1024
1025 if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
1026 ramdisk_execute_command = NULL;
1027 prepare_namespace();
1028 }
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039 integrity_load_keys();
1040 load_default_modules();
1041}
1042