main.c 21.3 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 26 27 28 29 30
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/utsname.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/initrd.h>
#include <linux/bootmem.h>
#include <linux/tty.h>
#include <linux/gfp.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
N
Nick Piggin 已提交
31
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
32
#include <linux/kernel_stat.h>
33
#include <linux/start_kernel.h>
L
Linus Torvalds 已提交
34
#include <linux/security.h>
35
#include <linux/smp.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43
#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>
44
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
45
#include <linux/efi.h>
46
#include <linux/tick.h>
47
#include <linux/interrupt.h>
48
#include <linux/taskstats_kern.h>
49
#include <linux/delayacct.h>
L
Linus Torvalds 已提交
50 51 52 53
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
A
Adrian Bunk 已提交
54
#include <linux/buffer_head.h>
55
#include <linux/page_cgroup.h>
56
#include <linux/debug_locks.h>
57
#include <linux/debugobjects.h>
I
Ingo Molnar 已提交
58
#include <linux/lockdep.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/ftrace.h>
66
#include <linux/async.h>
67
#include <trace/boot.h>
L
Linus Torvalds 已提交
68 69 70 71

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
72
#include <asm/sections.h>
73
#include <asm/cacheflush.h>
74
#include <trace/kmemtrace.h>
L
Linus Torvalds 已提交
75 76 77 78 79

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

80
static int kernel_init(void *);
L
Linus Torvalds 已提交
81 82 83 84 85 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);
#ifdef	CONFIG_ACPI
extern void acpi_early_init(void);
#else
static inline void acpi_early_init(void) { }
#endif
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

static int __init maxcpus(char *str)
{
155 156
	get_option(&str, &setup_max_cpus);
	if (setup_max_cpus == 0)
157
		arch_disable_smp_support();
158 159

	return 0;
L
Linus Torvalds 已提交
160 161
}

H
Hugh Dickins 已提交
162
early_param("maxcpus", maxcpus);
J
Jan Beulich 已提交
163
#else
164
const unsigned int setup_max_cpus = NR_CPUS;
J
Jan Beulich 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177
#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 已提交
178

179 180 181 182 183 184 185 186
static int __init set_reset_devices(char *str)
{
	reset_devices = 1;
	return 1;
}

__setup("reset_devices", set_reset_devices);

L
Linus Torvalds 已提交
187 188 189 190 191 192 193 194 195
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;
196
	int had_early_param = 0;
L
Linus Torvalds 已提交
197 198 199 200 201 202

	p = __setup_start;
	do {
		int n = strlen(p->str);
		if (!strncmp(line, p->str, n)) {
			if (p->early) {
203 204 205 206
				/* 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 已提交
207
				if (line[n] == '\0' || line[n] == '=')
208
					had_early_param = 1;
L
Linus Torvalds 已提交
209 210 211 212 213 214 215 216 217
			} 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);
218 219

	return had_early_param;
L
Linus Torvalds 已提交
220 221 222 223 224 225 226 227 228 229 230 231 232
}

/*
 * 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;
233
	return 0;
L
Linus Torvalds 已提交
234 235 236 237 238
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
239
	return 0;
L
Linus Torvalds 已提交
240 241
}

242 243
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
L
Linus Torvalds 已提交
244 245 246 247

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

251
early_param("loglevel", loglevel);
L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276

/*
 * Unknown boot options get handed to init, unless they look like
 * failed parameters
 */
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;

	/*
S
Simon Arlott 已提交
277
	 * Preemptive maintenance for "why didn't my misspelled command
L
Linus Torvalds 已提交
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 308 309 310 311 312 313
	 * line work?"
	 */
	if (strchr(param, '.') && (!val || strchr(param, '.') < val)) {
		printk(KERN_ERR "Unknown boot option `%s': ignoring\n", param);
		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;
}

314 315 316 317
#ifdef CONFIG_DEBUG_PAGEALLOC
int __read_mostly debug_pagealloc_enabled = 0;
#endif

L
Linus Torvalds 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
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);

335 336 337 338 339 340 341 342 343 344 345 346
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 已提交
347 348 349 350 351 352 353 354 355 356 357 358
#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

static inline void setup_per_cpu_areas(void) { }
359
static inline void setup_nr_cpu_ids(void) { }
L
Linus Torvalds 已提交
360 361 362 363
static inline void smp_prepare_cpus(unsigned int maxcpus) { }

#else

364 365 366 367 368
#if NR_CPUS > BITS_PER_LONG
cpumask_t cpu_mask_all __read_mostly = CPU_MASK_ALL;
EXPORT_SYMBOL(cpu_mask_all);
#endif

369 370 371 372 373 374 375
/* 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 已提交
376
	nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1;
377 378
}

379
#ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
E
Eric Dumazet 已提交
380
unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
L
Linus Torvalds 已提交
381 382 383 384 385 386 387

EXPORT_SYMBOL(__per_cpu_offset);

static void __init setup_per_cpu_areas(void)
{
	unsigned long size, i;
	char *ptr;
388
	unsigned long nr_possible_cpus = num_possible_cpus();
L
Linus Torvalds 已提交
389 390

	/* Copy section for each CPU (we discard the original) */
391 392
	size = ALIGN(PERCPU_ENOUGH_ROOM, PAGE_SIZE);
	ptr = alloc_bootmem_pages(size * nr_possible_cpus);
L
Linus Torvalds 已提交
393

394
	for_each_possible_cpu(i) {
L
Linus Torvalds 已提交
395 396
		__per_cpu_offset[i] = ptr - __per_cpu_start;
		memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
397
		ptr += size;
L
Linus Torvalds 已提交
398 399
	}
}
400
#endif /* CONFIG_HAVE_SETUP_PER_CPU_AREA */
L
Linus Torvalds 已提交
401 402 403 404

/* Called by boot processor to activate the rest. */
static void __init smp_init(void)
{
405
	unsigned int cpu;
L
Linus Torvalds 已提交
406

407 408 409 410 411 412 413
	/*
	 * Set up the current CPU as possible to migrate to.
	 * The other ones will be done by cpu_up/cpu_down()
	 */
	cpu = smp_processor_id();
	cpu_set(cpu, cpu_active_map);

L
Linus Torvalds 已提交
414
	/* FIXME: This should be done in userspace --RR */
415
	for_each_present_cpu(cpu) {
416
		if (num_online_cpus() >= setup_max_cpus)
L
Linus Torvalds 已提交
417
			break;
418 419
		if (!cpu_online(cpu))
			cpu_up(cpu);
L
Linus Torvalds 已提交
420 421 422 423
	}

	/* Any cleanup work */
	printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
424
	smp_cpus_done(setup_max_cpus);
L
Linus Torvalds 已提交
425 426 427 428
}

#endif

429 430 431 432 433 434 435 436 437 438 439 440 441 442
/*
 * 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 已提交
443 444 445 446 447 448 449 450 451
/*
 * 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.
 */

452
static noinline void __init_refok rest_init(void)
L
Linus Torvalds 已提交
453 454
	__releases(kernel_lock)
{
455 456
	int pid;

457
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
L
Linus Torvalds 已提交
458
	numa_default_policy();
459
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
P
Pavel Emelyanov 已提交
460
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
L
Linus Torvalds 已提交
461
	unlock_kernel();
462 463 464

	/*
	 * The boot idle thread must execute schedule()
I
Ingo Molnar 已提交
465
	 * at least once to get things moving:
466
	 */
I
Ingo Molnar 已提交
467
	init_idle_bootup_task(current);
468
	rcu_scheduler_starting();
469
	preempt_enable_no_resched();
470
	schedule();
471
	preempt_disable();
472

473
	/* Call into cpu_idle with preempt disabled */
L
Linus Torvalds 已提交
474
	cpu_idle();
I
Ingo Molnar 已提交
475
}
L
Linus Torvalds 已提交
476 477 478 479 480 481 482

/* 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++) {
483 484 485 486
		if ((p->early && strcmp(param, p->str) == 0) ||
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
L
Linus Torvalds 已提交
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
			if (p->setup_func(val) != 0)
				printk(KERN_WARNING
				       "Malformed early option '%s'\n", param);
		}
	}
	/* We accept everything at this stage. */
	return 0;
}

/* 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. */
506
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
L
Linus Torvalds 已提交
507 508 509 510 511 512 513 514
	parse_args("early options", tmp_cmdline, NULL, 0, do_early_param);
	done = 1;
}

/*
 *	Activate the first processor.
 */

515 516 517 518
static void __init boot_cpu_init(void)
{
	int cpu = smp_processor_id();
	/* Mark the boot cpu "present", "online" etc for SMP and UP case */
519 520 521
	set_cpu_online(cpu, true);
	set_cpu_present(cpu, true);
	set_cpu_possible(cpu, true);
522 523
}

524
void __init __weak smp_setup_processor_id(void)
525 526 527
{
}

528 529 530 531
void __init __weak thread_info_cache_init(void)
{
}

L
Linus Torvalds 已提交
532 533 534 535
asmlinkage void __init start_kernel(void)
{
	char * command_line;
	extern struct kernel_param __start___param[], __stop___param[];
536 537 538

	smp_setup_processor_id();

I
Ingo Molnar 已提交
539 540 541 542 543
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
	lockdep_init();
544
	debug_objects_early_init();
545 546 547 548 549 550

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

551
	cgroup_init_early();
I
Ingo Molnar 已提交
552 553 554

	local_irq_disable();
	early_boot_irqs_off();
I
Ingo Molnar 已提交
555
	early_init_irq_lock_class();
I
Ingo Molnar 已提交
556

L
Linus Torvalds 已提交
557 558 559 560 561
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
	lock_kernel();
562
	tick_init();
563
	boot_cpu_init();
L
Linus Torvalds 已提交
564 565
	page_address_init();
	printk(KERN_NOTICE);
566
	printk(linux_banner);
L
Linus Torvalds 已提交
567
	setup_arch(&command_line);
568
	mm_init_owner(&init_mm, &init_task);
569
	setup_command_line(command_line);
L
Linus Torvalds 已提交
570
	setup_per_cpu_areas();
571
	setup_nr_cpu_ids();
572
	smp_prepare_boot_cpu();	/* arch-specific boot-cpu hooks */
L
Linus Torvalds 已提交
573 574 575 576 577 578 579 580 581 582 583 584 585 586

	/*
	 * 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();
	build_all_zonelists();
	page_alloc_init();
587
	printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
L
Linus Torvalds 已提交
588
	parse_early_param();
589
	parse_args("Booting kernel", static_command_line, __start___param,
L
Linus Torvalds 已提交
590 591
		   __stop___param - __start___param,
		   &unknown_bootoption);
592 593 594 595 596
	if (!irqs_disabled()) {
		printk(KERN_WARNING "start_kernel(): bug: interrupts were "
				"enabled *very* early, fixing it\n");
		local_irq_disable();
	}
L
Linus Torvalds 已提交
597 598 599
	sort_main_extable();
	trap_init();
	rcu_init();
600 601
	/* init some links before init_ISA_irqs() */
	early_irq_init();
L
Linus Torvalds 已提交
602 603 604
	init_IRQ();
	pidhash_init();
	init_timers();
605
	hrtimers_init();
L
Linus Torvalds 已提交
606
	softirq_init();
607
	timekeeping_init();
J
john stultz 已提交
608
	time_init();
609
	sched_clock_init();
610 611
	profile_init();
	if (!irqs_disabled())
612 613
		printk(KERN_CRIT "start_kernel(): bug: interrupts were "
				 "enabled early\n");
I
Ingo Molnar 已提交
614
	early_boot_irqs_on();
615
	local_irq_enable();
L
Linus Torvalds 已提交
616 617 618 619 620 621 622 623 624

	/*
	 * 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 已提交
625 626 627

	lockdep_info();

628 629 630 631 632 633 634
	/*
	 * 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 已提交
635 636
#ifdef CONFIG_BLK_DEV_INITRD
	if (initrd_start && !initrd_below_start_ok &&
637
	    page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
L
Linus Torvalds 已提交
638
		printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
639
		    "disabling it.\n",
640 641
		    page_to_pfn(virt_to_page((void *)initrd_start)),
		    min_low_pfn);
L
Linus Torvalds 已提交
642 643 644
		initrd_start = 0;
	}
#endif
N
Nick Piggin 已提交
645
	vmalloc_init();
L
Linus Torvalds 已提交
646
	vfs_caches_init_early();
647
	cpuset_init_early();
648
	page_cgroup_init();
L
Linus Torvalds 已提交
649
	mem_init();
650
	enable_debug_pagealloc();
651
	cpu_hotplug_init();
L
Linus Torvalds 已提交
652
	kmem_cache_init();
653
	kmemtrace_init();
654
	debug_objects_mem_init();
655
	idr_init_cache();
656
	setup_per_cpu_pageset();
L
Linus Torvalds 已提交
657 658 659 660 661 662 663 664 665 666 667 668
	numa_policy_init();
	if (late_time_init)
		late_time_init();
	calibrate_delay();
	pidmap_init();
	pgtable_cache_init();
	prio_tree_init();
	anon_vma_init();
#ifdef CONFIG_X86
	if (efi_enabled)
		efi_enter_virtual_mode();
#endif
669
	thread_info_cache_init();
D
David Howells 已提交
670
	cred_init();
L
Linus Torvalds 已提交
671 672 673 674 675 676 677 678 679 680 681 682 683
	fork_init(num_physpages);
	proc_caches_init();
	buffer_init();
	key_init();
	security_init();
	vfs_caches_init(num_physpages);
	radix_tree_init();
	signals_init();
	/* rootfs populating might need page-writeback */
	page_writeback_init();
#ifdef CONFIG_PROC_FS
	proc_root_init();
#endif
684
	cgroup_init();
L
Linus Torvalds 已提交
685
	cpuset_init();
686
	taskstats_init_early();
687
	delayacct_init();
L
Linus Torvalds 已提交
688 689 690 691 692

	check_bugs();

	acpi_early_init(); /* before LAPIC and SMP init */

693 694
	ftrace_init();

L
Linus Torvalds 已提交
695 696 697 698
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

699
int initcall_debug;
R
Rusty Russell 已提交
700
core_param(initcall_debug, initcall_debug, bool, 0644);
L
Linus Torvalds 已提交
701

702
int do_one_initcall(initcall_t fn)
L
Linus Torvalds 已提交
703 704
{
	int count = preempt_count();
705
	ktime_t calltime, delta, rettime;
706
	char msgbuf[64];
707 708
	struct boot_trace_call call;
	struct boot_trace_ret ret;
L
Linus Torvalds 已提交
709

710
	if (initcall_debug) {
711 712 713 714
		call.caller = task_pid_nr(current);
		printk("calling  %pF @ %i\n", fn, call.caller);
		calltime = ktime_get();
		trace_boot_call(&call, fn);
715
		enable_boot_trace();
716
	}
L
Linus Torvalds 已提交
717

718
	ret.result = fn();
L
Linus Torvalds 已提交
719

720
	if (initcall_debug) {
721
		disable_boot_trace();
722 723
		rettime = ktime_get();
		delta = ktime_sub(rettime, calltime);
724
		ret.duration = (unsigned long long) ktime_to_ns(delta) >> 10;
725
		trace_boot_ret(&ret, fn);
726
		printk("initcall %pF returned %d after %Ld usecs\n", fn,
727
			ret.result, ret.duration);
728
	}
729

730
	msgbuf[0] = 0;
731

732 733
	if (ret.result && ret.result != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", ret.result);
734

735
	if (preempt_count() != count) {
736
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
737
		preempt_count() = count;
L
Linus Torvalds 已提交
738
	}
739
	if (irqs_disabled()) {
740
		strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
741 742 743
		local_irq_enable();
	}
	if (msgbuf[0]) {
744
		printk("initcall %pF returned with %s\n", fn, msgbuf);
745
	}
746

747
	return ret.result;
748 749 750
}


751
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
752 753 754 755 756

static void __init do_initcalls(void)
{
	initcall_t *call;

757
	for (call = __early_initcall_end; call < __initcall_end; call++)
758
		do_one_initcall(*call);
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772

	/* 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)
{
P
Paul E. McKenney 已提交
773
	rcu_init_sched(); /* needed by module_init stage. */
774
	init_workqueues();
L
Linus Torvalds 已提交
775 776
	usermodehelper_init();
	driver_init();
777
	init_irq_proc();
L
Linus Torvalds 已提交
778 779 780
	do_initcalls();
}

781
static void __init do_pre_smp_initcalls(void)
782 783 784 785 786 787 788
{
	initcall_t *call;

	for (call = __initcall_start; call < __early_initcall_end; call++)
		do_one_initcall(*call);
}

L
Linus Torvalds 已提交
789 790 791
static void run_init_process(char *init_filename)
{
	argv_init[0] = init_filename;
A
Arnd Bergmann 已提交
792
	kernel_execve(init_filename, argv_init, envp_init);
L
Linus Torvalds 已提交
793 794
}

795 796 797
/* 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
 */
798
static noinline int init_post(void)
799
{
800 801
	/* need to finish all async __init code before freeing the memory */
	async_synchronize_full();
802 803 804 805 806 807 808 809 810 811 812 813
	free_initmem();
	unlock_kernel();
	mark_rodata_ro();
	system_state = SYSTEM_RUNNING;
	numa_default_policy();

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

814 815
	current->signal->flags |= SIGNAL_UNKILLABLE;

816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
	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");

	panic("No init found.  Try passing init= option to kernel.");
}

841
static int __init kernel_init(void * unused)
L
Linus Torvalds 已提交
842 843 844 845 846
{
	lock_kernel();
	/*
	 * init can run on any cpu.
	 */
847
	set_cpus_allowed_ptr(current, CPU_MASK_ALL_PTR);
L
Linus Torvalds 已提交
848 849 850 851 852 853 854 855
	/*
	 * 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.
	 */
856
	init_pid_ns.child_reaper = current;
L
Linus Torvalds 已提交
857

858 859
	cad_pid = task_pid(current);

860
	smp_prepare_cpus(setup_max_cpus);
L
Linus Torvalds 已提交
861 862

	do_pre_smp_initcalls();
863
	start_boot_trace();
L
Linus Torvalds 已提交
864 865 866 867 868 869 870 871 872 873 874 875

	smp_init();
	sched_init_smp();

	cpuset_init_smp();

	do_basic_setup();

	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
876 877 878 879 880 881

	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 已提交
882
		prepare_namespace();
883
	}
L
Linus Torvalds 已提交
884 885 886 887 888 889

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

891 892
	init_post();
	return 0;
L
Linus Torvalds 已提交
893
}