Blame view
init/main.c
21.9 KB
1da177e4c
|
1 2 3 4 5 6 7 8 9 10 |
/* * linux/init/main.c * * Copyright (C) 1991, 1992 Linus Torvalds * * GK 2/5/95 - Changed to support mounting root fs via NFS * Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96 * Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96 * Simplified starting of init: Michael A. Griffith <grif@acm.org> */ |
ea676e846
|
11 |
#define DEBUG /* Enable initcall_debug */ |
1da177e4c
|
12 13 14 |
#include <linux/types.h> #include <linux/module.h> #include <linux/proc_fs.h> |
1da177e4c
|
15 16 |
#include <linux/kernel.h> #include <linux/syscalls.h> |
9b5609fd7
|
17 |
#include <linux/stackprotector.h> |
1da177e4c
|
18 19 20 |
#include <linux/string.h> #include <linux/ctype.h> #include <linux/delay.h> |
1da177e4c
|
21 22 |
#include <linux/ioport.h> #include <linux/init.h> |
1da177e4c
|
23 |
#include <linux/initrd.h> |
1da177e4c
|
24 |
#include <linux/bootmem.h> |
4a7a16dc0
|
25 |
#include <linux/acpi.h> |
1da177e4c
|
26 |
#include <linux/tty.h> |
1da177e4c
|
27 28 |
#include <linux/percpu.h> #include <linux/kmod.h> |
db64fe022
|
29 |
#include <linux/vmalloc.h> |
1da177e4c
|
30 |
#include <linux/kernel_stat.h> |
d7cd56111
|
31 |
#include <linux/start_kernel.h> |
1da177e4c
|
32 |
#include <linux/security.h> |
3d4422332
|
33 |
#include <linux/smp.h> |
1da177e4c
|
34 35 36 37 38 39 40 |
#include <linux/profile.h> #include <linux/rcupdate.h> #include <linux/moduleparam.h> #include <linux/kallsyms.h> #include <linux/writeback.h> #include <linux/cpu.h> #include <linux/cpuset.h> |
ddbcc7e8e
|
41 |
#include <linux/cgroup.h> |
1da177e4c
|
42 |
#include <linux/efi.h> |
906568c9c
|
43 |
#include <linux/tick.h> |
6168a702a
|
44 |
#include <linux/interrupt.h> |
c757249af
|
45 |
#include <linux/taskstats_kern.h> |
ca74e92b4
|
46 |
#include <linux/delayacct.h> |
1da177e4c
|
47 48 49 50 |
#include <linux/unistd.h> #include <linux/rmap.h> #include <linux/mempolicy.h> #include <linux/key.h> |
b6cd0b772
|
51 |
#include <linux/buffer_head.h> |
94b6da5ab
|
52 |
#include <linux/page_cgroup.h> |
9a11b49a8
|
53 |
#include <linux/debug_locks.h> |
3ac7fe5a4
|
54 |
#include <linux/debugobjects.h> |
fbb9ce953
|
55 |
#include <linux/lockdep.h> |
3c7b4e6b8
|
56 |
#include <linux/kmemleak.h> |
84d737866
|
57 |
#include <linux/pid_namespace.h> |
1f21782e6
|
58 |
#include <linux/device.h> |
73c279927
|
59 |
#include <linux/kthread.h> |
e6fe6649b
|
60 |
#include <linux/sched.h> |
a1c9eea9e
|
61 |
#include <linux/signal.h> |
199f0ca51
|
62 |
#include <linux/idr.h> |
0b4b3827d
|
63 |
#include <linux/kgdb.h> |
68bf21aa1
|
64 |
#include <linux/ftrace.h> |
22a9d6456
|
65 |
#include <linux/async.h> |
dfec072ec
|
66 |
#include <linux/kmemcheck.h> |
6ae6996a4
|
67 |
#include <linux/sfi.h> |
2b2af54a5
|
68 |
#include <linux/shmem_fs.h> |
5a0e3ad6a
|
69 |
#include <linux/slab.h> |
24a24bb6f
|
70 |
#include <linux/perf_event.h> |
4a9d4b024
|
71 |
#include <linux/file.h> |
a74fb73c1
|
72 |
#include <linux/ptrace.h> |
bb813f4c9
|
73 74 |
#include <linux/blkdev.h> #include <linux/elevator.h> |
38ff87f77
|
75 |
#include <linux/sched_clock.h> |
1da177e4c
|
76 77 78 79 |
#include <asm/io.h> #include <asm/bugs.h> #include <asm/setup.h> |
a940199f2
|
80 |
#include <asm/sections.h> |
37b73c828
|
81 |
#include <asm/cacheflush.h> |
1da177e4c
|
82 |
|
1da177e4c
|
83 84 85 |
#ifdef CONFIG_X86_LOCAL_APIC #include <asm/smp.h> #endif |
aae5f662a
|
86 |
static int kernel_init(void *); |
1da177e4c
|
87 88 |
extern void init_IRQ(void); |
1da177e4c
|
89 90 91 |
extern void fork_init(unsigned long); extern void mca_init(void); extern void sbus_init(void); |
1da177e4c
|
92 |
extern void radix_tree_init(void); |
37b73c828
|
93 94 95 |
#ifndef CONFIG_DEBUG_RODATA static inline void mark_rodata_ro(void) { } #endif |
1da177e4c
|
96 97 98 99 |
#ifdef CONFIG_TC extern void tc_init(void); #endif |
2ce802f62
|
100 101 102 103 104 105 106 107 |
/* * Debug helper: via this flag we know that we are in 'early bootup code' * where only the boot processor is running with IRQ disabled. This means * two things - IRQ must not be enabled before the flag is cleared and some * operations which are not allowed with IRQ disabled are allowed while the * flag is set. */ bool early_boot_irqs_disabled __read_mostly; |
a68260483
|
108 |
enum system_states system_state __read_mostly; |
1da177e4c
|
109 110 111 112 113 114 115 116 117 118 |
EXPORT_SYMBOL(system_state); /* * Boot command-line arguments */ #define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT #define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT extern void time_init(void); /* Default late time init is NULL. archs can override this later. */ |
d2e3192b6
|
119 |
void (*__initdata late_time_init)(void); |
1da177e4c
|
120 |
extern void softirq_init(void); |
30d7e0d46
|
121 122 123 124 125 126 |
/* Untouched command line saved by arch-specific code. */ char __initdata boot_command_line[COMMAND_LINE_SIZE]; /* Untouched saved command line (eg. for /proc) */ char *saved_command_line; /* Command line for parameter parsing */ static char *static_command_line; |
1da177e4c
|
127 128 |
static char *execute_command; |
ffdfc4097
|
129 |
static char *ramdisk_execute_command; |
1da177e4c
|
130 |
|
8b3b29550
|
131 132 133 134 135 136 137 138 139 140 141 |
/* * If set, this is an indication to the drivers that reset the underlying * device before going ahead with the initialization otherwise driver might * rely on the BIOS and skip the reset operation. * * This is useful if kernel is booting in an unreliable environment. * For ex. kdump situaiton where previous kernel has crashed, BIOS has been * skipped and devices will be in unknown state. */ unsigned int reset_devices; EXPORT_SYMBOL(reset_devices); |
1da177e4c
|
142 |
|
7e96287dd
|
143 144 145 146 147 148 149 |
static int __init set_reset_devices(char *str) { reset_devices = 1; return 1; } __setup("reset_devices", set_reset_devices); |
d7627467b
|
150 151 |
static const char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, }; const char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, }; |
1da177e4c
|
152 |
static const char *panic_later, *panic_param; |
914dcaa84
|
153 |
extern const struct obs_kernel_param __setup_start[], __setup_end[]; |
1da177e4c
|
154 155 156 |
static int __init obsolete_checksetup(char *line) { |
914dcaa84
|
157 |
const struct obs_kernel_param *p; |
33df0d19e
|
158 |
int had_early_param = 0; |
1da177e4c
|
159 160 161 162 |
p = __setup_start; do { int n = strlen(p->str); |
b1e4d20cb
|
163 |
if (parameqn(line, p->str, n)) { |
1da177e4c
|
164 |
if (p->early) { |
33df0d19e
|
165 166 167 168 |
/* Already done in parse_early_param? * (Needs exact match on param part). * Keep iterating, as we can have early * params and __setups of same names 8( */ |
1da177e4c
|
169 |
if (line[n] == '\0' || line[n] == '=') |
33df0d19e
|
170 |
had_early_param = 1; |
1da177e4c
|
171 |
} else if (!p->setup_func) { |
ea676e846
|
172 173 174 |
pr_warn("Parameter %s is obsolete, ignored ", p->str); |
1da177e4c
|
175 176 177 178 179 180 |
return 1; } else if (p->setup_func(line + n)) return 1; } p++; } while (p < __setup_end); |
33df0d19e
|
181 182 |
return had_early_param; |
1da177e4c
|
183 184 185 186 187 188 189 190 191 192 193 194 |
} /* * This should be approx 2 Bo*oMips to start (note initial shift), and will * still work even if initially too large, it will just take slightly longer */ unsigned long loops_per_jiffy = (1<<12); EXPORT_SYMBOL(loops_per_jiffy); static int __init debug_kernel(char *str) { |
1da177e4c
|
195 |
console_loglevel = 10; |
f6f21c814
|
196 |
return 0; |
1da177e4c
|
197 198 199 200 |
} static int __init quiet_kernel(char *str) { |
1da177e4c
|
201 |
console_loglevel = 4; |
f6f21c814
|
202 |
return 0; |
1da177e4c
|
203 |
} |
f6f21c814
|
204 205 |
early_param("debug", debug_kernel); early_param("quiet", quiet_kernel); |
1da177e4c
|
206 207 208 |
static int __init loglevel(char *str) { |
808bf29b9
|
209 210 211 212 213 214 215 216 217 218 219 220 221 |
int newlevel; /* * Only update loglevel value when a correct setting was passed, * to prevent blind crashes (when loglevel being set to 0) that * are quite hard to debug */ if (get_option(&str, &newlevel)) { console_loglevel = newlevel; return 0; } return -EINVAL; |
1da177e4c
|
222 |
} |
f6f21c814
|
223 |
early_param("loglevel", loglevel); |
1da177e4c
|
224 |
|
a99cd1125
|
225 |
/* Change NUL term back to "=", to make "param" the whole string. */ |
eb1574270
|
226 |
static int __init repair_env_string(char *param, char *val, const char *unused) |
1da177e4c
|
227 |
{ |
1da177e4c
|
228 229 230 231 232 233 234 235 236 237 238 |
if (val) { /* param=val or param="val"? */ if (val == param+strlen(param)+1) val[-1] = '='; else if (val == param+strlen(param)+2) { val[-2] = '='; memmove(val-1, val, strlen(val)+1); val--; } else BUG(); } |
a99cd1125
|
239 240 241 242 243 244 245 |
return 0; } /* * Unknown boot options get handed to init, unless they look like * unused parameters (modprobe will find them in /proc/cmdline). */ |
eb1574270
|
246 |
static int __init unknown_bootoption(char *param, char *val, const char *unused) |
a99cd1125
|
247 |
{ |
eb1574270
|
248 |
repair_env_string(param, val, unused); |
1da177e4c
|
249 250 251 252 |
/* Handle obsolete-style parameters */ if (obsolete_checksetup(param)) return 0; |
f066a4f6d
|
253 254 |
/* Unused module parameter. */ if (strchr(param, '.') && (!val || strchr(param, '.') < val)) |
1da177e4c
|
255 |
return 0; |
1da177e4c
|
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 |
if (panic_later) return 0; if (val) { /* Environment option */ unsigned int i; for (i = 0; envp_init[i]; i++) { if (i == MAX_INIT_ENVS) { panic_later = "Too many boot env vars at `%s'"; panic_param = param; } if (!strncmp(param, envp_init[i], val - param)) break; } envp_init[i] = param; } else { /* Command line option */ unsigned int i; for (i = 0; argv_init[i]; i++) { if (i == MAX_INIT_ARGS) { panic_later = "Too many boot init vars at `%s'"; panic_param = param; } } argv_init[i] = param; } return 0; } static int __init init_setup(char *str) { unsigned int i; execute_command = str; /* * In case LILO is going to boot us with default command line, * it prepends "auto" before the whole cmdline which makes * the shell think it should execute a script with such name. * So we ignore all arguments entered _before_ init=... [MJ] */ for (i = 1; i < MAX_INIT_ARGS; i++) argv_init[i] = NULL; return 1; } __setup("init=", init_setup); |
ffdfc4097
|
302 303 304 305 306 307 308 309 310 311 312 |
static int __init rdinit_setup(char *str) { unsigned int i; ramdisk_execute_command = str; /* See "auto" comment in init_setup */ for (i = 1; i < MAX_INIT_ARGS; i++) argv_init[i] = NULL; return 1; } __setup("rdinit=", rdinit_setup); |
1da177e4c
|
313 |
#ifndef CONFIG_SMP |
34db18a05
|
314 |
static const unsigned int setup_max_cpus = NR_CPUS; |
1da177e4c
|
315 316 317 318 319 320 321 322 |
#ifdef CONFIG_X86_LOCAL_APIC static void __init smp_init(void) { APIC_init_uniprocessor(); } #else #define smp_init() do { } while (0) #endif |
e0982e90c
|
323 |
static inline void setup_nr_cpu_ids(void) { } |
1da177e4c
|
324 |
static inline void smp_prepare_cpus(unsigned int maxcpus) { } |
1da177e4c
|
325 326 327 |
#endif /* |
30d7e0d46
|
328 329 330 331 332 333 334 335 336 337 338 339 340 341 |
* We need to store the untouched command line for future reference. * We also need to store the touched command line since the parameter * parsing is performed in place, and we should allow a component to * store reference of name/value for future reference. */ static void __init setup_command_line(char *command_line) { saved_command_line = alloc_bootmem(strlen (boot_command_line)+1); static_command_line = alloc_bootmem(strlen (command_line)+1); strcpy (saved_command_line, boot_command_line); strcpy (static_command_line, command_line); } /* |
1da177e4c
|
342 343 344 345 346 347 348 |
* We need to finalize in a non-__init function or else race conditions * between the root thread and the init thread may cause start_kernel to * be reaped by free_initmem before the root thread has proceeded to * cpu_idle. * * gcc-3.4 accidentally inlines this function, so use noinline. */ |
b433c3d45
|
349 |
static __initdata DECLARE_COMPLETION(kthreadd_done); |
f99ebf0a8
|
350 |
static noinline void __init_refok rest_init(void) |
1da177e4c
|
351 |
{ |
73c279927
|
352 |
int pid; |
7db905e63
|
353 |
rcu_scheduler_starting(); |
b433c3d45
|
354 |
/* |
971585692
|
355 |
* We need to spawn init first so that it obtains pid 1, however |
b433c3d45
|
356 357 358 |
* the init task will end up wanting to create kthreads, which, if * we schedule it before we create kthreadd, will OOPS. */ |
aae5f662a
|
359 |
kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND); |
1da177e4c
|
360 |
numa_default_policy(); |
73c279927
|
361 |
pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES); |
d11c563dd
|
362 |
rcu_read_lock(); |
5cd204550
|
363 |
kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns); |
d11c563dd
|
364 |
rcu_read_unlock(); |
b433c3d45
|
365 |
complete(&kthreadd_done); |
f340c0d1a
|
366 367 368 |
/* * The boot idle thread must execute schedule() |
1df21055e
|
369 |
* at least once to get things moving: |
f340c0d1a
|
370 |
*/ |
1df21055e
|
371 |
init_idle_bootup_task(current); |
bd2f55361
|
372 |
schedule_preempt_disabled(); |
5bfb5d690
|
373 |
/* Call into cpu_idle with preempt disabled */ |
a1a04ec3c
|
374 |
cpu_startup_entry(CPUHP_ONLINE); |
1df21055e
|
375 |
} |
1da177e4c
|
376 377 |
/* Check for early params. */ |
9fb48c744
|
378 |
static int __init do_early_param(char *param, char *val, const char *unused) |
1da177e4c
|
379 |
{ |
914dcaa84
|
380 |
const struct obs_kernel_param *p; |
1da177e4c
|
381 382 |
for (p = __setup_start; p < __setup_end; p++) { |
b1e4d20cb
|
383 |
if ((p->early && parameq(param, p->str)) || |
18a8bd949
|
384 385 386 |
(strcmp(param, "console") == 0 && strcmp(p->str, "earlycon") == 0) ) { |
1da177e4c
|
387 |
if (p->setup_func(val) != 0) |
ea676e846
|
388 389 |
pr_warn("Malformed early option '%s' ", param); |
1da177e4c
|
390 391 392 393 394 |
} } /* We accept everything at this stage. */ return 0; } |
13977091a
|
395 396 |
void __init parse_early_options(char *cmdline) { |
026cee008
|
397 |
parse_args("early options", cmdline, NULL, 0, 0, 0, do_early_param); |
13977091a
|
398 |
} |
1da177e4c
|
399 400 401 402 403 404 405 406 407 408 |
/* Arch code calls this early on, or if not, just before other parsing. */ void __init parse_early_param(void) { static __initdata int done = 0; static __initdata char tmp_cmdline[COMMAND_LINE_SIZE]; if (done) return; /* All fall through to do_early_param. */ |
30d7e0d46
|
409 |
strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE); |
13977091a
|
410 |
parse_early_options(tmp_cmdline); |
1da177e4c
|
411 412 413 414 415 416 |
done = 1; } /* * Activate the first processor. */ |
44fd22992
|
417 418 419 420 |
static void __init boot_cpu_init(void) { int cpu = smp_processor_id(); /* Mark the boot cpu "present", "online" etc for SMP and UP case */ |
915441b60
|
421 |
set_cpu_online(cpu, true); |
933b0618d
|
422 |
set_cpu_active(cpu, true); |
915441b60
|
423 424 |
set_cpu_present(cpu, true); set_cpu_possible(cpu, true); |
44fd22992
|
425 |
} |
839ad62e7
|
426 |
void __init __weak smp_setup_processor_id(void) |
033ab7f8e
|
427 428 |
{ } |
eded09ccf
|
429 |
# if THREAD_SIZE >= PAGE_SIZE |
8c9843e57
|
430 431 432 |
void __init __weak thread_info_cache_init(void) { } |
eded09ccf
|
433 |
#endif |
8c9843e57
|
434 |
|
444f478f6
|
435 436 437 438 439 |
/* * Set up kernel memory allocators */ static void __init mm_init(void) { |
ca371c0d7
|
440 |
/* |
7fa87ce72
|
441 442 |
* page_cgroup requires contiguous pages, * bigger than MAX_ORDER unless SPARSEMEM. |
ca371c0d7
|
443 444 |
*/ page_cgroup_init_flatmem(); |
444f478f6
|
445 446 |
mem_init(); kmem_cache_init(); |
099a19d91
|
447 |
percpu_init_late(); |
c868d5501
|
448 |
pgtable_cache_init(); |
444f478f6
|
449 450 |
vmalloc_init(); } |
1da177e4c
|
451 452 453 |
asmlinkage void __init start_kernel(void) { char * command_line; |
914dcaa84
|
454 |
extern const struct kernel_param __start___param[], __stop___param[]; |
033ab7f8e
|
455 |
|
fbb9ce953
|
456 457 458 459 460 |
/* * Need to run as early as possible, to initialize the * lockdep hash: */ lockdep_init(); |
73839c5b2
|
461 |
smp_setup_processor_id(); |
3ac7fe5a4
|
462 |
debug_objects_early_init(); |
420594296
|
463 464 465 466 467 |
/* * Set up the the initial canary ASAP: */ boot_init_stack_canary(); |
ddbcc7e8e
|
468 |
cgroup_init_early(); |
fbb9ce953
|
469 470 |
local_irq_disable(); |
2ce802f62
|
471 |
early_boot_irqs_disabled = true; |
fbb9ce953
|
472 |
|
1da177e4c
|
473 474 475 476 |
/* * Interrupts are still disabled. Do necessary setups, then * enable them */ |
44fd22992
|
477 |
boot_cpu_init(); |
1da177e4c
|
478 |
page_address_init(); |
ea676e846
|
479 |
pr_notice("%s", linux_banner); |
1da177e4c
|
480 |
setup_arch(&command_line); |
cf475ad28
|
481 |
mm_init_owner(&init_mm, &init_task); |
6345d24da
|
482 |
mm_init_cpumask(&init_mm); |
30d7e0d46
|
483 |
setup_command_line(command_line); |
e0982e90c
|
484 |
setup_nr_cpu_ids(); |
d6647bdf9
|
485 |
setup_per_cpu_areas(); |
44fd22992
|
486 |
smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */ |
1da177e4c
|
487 |
|
9adb62a5d
|
488 |
build_all_zonelists(NULL, NULL); |
83b519e8b
|
489 |
page_alloc_init(); |
ea676e846
|
490 491 |
pr_notice("Kernel command line: %s ", boot_command_line); |
83b519e8b
|
492 493 494 |
parse_early_param(); parse_args("Booting kernel", static_command_line, __start___param, __stop___param - __start___param, |
ae82fdb14
|
495 |
-1, -1, &unknown_bootoption); |
97ce2c88f
|
496 497 |
jump_label_init(); |
83b519e8b
|
498 499 500 501 |
/* * These use large bootmem allocations and must precede * kmem_cache_init() */ |
162a7e750
|
502 |
setup_log_buf(0); |
83b519e8b
|
503 |
pidhash_init(); |
83b519e8b
|
504 505 506 |
vfs_caches_init_early(); sort_main_extable(); trap_init(); |
444f478f6
|
507 |
mm_init(); |
de03c72cf
|
508 |
|
1da177e4c
|
509 510 511 512 513 514 515 516 517 518 519 |
/* * Set up the scheduler prior starting any interrupts (such as the * timer interrupt). Full topology setup happens at smp_init() * time - but meanwhile we still have a functioning scheduler. */ sched_init(); /* * Disable preemption - early bootup scheduling is extremely * fragile until we cpu_idle() for the first time. */ preempt_disable(); |
f91eb62f7
|
520 521 |
if (WARN(!irqs_disabled(), "Interrupts were enabled *very* early, fixing it ")) |
c4a68306b
|
522 |
local_irq_disable(); |
9f58a205c
|
523 |
idr_init_cache(); |
1da177e4c
|
524 |
rcu_init(); |
d1e43fa5f
|
525 |
tick_nohz_init(); |
773e3eb7b
|
526 |
radix_tree_init(); |
0b8f1efad
|
527 528 |
/* init some links before init_ISA_irqs() */ early_irq_init(); |
1da177e4c
|
529 |
init_IRQ(); |
ad2b13536
|
530 |
tick_init(); |
1da177e4c
|
531 |
init_timers(); |
c0a313296
|
532 |
hrtimers_init(); |
1da177e4c
|
533 |
softirq_init(); |
ad596171e
|
534 |
timekeeping_init(); |
88fecaa27
|
535 |
time_init(); |
38ff87f77
|
536 |
sched_clock_postinit(); |
9e6302056
|
537 |
perf_event_init(); |
93e028148
|
538 |
profile_init(); |
d8ad7d112
|
539 |
call_function_init(); |
f91eb62f7
|
540 541 |
WARN(!irqs_disabled(), "Interrupts were enabled early "); |
2ce802f62
|
542 |
early_boot_irqs_disabled = false; |
93e028148
|
543 |
local_irq_enable(); |
dcce284a2
|
544 |
|
7e85ee0c1
|
545 |
kmem_cache_init_late(); |
1da177e4c
|
546 547 548 549 550 551 552 553 554 |
/* * HACK ALERT! This is early. We're enabling the console before * we've done PCI setups etc, and console_init() must be aware of * this. But we do want output early, in case something goes wrong. */ console_init(); if (panic_later) panic(panic_later, panic_param); |
fbb9ce953
|
555 556 |
lockdep_info(); |
9a11b49a8
|
557 558 559 560 561 562 |
/* * Need to run this when irqs are enabled, because it wants * to self-test [hard/soft]-irqs on/off lock inversion bugs * too: */ locking_selftest(); |
1da177e4c
|
563 564 |
#ifdef CONFIG_BLK_DEV_INITRD if (initrd_start && !initrd_below_start_ok && |
bd673c7c3
|
565 |
page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) { |
ea676e846
|
566 567 |
pr_crit("initrd overwritten (0x%08lx < 0x%08lx) - disabling it. ", |
bd673c7c3
|
568 569 |
page_to_pfn(virt_to_page((void *)initrd_start)), min_low_pfn); |
1da177e4c
|
570 571 572 |
initrd_start = 0; } #endif |
94b6da5ab
|
573 |
page_cgroup_init(); |
3ac7fe5a4
|
574 |
debug_objects_mem_init(); |
9b090f2da
|
575 |
kmemleak_init(); |
e7c8d5c99
|
576 |
setup_per_cpu_pageset(); |
1da177e4c
|
577 578 579 |
numa_policy_init(); if (late_time_init) late_time_init(); |
fa84e9eec
|
580 |
sched_clock_init(); |
1da177e4c
|
581 582 |
calibrate_delay(); pidmap_init(); |
1da177e4c
|
583 |
anon_vma_init(); |
11520e5e7
|
584 |
#ifdef CONFIG_X86 |
83e681897
|
585 |
if (efi_enabled(EFI_RUNTIME_SERVICES)) |
11520e5e7
|
586 587 |
efi_enter_virtual_mode(); #endif |
8c9843e57
|
588 |
thread_info_cache_init(); |
d84f4f992
|
589 |
cred_init(); |
4481374ce
|
590 |
fork_init(totalram_pages); |
1da177e4c
|
591 592 |
proc_caches_init(); buffer_init(); |
1da177e4c
|
593 594 |
key_init(); security_init(); |
0b4b3827d
|
595 |
dbg_late_init(); |
4481374ce
|
596 |
vfs_caches_init(totalram_pages); |
1da177e4c
|
597 598 599 600 601 602 |
signals_init(); /* rootfs populating might need page-writeback */ page_writeback_init(); #ifdef CONFIG_PROC_FS proc_root_init(); #endif |
ddbcc7e8e
|
603 |
cgroup_init(); |
1da177e4c
|
604 |
cpuset_init(); |
c757249af
|
605 |
taskstats_init_early(); |
ca74e92b4
|
606 |
delayacct_init(); |
1da177e4c
|
607 608 609 610 |
check_bugs(); acpi_early_init(); /* before LAPIC and SMP init */ |
6ae6996a4
|
611 |
sfi_init_late(); |
1da177e4c
|
612 |
|
83e681897
|
613 |
if (efi_enabled(EFI_RUNTIME_SERVICES)) { |
2223af389
|
614 |
efi_late_init(); |
785107923
|
615 |
efi_free_boot_services(); |
2223af389
|
616 |
} |
785107923
|
617 |
|
68bf21aa1
|
618 |
ftrace_init(); |
1da177e4c
|
619 620 621 |
/* Do the rest non-__init'ed, we're now alive */ rest_init(); } |
b99b87f70
|
622 623 624 625 |
/* Call all constructor functions linked into the kernel. */ static void __init do_ctors(void) { #ifdef CONFIG_CONSTRUCTORS |
196a15b4e
|
626 |
ctor_fn_t *fn = (ctor_fn_t *) __ctors_start; |
b99b87f70
|
627 |
|
196a15b4e
|
628 629 |
for (; fn < (ctor_fn_t *) __ctors_end; fn++) (*fn)(); |
b99b87f70
|
630 631 |
#endif } |
2329abfa3
|
632 |
bool initcall_debug; |
d0ea3d7d2
|
633 |
core_param(initcall_debug, initcall_debug, bool, 0644); |
1da177e4c
|
634 |
|
e44612713
|
635 |
static int __init_or_module do_one_initcall_debug(initcall_t fn) |
1da177e4c
|
636 |
{ |
742390728
|
637 |
ktime_t calltime, delta, rettime; |
30dbb20e6
|
638 639 |
unsigned long long duration; int ret; |
1da177e4c
|
640 |
|
ea676e846
|
641 642 |
pr_debug("calling %pF @ %i ", fn, task_pid_nr(current)); |
22c5c03b4
|
643 |
calltime = ktime_get(); |
30dbb20e6
|
644 |
ret = fn(); |
22c5c03b4
|
645 646 647 |
rettime = ktime_get(); delta = ktime_sub(rettime, calltime); duration = (unsigned long long) ktime_to_ns(delta) >> 10; |
ea676e846
|
648 649 650 |
pr_debug("initcall %pF returned %d after %lld usecs ", fn, ret, duration); |
1da177e4c
|
651 |
|
22c5c03b4
|
652 653 |
return ret; } |
e44612713
|
654 |
int __init_or_module do_one_initcall(initcall_t fn) |
22c5c03b4
|
655 656 657 |
{ int count = preempt_count(); int ret; |
ff1c8fac8
|
658 |
char msgbuf[64]; |
22c5c03b4
|
659 660 661 662 663 |
if (initcall_debug) ret = do_one_initcall_debug(fn); else ret = fn(); |
8f0c45cdf
|
664 |
|
e0df154f4
|
665 |
msgbuf[0] = 0; |
e662e1cfd
|
666 |
|
e0df154f4
|
667 |
if (preempt_count() != count) { |
bf5d770bd
|
668 |
sprintf(msgbuf, "preemption imbalance "); |
e0df154f4
|
669 |
preempt_count() = count; |
1da177e4c
|
670 |
} |
e0df154f4
|
671 |
if (irqs_disabled()) { |
a76bfd0da
|
672 |
strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf)); |
e0df154f4
|
673 674 |
local_irq_enable(); } |
f91eb62f7
|
675 676 |
WARN(msgbuf[0], "initcall %pF returned with %s ", fn, msgbuf); |
59f9415ff
|
677 |
|
30dbb20e6
|
678 |
return ret; |
e0df154f4
|
679 |
} |
026cee008
|
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 |
extern initcall_t __initcall_start[]; extern initcall_t __initcall0_start[]; extern initcall_t __initcall1_start[]; extern initcall_t __initcall2_start[]; extern initcall_t __initcall3_start[]; extern initcall_t __initcall4_start[]; extern initcall_t __initcall5_start[]; extern initcall_t __initcall6_start[]; extern initcall_t __initcall7_start[]; extern initcall_t __initcall_end[]; static initcall_t *initcall_levels[] __initdata = { __initcall0_start, __initcall1_start, __initcall2_start, __initcall3_start, __initcall4_start, __initcall5_start, __initcall6_start, __initcall7_start, __initcall_end, }; |
96263d286
|
702 |
/* Keep these in sync with initcalls in include/linux/init.h */ |
026cee008
|
703 |
static char *initcall_level_names[] __initdata = { |
9fb48c744
|
704 705 706 707 708 709 710 711 |
"early", "core", "postcore", "arch", "subsys", "fs", "device", "late", |
026cee008
|
712 |
}; |
026cee008
|
713 |
static void __init do_initcall_level(int level) |
e0df154f4
|
714 |
{ |
026cee008
|
715 |
extern const struct kernel_param __start___param[], __stop___param[]; |
196a15b4e
|
716 |
initcall_t *fn; |
e0df154f4
|
717 |
|
026cee008
|
718 719 720 721 722 |
strcpy(static_command_line, saved_command_line); parse_args(initcall_level_names[level], static_command_line, __start___param, __stop___param - __start___param, level, level, |
eb1574270
|
723 |
&repair_env_string); |
026cee008
|
724 725 |
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++) |
196a15b4e
|
726 |
do_one_initcall(*fn); |
1da177e4c
|
727 |
} |
026cee008
|
728 729 730 |
static void __init do_initcalls(void) { int level; |
19efb72fd
|
731 |
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++) |
026cee008
|
732 733 |
do_initcall_level(level); } |
1da177e4c
|
734 735 736 737 738 739 740 741 742 |
/* * Ok, the machine is now initialized. None of the devices * have been touched yet, but the CPU subsystem is up and * running, and memory and process management works. * * Now we can finally start doing some real work.. */ static void __init do_basic_setup(void) { |
759ee0915
|
743 |
cpuset_init_smp(); |
1da177e4c
|
744 |
usermodehelper_init(); |
41ffe5d5c
|
745 |
shmem_init(); |
1da177e4c
|
746 |
driver_init(); |
b04c3afb2
|
747 |
init_irq_proc(); |
b99b87f70
|
748 |
do_ctors(); |
d5767c535
|
749 |
usermodehelper_enable(); |
b0f84374b
|
750 |
do_initcalls(); |
1da177e4c
|
751 |
} |
7babe8db9
|
752 |
static void __init do_pre_smp_initcalls(void) |
c2147a509
|
753 |
{ |
196a15b4e
|
754 |
initcall_t *fn; |
c2147a509
|
755 |
|
026cee008
|
756 |
for (fn = __initcall_start; fn < __initcall0_start; fn++) |
196a15b4e
|
757 |
do_one_initcall(*fn); |
c2147a509
|
758 |
} |
bb813f4c9
|
759 760 761 762 763 764 765 766 767 768 |
/* * This function requests modules which should be loaded by default and is * called twice right after initrd is mounted and right before init is * exec'd. If such modules are on either initrd or rootfs, they will be * loaded before control is passed to userland. */ void __init load_default_modules(void) { load_default_elevator_module(); } |
a74fb73c1
|
769 |
static int run_init_process(const char *init_filename) |
1da177e4c
|
770 771 |
{ argv_init[0] = init_filename; |
ae903caae
|
772 773 774 |
return do_execve(init_filename, (const char __user *const __user *)argv_init, (const char __user *const __user *)envp_init); |
1da177e4c
|
775 |
} |
f80b0c904
|
776 |
static noinline void __init kernel_init_freeable(void); |
d6b212380
|
777 778 |
static int __ref kernel_init(void *unused) |
ee5bfa642
|
779 |
{ |
d6b212380
|
780 |
kernel_init_freeable(); |
22a9d6456
|
781 782 |
/* need to finish all async __init code before freeing the memory */ async_synchronize_full(); |
ee5bfa642
|
783 |
free_initmem(); |
ee5bfa642
|
784 785 786 |
mark_rodata_ro(); system_state = SYSTEM_RUNNING; numa_default_policy(); |
4a9d4b024
|
787 |
flush_delayed_fput(); |
fae5fa44f
|
788 |
|
ee5bfa642
|
789 |
if (ramdisk_execute_command) { |
a74fb73c1
|
790 791 |
if (!run_init_process(ramdisk_execute_command)) return 0; |
ea676e846
|
792 793 |
pr_err("Failed to execute %s ", ramdisk_execute_command); |
ee5bfa642
|
794 795 796 797 798 799 800 801 802 |
} /* * We try each of these until one succeeds. * * The Bourne shell can be used instead of init if we are * trying to recover a really broken machine. */ if (execute_command) { |
a74fb73c1
|
803 804 |
if (!run_init_process(execute_command)) return 0; |
ea676e846
|
805 806 807 |
pr_err("Failed to execute %s. Attempting defaults... ", execute_command); |
ee5bfa642
|
808 |
} |
a74fb73c1
|
809 810 811 812 813 |
if (!run_init_process("/sbin/init") || !run_init_process("/etc/init") || !run_init_process("/bin/init") || !run_init_process("/bin/sh")) return 0; |
ee5bfa642
|
814 |
|
9a85b8d60
|
815 816 |
panic("No init found. Try passing init= option to kernel. " "See Linux Documentation/init.txt for guidance."); |
ee5bfa642
|
817 |
} |
f80b0c904
|
818 |
static noinline void __init kernel_init_freeable(void) |
1da177e4c
|
819 |
{ |
b433c3d45
|
820 821 822 823 |
/* * Wait until kthreadd is all set-up. */ wait_for_completion(&kthreadd_done); |
31a67102f
|
824 825 826 |
/* Now the scheduler is fully set up and can do blocking allocations */ gfp_allowed_mask = __GFP_BITS_MASK; |
58568d2a8
|
827 828 829 |
/* * init can allocate pages on any node */ |
3c466d46a
|
830 |
set_mems_allowed(node_states[N_MEMORY]); |
1da177e4c
|
831 832 833 |
/* * init can run on any cpu. */ |
1a2142afa
|
834 |
set_cpus_allowed_ptr(current, cpu_all_mask); |
1da177e4c
|
835 |
|
9ec52099e
|
836 |
cad_pid = task_pid(current); |
ca74a6f84
|
837 |
smp_prepare_cpus(setup_max_cpus); |
1da177e4c
|
838 839 |
do_pre_smp_initcalls(); |
004417a6d
|
840 |
lockup_detector_init(); |
1da177e4c
|
841 |
|
1da177e4c
|
842 843 |
smp_init(); sched_init_smp(); |
1da177e4c
|
844 |
do_basic_setup(); |
2bd3a997b
|
845 846 |
/* Open the /dev/console on the rootfs, this should never fail */ if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) |
ea676e846
|
847 848 |
pr_err("Warning: unable to open an initial console. "); |
2bd3a997b
|
849 850 851 |
(void) sys_dup(0); (void) sys_dup(0); |
1da177e4c
|
852 853 854 855 |
/* * check if there is an early userspace init. If yes, let it do all * the work */ |
ffdfc4097
|
856 857 858 859 860 861 |
if (!ramdisk_execute_command) ramdisk_execute_command = "/init"; if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { ramdisk_execute_command = NULL; |
1da177e4c
|
862 |
prepare_namespace(); |
ffdfc4097
|
863 |
} |
1da177e4c
|
864 865 866 867 868 869 |
/* * Ok, we have completed the initial bootup, and * we're essentially up and running. Get rid of the * initmem segments and start the user-mode stuff.. */ |
bb813f4c9
|
870 871 872 |
/* rootfs is available now, try loading default modules */ load_default_modules(); |
1da177e4c
|
873 |
} |