main.c 20.1 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>
Linus Torvalds's avatar
Linus Torvalds committed
71 72 73 74

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
75
#include <asm/sections.h>
76
#include <asm/cacheflush.h>
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80 81

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

82
static int kernel_init(void *);
Linus Torvalds's avatar
Linus Torvalds committed
83 84 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 prio_tree_init(void);
extern void radix_tree_init(void);
extern void free_initmem(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 230

/*
 * Unknown boot options get handed to init, unless they look like
231
 * unused parameters (modprobe will find them in /proc/cmdline).
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
 */
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;

252 253
	/* Unused module parameter. */
	if (strchr(param, '.') && (!val || strchr(param, '.') < val))
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 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 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
		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);

302 303 304 305 306 307 308 309 310 311 312 313
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
314
#ifndef CONFIG_SMP
315
static const unsigned int setup_max_cpus = NR_CPUS;
Linus Torvalds's avatar
Linus Torvalds committed
316 317 318 319 320 321 322 323 324
#ifdef CONFIG_X86_LOCAL_APIC
static void __init smp_init(void)
{
	APIC_init_uniprocessor();
}
#else
#define smp_init()	do { } while (0)
#endif

325
static inline void setup_nr_cpu_ids(void) { }
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328
static inline void smp_prepare_cpus(unsigned int maxcpus) { }
#endif

329 330 331 332 333 334 335 336 337 338 339 340 341 342
/*
 * 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
343 344 345 346 347 348 349 350 351
/*
 * 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.
 */

352 353
static __initdata DECLARE_COMPLETION(kthreadd_done);

354
static noinline void __init_refok rest_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
355
{
356 357
	int pid;

358
	rcu_scheduler_starting();
359
	/*
Peter Zijlstra's avatar
Peter Zijlstra committed
360
	 * We need to spawn init first so that it obtains pid 1, however
361 362 363
	 * the init task will end up wanting to create kthreads, which, if
	 * we schedule it before we create kthreadd, will OOPS.
	 */
364
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
Linus Torvalds's avatar
Linus Torvalds committed
365
	numa_default_policy();
366
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
367
	rcu_read_lock();
368
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
369
	rcu_read_unlock();
370
	complete(&kthreadd_done);
371 372 373

	/*
	 * The boot idle thread must execute schedule()
374
	 * at least once to get things moving:
375
	 */
376
	init_idle_bootup_task(current);
377
	preempt_enable_no_resched();
378
	schedule();
379

380
	/* Call into cpu_idle with preempt disabled */
381
	preempt_disable();
Linus Torvalds's avatar
Linus Torvalds committed
382
	cpu_idle();
383
}
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386 387

/* Check for early params. */
static int __init do_early_param(char *param, char *val)
{
388
	const struct obs_kernel_param *p;
Linus Torvalds's avatar
Linus Torvalds committed
389 390

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

404 405 406 407 408
void __init parse_early_options(char *cmdline)
{
	parse_args("early options", cmdline, NULL, 0, do_early_param);
}

Linus Torvalds's avatar
Linus Torvalds committed
409 410 411 412 413 414 415 416 417 418
/* 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. */
419
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
420
	parse_early_options(tmp_cmdline);
Linus Torvalds's avatar
Linus Torvalds committed
421 422 423 424 425 426 427
	done = 1;
}

/*
 *	Activate the first processor.
 */

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

438
void __init __weak smp_setup_processor_id(void)
439 440 441
{
}

442 443 444 445
void __init __weak thread_info_cache_init(void)
{
}

Pekka Enberg's avatar
Pekka Enberg committed
446 447 448 449 450
/*
 * Set up kernel memory allocators
 */
static void __init mm_init(void)
{
451 452 453 454 455
	/*
	 * page_cgroup requires countinous pages as memmap
	 * and it's bigger than MAX_ORDER unless SPARSEMEM.
	 */
	page_cgroup_init_flatmem();
Pekka Enberg's avatar
Pekka Enberg committed
456 457
	mem_init();
	kmem_cache_init();
458
	percpu_init_late();
459
	pgtable_cache_init();
Pekka Enberg's avatar
Pekka Enberg committed
460 461 462
	vmalloc_init();
}

Linus Torvalds's avatar
Linus Torvalds committed
463 464 465
asmlinkage void __init start_kernel(void)
{
	char * command_line;
466
	extern const struct kernel_param __start___param[], __stop___param[];
467

Ingo Molnar's avatar
Ingo Molnar committed
468 469 470 471 472
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
	lockdep_init();
473
	smp_setup_processor_id();
474
	debug_objects_early_init();
475 476 477 478 479 480

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

481
	cgroup_init_early();
Ingo Molnar's avatar
Ingo Molnar committed
482 483

	local_irq_disable();
484
	early_boot_irqs_disabled = true;
Ingo Molnar's avatar
Ingo Molnar committed
485

Linus Torvalds's avatar
Linus Torvalds committed
486 487 488 489
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
490
	tick_init();
491
	boot_cpu_init();
Linus Torvalds's avatar
Linus Torvalds committed
492
	page_address_init();
Alex Riesen's avatar
Alex Riesen committed
493
	printk(KERN_NOTICE "%s", linux_banner);
Linus Torvalds's avatar
Linus Torvalds committed
494
	setup_arch(&command_line);
495
	mm_init_owner(&init_mm, &init_task);
496
	mm_init_cpumask(&init_mm);
497
	setup_command_line(command_line);
498
	setup_nr_cpu_ids();
499
	setup_per_cpu_areas();
500
	smp_prepare_boot_cpu();	/* arch-specific boot-cpu hooks */
Linus Torvalds's avatar
Linus Torvalds committed
501

502
	build_all_zonelists(NULL);
503 504 505 506 507 508 509
	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);
510 511 512

	jump_label_init();

513 514 515 516
	/*
	 * These use large bootmem allocations and must precede
	 * kmem_cache_init()
	 */
517
	setup_log_buf(0);
518 519 520 521
	pidhash_init();
	vfs_caches_init_early();
	sort_main_extable();
	trap_init();
Pekka Enberg's avatar
Pekka Enberg committed
522
	mm_init();
523

Linus Torvalds's avatar
Linus Torvalds committed
524 525 526 527 528 529 530 531 532 533 534
	/*
	 * 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();
535 536 537 538 539
	if (!irqs_disabled()) {
		printk(KERN_WARNING "start_kernel(): bug: interrupts were "
				"enabled *very* early, fixing it\n");
		local_irq_disable();
	}
540
	idr_init_cache();
541
	perf_event_init();
Linus Torvalds's avatar
Linus Torvalds committed
542
	rcu_init();
543
	radix_tree_init();
544 545
	/* init some links before init_ISA_irqs() */
	early_irq_init();
Linus Torvalds's avatar
Linus Torvalds committed
546
	init_IRQ();
547
	prio_tree_init();
Linus Torvalds's avatar
Linus Torvalds committed
548
	init_timers();
549
	hrtimers_init();
Linus Torvalds's avatar
Linus Torvalds committed
550
	softirq_init();
551
	timekeeping_init();
552
	time_init();
553
	profile_init();
554
	call_function_init();
555
	if (!irqs_disabled())
556 557
		printk(KERN_CRIT "start_kernel(): bug: interrupts were "
				 "enabled early\n");
558
	early_boot_irqs_disabled = false;
559
	local_irq_enable();
560 561

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

564
	kmem_cache_init_late();
Linus Torvalds's avatar
Linus Torvalds committed
565 566 567 568 569 570 571 572 573

	/*
	 * 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
574 575 576

	lockdep_info();

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

	check_bugs();

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

634 635
	ftrace_init();

Linus Torvalds's avatar
Linus Torvalds committed
636 637 638 639
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

640 641 642 643
/* Call all constructor functions linked into the kernel. */
static void __init do_ctors(void)
{
#ifdef CONFIG_CONSTRUCTORS
644
	ctor_fn_t *fn = (ctor_fn_t *) __ctors_start;
645

646 647
	for (; fn < (ctor_fn_t *) __ctors_end; fn++)
		(*fn)();
648 649 650
#endif
}

651
int initcall_debug;
652
core_param(initcall_debug, initcall_debug, bool, 0644);
Linus Torvalds's avatar
Linus Torvalds committed
653

654 655
static char msgbuf[64];

656
static int __init_or_module do_one_initcall_debug(initcall_t fn)
Linus Torvalds's avatar
Linus Torvalds committed
657
{
658
	ktime_t calltime, delta, rettime;
Américo Wang's avatar
Américo Wang committed
659 660
	unsigned long long duration;
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
661

662 663
	printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
	calltime = ktime_get();
Américo Wang's avatar
Américo Wang committed
664
	ret = fn();
665 666 667 668 669
	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
670

671 672 673
	return ret;
}

674
int __init_or_module do_one_initcall(initcall_t fn)
675 676 677 678 679 680 681 682
{
	int count = preempt_count();
	int ret;

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

684
	msgbuf[0] = 0;
685

Américo Wang's avatar
Américo Wang committed
686 687
	if (ret && ret != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", ret);
688

689
	if (preempt_count() != count) {
690
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
691
		preempt_count() = count;
Linus Torvalds's avatar
Linus Torvalds committed
692
	}
693
	if (irqs_disabled()) {
694
		strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
695 696 697
		local_irq_enable();
	}
	if (msgbuf[0]) {
698
		printk("initcall %pF returned with %s\n", fn, msgbuf);
699
	}
700

Américo Wang's avatar
Américo Wang committed
701
	return ret;
702 703 704
}


705
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
706 707 708

static void __init do_initcalls(void)
{
709
	initcall_t *fn;
710

711 712
	for (fn = __early_initcall_end; fn < __initcall_end; fn++)
		do_one_initcall(*fn);
Linus Torvalds's avatar
Linus Torvalds committed
713 714 715 716 717 718 719 720 721 722 723
}

/*
 * 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)
{
724
	cpuset_init_smp();
Linus Torvalds's avatar
Linus Torvalds committed
725
	usermodehelper_init();
726
	shmem_init();
Linus Torvalds's avatar
Linus Torvalds committed
727
	driver_init();
728
	init_irq_proc();
729
	do_ctors();
730
	usermodehelper_enable();
731
	do_initcalls();
Linus Torvalds's avatar
Linus Torvalds committed
732 733
}

734
static void __init do_pre_smp_initcalls(void)
735
{
736
	initcall_t *fn;
737

738 739
	for (fn = __initcall_start; fn < __early_initcall_end; fn++)
		do_one_initcall(*fn);
740 741
}

742
static void run_init_process(const char *init_filename)
Linus Torvalds's avatar
Linus Torvalds committed
743 744
{
	argv_init[0] = init_filename;
745
	kernel_execve(init_filename, argv_init, envp_init);
Linus Torvalds's avatar
Linus Torvalds committed
746 747
}

748 749 750
/* 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
 */
751
static noinline int init_post(void)
752
{
753 754
	/* need to finish all async __init code before freeing the memory */
	async_synchronize_full();
755 756 757 758 759 760
	free_initmem();
	mark_rodata_ro();
	system_state = SYSTEM_RUNNING;
	numa_default_policy();


761 762
	current->signal->flags |= SIGNAL_UNKILLABLE;

763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
	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");

785 786
	panic("No init found.  Try passing init= option to kernel. "
	      "See Linux Documentation/init.txt for guidance.");
787 788
}

789
static int __init kernel_init(void * unused)
Linus Torvalds's avatar
Linus Torvalds committed
790
{
791 792 793 794
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done);
795 796 797
	/*
	 * init can allocate pages on any node
	 */
798
	set_mems_allowed(node_states[N_HIGH_MEMORY]);
Linus Torvalds's avatar
Linus Torvalds committed
799 800 801
	/*
	 * init can run on any cpu.
	 */
802
	set_cpus_allowed_ptr(current, cpu_all_mask);
Linus Torvalds's avatar
Linus Torvalds committed
803

804 805
	cad_pid = task_pid(current);

806
	smp_prepare_cpus(setup_max_cpus);
Linus Torvalds's avatar
Linus Torvalds committed
807 808

	do_pre_smp_initcalls();
809
	lockup_detector_init();
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812 813 814 815

	smp_init();
	sched_init_smp();

	do_basic_setup();

816 817 818 819 820 821
	/* 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
822 823 824 825
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
826 827 828 829 830 831

	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
832
		prepare_namespace();
833
	}
Linus Torvalds's avatar
Linus Torvalds committed
834 835 836 837 838 839

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

841 842
	init_post();
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
843
}