main.c 20.9 KB
Newer Older
L
Linus Torvalds 已提交
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 30
/*
 *  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>
#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 41
#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>
42
#include <linux/cgroup.h>
L
Linus Torvalds 已提交
43
#include <linux/efi.h>
44
#include <linux/tick.h>
45
#include <linux/interrupt.h>
46
#include <linux/taskstats_kern.h>
47
#include <linux/delayacct.h>
L
Linus Torvalds 已提交
48 49 50 51
#include <linux/unistd.h>
#include <linux/rmap.h>
#include <linux/mempolicy.h>
#include <linux/key.h>
52
#include <linux/unwind.h>
A
Adrian Bunk 已提交
53
#include <linux/buffer_head.h>
54
#include <linux/debug_locks.h>
55
#include <linux/debugobjects.h>
I
Ingo Molnar 已提交
56
#include <linux/lockdep.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>
L
Linus Torvalds 已提交
63 64 65 66

#include <asm/io.h>
#include <asm/bugs.h>
#include <asm/setup.h>
67
#include <asm/sections.h>
68
#include <asm/cacheflush.h>
L
Linus Torvalds 已提交
69 70 71 72 73 74

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

/*
75 76
 * This is one of the first .c files built. Error out early if we have compiler
 * trouble.
L
Linus Torvalds 已提交
77 78
 */

A
Andrew Morton 已提交
79 80 81 82
#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

83
static int kernel_init(void *);
L
Linus Torvalds 已提交
84 85 86 87 88 89 90 91 92 93 94 95 96

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
97 98 99
#ifndef CONFIG_DEBUG_RODATA
static inline void mark_rodata_ro(void) { }
#endif
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

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

119 120 121 122 123 124
/* 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 已提交
125 126

static char *execute_command;
127
static char *ramdisk_execute_command;
L
Linus Torvalds 已提交
128

J
Jan Beulich 已提交
129
#ifdef CONFIG_SMP
L
Linus Torvalds 已提交
130
/* Setup configured maximum number of CPUs to activate */
131
unsigned int __initdata setup_max_cpus = NR_CPUS;
132

L
Linus Torvalds 已提交
133 134 135 136 137 138 139 140 141 142
/*
 * 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>.
 */
143 144 145 146
#ifndef CONFIG_X86_IO_APIC
static inline void disable_ioapic_setup(void) {};
#endif

L
Linus Torvalds 已提交
147 148
static int __init nosmp(char *str)
{
149
	setup_max_cpus = 0;
150
	disable_ioapic_setup();
J
Jan Beulich 已提交
151
	return 0;
L
Linus Torvalds 已提交
152 153
}

J
Jan Beulich 已提交
154
early_param("nosmp", nosmp);
L
Linus Torvalds 已提交
155 156 157

static int __init maxcpus(char *str)
{
158 159
	get_option(&str, &setup_max_cpus);
	if (setup_max_cpus == 0)
160 161 162
		disable_ioapic_setup();

	return 0;
L
Linus Torvalds 已提交
163 164
}

H
Hugh Dickins 已提交
165
early_param("maxcpus", maxcpus);
J
Jan Beulich 已提交
166
#else
167
#define setup_max_cpus NR_CPUS
J
Jan Beulich 已提交
168 169 170 171 172 173 174 175 176 177 178 179 180
#endif

/*
 * If set, this is an indication to the drivers that reset the underlying
 * device before going ahead with the initialization otherwise driver might
 * rely on the BIOS and skip the reset operation.
 *
 * This is useful if kernel is booting in an unreliable environment.
 * For ex. kdump situaiton where previous kernel has crashed, BIOS has been
 * skipped and devices will be in unknown state.
 */
unsigned int reset_devices;
EXPORT_SYMBOL(reset_devices);
L
Linus Torvalds 已提交
181

182 183 184 185 186 187 188 189
static int __init set_reset_devices(char *str)
{
	reset_devices = 1;
	return 1;
}

__setup("reset_devices", set_reset_devices);

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

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

	return had_early_param;
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231 232 233 234 235
}

/*
 * 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;
236
	return 0;
L
Linus Torvalds 已提交
237 238 239 240 241
}

static int __init quiet_kernel(char *str)
{
	console_loglevel = 4;
242
	return 0;
L
Linus Torvalds 已提交
243 244
}

245 246
early_param("debug", debug_kernel);
early_param("quiet", quiet_kernel);
L
Linus Torvalds 已提交
247 248 249 250

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

254
early_param("loglevel", loglevel);
L
Linus Torvalds 已提交
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

/*
 * Unknown boot options get handed to init, unless they look like
 * failed parameters
 */
static int __init unknown_bootoption(char *param, char *val)
{
	/* Change NUL term back to "=", to make "param" the whole string. */
	if (val) {
		/* param=val or param="val"? */
		if (val == param+strlen(param)+1)
			val[-1] = '=';
		else if (val == param+strlen(param)+2) {
			val[-2] = '=';
			memmove(val-1, val, strlen(val)+1);
			val--;
		} else
			BUG();
	}

	/* Handle obsolete-style parameters */
	if (obsolete_checksetup(param))
		return 0;

	/*
S
Simon Arlott 已提交
280
	 * Preemptive maintenance for "why didn't my misspelled command
L
Linus Torvalds 已提交
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
	 * 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;
}

317 318 319 320
#ifdef CONFIG_DEBUG_PAGEALLOC
int __read_mostly debug_pagealloc_enabled = 0;
#endif

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

338 339 340 341 342 343 344 345 346 347 348 349
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 已提交
350 351 352 353 354 355 356 357 358 359 360 361
#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) { }
362
static inline void setup_nr_cpu_ids(void) { }
L
Linus Torvalds 已提交
363 364 365 366
static inline void smp_prepare_cpus(unsigned int maxcpus) { }

#else

367 368 369 370 371
#if NR_CPUS > BITS_PER_LONG
cpumask_t cpu_mask_all __read_mostly = CPU_MASK_ALL;
EXPORT_SYMBOL(cpu_mask_all);
#endif

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
/* 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;
}

387
#ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
E
Eric Dumazet 已提交
388
unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
L
Linus Torvalds 已提交
389 390 391 392 393 394 395

EXPORT_SYMBOL(__per_cpu_offset);

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

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

402
	for_each_possible_cpu(i) {
L
Linus Torvalds 已提交
403 404
		__per_cpu_offset[i] = ptr - __per_cpu_start;
		memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
405
		ptr += size;
L
Linus Torvalds 已提交
406 407
	}
}
408
#endif /* CONFIG_HAVE_SETUP_PER_CPU_AREA */
L
Linus Torvalds 已提交
409 410 411 412

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

415 416 417 418 419 420 421
	/*
	 * Set up the current CPU as possible to migrate to.
	 * The other ones will be done by cpu_up/cpu_down()
	 */
	cpu = smp_processor_id();
	cpu_set(cpu, cpu_active_map);

L
Linus Torvalds 已提交
422
	/* FIXME: This should be done in userspace --RR */
423
	for_each_present_cpu(cpu) {
424
		if (num_online_cpus() >= setup_max_cpus)
L
Linus Torvalds 已提交
425
			break;
426 427
		if (!cpu_online(cpu))
			cpu_up(cpu);
L
Linus Torvalds 已提交
428 429 430 431
	}

	/* Any cleanup work */
	printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
432
	smp_cpus_done(setup_max_cpus);
L
Linus Torvalds 已提交
433 434 435 436
}

#endif

437 438 439 440 441 442 443 444 445 446 447 448 449 450
/*
 * 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 已提交
451 452 453 454 455 456 457 458 459
/*
 * 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.
 */

460
static void noinline __init_refok rest_init(void)
L
Linus Torvalds 已提交
461 462
	__releases(kernel_lock)
{
463 464
	int pid;

465
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
L
Linus Torvalds 已提交
466
	numa_default_policy();
467
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
P
Pavel Emelyanov 已提交
468
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
L
Linus Torvalds 已提交
469
	unlock_kernel();
470 471 472

	/*
	 * The boot idle thread must execute schedule()
I
Ingo Molnar 已提交
473
	 * at least once to get things moving:
474
	 */
I
Ingo Molnar 已提交
475
	init_idle_bootup_task(current);
476
	preempt_enable_no_resched();
477
	schedule();
478
	preempt_disable();
479

480
	/* Call into cpu_idle with preempt disabled */
L
Linus Torvalds 已提交
481
	cpu_idle();
I
Ingo Molnar 已提交
482
}
L
Linus Torvalds 已提交
483 484 485 486 487 488 489

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

/*
 *	Activate the first processor.
 */

522 523 524 525 526 527 528 529 530
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);
}

531
void __init __weak smp_setup_processor_id(void)
532 533 534
{
}

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

L
Linus Torvalds 已提交
539 540 541 542
asmlinkage void __init start_kernel(void)
{
	char * command_line;
	extern struct kernel_param __start___param[], __stop___param[];
543 544 545

	smp_setup_processor_id();

I
Ingo Molnar 已提交
546 547 548 549
	/*
	 * Need to run as early as possible, to initialize the
	 * lockdep hash:
	 */
A
Andi Kleen 已提交
550
	unwind_init();
I
Ingo Molnar 已提交
551
	lockdep_init();
552
	debug_objects_early_init();
553
	cgroup_init_early();
I
Ingo Molnar 已提交
554 555 556

	local_irq_disable();
	early_boot_irqs_off();
I
Ingo Molnar 已提交
557
	early_init_irq_lock_class();
I
Ingo Molnar 已提交
558

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

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

	/*
	 * HACK ALERT! This is early. We're enabling the console before
	 * we've done PCI setups etc, and console_init() must be aware of
	 * this. But we do want output early, in case something goes wrong.
	 */
	console_init();
	if (panic_later)
		panic(panic_later, panic_param);
I
Ingo Molnar 已提交
625 626 627

	lockdep_info();

628 629 630 631 632 633 634
	/*
	 * Need to run this when irqs are enabled, because it wants
	 * to self-test [hard/soft]-irqs on/off lock inversion bugs
	 * too:
	 */
	locking_selftest();

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

	check_bugs();

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

	/* Do the rest non-__init'ed, we're now alive */
	rest_init();
}

694
static int initcall_debug;
L
Linus Torvalds 已提交
695 696 697 698 699 700 701 702

static int __init initcall_debug_setup(char *str)
{
	initcall_debug = 1;
	return 1;
}
__setup("initcall_debug", initcall_debug_setup);

703
int do_one_initcall(initcall_t fn)
L
Linus Torvalds 已提交
704 705
{
	int count = preempt_count();
706
	ktime_t t0, t1, delta;
707
	char msgbuf[64];
708
	int result;
L
Linus Torvalds 已提交
709

710
	if (initcall_debug) {
711
		printk("calling  %pF @ %i\n", fn, task_pid_nr(current));
712 713
		t0 = ktime_get();
	}
L
Linus Torvalds 已提交
714

715
	result = fn();
L
Linus Torvalds 已提交
716

717 718 719
	if (initcall_debug) {
		t1 = ktime_get();
		delta = ktime_sub(t1, t0);
720

721 722
		printk("initcall %pF returned %d after %Ld msecs\n",
			fn, result,
723 724
			(unsigned long long) delta.tv64 >> 20);
	}
725

726
	msgbuf[0] = 0;
727

728 729
	if (result && result != -ENODEV && initcall_debug)
		sprintf(msgbuf, "error code %d ", result);
730

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

	return result;
744 745 746
}


747
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
748 749 750 751 752

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

753
	for (call = __early_initcall_end; call < __initcall_end; call++)
754
		do_one_initcall(*call);
L
Linus Torvalds 已提交
755 756 757 758 759 760 761 762 763 764 765 766 767 768

	/* Make sure there is no pending stuff from the initcall sequence */
	flush_scheduled_work();
}

/*
 * Ok, the machine is now initialized. None of the devices
 * have been touched yet, but the CPU subsystem is up and
 * running, and memory and process management works.
 *
 * Now we can finally start doing some real work..
 */
static void __init do_basic_setup(void)
{
P
Paul E. McKenney 已提交
769
	rcu_init_sched(); /* needed by module_init stage. */
L
Linus Torvalds 已提交
770 771 772 773
	/* drivers will send hotplug events */
	init_workqueues();
	usermodehelper_init();
	driver_init();
774
	init_irq_proc();
L
Linus Torvalds 已提交
775 776 777
	do_initcalls();
}

778
static void __init do_pre_smp_initcalls(void)
779 780 781 782 783 784 785
{
	initcall_t *call;

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

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

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
/* 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);

809 810
	current->signal->flags |= SIGNAL_UNKILLABLE;

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

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

853 854
	cad_pid = task_pid(current);

855
	smp_prepare_cpus(setup_max_cpus);
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863 864 865 866 867 868 869

	do_pre_smp_initcalls();

	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
	 */
870 871 872 873 874 875

	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 已提交
876
		prepare_namespace();
877
	}
L
Linus Torvalds 已提交
878 879 880 881 882 883

	/*
	 * 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..
	 */
884 885
	init_post();
	return 0;
L
Linus Torvalds 已提交
886
}