main.c 21.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *  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> 
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
I
Ingo Molnar 已提交
17
#include <linux/stackprotector.h>
L
Linus Torvalds 已提交
18 19 20 21 22 23 24
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
25
#include <linux/acpi.h>
L
Linus Torvalds 已提交
26 27 28
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
N
Nick Piggin 已提交
29
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
30
#include <linux/kernel_stat.h>
31
#include <linux/start_kernel.h>
L
Linus Torvalds 已提交
32
#include <linux/security.h>
33
#include <linux/smp.h>
L
Linus Torvalds 已提交
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>
41
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
42
#include <linux/efi.h>
43
#include <linux/tick.h>
44
#include <linux/interrupt.h>
45
#include <linux/taskstats_kern.h>
46
#include <linux/delayacct.h>
L
Linus Torvalds 已提交
47 48 49 50
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
A
Adrian Bunk 已提交
51
#include <linux/buffer_head.h>
52
#include <linux/page_cgroup.h>
53
#include <linux/debug_locks.h>
54
#include <linux/debugobjects.h>
I
Ingo Molnar 已提交
55
#include <linux/lockdep.h>
C
Catalin Marinas 已提交
56
#include <linux/kmemleak.h>
57
#include <linux/pid_namespace.h>
58
#include <linux/device.h>
59
#include <linux/kthread.h>
60
#include <linux/sched.h>
61
#include <linux/signal.h>
62
#include <linux/idr.h>
63
#include <linux/kgdb.h>
64
#include <linux/ftrace.h>
65
#include <linux/async.h>
66
#include <linux/kmemcheck.h>
67
#include <linux/sfi.h>
68
#include <linux/shmem_fs.h>
69
#include <linux/slab.h>
70
#include <linux/perf_event.h>
A
Al Viro 已提交
71
#include <linux/file.h>
72
#include <linux/ptrace.h>
L
Linus Torvalds 已提交
73 74 75 76

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
77
#include <asm/sections.h>
78
#include <asm/cacheflush.h>
L
Linus Torvalds 已提交
79 80 81 82 83

#ifdef CONFIG_X86_LOCAL_APIC
#include <asm/smp.h>
#endif

84
static int kernel_init(void *);
L
Linus Torvalds 已提交
85 86 87 88 89 90

extern void init_IRQ(void);
extern void fork_init(unsigned long);
extern void mca_init(void);
extern void sbus_init(void);
extern void radix_tree_init(void);
91 92 93
#ifndef CONFIG_DEBUG_RODATA
static inline void mark_rodata_ro(void) { }
#endif
L
Linus Torvalds 已提交
94 95 96 97 98

#ifdef CONFIG_TC
extern void tc_init(void);
#endif

99 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;

108
enum system_states system_state __read_mostly;
L
Linus Torvalds 已提交
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. */
119
void (*__initdata late_time_init)(void);
L
Linus Torvalds 已提交
120 121
extern void softirq_init(void);

122 123 124 125 126 127
/* 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;
L
Linus Torvalds 已提交
128 129

static char *execute_command;
130
static char *ramdisk_execute_command;
L
Linus Torvalds 已提交
131

J
Jan Beulich 已提交
132 133 134 135 136 137 138 139 140 141 142
/*
 * 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);
L
Linus Torvalds 已提交
143

144 145 146 147 148 149 150 151
static int __init set_reset_devices(char *str)
{
	reset_devices = 1;
	return 1;
}

__setup("reset_devices", set_reset_devices);

152 153
static const char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
const char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
L
Linus Torvalds 已提交
154 155
static const char *panic_later, *panic_param;

156
extern const struct obs_kernel_param __setup_start[], __setup_end[];
L
Linus Torvalds 已提交
157 158 159

static int __init obsolete_checksetup(char *line)
{
160
	const struct obs_kernel_param *p;
161
	int had_early_param = 0;
L
Linus Torvalds 已提交
162 163 164 165

	p = __setup_start;
	do {
		int n = strlen(p->str);
166
		if (parameqn(line, p->str, n)) {
L
Linus Torvalds 已提交
167
			if (p->early) {
168 169 170 171
				/* 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( */
L
Linus Torvalds 已提交
172
				if (line[n] == '\0' || line[n] == '=')
173
					had_early_param = 1;
L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181 182
			} else if (!p->setup_func) {
				printk(KERN_WARNING "Parameter %s is obsolete,"
				       " ignored\n", p->str);
				return 1;
			} else if (p->setup_func(line + n))
				return 1;
		}
		p++;
	} while (p < __setup_end);
183 184

	return had_early_param;
L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197
}

/*
 * 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)
{
	console_loglevel = 10;
198
	return 0;
L
Linus Torvalds 已提交
199 200 201 202 203
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
204
	return 0;
L
Linus Torvalds 已提交
205 206
}

207 208
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
L
Linus Torvalds 已提交
209 210 211

static int __init loglevel(char *str)
{
212 213 214 215 216 217 218 219 220 221 222 223 224
	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;
L
Linus Torvalds 已提交
225 226
}

227
early_param("loglevel", loglevel);
L
Linus Torvalds 已提交
228

229
/* Change NUL term back to "=", to make "param" the whole string. */
230
static int __init repair_env_string(char *param, char *val, const char *unused)
L
Linus Torvalds 已提交
231 232 233 234 235 236 237 238 239 240 241 242
{
	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();
	}
243 244 245 246 247 248 249
	return 0;
}

/*
 * Unknown boot options get handed to init, unless they look like
 * unused parameters (modprobe will find them in /proc/cmdline).
 */
250
static int __init unknown_bootoption(char *param, char *val, const char *unused)
251
{
252
	repair_env_string(param, val, unused);
L
Linus Torvalds 已提交
253 254 255 256 257

	/* Handle obsolete-style parameters */
	if (obsolete_checksetup(param))
		return 0;

258 259
	/* Unused module parameter. */
	if (strchr(param, '.') && (!val || strchr(param, '.') < val))
L
Linus Torvalds 已提交
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 302 303 304 305 306 307
		return 0;

	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);

308 309 310 311 312 313 314 315 316 317 318 319
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);

L
Linus Torvalds 已提交
320
#ifndef CONFIG_SMP
321
static const unsigned int setup_max_cpus = NR_CPUS;
L
Linus Torvalds 已提交
322 323 324 325 326 327 328 329 330
#ifdef CONFIG_X86_LOCAL_APIC
static void __init smp_init(void)
{
	APIC_init_uniprocessor();
}
#else
#define smp_init()	do { } while (0)
#endif

331
static inline void setup_nr_cpu_ids(void) { }
L
Linus Torvalds 已提交
332 333 334
static inline void smp_prepare_cpus(unsigned int maxcpus) { }
#endif

335 336 337 338 339 340 341 342 343 344 345 346 347 348
/*
 * 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);
}

L
Linus Torvalds 已提交
349 350 351 352 353 354 355 356 357
/*
 * 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.
 */

358 359
static __initdata DECLARE_COMPLETION(kthreadd_done);

360
static noinline void __init_refok rest_init(void)
L
Linus Torvalds 已提交
361
{
362 363
	int pid;

364
	rcu_scheduler_starting();
365
	/*
P
Peter Zijlstra 已提交
366
	 * We need to spawn init first so that it obtains pid 1, however
367 368 369
	 * the init task will end up wanting to create kthreads, which, if
	 * we schedule it before we create kthreadd, will OOPS.
	 */
370
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
L
Linus Torvalds 已提交
371
	numa_default_policy();
372
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
373
	rcu_read_lock();
P
Pavel Emelyanov 已提交
374
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
375
	rcu_read_unlock();
376
	complete(&kthreadd_done);
377 378 379

	/*
	 * The boot idle thread must execute schedule()
I
Ingo Molnar 已提交
380
	 * at least once to get things moving:
381
	 */
I
Ingo Molnar 已提交
382
	init_idle_bootup_task(current);
383
	schedule_preempt_disabled();
384
	/* Call into cpu_idle with preempt disabled */
L
Linus Torvalds 已提交
385
	cpu_idle();
I
Ingo Molnar 已提交
386
}
L
Linus Torvalds 已提交
387 388

/* Check for early params. */
389
static int __init do_early_param(char *param, char *val, const char *unused)
L
Linus Torvalds 已提交
390
{
391
	const struct obs_kernel_param *p;
L
Linus Torvalds 已提交
392 393

	for (p = __setup_start; p < __setup_end; p++) {
394
		if ((p->early && parameq(param, p->str)) ||
395 396 397
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
L
Linus Torvalds 已提交
398 399 400 401 402 403 404 405 406
			if (p->setup_func(val) != 0)
				printk(KERN_WARNING
				       "Malformed early option '%s'\n", param);
		}
	}
	/* We accept everything at this stage. */
	return 0;
}

M
Magnus Damm 已提交
407 408
void __init parse_early_options(char *cmdline)
{
409
	parse_args("early options", cmdline, NULL, 0, 0, 0, do_early_param);
M
Magnus Damm 已提交
410 411
}

L
Linus Torvalds 已提交
412 413 414 415 416 417 418 419 420 421
/* 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. */
422
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
M
Magnus Damm 已提交
423
	parse_early_options(tmp_cmdline);
L
Linus Torvalds 已提交
424 425 426 427 428 429 430
	done = 1;
}

/*
 *	Activate the first processor.
 */

431 432 433 434
static void __init boot_cpu_init(void)
{
	int cpu = smp_processor_id();
	/* Mark the boot cpu "present", "online" etc for SMP and UP case */
435
	set_cpu_online(cpu, true);
436
	set_cpu_active(cpu, true);
437 438
	set_cpu_present(cpu, true);
	set_cpu_possible(cpu, true);
439 440
}

441
void __init __weak smp_setup_processor_id(void)
442 443 444
{
}

445
# if THREAD_SIZE >= PAGE_SIZE
446 447 448
void __init __weak thread_info_cache_init(void)
{
}
449
#endif
450

P
Pekka Enberg 已提交
451 452 453 454 455
/*
 * Set up kernel memory allocators
 */
static void __init mm_init(void)
{
456
	/*
457 458
	 * page_cgroup requires contiguous pages,
	 * bigger than MAX_ORDER unless SPARSEMEM.
459 460
	 */
	page_cgroup_init_flatmem();
P
Pekka Enberg 已提交
461 462
	mem_init();
	kmem_cache_init();
463
	percpu_init_late();
464
	pgtable_cache_init();
P
Pekka Enberg 已提交
465 466 467
	vmalloc_init();
}

L
Linus Torvalds 已提交
468 469 470
asmlinkage void __init start_kernel(void)
{
	char * command_line;
471
	extern const struct kernel_param __start___param[], __stop___param[];
472

I
Ingo Molnar 已提交
473 474 475 476 477
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
	lockdep_init();
478
	smp_setup_processor_id();
479
	debug_objects_early_init();
480 481 482 483 484 485

	/*
	 * Set up the the initial canary ASAP:
	 */
	boot_init_stack_canary();

486
	cgroup_init_early();
I
Ingo Molnar 已提交
487 488

	local_irq_disable();
489
	early_boot_irqs_disabled = true;
I
Ingo Molnar 已提交
490

L
Linus Torvalds 已提交
491 492 493 494
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
495
	tick_init();
496
	boot_cpu_init();
L
Linus Torvalds 已提交
497
	page_address_init();
A
Alex Riesen 已提交
498
	printk(KERN_NOTICE "%s", linux_banner);
L
Linus Torvalds 已提交
499
	setup_arch(&command_line);
500
	mm_init_owner(&init_mm, &init_task);
501
	mm_init_cpumask(&init_mm);
502
	setup_command_line(command_line);
503
	setup_nr_cpu_ids();
504
	setup_per_cpu_areas();
505
	smp_prepare_boot_cpu();	/* arch-specific boot-cpu hooks */
L
Linus Torvalds 已提交
506

507
	build_all_zonelists(NULL, NULL);
508 509 510 511 512 513
	page_alloc_init();

	printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
	parse_early_param();
	parse_args("Booting kernel", static_command_line, __start___param,
		   __stop___param - __start___param,
514
		   -1, -1, &unknown_bootoption);
515 516 517

	jump_label_init();

518 519 520 521
	/*
	 * These use large bootmem allocations and must precede
	 * kmem_cache_init()
	 */
522
	setup_log_buf(0);
523 524 525 526
	pidhash_init();
	vfs_caches_init_early();
	sort_main_extable();
	trap_init();
P
Pekka Enberg 已提交
527
	mm_init();
528

L
Linus Torvalds 已提交
529 530 531 532 533 534 535 536 537 538 539
	/*
	 * 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();
540 541 542 543 544
	if (!irqs_disabled()) {
		printk(KERN_WARNING "start_kernel(): bug: interrupts were "
				"enabled *very* early, fixing it\n");
		local_irq_disable();
	}
P
Peter Zijlstra 已提交
545
	idr_init_cache();
546
	perf_event_init();
L
Linus Torvalds 已提交
547
	rcu_init();
Y
Yinghai Lu 已提交
548
	radix_tree_init();
549 550
	/* init some links before init_ISA_irqs() */
	early_irq_init();
L
Linus Torvalds 已提交
551 552
	init_IRQ();
	init_timers();
553
	hrtimers_init();
L
Linus Torvalds 已提交
554
	softirq_init();
555
	timekeeping_init();
J
john stultz 已提交
556
	time_init();
557
	profile_init();
558
	call_function_init();
559
	if (!irqs_disabled())
560 561
		printk(KERN_CRIT "start_kernel(): bug: interrupts were "
				 "enabled early\n");
562
	early_boot_irqs_disabled = false;
563
	local_irq_enable();
564

565
	kmem_cache_init_late();
L
Linus Torvalds 已提交
566 567 568 569 570 571 572 573 574

	/*
	 * 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);
I
Ingo Molnar 已提交
575 576 577

	lockdep_info();

578 579 580 581 582 583 584
	/*
	 * 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();

L
Linus Torvalds 已提交
585 586
#ifdef CONFIG_BLK_DEV_INITRD
	if (initrd_start && !initrd_below_start_ok &&
587
	    page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
L
Linus Torvalds 已提交
588
		printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
589
		    "disabling it.\n",
590 591
		    page_to_pfn(virt_to_page((void *)initrd_start)),
		    min_low_pfn);
L
Linus Torvalds 已提交
592 593 594
		initrd_start = 0;
	}
#endif
595
	page_cgroup_init();
596
	debug_objects_mem_init();
597
	kmemleak_init();
598
	setup_per_cpu_pageset();
L
Linus Torvalds 已提交
599 600 601
	numa_policy_init();
	if (late_time_init)
		late_time_init();
602
	sched_clock_init();
L
Linus Torvalds 已提交
603 604 605
	calibrate_delay();
	pidmap_init();
	anon_vma_init();
606 607 608 609
#ifdef CONFIG_X86
	if (efi_enabled)
		efi_enter_virtual_mode();
#endif
610
	thread_info_cache_init();
D
David Howells 已提交
611
	cred_init();
612
	fork_init(totalram_pages);
L
Linus Torvalds 已提交
613 614 615 616
	proc_caches_init();
	buffer_init();
	key_init();
	security_init();
617
	dbg_late_init();
618
	vfs_caches_init(totalram_pages);
L
Linus Torvalds 已提交
619 620 621 622 623 624
	signals_init();
	/* rootfs populating might need page-writeback */
	page_writeback_init();
#ifdef CONFIG_PROC_FS
	proc_root_init();
#endif
625
	cgroup_init();
L
Linus Torvalds 已提交
626
	cpuset_init();
627
	taskstats_init_early();
628
	delayacct_init();
L
Linus Torvalds 已提交
629 630 631 632

	check_bugs();

	acpi_early_init(); /* before LAPIC and SMP init */
633
	sfi_init_late();
L
Linus Torvalds 已提交
634

635 636
	if (efi_enabled) {
		efi_late_init();
637
		efi_free_boot_services();
638
	}
639

640 641
	ftrace_init();

L
Linus Torvalds 已提交
642 643 644 645
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

646 647 648 649
/* Call all constructor functions linked into the kernel. */
static void __init do_ctors(void)
{
#ifdef CONFIG_CONSTRUCTORS
650
	ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
651

652 653
	for (; fn < (ctor_fn_t *) __ctors_end; fn++)
		(*fn)();
654 655 656
#endif
}

657
bool initcall_debug;
R
Rusty Russell 已提交
658
core_param(initcall_debug, initcall_debug, bool, 0644);
L
Linus Torvalds 已提交
659

660 661
static char msgbuf[64];

662
static int __init_or_module do_one_initcall_debug(initcall_t fn)
L
Linus Torvalds 已提交
663
{
664
	ktime_t calltime, delta, rettime;
A
Américo Wang 已提交
665 666
	unsigned long long duration;
	int ret;
L
Linus Torvalds 已提交
667

668 669
	printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
	calltime = ktime_get();
A
Américo Wang 已提交
670
	ret = fn();
671 672 673 674 675
	rettime = ktime_get();
	delta = ktime_sub(rettime, calltime);
	duration = (unsigned long long) ktime_to_ns(delta) >> 10;
	printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n", fn,
		ret, duration);
L
Linus Torvalds 已提交
676

677 678 679
	return ret;
}

680
int __init_or_module do_one_initcall(initcall_t fn)
681 682 683 684 685 686 687 688
{
	int count = preempt_count();
	int ret;

	if (initcall_debug)
		ret = do_one_initcall_debug(fn);
	else
		ret = fn();
689

690
	msgbuf[0] = 0;
691

A
Américo Wang 已提交
692 693
	if (ret && ret != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", ret);
694

695
	if (preempt_count() != count) {
696
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
697
		preempt_count() = count;
L
Linus Torvalds 已提交
698
	}
699
	if (irqs_disabled()) {
700
		strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
701 702 703
		local_irq_enable();
	}
	if (msgbuf[0]) {
704
		printk("initcall %pF returned with %s\n", fn, msgbuf);
705
	}
706

A
Américo Wang 已提交
707
	return ret;
708 709 710
}


711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
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,
};

734
/* Keep these in sync with initcalls in include/linux/init.h */
735
static char *initcall_level_names[] __initdata = {
736 737 738 739 740 741 742 743
	"early",
	"core",
	"postcore",
	"arch",
	"subsys",
	"fs",
	"device",
	"late",
744 745 746
};

static void __init do_initcall_level(int level)
747
{
748
	extern const struct kernel_param __start___param[], __stop___param[];
749
	initcall_t *fn;
750

751 752 753 754 755
	strcpy(static_command_line, saved_command_line);
	parse_args(initcall_level_names[level],
		   static_command_line, __start___param,
		   __stop___param - __start___param,
		   level, level,
756
		   &repair_env_string);
757 758

	for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
759
		do_one_initcall(*fn);
L
Linus Torvalds 已提交
760 761
}

762 763 764 765
static void __init do_initcalls(void)
{
	int level;

766
	for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
767 768 769
		do_initcall_level(level);
}

L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778
/*
 * 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)
{
779
	cpuset_init_smp();
L
Linus Torvalds 已提交
780
	usermodehelper_init();
781
	shmem_init();
L
Linus Torvalds 已提交
782
	driver_init();
783
	init_irq_proc();
784
	do_ctors();
785
	usermodehelper_enable();
786
	do_initcalls();
L
Linus Torvalds 已提交
787 788
}

789
static void __init do_pre_smp_initcalls(void)
790
{
791
	initcall_t *fn;
792

793
	for (fn = __initcall_start; fn < __initcall0_start; fn++)
794
		do_one_initcall(*fn);
795 796
}

797
static int run_init_process(const char *init_filename)
L
Linus Torvalds 已提交
798 799
{
	argv_init[0] = init_filename;
800
	return kernel_execve(init_filename, argv_init, envp_init);
L
Linus Torvalds 已提交
801 802
}

803 804 805
static void __init kernel_init_freeable(void);

static int __ref kernel_init(void *unused)
806
{
807
	kernel_init_freeable();
808 809
	/* need to finish all async __init code before freeing the memory */
	async_synchronize_full();
810 811 812 813 814
	free_initmem();
	mark_rodata_ro();
	system_state = SYSTEM_RUNNING;
	numa_default_policy();

815
	current->signal->flags |= SIGNAL_UNKILLABLE;
A
Al Viro 已提交
816
	flush_delayed_fput();
817

818
	if (ramdisk_execute_command) {
819 820
		if (!run_init_process(ramdisk_execute_command))
			return 0;
821 822 823 824 825 826 827 828 829 830 831
		printk(KERN_WARNING "Failed to execute %s\n",
				ramdisk_execute_command);
	}

	/*
	 * 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) {
832 833
		if (!run_init_process(execute_command))
			return 0;
834 835 836
		printk(KERN_WARNING "Failed to execute %s.  Attempting "
					"defaults...\n", execute_command);
	}
837 838 839 840 841
	if (!run_init_process("/sbin/init") ||
	    !run_init_process("/etc/init") ||
	    !run_init_process("/bin/init") ||
	    !run_init_process("/bin/sh"))
		return 0;
842

843 844
	panic("No init found.  Try passing init= option to kernel. "
	      "See Linux Documentation/init.txt for guidance.");
845 846
}

847
static void __init kernel_init_freeable(void)
L
Linus Torvalds 已提交
848
{
849 850 851 852
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done);
853 854 855 856

	/* Now the scheduler is fully set up and can do blocking allocations */
	gfp_allowed_mask = __GFP_BITS_MASK;

857 858 859
	/*
	 * init can allocate pages on any node
	 */
860
	set_mems_allowed(node_states[N_HIGH_MEMORY]);
L
Linus Torvalds 已提交
861 862 863
	/*
	 * init can run on any cpu.
	 */
864
	set_cpus_allowed_ptr(current, cpu_all_mask);
L
Linus Torvalds 已提交
865

866 867
	cad_pid = task_pid(current);

868
	smp_prepare_cpus(setup_max_cpus);
L
Linus Torvalds 已提交
869 870

	do_pre_smp_initcalls();
871
	lockup_detector_init();
L
Linus Torvalds 已提交
872 873 874 875 876 877

	smp_init();
	sched_init_smp();

	do_basic_setup();

878 879 880 881 882 883
	/* Open the /dev/console on the rootfs, this should never fail */
	if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
		printk(KERN_WARNING "Warning: unable to open an initial console.\n");

	(void) sys_dup(0);
	(void) sys_dup(0);
L
Linus Torvalds 已提交
884 885 886 887
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
888 889 890 891 892 893

	if (!ramdisk_execute_command)
		ramdisk_execute_command = "/init";

	if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
		ramdisk_execute_command = NULL;
L
Linus Torvalds 已提交
894
		prepare_namespace();
895
	}
L
Linus Torvalds 已提交
896 897 898 899 900 901 902

	/*
	 * 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..
	 */
}