main.c 21.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 *  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>
#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>
Nick Piggin's avatar
Nick Piggin committed
30
#include <linux/vmalloc.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
#include <linux/kernel_stat.h>
32
#include <linux/start_kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
33
#include <linux/security.h>
34
#include <linux/smp.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
53
#include <linux/unwind.h>
Adrian Bunk's avatar
Adrian Bunk committed
54
#include <linux/buffer_head.h>
55
#include <linux/page_cgroup.h>
56
#include <linux/debug_locks.h>
57
#include <linux/debugobjects.h>
Ingo Molnar's avatar
Ingo Molnar committed
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 <trace/boot.h>
Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
71
#include <asm/sections.h>
72
#include <asm/cacheflush.h>
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78

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

/*
79 80
 * This is one of the first .c files built. Error out early if we have compiler
 * trouble.
Linus Torvalds's avatar
Linus Torvalds committed
81 82
 */

Andrew Morton's avatar
Andrew Morton committed
83 84 85 86
#if __GNUC__ == 4 && __GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ == 0
#warning gcc-4.1.0 is known to miscompile the kernel.  A different compiler version is recommended.
#endif

87
static int kernel_init(void *);
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90 91 92 93 94 95 96 97 98 99 100

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
101 102 103
#ifndef CONFIG_DEBUG_RODATA
static inline void mark_rodata_ro(void) { }
#endif
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

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

enum system_states system_state;
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. */
void (*late_time_init)(void);
extern void softirq_init(void);

123 124 125 126 127 128
/* 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;
Linus Torvalds's avatar
Linus Torvalds committed
129 130

static char *execute_command;
131
static char *ramdisk_execute_command;
Linus Torvalds's avatar
Linus Torvalds committed
132

Jan Beulich's avatar
Jan Beulich committed
133
#ifdef CONFIG_SMP
Linus Torvalds's avatar
Linus Torvalds committed
134
/* Setup configured maximum number of CPUs to activate */
135
unsigned int __initdata setup_max_cpus = NR_CPUS;
136

Linus Torvalds's avatar
Linus Torvalds committed
137 138 139 140 141 142 143 144 145 146
/*
 * 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>.
 */
147 148 149 150
#ifndef CONFIG_X86_IO_APIC
static inline void disable_ioapic_setup(void) {};
#endif

Linus Torvalds's avatar
Linus Torvalds committed
151 152
static int __init nosmp(char *str)
{
153
	setup_max_cpus = 0;
154
	disable_ioapic_setup();
Jan Beulich's avatar
Jan Beulich committed
155
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
156 157
}

Jan Beulich's avatar
Jan Beulich committed
158
early_param("nosmp", nosmp);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161

static int __init maxcpus(char *str)
{
162 163
	get_option(&str, &setup_max_cpus);
	if (setup_max_cpus == 0)
164 165 166
		disable_ioapic_setup();

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
167 168
}

Hugh Dickins's avatar
Hugh Dickins committed
169
early_param("maxcpus", maxcpus);
Jan Beulich's avatar
Jan Beulich committed
170
#else
171
#define setup_max_cpus NR_CPUS
Jan Beulich's avatar
Jan Beulich committed
172 173 174 175 176 177 178 179 180 181 182 183 184
#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);
Linus Torvalds's avatar
Linus Torvalds committed
185

186 187 188 189 190 191 192 193
static int __init set_reset_devices(char *str)
{
	reset_devices = 1;
	return 1;
}

__setup("reset_devices", set_reset_devices);

Linus Torvalds's avatar
Linus Torvalds committed
194 195 196 197 198 199 200 201 202
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;
203
	int had_early_param = 0;
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208 209

	p = __setup_start;
	do {
		int n = strlen(p->str);
		if (!strncmp(line, p->str, n)) {
			if (p->early) {
210 211 212 213
				/* 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( */
Linus Torvalds's avatar
Linus Torvalds committed
214
				if (line[n] == '\0' || line[n] == '=')
215
					had_early_param = 1;
Linus Torvalds's avatar
Linus Torvalds committed
216 217 218 219 220 221 222 223 224
			} 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);
225 226

	return had_early_param;
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232 233 234 235 236 237 238 239
}

/*
 * 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;
240
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
246
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
247 248
}

249 250
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
Linus Torvalds's avatar
Linus Torvalds committed
251 252 253 254

static int __init loglevel(char *str)
{
	get_option(&str, &console_loglevel);
255
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
256 257
}

258
early_param("loglevel", loglevel);
Linus Torvalds's avatar
Linus Torvalds committed
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

/*
 * 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;

	/*
Simon Arlott's avatar
Simon Arlott committed
284
	 * Preemptive maintenance for "why didn't my misspelled command
Linus Torvalds's avatar
Linus Torvalds committed
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 314 315 316 317 318 319 320
	 * 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;
}

321 322 323 324
#ifdef CONFIG_DEBUG_PAGEALLOC
int __read_mostly debug_pagealloc_enabled = 0;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
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);

342 343 344 345 346 347 348 349 350 351 352 353
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);

Linus Torvalds's avatar
Linus Torvalds committed
354 355 356 357 358 359 360 361 362 363 364 365
#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) { }
366
static inline void setup_nr_cpu_ids(void) { }
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369 370
static inline void smp_prepare_cpus(unsigned int maxcpus) { }

#else

371 372 373 374 375
#if NR_CPUS > BITS_PER_LONG
cpumask_t cpu_mask_all __read_mostly = CPU_MASK_ALL;
EXPORT_SYMBOL(cpu_mask_all);
#endif

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
/* 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)
{
	int cpu, highest_cpu = 0;

	for_each_possible_cpu(cpu)
		highest_cpu = cpu;

	nr_cpu_ids = highest_cpu + 1;
}

391
#ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
392
unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395 396 397 398 399

EXPORT_SYMBOL(__per_cpu_offset);

static void __init setup_per_cpu_areas(void)
{
	unsigned long size, i;
	char *ptr;
400
	unsigned long nr_possible_cpus = num_possible_cpus();
Linus Torvalds's avatar
Linus Torvalds committed
401 402

	/* Copy section for each CPU (we discard the original) */
403 404
	size = ALIGN(PERCPU_ENOUGH_ROOM, PAGE_SIZE);
	ptr = alloc_bootmem_pages(size * nr_possible_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
405

406
	for_each_possible_cpu(i) {
Linus Torvalds's avatar
Linus Torvalds committed
407 408
		__per_cpu_offset[i] = ptr - __per_cpu_start;
		memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
409
		ptr += size;
Linus Torvalds's avatar
Linus Torvalds committed
410 411
	}
}
412
#endif /* CONFIG_HAVE_SETUP_PER_CPU_AREA */
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415 416

/* Called by boot processor to activate the rest. */
static void __init smp_init(void)
{
417
	unsigned int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
418

419 420 421 422 423 424 425
	/*
	 * 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);

Linus Torvalds's avatar
Linus Torvalds committed
426
	/* FIXME: This should be done in userspace --RR */
427
	for_each_present_cpu(cpu) {
428
		if (num_online_cpus() >= setup_max_cpus)
Linus Torvalds's avatar
Linus Torvalds committed
429
			break;
430 431
		if (!cpu_online(cpu))
			cpu_up(cpu);
Linus Torvalds's avatar
Linus Torvalds committed
432 433 434 435
	}

	/* Any cleanup work */
	printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
436
	smp_cpus_done(setup_max_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
437 438 439 440
}

#endif

441 442 443 444 445 446 447 448 449 450 451 452 453 454
/*
 * 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);
}

Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458 459 460 461 462 463
/*
 * 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.
 */

464
static void noinline __init_refok rest_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
465 466
	__releases(kernel_lock)
{
467 468
	int pid;

469
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
Linus Torvalds's avatar
Linus Torvalds committed
470
	numa_default_policy();
471
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
472
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
Linus Torvalds's avatar
Linus Torvalds committed
473
	unlock_kernel();
474 475 476

	/*
	 * The boot idle thread must execute schedule()
477
	 * at least once to get things moving:
478
	 */
479
	init_idle_bootup_task(current);
480
	preempt_enable_no_resched();
481
	schedule();
482
	preempt_disable();
483

484
	/* Call into cpu_idle with preempt disabled */
Linus Torvalds's avatar
Linus Torvalds committed
485
	cpu_idle();
486
}
Linus Torvalds's avatar
Linus Torvalds committed
487 488 489 490 491 492 493

/* 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++) {
494 495 496 497
		if ((p->early && strcmp(param, p->str) == 0) ||
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
			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. */
517
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
518 519 520 521 522 523 524 525
	parse_args("early options", tmp_cmdline, NULL, 0, do_early_param);
	done = 1;
}

/*
 *	Activate the first processor.
 */

526 527 528 529 530 531 532 533 534
static void __init boot_cpu_init(void)
{
	int cpu = smp_processor_id();
	/* Mark the boot cpu "present", "online" etc for SMP and UP case */
	cpu_set(cpu, cpu_online_map);
	cpu_set(cpu, cpu_present_map);
	cpu_set(cpu, cpu_possible_map);
}

535
void __init __weak smp_setup_processor_id(void)
536 537 538
{
}

539 540 541 542
void __init __weak thread_info_cache_init(void)
{
}

Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546
asmlinkage void __init start_kernel(void)
{
	char * command_line;
	extern struct kernel_param __start___param[], __stop___param[];
547 548 549

	smp_setup_processor_id();

Ingo Molnar's avatar
Ingo Molnar committed
550 551 552 553
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
554
	unwind_init();
Ingo Molnar's avatar
Ingo Molnar committed
555
	lockdep_init();
556
	debug_objects_early_init();
557
	cgroup_init_early();
Ingo Molnar's avatar
Ingo Molnar committed
558 559 560

	local_irq_disable();
	early_boot_irqs_off();
561
	early_init_irq_lock_class();
Ingo Molnar's avatar
Ingo Molnar committed
562

Linus Torvalds's avatar
Linus Torvalds committed
563 564 565 566 567
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
	lock_kernel();
568
	tick_init();
569
	boot_cpu_init();
Linus Torvalds's avatar
Linus Torvalds committed
570 571
	page_address_init();
	printk(KERN_NOTICE);
572
	printk(linux_banner);
Linus Torvalds's avatar
Linus Torvalds committed
573
	setup_arch(&command_line);
574
	mm_init_owner(&init_mm, &init_task);
575
	setup_command_line(command_line);
576
	unwind_setup();
Linus Torvalds's avatar
Linus Torvalds committed
577
	setup_per_cpu_areas();
578
	setup_nr_cpu_ids();
579
	smp_prepare_boot_cpu();	/* arch-specific boot-cpu hooks */
Linus Torvalds's avatar
Linus Torvalds committed
580 581 582 583 584 585 586 587 588 589 590 591 592 593

	/*
	 * 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();
594
	printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
Linus Torvalds's avatar
Linus Torvalds committed
595
	parse_early_param();
596
	parse_args("Booting kernel", static_command_line, __start___param,
Linus Torvalds's avatar
Linus Torvalds committed
597 598
		   __stop___param - __start___param,
		   &unknown_bootoption);
599 600 601 602 603
	if (!irqs_disabled()) {
		printk(KERN_WARNING "start_kernel(): bug: interrupts were "
				"enabled *very* early, fixing it\n");
		local_irq_disable();
	}
Linus Torvalds's avatar
Linus Torvalds committed
604 605 606 607 608 609
	sort_main_extable();
	trap_init();
	rcu_init();
	init_IRQ();
	pidhash_init();
	init_timers();
610
	hrtimers_init();
Linus Torvalds's avatar
Linus Torvalds committed
611
	softirq_init();
612
	timekeeping_init();
613
	time_init();
614
	sched_clock_init();
615 616 617
	profile_init();
	if (!irqs_disabled())
		printk("start_kernel(): bug: interrupts were enabled early\n");
Ingo Molnar's avatar
Ingo Molnar committed
618
	early_boot_irqs_on();
619
	local_irq_enable();
Linus Torvalds's avatar
Linus Torvalds committed
620 621 622 623 624 625 626 627 628

	/*
	 * 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);
Ingo Molnar's avatar
Ingo Molnar committed
629 630 631

	lockdep_info();

632 633 634 635 636 637 638
	/*
	 * 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();

Linus Torvalds's avatar
Linus Torvalds committed
639 640
#ifdef CONFIG_BLK_DEV_INITRD
	if (initrd_start && !initrd_below_start_ok &&
641
	    page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
Linus Torvalds's avatar
Linus Torvalds committed
642
		printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
643
		    "disabling it.\n",
644 645
		    page_to_pfn(virt_to_page((void *)initrd_start)),
		    min_low_pfn);
Linus Torvalds's avatar
Linus Torvalds committed
646 647 648
		initrd_start = 0;
	}
#endif
Nick Piggin's avatar
Nick Piggin committed
649
	vmalloc_init();
Linus Torvalds's avatar
Linus Torvalds committed
650
	vfs_caches_init_early();
651
	cpuset_init_early();
652
	page_cgroup_init();
Linus Torvalds's avatar
Linus Torvalds committed
653
	mem_init();
654
	enable_debug_pagealloc();
655
	cpu_hotplug_init();
Linus Torvalds's avatar
Linus Torvalds committed
656
	kmem_cache_init();
657
	debug_objects_mem_init();
658
	idr_init_cache();
659
	setup_per_cpu_pageset();
Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663 664 665 666 667 668 669 670 671
	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
672
	thread_info_cache_init();
Linus Torvalds's avatar
Linus Torvalds committed
673 674 675 676 677 678 679 680 681 682 683 684 685
	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
686
	cgroup_init();
Linus Torvalds's avatar
Linus Torvalds committed
687
	cpuset_init();
688
	taskstats_init_early();
689
	delayacct_init();
Linus Torvalds's avatar
Linus Torvalds committed
690 691 692 693 694

	check_bugs();

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

695 696
	ftrace_init();

Linus Torvalds's avatar
Linus Torvalds committed
697 698 699 700
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

701
static int initcall_debug;
702
core_param(initcall_debug, initcall_debug, bool, 0644);
Linus Torvalds's avatar
Linus Torvalds committed
703

704
int do_one_initcall(initcall_t fn)
Linus Torvalds's avatar
Linus Torvalds committed
705 706
{
	int count = preempt_count();
707
	ktime_t delta;
708
	char msgbuf[64];
709
	struct boot_trace it;
Linus Torvalds's avatar
Linus Torvalds committed
710

711
	if (initcall_debug) {
712 713
		it.caller = task_pid_nr(current);
		printk("calling  %pF @ %i\n", fn, it.caller);
714
		it.calltime = ktime_get();
715
		enable_boot_trace();
716
	}
Linus Torvalds's avatar
Linus Torvalds committed
717

718
	it.result = fn();
Linus Torvalds's avatar
Linus Torvalds committed
719

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

730
	msgbuf[0] = 0;
731

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

735
	if (preempt_count() != count) {
736
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
737
		preempt_count() = count;
Linus Torvalds's avatar
Linus Torvalds committed
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 it.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);
Linus Torvalds's avatar
Linus Torvalds committed
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)
{
Paul E. McKenney's avatar
Paul E. McKenney committed
773
	rcu_init_sched(); /* needed by module_init stage. */
774
	init_workqueues();
Linus Torvalds's avatar
Linus Torvalds committed
775 776
	usermodehelper_init();
	driver_init();
777
	init_irq_proc();
Linus Torvalds's avatar
Linus Torvalds committed
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
789 790 791
static void run_init_process(char *init_filename)
{
	argv_init[0] = init_filename;
792
	kernel_execve(init_filename, argv_init, envp_init);
Linus Torvalds's avatar
Linus Torvalds committed
793 794
}

795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
/* 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
 */
static int noinline init_post(void)
{
	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);

812 813
	current->signal->flags |= SIGNAL_UNKILLABLE;

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

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

856 857
	cad_pid = task_pid(current);

858
	smp_prepare_cpus(setup_max_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
859 860

	do_pre_smp_initcalls();
861
	start_boot_trace();
Linus Torvalds's avatar
Linus Torvalds committed
862 863 864 865 866 867 868 869 870 871 872 873

	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
	 */
874 875 876 877 878 879

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

	if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
		ramdisk_execute_command = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
880
		prepare_namespace();
881
	}
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884 885 886 887

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

889 890
	init_post();
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
891
}