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