main.c 20.2 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
#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>
L
Linus Torvalds 已提交
26 27 28
#include <linux/tty.h>
#include <linux/percpu.h>
#include <linux/kmod.h>
N
Nick Piggin 已提交
29
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
30
#include <linux/kernel_stat.h>
31
#include <linux/start_kernel.h>
L
Linus Torvalds 已提交
32
#include <linux/security.h>
33
#include <linux/smp.h>
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
47 48 49 50
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
A
Adrian Bunk 已提交
51
#include <linux/buffer_head.h>
52
#include <linux/page_cgroup.h>
53
#include <linux/debug_locks.h>
54
#include <linux/debugobjects.h>
I
Ingo Molnar 已提交
55
#include <linux/lockdep.h>
C
Catalin Marinas 已提交
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>
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
77 78 79 80 81

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

82
static int kernel_init(void *);
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
128 129

static char *execute_command;
130
static char *ramdisk_execute_command;
L
Linus Torvalds 已提交
131

J
Jan Beulich 已提交
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);
L
Linus Torvalds 已提交
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, };
L
Linus Torvalds 已提交
154 155
static const char *panic_later, *panic_param;

156
extern const struct obs_kernel_param __setup_start[], __setup_end[];
L
Linus Torvalds 已提交
157 158 159

static int __init obsolete_checksetup(char *line)
{
160
	const struct obs_kernel_param *p;
161
	int had_early_param = 0;
L
Linus Torvalds 已提交
162 163 164 165 166 167

	p = __setup_start;
	do {
		int n = strlen(p->str);
		if (!strncmp(line, p->str, n)) {
			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( */
L
Linus Torvalds 已提交
172
				if (line[n] == '\0' || line[n] == '=')
173
					had_early_param = 1;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
199 200 201 202 203
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
204
	return 0;
L
Linus Torvalds 已提交
205 206
}

207 208
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
225 226
}

227
early_param("loglevel", loglevel);
L
Linus Torvalds 已提交
228 229 230

/*
 * Unknown boot options get handed to init, unless they look like
231
 * unused parameters (modprobe will find them in /proc/cmdline).
L
Linus Torvalds 已提交
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))
L
Linus Torvalds 已提交
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
		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;
}

285 286 287 288
#ifdef CONFIG_DEBUG_PAGEALLOC
int __read_mostly debug_pagealloc_enabled = 0;
#endif

L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
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);

306 307 308 309 310 311 312 313 314 315 316 317
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 已提交
318
#ifndef CONFIG_SMP
319
static const unsigned int setup_max_cpus = NR_CPUS;
L
Linus Torvalds 已提交
320 321 322 323 324 325 326 327 328
#ifdef CONFIG_X86_LOCAL_APIC
static void __init smp_init(void)
{
	APIC_init_uniprocessor();
}
#else
#define smp_init()	do { } while (0)
#endif

329
static inline void setup_nr_cpu_ids(void) { }
L
Linus Torvalds 已提交
330 331 332
static inline void smp_prepare_cpus(unsigned int maxcpus) { }
#endif

333 334 335 336 337 338 339 340 341 342 343 344 345 346
/*
 * 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 已提交
347 348 349 350 351 352 353 354 355
/*
 * 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.
 */

356 357
static __initdata DECLARE_COMPLETION(kthreadd_done);

358
static noinline void __init_refok rest_init(void)
L
Linus Torvalds 已提交
359
{
360 361
	int pid;

362
	rcu_scheduler_starting();
363
	/*
P
Peter Zijlstra 已提交
364
	 * We need to spawn init first so that it obtains pid 1, however
365 366 367
	 * the init task will end up wanting to create kthreads, which, if
	 * we schedule it before we create kthreadd, will OOPS.
	 */
368
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
L
Linus Torvalds 已提交
369
	numa_default_policy();
370
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
371
	rcu_read_lock();
P
Pavel Emelyanov 已提交
372
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
373
	rcu_read_unlock();
374
	complete(&kthreadd_done);
375 376 377

	/*
	 * The boot idle thread must execute schedule()
I
Ingo Molnar 已提交
378
	 * at least once to get things moving:
379
	 */
I
Ingo Molnar 已提交
380
	init_idle_bootup_task(current);
381
	preempt_enable_no_resched();
382
	schedule();
383

384
	/* Call into cpu_idle with preempt disabled */
385
	preempt_disable();
L
Linus Torvalds 已提交
386
	cpu_idle();
I
Ingo Molnar 已提交
387
}
L
Linus Torvalds 已提交
388 389 390 391

/* Check for early params. */
static int __init do_early_param(char *param, char *val)
{
392
	const struct obs_kernel_param *p;
L
Linus Torvalds 已提交
393 394

	for (p = __setup_start; p < __setup_end; p++) {
395 396 397 398
		if ((p->early && strcmp(param, p->str) == 0) ||
		    (strcmp(param, "console") == 0 &&
		     strcmp(p->str, "earlycon") == 0)
		) {
L
Linus Torvalds 已提交
399 400 401 402 403 404 405 406 407
			if (p->setup_func(val) != 0)
				printk(KERN_WARNING
				       "Malformed early option '%s'\n", param);
		}
	}
	/* We accept everything at this stage. */
	return 0;
}

M
Magnus Damm 已提交
408 409 410 411 412
void __init parse_early_options(char *cmdline)
{
	parse_args("early options", cmdline, NULL, 0, do_early_param);
}

L
Linus Torvalds 已提交
413 414 415 416 417 418 419 420 421 422
/* 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. */
423
	strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
M
Magnus Damm 已提交
424
	parse_early_options(tmp_cmdline);
L
Linus Torvalds 已提交
425 426 427 428 429 430 431
	done = 1;
}

/*
 *	Activate the first processor.
 */

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

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

446 447 448 449
void __init __weak thread_info_cache_init(void)
{
}

P
Pekka Enberg 已提交
450 451 452 453 454
/*
 * Set up kernel memory allocators
 */
static void __init mm_init(void)
{
455 456 457 458 459
	/*
	 * page_cgroup requires countinous pages as memmap
	 * and it's bigger than MAX_ORDER unless SPARSEMEM.
	 */
	page_cgroup_init_flatmem();
P
Pekka Enberg 已提交
460 461
	mem_init();
	kmem_cache_init();
462
	percpu_init_late();
463
	pgtable_cache_init();
P
Pekka Enberg 已提交
464 465 466
	vmalloc_init();
}

L
Linus Torvalds 已提交
467 468 469
asmlinkage void __init start_kernel(void)
{
	char * command_line;
470
	extern const struct kernel_param __start___param[], __stop___param[];
471 472 473

	smp_setup_processor_id();

I
Ingo Molnar 已提交
474 475 476 477 478
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
	lockdep_init();
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();
I
Ingo Molnar 已提交
487 488

	local_irq_disable();
489
	early_boot_irqs_disabled = true;
I
Ingo Molnar 已提交
490

L
Linus Torvalds 已提交
491 492 493 494
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
495
	tick_init();
496
	boot_cpu_init();
L
Linus Torvalds 已提交
497
	page_address_init();
A
Alex Riesen 已提交
498
	printk(KERN_NOTICE "%s", linux_banner);
L
Linus Torvalds 已提交
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 */
L
Linus Torvalds 已提交
506

507
	build_all_zonelists(NULL);
508 509 510 511 512 513 514 515 516 517 518
	page_alloc_init();

	printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
	parse_early_param();
	parse_args("Booting kernel", static_command_line, __start___param,
		   __stop___param - __start___param,
		   &unknown_bootoption);
	/*
	 * These use large bootmem allocations and must precede
	 * kmem_cache_init()
	 */
519
	setup_log_buf(0);
520 521 522 523
	pidhash_init();
	vfs_caches_init_early();
	sort_main_extable();
	trap_init();
P
Pekka Enberg 已提交
524
	mm_init();
525

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

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

566
	kmem_cache_init_late();
L
Linus Torvalds 已提交
567 568 569 570 571 572 573 574 575

	/*
	 * 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 已提交
576 577 578

	lockdep_info();

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

	check_bugs();

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

637 638
	ftrace_init();

L
Linus Torvalds 已提交
639 640 641 642
	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

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

649 650
	for (; fn < (ctor_fn_t *) __ctors_end; fn++)
		(*fn)();
651 652 653
#endif
}

654
int initcall_debug;
R
Rusty Russell 已提交
655
core_param(initcall_debug, initcall_debug, bool, 0644);
L
Linus Torvalds 已提交
656

657 658
static char msgbuf[64];

659
static int __init_or_module do_one_initcall_debug(initcall_t fn)
L
Linus Torvalds 已提交
660
{
661
	ktime_t calltime, delta, rettime;
A
Américo Wang 已提交
662 663
	unsigned long long duration;
	int ret;
L
Linus Torvalds 已提交
664

665 666
	printk(KERN_DEBUG "calling  %pF @ %i\n", fn, task_pid_nr(current));
	calltime = ktime_get();
A
Américo Wang 已提交
667
	ret = fn();
668 669 670 671 672
	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);
L
Linus Torvalds 已提交
673

674 675 676
	return ret;
}

677
int __init_or_module do_one_initcall(initcall_t fn)
678 679 680 681 682 683 684 685
{
	int count = preempt_count();
	int ret;

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

687
	msgbuf[0] = 0;
688

A
Américo Wang 已提交
689 690
	if (ret && ret != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", ret);
691

692
	if (preempt_count() != count) {
693
		strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
694
		preempt_count() = count;
L
Linus Torvalds 已提交
695
	}
696
	if (irqs_disabled()) {
697
		strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
698 699 700
		local_irq_enable();
	}
	if (msgbuf[0]) {
701
		printk("initcall %pF returned with %s\n", fn, msgbuf);
702
	}
703

A
Américo Wang 已提交
704
	return ret;
705 706 707
}


708
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
709 710 711

static void __init do_initcalls(void)
{
712
	initcall_t *fn;
713

714 715
	for (fn = __early_initcall_end; fn < __initcall_end; fn++)
		do_one_initcall(*fn);
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726
}

/*
 * 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)
{
727
	cpuset_init_smp();
L
Linus Torvalds 已提交
728
	usermodehelper_init();
729
	shmem_init();
L
Linus Torvalds 已提交
730
	driver_init();
731
	init_irq_proc();
732
	do_ctors();
L
Linus Torvalds 已提交
733
	do_initcalls();
734
	usermodehelper_enable();
L
Linus Torvalds 已提交
735 736
}

737
static void __init do_pre_smp_initcalls(void)
738
{
739
	initcall_t *fn;
740

741 742
	for (fn = __initcall_start; fn < __early_initcall_end; fn++)
		do_one_initcall(*fn);
743 744
}

745
static void run_init_process(const char *init_filename)
L
Linus Torvalds 已提交
746 747
{
	argv_init[0] = init_filename;
A
Arnd Bergmann 已提交
748
	kernel_execve(init_filename, argv_init, envp_init);
L
Linus Torvalds 已提交
749 750
}

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


764 765
	current->signal->flags |= SIGNAL_UNKILLABLE;

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

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

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

807 808
	cad_pid = task_pid(current);

809
	smp_prepare_cpus(setup_max_cpus);
L
Linus Torvalds 已提交
810 811

	do_pre_smp_initcalls();
812
	lockup_detector_init();
L
Linus Torvalds 已提交
813 814 815 816 817 818

	smp_init();
	sched_init_smp();

	do_basic_setup();

819 820 821 822 823 824
	/* Open the /dev/console on the rootfs, this should never fail */
	if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
		printk(KERN_WARNING "Warning: unable to open an initial console.\n");

	(void) sys_dup(0);
	(void) sys_dup(0);
L
Linus Torvalds 已提交
825 826 827 828
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */
829 830 831 832 833 834

	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 已提交
835
		prepare_namespace();
836
	}
L
Linus Torvalds 已提交
837 838 839 840 841 842

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

844 845
	init_post();
	return 0;
L
Linus Torvalds 已提交
846
}