main.c 21.9 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 25
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
26
#include <linux/acpi.h>
L
Linus Torvalds 已提交
27 28 29
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
N
Nick Piggin 已提交
30
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
31
#include <linux/kernel_stat.h>
32
#include <linux/start_kernel.h>
L
Linus Torvalds 已提交
33
#include <linux/security.h>
34
#include <linux/smp.h>
L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42
#include <linux/workqueue.h>
#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>
43
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
44
#include <linux/efi.h>
45
#include <linux/tick.h>
46
#include <linux/interrupt.h>
47
#include <linux/taskstats_kern.h>
48
#include <linux/delayacct.h>
L
Linus Torvalds 已提交
49 50 51 52
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
A
Adrian Bunk 已提交
53
#include <linux/buffer_head.h>
54
#include <linux/page_cgroup.h>
55
#include <linux/debug_locks.h>
56
#include <linux/debugobjects.h>
I
Ingo Molnar 已提交
57
#include <linux/lockdep.h>
C
Catalin Marinas 已提交
58
#include <linux/kmemleak.h>
59
#include <linux/pid_namespace.h>
60
#include <linux/device.h>
61
#include <linux/kthread.h>
62
#include <linux/sched.h>
63
#include <linux/signal.h>
64
#include <linux/idr.h>
65
#include <linux/kgdb.h>
66
#include <linux/ftrace.h>
67
#include <linux/async.h>
68
#include <linux/kmemcheck.h>
69
#include <linux/kmemtrace.h>
70
#include <linux/sfi.h>
71
#include <linux/shmem_fs.h>
72
#include <linux/slab.h>
73
#include <trace/boot.h>
L
Linus Torvalds 已提交
74 75 76 77

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

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

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

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

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

102
enum system_states system_state __read_mostly;
L
Linus Torvalds 已提交
103 104 105 106 107 108 109 110 111 112
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. */
113
void (*__initdata late_time_init)(void);
L
Linus Torvalds 已提交
114 115
extern void softirq_init(void);

116 117 118 119 120 121
/* 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 已提交
122 123

static char *execute_command;
124
static char *ramdisk_execute_command;
L
Linus Torvalds 已提交
125

J
Jan Beulich 已提交
126
#ifdef CONFIG_SMP
L
Linus Torvalds 已提交
127
/* Setup configured maximum number of CPUs to activate */
128
unsigned int __initdata setup_max_cpus = NR_CPUS;
129

L
Linus Torvalds 已提交
130 131 132 133 134 135 136 137 138 139
/*
 * Setup routine for controlling SMP activation
 *
 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
 * activation entirely (the MPS table probe still happens, though).
 *
 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
 * greater than 0, limits the maximum number of CPUs activated in
 * SMP mode to <NUM>.
 */
140 141

void __weak arch_disable_smp_support(void) { }
142

L
Linus Torvalds 已提交
143 144
static int __init nosmp(char *str)
{
145
	setup_max_cpus = 0;
146 147
	arch_disable_smp_support();

J
Jan Beulich 已提交
148
	return 0;
L
Linus Torvalds 已提交
149 150
}

J
Jan Beulich 已提交
151
early_param("nosmp", nosmp);
L
Linus Torvalds 已提交
152

153 154 155 156 157 158 159 160 161 162 163 164 165 166
/* this is hard limit */
static int __init nrcpus(char *str)
{
	int nr_cpus;

	get_option(&str, &nr_cpus);
	if (nr_cpus > 0 && nr_cpus < nr_cpu_ids)
		nr_cpu_ids = nr_cpus;

	return 0;
}

early_param("nr_cpus", nrcpus);

L
Linus Torvalds 已提交
167 168
static int __init maxcpus(char *str)
{
169 170
	get_option(&str, &setup_max_cpus);
	if (setup_max_cpus == 0)
171
		arch_disable_smp_support();
172 173

	return 0;
L
Linus Torvalds 已提交
174 175
}

H
Hugh Dickins 已提交
176
early_param("maxcpus", maxcpus);
J
Jan Beulich 已提交
177
#else
178
static const unsigned int setup_max_cpus = NR_CPUS;
J
Jan Beulich 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191
#endif

/*
 * 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 已提交
192

193 194 195 196 197 198 199 200
static int __init set_reset_devices(char *str)
{
	reset_devices = 1;
	return 1;
}

__setup("reset_devices", set_reset_devices);

L
Linus Torvalds 已提交
201 202 203 204 205 206 207 208 209
static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
static const char *panic_later, *panic_param;

extern struct obs_kernel_param __setup_start[], __setup_end[];

static int __init obsolete_checksetup(char *line)
{
	struct obs_kernel_param *p;
210
	int had_early_param = 0;
L
Linus Torvalds 已提交
211 212 213 214 215 216

	p = __setup_start;
	do {
		int n = strlen(p->str);
		if (!strncmp(line, p->str, n)) {
			if (p->early) {
217 218 219 220
				/* 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 已提交
221
				if (line[n] == '\0' || line[n] == '=')
222
					had_early_param = 1;
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231
			} 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);
232 233

	return had_early_param;
L
Linus Torvalds 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246
}

/*
 * 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;
247
	return 0;
L
Linus Torvalds 已提交
248 249 250 251 252
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
253
	return 0;
L
Linus Torvalds 已提交
254 255
}

256 257
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
L
Linus Torvalds 已提交
258 259 260 261

static int __init loglevel(char *str)
{
	get_option(&str, &console_loglevel);
262
	return 0;
L
Linus Torvalds 已提交
263 264
}

265
early_param("loglevel", loglevel);
L
Linus Torvalds 已提交
266 267 268

/*
 * Unknown boot options get handed to init, unless they look like
269
 * unused parameters (modprobe will find them in /proc/cmdline).
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
 */
static int __init unknown_bootoption(char *param, char *val)
{
	/* Change NUL term back to "=", to make "param" the whole string. */
	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();
	}

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

290 291
	/* Unused module parameter. */
	if (strchr(param, '.') && (!val || strchr(param, '.') < val))
L
Linus Torvalds 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
		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;
}

323 324 325 326
#ifdef CONFIG_DEBUG_PAGEALLOC
int __read_mostly debug_pagealloc_enabled = 0;
#endif

L
Linus Torvalds 已提交
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
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);

344 345 346 347 348 349 350 351 352 353 354 355
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 已提交
356 357 358 359 360 361 362 363 364 365 366
#ifndef CONFIG_SMP

#ifdef CONFIG_X86_LOCAL_APIC
static void __init smp_init(void)
{
	APIC_init_uniprocessor();
}
#else
#define smp_init()	do { } while (0)
#endif

367
static inline void setup_nr_cpu_ids(void) { }
L
Linus Torvalds 已提交
368 369 370 371
static inline void smp_prepare_cpus(unsigned int maxcpus) { }

#else

372 373 374 375 376 377 378
/* Setup number of possible processor ids */
int nr_cpu_ids __read_mostly = NR_CPUS;
EXPORT_SYMBOL(nr_cpu_ids);

/* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
static void __init setup_nr_cpu_ids(void)
{
R
Rusty Russell 已提交
379
	nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1;
380 381
}

L
Linus Torvalds 已提交
382 383 384
/* Called by boot processor to activate the rest. */
static void __init smp_init(void)
{
385
	unsigned int cpu;
L
Linus Torvalds 已提交
386 387

	/* FIXME: This should be done in userspace --RR */
388
	for_each_present_cpu(cpu) {
389
		if (num_online_cpus() >= setup_max_cpus)
L
Linus Torvalds 已提交
390
			break;
391 392
		if (!cpu_online(cpu))
			cpu_up(cpu);
L
Linus Torvalds 已提交
393 394 395 396
	}

	/* Any cleanup work */
	printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
397
	smp_cpus_done(setup_max_cpus);
L
Linus Torvalds 已提交
398 399 400 401
}

#endif

402 403 404 405 406 407 408 409 410 411 412 413 414 415
/*
 * 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 已提交
416 417 418 419 420 421 422 423 424
/*
 * 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.
 */

425 426
static __initdata DECLARE_COMPLETION(kthreadd_done);

427
static noinline void __init_refok rest_init(void)
L
Linus Torvalds 已提交
428 429
	__releases(kernel_lock)
{
430 431
	int pid;

432
	rcu_scheduler_starting();
433 434 435 436 437
	/*
	 * We need to spawn init first so that it obtains pid-1, however
	 * the init task will end up wanting to create kthreads, which, if
	 * we schedule it before we create kthreadd, will OOPS.
	 */
438
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
L
Linus Torvalds 已提交
439
	numa_default_policy();
440
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
441
	rcu_read_lock();
P
Pavel Emelyanov 已提交
442
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
443
	rcu_read_unlock();
444
	complete(&kthreadd_done);
L
Linus Torvalds 已提交
445
	unlock_kernel();
446 447 448

	/*
	 * The boot idle thread must execute schedule()
I
Ingo Molnar 已提交
449
	 * at least once to get things moving:
450
	 */
I
Ingo Molnar 已提交
451
	init_idle_bootup_task(current);
452
	preempt_enable_no_resched();
453
	schedule();
454
	preempt_disable();
455

456
	/* Call into cpu_idle with preempt disabled */
L
Linus Torvalds 已提交
457
	cpu_idle();
I
Ingo Molnar 已提交
458
}
L
Linus Torvalds 已提交
459 460 461 462 463 464 465

/* Check for early params. */
static int __init do_early_param(char *param, char *val)
{
	struct obs_kernel_param *p;

	for (p = __setup_start; p < __setup_end; p++) {
466 467 468 469
		if ((p->early && strcmp(param, p->str) == 0) ||
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
L
Linus Torvalds 已提交
470 471 472 473 474 475 476 477 478
			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 已提交
479 480 481 482 483
void __init parse_early_options(char *cmdline)
{
	parse_args("early options", cmdline, NULL, 0, do_early_param);
}

L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491 492 493
/* 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. */
494
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
M
Magnus Damm 已提交
495
	parse_early_options(tmp_cmdline);
L
Linus Torvalds 已提交
496 497 498 499 500 501 502
	done = 1;
}

/*
 *	Activate the first processor.
 */

503 504 505 506
static void __init boot_cpu_init(void)
{
	int cpu = smp_processor_id();
	/* Mark the boot cpu "present", "online" etc for SMP and UP case */
507
	set_cpu_online(cpu, true);
508
	set_cpu_active(cpu, true);
509 510
	set_cpu_present(cpu, true);
	set_cpu_possible(cpu, true);
511 512
}

513
void __init __weak smp_setup_processor_id(void)
514 515 516
{
}

517 518 519 520
void __init __weak thread_info_cache_init(void)
{
}

P
Pekka Enberg 已提交
521 522 523 524 525
/*
 * Set up kernel memory allocators
 */
static void __init mm_init(void)
{
526 527 528 529 530
	/*
	 * page_cgroup requires countinous pages as memmap
	 * and it's bigger than MAX_ORDER unless SPARSEMEM.
	 */
	page_cgroup_init_flatmem();
P
Pekka Enberg 已提交
531 532
	mem_init();
	kmem_cache_init();
533
	pgtable_cache_init();
P
Pekka Enberg 已提交
534 535 536
	vmalloc_init();
}

L
Linus Torvalds 已提交
537 538 539 540
asmlinkage void __init start_kernel(void)
{
	char * command_line;
	extern struct kernel_param __start___param[], __stop___param[];
541 542 543

	smp_setup_processor_id();

I
Ingo Molnar 已提交
544 545 546 547 548
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
	lockdep_init();
549
	debug_objects_early_init();
550 551 552 553 554 555

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

556
	cgroup_init_early();
I
Ingo Molnar 已提交
557 558 559

	local_irq_disable();
	early_boot_irqs_off();
I
Ingo Molnar 已提交
560
	early_init_irq_lock_class();
I
Ingo Molnar 已提交
561

L
Linus Torvalds 已提交
562 563 564 565 566
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
	lock_kernel();
567
	tick_init();
568
	boot_cpu_init();
L
Linus Torvalds 已提交
569
	page_address_init();
A
Alex Riesen 已提交
570
	printk(KERN_NOTICE "%s", linux_banner);
L
Linus Torvalds 已提交
571
	setup_arch(&command_line);
572
	mm_init_owner(&init_mm, &init_task);
573
	setup_command_line(command_line);
574
	setup_nr_cpu_ids();
575
	setup_per_cpu_areas();
576
	smp_prepare_boot_cpu();	/* arch-specific boot-cpu hooks */
L
Linus Torvalds 已提交
577

578
	build_all_zonelists(NULL);
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
	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,
		   &unknown_bootoption);
	/*
	 * These use large bootmem allocations and must precede
	 * kmem_cache_init()
	 */
	pidhash_init();
	vfs_caches_init_early();
	sort_main_extable();
	trap_init();
P
Pekka Enberg 已提交
594
	mm_init();
L
Linus Torvalds 已提交
595 596 597 598 599 600 601 602 603 604 605
	/*
	 * 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();
606 607 608 609 610
	if (!irqs_disabled()) {
		printk(KERN_WARNING "start_kernel(): bug: interrupts were "
				"enabled *very* early, fixing it\n");
		local_irq_disable();
	}
L
Linus Torvalds 已提交
611
	rcu_init();
Y
Yinghai Lu 已提交
612
	radix_tree_init();
613 614
	/* init some links before init_ISA_irqs() */
	early_irq_init();
L
Linus Torvalds 已提交
615
	init_IRQ();
C
Catalin Marinas 已提交
616
	prio_tree_init();
L
Linus Torvalds 已提交
617
	init_timers();
618
	hrtimers_init();
L
Linus Torvalds 已提交
619
	softirq_init();
620
	timekeeping_init();
J
john stultz 已提交
621
	time_init();
622 623
	profile_init();
	if (!irqs_disabled())
624 625
		printk(KERN_CRIT "start_kernel(): bug: interrupts were "
				 "enabled early\n");
I
Ingo Molnar 已提交
626
	early_boot_irqs_on();
627
	local_irq_enable();
628 629

	/* Interrupts are enabled now so all GFP allocations are safe. */
630
	gfp_allowed_mask = __GFP_BITS_MASK;
631

632
	kmem_cache_init_late();
L
Linus Torvalds 已提交
633 634 635 636 637 638 639 640 641

	/*
	 * 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 已提交
642 643 644

	lockdep_info();

645 646 647 648 649 650 651
	/*
	 * 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 已提交
652 653
#ifdef CONFIG_BLK_DEV_INITRD
	if (initrd_start && !initrd_below_start_ok &&
654
	    page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
L
Linus Torvalds 已提交
655
		printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
656
		    "disabling it.\n",
657 658
		    page_to_pfn(virt_to_page((void *)initrd_start)),
		    min_low_pfn);
L
Linus Torvalds 已提交
659 660 661
		initrd_start = 0;
	}
#endif
662
	page_cgroup_init();
663
	enable_debug_pagealloc();
664
	kmemtrace_init();
C
Catalin Marinas 已提交
665
	kmemleak_init();
666
	debug_objects_mem_init();
667
	idr_init_cache();
668
	setup_per_cpu_pageset();
L
Linus Torvalds 已提交
669 670 671
	numa_policy_init();
	if (late_time_init)
		late_time_init();
672
	sched_clock_init();
L
Linus Torvalds 已提交
673 674 675 676 677 678 679
	calibrate_delay();
	pidmap_init();
	anon_vma_init();
#ifdef CONFIG_X86
	if (efi_enabled)
		efi_enter_virtual_mode();
#endif
680
	thread_info_cache_init();
D
David Howells 已提交
681
	cred_init();
682
	fork_init(totalram_pages);
L
Linus Torvalds 已提交
683 684 685 686
	proc_caches_init();
	buffer_init();
	key_init();
	security_init();
687
	dbg_late_init();
688
	vfs_caches_init(totalram_pages);
L
Linus Torvalds 已提交
689 690 691 692 693 694
	signals_init();
	/* rootfs populating might need page-writeback */
	page_writeback_init();
#ifdef CONFIG_PROC_FS
	proc_root_init();
#endif
695
	cgroup_init();
L
Linus Torvalds 已提交
696
	cpuset_init();
697
	taskstats_init_early();
698
	delayacct_init();
L
Linus Torvalds 已提交
699 700 701 702

	check_bugs();

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

705 706
	ftrace_init();

L
Linus Torvalds 已提交
707 708 709 710
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

711 712 713 714
/* Call all constructor functions linked into the kernel. */
static void __init do_ctors(void)
{
#ifdef CONFIG_CONSTRUCTORS
715
	ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
716

717 718
	for (; fn < (ctor_fn_t *) __ctors_end; fn++)
		(*fn)();
719 720 721
#endif
}

722
int initcall_debug;
R
Rusty Russell 已提交
723
core_param(initcall_debug, initcall_debug, bool, 0644);
L
Linus Torvalds 已提交
724

725 726 727 728
static char msgbuf[64];
static struct boot_trace_call call;
static struct boot_trace_ret ret;

729
int do_one_initcall(initcall_t fn)
L
Linus Torvalds 已提交
730 731
{
	int count = preempt_count();
732
	ktime_t calltime, delta, rettime;
L
Linus Torvalds 已提交
733

734
	if (initcall_debug) {
735 736 737 738
		call.caller = task_pid_nr(current);
		printk("calling  %pF @ %i\n", fn, call.caller);
		calltime = ktime_get();
		trace_boot_call(&call, fn);
739
		enable_boot_trace();
740
	}
L
Linus Torvalds 已提交
741

742
	ret.result = fn();
L
Linus Torvalds 已提交
743

744
	if (initcall_debug) {
745
		disable_boot_trace();
746 747
		rettime = ktime_get();
		delta = ktime_sub(rettime, calltime);
748
		ret.duration = (unsigned long long) ktime_to_ns(delta) >> 10;
749
		trace_boot_ret(&ret, fn);
750
		printk("initcall %pF returned %d after %Ld usecs\n", fn,
751
			ret.result, ret.duration);
752
	}
753

754
	msgbuf[0] = 0;
755

756 757
	if (ret.result && ret.result != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", ret.result);
758

759
	if (preempt_count() != count) {
760
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
761
		preempt_count() = count;
L
Linus Torvalds 已提交
762
	}
763
	if (irqs_disabled()) {
764
		strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
765 766 767
		local_irq_enable();
	}
	if (msgbuf[0]) {
768
		printk("initcall %pF returned with %s\n", fn, msgbuf);
769
	}
770

771
	return ret.result;
772 773 774
}


775
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
776 777 778

static void __init do_initcalls(void)
{
779
	initcall_t *fn;
780

781 782
	for (fn = __early_initcall_end; fn < __initcall_end; fn++)
		do_one_initcall(*fn);
L
Linus Torvalds 已提交
783 784 785 786 787 788 789 790 791 792 793 794 795 796

	/* Make sure there is no pending stuff from the initcall sequence */
	flush_scheduled_work();
}

/*
 * 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)
{
797
	init_workqueues();
798
	cpuset_init_smp();
L
Linus Torvalds 已提交
799
	usermodehelper_init();
800
	init_tmpfs();
L
Linus Torvalds 已提交
801
	driver_init();
802
	init_irq_proc();
803
	do_ctors();
L
Linus Torvalds 已提交
804 805 806
	do_initcalls();
}

807
static void __init do_pre_smp_initcalls(void)
808
{
809
	initcall_t *fn;
810

811 812
	for (fn = __initcall_start; fn < __early_initcall_end; fn++)
		do_one_initcall(*fn);
813 814
}

L
Linus Torvalds 已提交
815 816 817
static void run_init_process(char *init_filename)
{
	argv_init[0] = init_filename;
A
Arnd Bergmann 已提交
818
	kernel_execve(init_filename, argv_init, envp_init);
L
Linus Torvalds 已提交
819 820
}

821 822 823
/* This is a non __init function. Force it to be noinline otherwise gcc
 * makes it inline to init() and it becomes part of init.text section
 */
824
static noinline int init_post(void)
825
	__releases(kernel_lock)
826
{
827 828
	/* need to finish all async __init code before freeing the memory */
	async_synchronize_full();
829 830 831 832 833 834 835
	free_initmem();
	unlock_kernel();
	mark_rodata_ro();
	system_state = SYSTEM_RUNNING;
	numa_default_policy();


836 837
	current->signal->flags |= SIGNAL_UNKILLABLE;

838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
	if (ramdisk_execute_command) {
		run_init_process(ramdisk_execute_command);
		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) {
		run_init_process(execute_command);
		printk(KERN_WARNING "Failed to execute %s.  Attempting "
					"defaults...\n", execute_command);
	}
	run_init_process("/sbin/init");
	run_init_process("/etc/init");
	run_init_process("/bin/init");
	run_init_process("/bin/sh");

860 861
	panic("No init found.  Try passing init= option to kernel. "
	      "See Linux Documentation/init.txt for guidance.");
862 863
}

864
static int __init kernel_init(void * unused)
L
Linus Torvalds 已提交
865
{
866 867 868 869
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done);
L
Linus Torvalds 已提交
870
	lock_kernel();
871 872 873 874

	/*
	 * init can allocate pages on any node
	 */
875
	set_mems_allowed(node_states[N_HIGH_MEMORY]);
L
Linus Torvalds 已提交
876 877 878
	/*
	 * init can run on any cpu.
	 */
879
	set_cpus_allowed_ptr(current, cpu_all_mask);
L
Linus Torvalds 已提交
880 881 882 883 884 885 886 887
	/*
	 * Tell the world that we're going to be the grim
	 * reaper of innocent orphaned children.
	 *
	 * We don't want people to have to make incorrect
	 * assumptions about where in the task array this
	 * can be found.
	 */
888
	init_pid_ns.child_reaper = current;
L
Linus Torvalds 已提交
889

890 891
	cad_pid = task_pid(current);

892
	smp_prepare_cpus(setup_max_cpus);
L
Linus Torvalds 已提交
893 894

	do_pre_smp_initcalls();
895
	start_boot_trace();
L
Linus Torvalds 已提交
896 897 898 899 900 901

	smp_init();
	sched_init_smp();

	do_basic_setup();

902 903 904 905 906 907
	/* 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 已提交
908 909 910 911
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
912 913 914 915 916 917

	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 已提交
918
		prepare_namespace();
919
	}
L
Linus Torvalds 已提交
920 921 922 923 924 925

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

927 928
	init_post();
	return 0;
L
Linus Torvalds 已提交
929
}