main.c 21.6 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
/*
 *  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>
Ingo Molnar's avatar
Ingo Molnar committed
17
#include <linux/stackprotector.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
26 27 28
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
Nick Piggin's avatar
Nick Piggin committed
29
#include <linux/vmalloc.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
#include <linux/kernel_stat.h>
31
#include <linux/start_kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
32
#include <linux/security.h>
33
#include <linux/smp.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
Adrian Bunk's avatar
Adrian Bunk committed
51
#include <linux/buffer_head.h>
52
#include <linux/page_cgroup.h>
53
#include <linux/debug_locks.h>
54
#include <linux/debugobjects.h>
Ingo Molnar's avatar
Ingo Molnar committed
55
#include <linux/lockdep.h>
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>
Al Viro's avatar
Al Viro committed
71
#include <linux/file.h>
72
#include <linux/ptrace.h>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
79 80 81 82 83

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

84
static int kernel_init(void *);
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
128 129

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

Jan Beulich's avatar
Jan Beulich committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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, };
Linus Torvalds's avatar
Linus Torvalds committed
154 155
static const char *panic_later, *panic_param;

156
extern const struct obs_kernel_param __setup_start[], __setup_end[];
Linus Torvalds's avatar
Linus Torvalds committed
157 158 159

static int __init obsolete_checksetup(char *line)
{
160
	const struct obs_kernel_param *p;
161
	int had_early_param = 0;
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164 165

	p = __setup_start;
	do {
		int n = strlen(p->str);
166
		if (parameqn(line, p->str, n)) {
Linus Torvalds's avatar
Linus Torvalds committed
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( */
Linus Torvalds's avatar
Linus Torvalds committed
172
				if (line[n] == '\0' || line[n] == '=')
173
					had_early_param = 1;
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202 203
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
204
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
205 206
}

207 208
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
225 226
}

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

Linus Torvalds's avatar
Linus Torvalds committed
320
#ifndef CONFIG_SMP
321
static const unsigned int setup_max_cpus = NR_CPUS;
Linus Torvalds's avatar
Linus Torvalds committed
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) { }
Linus Torvalds's avatar
Linus Torvalds committed
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
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)
Linus Torvalds's avatar
Linus Torvalds committed
361
{
362 363
	int pid;

364
	rcu_scheduler_starting();
365
	/*
Peter Zijlstra's avatar
Peter Zijlstra committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
371
	numa_default_policy();
372
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
373
	rcu_read_lock();
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()
380
	 * at least once to get things moving:
381
	 */
382
	init_idle_bootup_task(current);
383
	schedule_preempt_disabled();
384
	/* Call into cpu_idle with preempt disabled */
Linus Torvalds's avatar
Linus Torvalds committed
385
	cpu_idle();
386
}
Linus Torvalds's avatar
Linus Torvalds committed
387 388

/* Check for early params. */
389
static int __init do_early_param(char *param, char *val, const char *unused)
Linus Torvalds's avatar
Linus Torvalds committed
390
{
391
	const struct obs_kernel_param *p;
Linus Torvalds's avatar
Linus Torvalds committed
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)
		) {
Linus Torvalds's avatar
Linus Torvalds committed
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;
}

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

Linus Torvalds's avatar
Linus Torvalds committed
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);
423
	parse_early_options(tmp_cmdline);
Linus Torvalds's avatar
Linus Torvalds committed
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

Pekka Enberg's avatar
Pekka Enberg committed
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();
Pekka Enberg's avatar
Pekka Enberg committed
461 462
	mem_init();
	kmem_cache_init();
463
	percpu_init_late();
464
	pgtable_cache_init();
Pekka Enberg's avatar
Pekka Enberg committed
465 466 467
	vmalloc_init();
}

Linus Torvalds's avatar
Linus Torvalds committed
468 469 470
asmlinkage void __init start_kernel(void)
{
	char * command_line;
471
	extern const struct kernel_param __start___param[], __stop___param[];
472

Ingo Molnar's avatar
Ingo Molnar committed
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();
Ingo Molnar's avatar
Ingo Molnar committed
487 488

	local_irq_disable();
489
	early_boot_irqs_disabled = true;
Ingo Molnar's avatar
Ingo Molnar committed
490

Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
495
	tick_init();
496
	boot_cpu_init();
Linus Torvalds's avatar
Linus Torvalds committed
497
	page_address_init();
Alex Riesen's avatar
Alex Riesen committed
498
	printk(KERN_NOTICE "%s", linux_banner);
Linus Torvalds's avatar
Linus Torvalds committed
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 */
Linus Torvalds's avatar
Linus Torvalds committed
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();
Pekka Enberg's avatar
Pekka Enberg committed
527
	mm_init();
528

Linus Torvalds's avatar
Linus Torvalds committed
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();
	}
545
	idr_init_cache();
546
	perf_event_init();
Linus Torvalds's avatar
Linus Torvalds committed
547
	rcu_init();
548
	radix_tree_init();
549 550
	/* init some links before init_ISA_irqs() */
	early_irq_init();
Linus Torvalds's avatar
Linus Torvalds committed
551 552
	init_IRQ();
	init_timers();
553
	hrtimers_init();
Linus Torvalds's avatar
Linus Torvalds committed
554
	softirq_init();
555
	timekeeping_init();
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();
Linus Torvalds's avatar
Linus Torvalds committed
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);
Ingo Molnar's avatar
Ingo Molnar committed
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();

Linus Torvalds's avatar
Linus Torvalds committed
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) {
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594
		initrd_start = 0;
	}
#endif
595
	page_cgroup_init();
596
	debug_objects_mem_init();
597
	kmemleak_init();
598
	setup_per_cpu_pageset();
Linus Torvalds's avatar
Linus Torvalds committed
599 600 601
	numa_policy_init();
	if (late_time_init)
		late_time_init();
602
	sched_clock_init();
Linus Torvalds's avatar
Linus Torvalds committed
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();
611
	cred_init();
612
	fork_init(totalram_pages);
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615 616
	proc_caches_init();
	buffer_init();
	key_init();
	security_init();
617
	dbg_late_init();
618
	vfs_caches_init(totalram_pages);
Linus Torvalds's avatar
Linus Torvalds committed
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();
Linus Torvalds's avatar
Linus Torvalds committed
626
	cpuset_init();
627
	taskstats_init_early();
628
	delayacct_init();
Linus Torvalds's avatar
Linus Torvalds committed
629 630 631 632

	check_bugs();

	acpi_early_init(); /* before LAPIC and SMP init */
633
	sfi_init_late();
Linus Torvalds's avatar
Linus Torvalds committed
634

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

640 641
	ftrace_init();

Linus Torvalds's avatar
Linus Torvalds committed
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;
658
core_param(initcall_debug, initcall_debug, bool, 0644);
Linus Torvalds's avatar
Linus Torvalds committed
659

660 661
static char msgbuf[64];

662
static int __init_or_module do_one_initcall_debug(initcall_t fn)
Linus Torvalds's avatar
Linus Torvalds committed
663
{
664
	ktime_t calltime, delta, rettime;
Américo Wang's avatar
Américo Wang committed
665 666
	unsigned long long duration;
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
667

668 669
	printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
	calltime = ktime_get();
Américo Wang's avatar
Américo Wang committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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

Américo Wang's avatar
Américo Wang committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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

Américo Wang's avatar
Américo Wang committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
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();
Linus Torvalds's avatar
Linus Torvalds committed
780
	usermodehelper_init();
781
	shmem_init();
Linus Torvalds's avatar
Linus Torvalds committed
782
	driver_init();
783
	init_irq_proc();
784
	do_ctors();
785
	usermodehelper_enable();
786
	do_initcalls();
Linus Torvalds's avatar
Linus Torvalds committed
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)
Linus Torvalds's avatar
Linus Torvalds committed
798 799
{
	argv_init[0] = init_filename;
800 801 802
	return do_execve(init_filename,
		(const char __user *const __user *)argv_init,
		(const char __user *const __user *)envp_init);
Linus Torvalds's avatar
Linus Torvalds committed
803 804
}

805 806 807
static void __init kernel_init_freeable(void);

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

Al Viro's avatar
Al Viro committed
817
	flush_delayed_fput();
818

819
	if (ramdisk_execute_command) {
820 821
		if (!run_init_process(ramdisk_execute_command))
			return 0;
822 823 824 825 826 827 828 829 830 831 832
		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) {
833 834
		if (!run_init_process(execute_command))
			return 0;
835 836 837
		printk(KERN_WARNING "Failed to execute %s.  Attempting "
					"defaults...\n", execute_command);
	}
838 839 840 841 842
	if (!run_init_process("/sbin/init") ||
	    !run_init_process("/etc/init") ||
	    !run_init_process("/bin/init") ||
	    !run_init_process("/bin/sh"))
		return 0;
843

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

848
static void __init kernel_init_freeable(void)
Linus Torvalds's avatar
Linus Torvalds committed
849
{
850 851 852 853
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done);
854 855 856 857

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

858 859 860
	/*
	 * init can allocate pages on any node
	 */
861
	set_mems_allowed(node_states[N_MEMORY]);
Linus Torvalds's avatar
Linus Torvalds committed
862 863 864
	/*
	 * init can run on any cpu.
	 */
865
	set_cpus_allowed_ptr(current, cpu_all_mask);
Linus Torvalds's avatar
Linus Torvalds committed
866

867 868
	cad_pid = task_pid(current);

869
	smp_prepare_cpus(setup_max_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
870 871

	do_pre_smp_initcalls();
872
	lockup_detector_init();
Linus Torvalds's avatar
Linus Torvalds committed
873 874 875 876 877 878

	smp_init();
	sched_init_smp();

	do_basic_setup();

879 880 881 882 883 884
	/* 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);
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887 888
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
889 890 891 892 893 894

	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
895
		prepare_namespace();
896
	}
Linus Torvalds's avatar
Linus Torvalds committed
897 898 899 900 901 902 903

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