1/* 2 * linux/init/main.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * GK 2/5/95 - Changed to support mounting root fs via NFS 7 * Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96 8 * Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96 9 * Simplified starting of init: Michael A. Griffith <grif@acm.org> 10 */ 11 12#include <linux/types.h> 13#include <linux/module.h> 14#include <linux/proc_fs.h> 15#include <linux/kernel.h> 16#include <linux/syscalls.h> 17#include <linux/stackprotector.h> 18#include <linux/string.h> 19#include <linux/ctype.h> 20#include <linux/delay.h> 21#include <linux/ioport.h> 22#include <linux/init.h> 23#include <linux/smp_lock.h> 24#include <linux/initrd.h> 25#include <linux/bootmem.h> 26#include <linux/acpi.h> 27#include <linux/tty.h> 28#include <linux/percpu.h> 29#include <linux/kmod.h> 30#include <linux/vmalloc.h> 31#include <linux/kernel_stat.h> 32#include <linux/start_kernel.h> 33#include <linux/security.h> 34#include <linux/smp.h> 35#include <linux/profile.h> 36#include <linux/rcupdate.h> 37#include <linux/moduleparam.h> 38#include <linux/kallsyms.h> 39#include <linux/writeback.h> 40#include <linux/cpu.h> 41#include <linux/cpuset.h> 42#include <linux/cgroup.h> 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> 48#include <linux/unistd.h> 49#include <linux/rmap.h> 50#include <linux/mempolicy.h> 51#include <linux/key.h> 52#include <linux/buffer_head.h> 53#include <linux/page_cgroup.h> 54#include <linux/debug_locks.h> 55#include <linux/debugobjects.h> 56#include <linux/lockdep.h> 57#include <linux/kmemleak.h> 58#include <linux/pid_namespace.h> 59#include <linux/device.h> 60#include <linux/kthread.h> 61#include <linux/sched.h> 62#include <linux/signal.h> 63#include <linux/idr.h> 64#include <linux/kgdb.h> 65#include <linux/ftrace.h> 66#include <linux/async.h> 67#include <linux/kmemcheck.h> 68#include <linux/sfi.h> 69#include <linux/shmem_fs.h> 70#include <linux/slab.h> 71 72#include <asm/io.h> 73#include <asm/bugs.h> 74#include <asm/setup.h> 75#include <asm/sections.h> 76#include <asm/cacheflush.h> 77 78#ifdef CONFIG_X86_LOCAL_APIC 79#include <asm/smp.h> 80#endif 81 82static int kernel_init(void *); 83 84extern void init_IRQ(void); 85extern void fork_init(unsigned long); 86extern void mca_init(void); 87extern void sbus_init(void); 88extern void prio_tree_init(void); 89extern void radix_tree_init(void); 90extern void free_initmem(void); 91#ifndef CONFIG_DEBUG_RODATA 92static inline void mark_rodata_ro(void) { } 93#endif 94 95#ifdef CONFIG_TC 96extern void tc_init(void); 97#endif 98 99enum system_states system_state __read_mostly; 100EXPORT_SYMBOL(system_state); 101 102/* 103 * Boot command-line arguments 104 */ 105#define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT 106#define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT 107 108extern void time_init(void); 109/* Default late time init is NULL. archs can override this later. */ 110void (*__initdata late_time_init)(void); 111extern void softirq_init(void); 112 113/* Untouched command line saved by arch-specific code. */ 114char __initdata boot_command_line[COMMAND_LINE_SIZE]; 115/* Untouched saved command line (eg. for /proc) */ 116char *saved_command_line; 117/* Command line for parameter parsing */ 118static char *static_command_line; 119 120static char *execute_command; 121static char *ramdisk_execute_command; 122 123#ifdef CONFIG_SMP 124/* Setup configured maximum number of CPUs to activate */ 125unsigned int setup_max_cpus = NR_CPUS; 126EXPORT_SYMBOL(setup_max_cpus); 127 128 129/* 130 * Setup routine for controlling SMP activation 131 * 132 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP 133 * activation entirely (the MPS table probe still happens, though). 134 * 135 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer 136 * greater than 0, limits the maximum number of CPUs activated in 137 * SMP mode to <NUM>. 138 */ 139 140void __weak arch_disable_smp_support(void) { } 141 142static int __init nosmp(char *str) 143{ 144 setup_max_cpus = 0; 145 arch_disable_smp_support(); 146 147 return 0; 148} 149 150early_param("nosmp", nosmp); 151 152/* this is hard limit */ 153static int __init nrcpus(char *str) 154{ 155 int nr_cpus; 156 157 get_option(&str, &nr_cpus); 158 if (nr_cpus > 0 && nr_cpus < nr_cpu_ids) 159 nr_cpu_ids = nr_cpus; 160 161 return 0; 162} 163 164early_param("nr_cpus", nrcpus); 165 166static int __init maxcpus(char *str) 167{ 168 get_option(&str, &setup_max_cpus); 169 if (setup_max_cpus == 0) 170 arch_disable_smp_support(); 171 172 return 0; 173} 174 175early_param("maxcpus", maxcpus); 176#else 177static const unsigned int setup_max_cpus = NR_CPUS; 178#endif 179 180/* 181 * If set, this is an indication to the drivers that reset the underlying 182 * device before going ahead with the initialization otherwise driver might 183 * rely on the BIOS and skip the reset operation. 184 * 185 * This is useful if kernel is booting in an unreliable environment. 186 * For ex. kdump situaiton where previous kernel has crashed, BIOS has been 187 * skipped and devices will be in unknown state. 188 */ 189unsigned int reset_devices; 190EXPORT_SYMBOL(reset_devices); 191 192static int __init set_reset_devices(char *str) 193{ 194 reset_devices = 1; 195 return 1; 196} 197 198__setup("reset_devices", set_reset_devices); 199 200static const char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, }; 201const char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, }; 202static const char *panic_later, *panic_param; 203 204extern const struct obs_kernel_param __setup_start[], __setup_end[]; 205 206static int __init obsolete_checksetup(char *line) 207{ 208 const struct obs_kernel_param *p; 209 int had_early_param = 0; 210 211 p = __setup_start; 212 do { 213 int n = strlen(p->str); 214 if (!strncmp(line, p->str, n)) { 215 if (p->early) { 216 /* Already done in parse_early_param? 217 * (Needs exact match on param part). 218 * Keep iterating, as we can have early 219 * params and __setups of same names 8( */ 220 if (line[n] == '\0' || line[n] == '=') 221 had_early_param = 1; 222 } else if (!p->setup_func) { 223 printk(KERN_WARNING "Parameter %s is obsolete," 224 " ignored\n", p->str); 225 return 1; 226 } else if (p->setup_func(line + n)) 227 return 1; 228 } 229 p++; 230 } while (p < __setup_end); 231 232 return had_early_param; 233} 234 235/* 236 * This should be approx 2 Bo*oMips to start (note initial shift), and will 237 * still work even if initially too large, it will just take slightly longer 238 */ 239unsigned long loops_per_jiffy = (1<<12); 240 241EXPORT_SYMBOL(loops_per_jiffy); 242 243static int __init debug_kernel(char *str) 244{ 245 console_loglevel = 10; 246 return 0; 247} 248 249static int __init quiet_kernel(char *str) 250{ 251 console_loglevel = 4; 252 return 0; 253} 254 255early_param("debug", debug_kernel); 256early_param("quiet", quiet_kernel); 257 258static int __init loglevel(char *str) 259{ 260 get_option(&str, &console_loglevel); 261 return 0; 262} 263 264early_param("loglevel", loglevel); 265 266/* 267 * Unknown boot options get handed to init, unless they look like 268 * unused parameters (modprobe will find them in /proc/cmdline). 269 */ 270static int __init unknown_bootoption(char *param, char *val) 271{ 272 /* Change NUL term back to "=", to make "param" the whole string. */ 273 if (val) { 274 /* param=val or param="val"? */ 275 if (val == param+strlen(param)+1) 276 val[-1] = '='; 277 else if (val == param+strlen(param)+2) { 278 val[-2] = '='; 279 memmove(val-1, val, strlen(val)+1); 280 val--; 281 } else 282 BUG(); 283 } 284 285 /* Handle obsolete-style parameters */ 286 if (obsolete_checksetup(param)) 287 return 0; 288 289 /* Unused module parameter. */ 290 if (strchr(param, '.') && (!val || strchr(param, '.') < val)) 291 return 0; 292 293 if (panic_later) 294 return 0; 295 296 if (val) { 297 /* Environment option */ 298 unsigned int i; 299 for (i = 0; envp_init[i]; i++) { 300 if (i == MAX_INIT_ENVS) { 301 panic_later = "Too many boot env vars at `%s'"; 302 panic_param = param; 303 } 304 if (!strncmp(param, envp_init[i], val - param)) 305 break; 306 } 307 envp_init[i] = param; 308 } else { 309 /* Command line option */ 310 unsigned int i; 311 for (i = 0; argv_init[i]; i++) { 312 if (i == MAX_INIT_ARGS) { 313 panic_later = "Too many boot init vars at `%s'"; 314 panic_param = param; 315 } 316 } 317 argv_init[i] = param; 318 } 319 return 0; 320} 321 322#ifdef CONFIG_DEBUG_PAGEALLOC 323int __read_mostly debug_pagealloc_enabled = 0; 324#endif 325 326static int __init init_setup(char *str) 327{ 328 unsigned int i; 329 330 execute_command = str; 331 /* 332 * In case LILO is going to boot us with default command line, 333 * it prepends "auto" before the whole cmdline which makes 334 * the shell think it should execute a script with such name. 335 * So we ignore all arguments entered _before_ init=... [MJ] 336 */ 337 for (i = 1; i < MAX_INIT_ARGS; i++) 338 argv_init[i] = NULL; 339 return 1; 340} 341__setup("init=", init_setup); 342 343static int __init rdinit_setup(char *str) 344{ 345 unsigned int i; 346 347 ramdisk_execute_command = str; 348 /* See "auto" comment in init_setup */ 349 for (i = 1; i < MAX_INIT_ARGS; i++) 350 argv_init[i] = NULL; 351 return 1; 352} 353__setup("rdinit=", rdinit_setup); 354 355#ifndef CONFIG_SMP 356 357#ifdef CONFIG_X86_LOCAL_APIC 358static void __init smp_init(void) 359{ 360 APIC_init_uniprocessor(); 361} 362#else 363#define smp_init() do { } while (0) 364#endif 365 366static inline void setup_nr_cpu_ids(void) { } 367static inline void smp_prepare_cpus(unsigned int maxcpus) { } 368 369#else 370 371/* Setup number of possible processor ids */ 372int nr_cpu_ids __read_mostly = NR_CPUS; 373EXPORT_SYMBOL(nr_cpu_ids); 374 375/* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */ 376static void __init setup_nr_cpu_ids(void) 377{ 378 nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1; 379} 380 381/* Called by boot processor to activate the rest. */ 382static void __init smp_init(void) 383{ 384 unsigned int cpu; 385 386 for_each_present_cpu(cpu) { 387 if (num_online_cpus() >= setup_max_cpus) 388 break; 389 if (!cpu_online(cpu)) 390 cpu_up(cpu); 391 } 392 393 /* Any cleanup work */ 394 printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus()); 395 smp_cpus_done(setup_max_cpus); 396} 397 398#endif 399 400/* 401 * We need to store the untouched command line for future reference. 402 * We also need to store the touched command line since the parameter 403 * parsing is performed in place, and we should allow a component to 404 * store reference of name/value for future reference. 405 */ 406static void __init setup_command_line(char *command_line) 407{ 408 saved_command_line = alloc_bootmem(strlen (boot_command_line)+1); 409 static_command_line = alloc_bootmem(strlen (command_line)+1); 410 strcpy (saved_command_line, boot_command_line); 411 strcpy (static_command_line, command_line); 412} 413 414/* 415 * We need to finalize in a non-__init function or else race conditions 416 * between the root thread and the init thread may cause start_kernel to 417 * be reaped by free_initmem before the root thread has proceeded to 418 * cpu_idle. 419 * 420 * gcc-3.4 accidentally inlines this function, so use noinline. 421 */ 422 423static __initdata DECLARE_COMPLETION(kthreadd_done); 424 425static noinline void __init_refok rest_init(void) 426 __releases(kernel_lock) 427{ 428 int pid; 429 430 rcu_scheduler_starting(); 431 /* 432 * We need to spawn init first so that it obtains pid 1, however 433 * the init task will end up wanting to create kthreads, which, if 434 * we schedule it before we create kthreadd, will OOPS. 435 */ 436 kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND); 437 numa_default_policy(); 438 pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES); 439 rcu_read_lock(); 440 kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns); 441 rcu_read_unlock(); 442 complete(&kthreadd_done); 443 444 /* 445 * The boot idle thread must execute schedule() 446 * at least once to get things moving: 447 */ 448 init_idle_bootup_task(current); 449 preempt_enable_no_resched(); 450 schedule(); 451 preempt_disable(); 452 453 /* Call into cpu_idle with preempt disabled */ 454 cpu_idle(); 455} 456 457/* Check for early params. */ 458static int __init do_early_param(char *param, char *val) 459{ 460 const struct obs_kernel_param *p; 461 462 for (p = __setup_start; p < __setup_end; p++) { 463 if ((p->early && strcmp(param, p->str) == 0) || 464 (strcmp(param, "console") == 0 && 465 strcmp(p->str, "earlycon") == 0) 466 ) { 467 if (p->setup_func(val) != 0) 468 printk(KERN_WARNING 469 "Malformed early option '%s'\n", param); 470 } 471 } 472 /* We accept everything at this stage. */ 473 return 0; 474} 475 476void __init parse_early_options(char *cmdline) 477{ 478 parse_args("early options", cmdline, NULL, 0, do_early_param); 479} 480 481/* Arch code calls this early on, or if not, just before other parsing. */ 482void __init parse_early_param(void) 483{ 484 static __initdata int done = 0; 485 static __initdata char tmp_cmdline[COMMAND_LINE_SIZE]; 486 487 if (done) 488 return; 489 490 /* All fall through to do_early_param. */ 491 strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE); 492 parse_early_options(tmp_cmdline); 493 done = 1; 494} 495 496/* 497 * Activate the first processor. 498 */ 499 500static void __init boot_cpu_init(void) 501{ 502 int cpu = smp_processor_id(); 503 /* Mark the boot cpu "present", "online" etc for SMP and UP case */ 504 set_cpu_online(cpu, true); 505 set_cpu_active(cpu, true); 506 set_cpu_present(cpu, true); 507 set_cpu_possible(cpu, true); 508} 509 510void __init __weak smp_setup_processor_id(void) 511{ 512} 513 514void __init __weak thread_info_cache_init(void) 515{ 516} 517 518/* 519 * Set up kernel memory allocators 520 */ 521static void __init mm_init(void) 522{ 523 /* 524 * page_cgroup requires countinous pages as memmap 525 * and it's bigger than MAX_ORDER unless SPARSEMEM. 526 */ 527 page_cgroup_init_flatmem(); 528 mem_init(); 529 kmem_cache_init(); 530 percpu_init_late(); 531 pgtable_cache_init(); 532 vmalloc_init(); 533} 534 535asmlinkage void __init start_kernel(void) 536{ 537 char * command_line; 538 extern const struct kernel_param __start___param[], __stop___param[]; 539 540 smp_setup_processor_id(); 541 542 /* 543 * Need to run as early as possible, to initialize the 544 * lockdep hash: 545 */ 546 lockdep_init(); 547 debug_objects_early_init(); 548 549 /* 550 * Set up the the initial canary ASAP: 551 */ 552 boot_init_stack_canary(); 553 554 cgroup_init_early(); 555 556 local_irq_disable(); 557 early_boot_irqs_off(); 558 early_init_irq_lock_class(); 559 560/* 561 * Interrupts are still disabled. Do necessary setups, then 562 * enable them 563 */ 564 tick_init(); 565 boot_cpu_init(); 566 page_address_init(); 567 printk(KERN_NOTICE "%s", linux_banner); 568 setup_arch(&command_line); 569 mm_init_owner(&init_mm, &init_task); 570 setup_command_line(command_line); 571 setup_nr_cpu_ids(); 572 setup_per_cpu_areas(); 573 smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */ 574 575 build_all_zonelists(NULL); 576 page_alloc_init(); 577 578 printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line); 579 parse_early_param(); 580 parse_args("Booting kernel", static_command_line, __start___param, 581 __stop___param - __start___param, 582 &unknown_bootoption); 583 /* 584 * These use large bootmem allocations and must precede 585 * kmem_cache_init() 586 */ 587 pidhash_init(); 588 vfs_caches_init_early(); 589 sort_main_extable(); 590 trap_init(); 591 mm_init(); 592#ifdef CONFIG_DUMP_PREV_OOPS_MSG 593 prepare_and_dump_previous_oops(); 594#endif 595 /* 596 * Set up the scheduler prior starting any interrupts (such as the 597 * timer interrupt). Full topology setup happens at smp_init() 598 * time - but meanwhile we still have a functioning scheduler. 599 */ 600 sched_init(); 601 /* 602 * Disable preemption - early bootup scheduling is extremely 603 * fragile until we cpu_idle() for the first time. 604 */ 605 preempt_disable(); 606 if (!irqs_disabled()) { 607 printk(KERN_WARNING "start_kernel(): bug: interrupts were " 608 "enabled *very* early, fixing it\n"); 609 local_irq_disable(); 610 } 611 rcu_init(); 612 radix_tree_init(); 613 /* init some links before init_ISA_irqs() */ 614 early_irq_init(); 615 init_IRQ(); 616 prio_tree_init(); 617 init_timers(); 618 hrtimers_init(); 619 softirq_init(); 620 timekeeping_init(); 621 time_init(); 622 profile_init(); 623 if (!irqs_disabled()) 624 printk(KERN_CRIT "start_kernel(): bug: interrupts were " 625 "enabled early\n"); 626 early_boot_irqs_on(); 627 local_irq_enable(); 628 629 /* Interrupts are enabled now so all GFP allocations are safe. */ 630 gfp_allowed_mask = __GFP_BITS_MASK; 631 632 kmem_cache_init_late(); 633 634 /* 635 * HACK ALERT! This is early. We're enabling the console before 636 * we've done PCI setups etc, and console_init() must be aware of 637 * this. But we do want output early, in case something goes wrong. 638 */ 639 console_init(); 640 if (panic_later) 641 panic(panic_later, panic_param); 642 643 lockdep_info(); 644 645 /* 646 * Need to run this when irqs are enabled, because it wants 647 * to self-test [hard/soft]-irqs on/off lock inversion bugs 648 * too: 649 */ 650 locking_selftest(); 651 652#ifdef CONFIG_BLK_DEV_INITRD 653 if (initrd_start && !initrd_below_start_ok && 654 page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) { 655 printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - " 656 "disabling it.\n", 657 page_to_pfn(virt_to_page((void *)initrd_start)), 658 min_low_pfn); 659 initrd_start = 0; 660 } 661#endif 662 page_cgroup_init(); 663 enable_debug_pagealloc(); 664 kmemleak_init(); 665 debug_objects_mem_init(); 666 idr_init_cache(); 667 setup_per_cpu_pageset(); 668 numa_policy_init(); 669 if (late_time_init) 670 late_time_init(); 671 sched_clock_init(); 672 calibrate_delay(); 673 pidmap_init(); 674 anon_vma_init(); 675#ifdef CONFIG_X86 676 if (efi_enabled) 677 efi_enter_virtual_mode(); 678#endif 679 thread_info_cache_init(); 680 cred_init(); 681 fork_init(totalram_pages); 682 proc_caches_init(); 683 buffer_init(); 684 key_init(); 685 security_init(); 686 dbg_late_init(); 687 vfs_caches_init(totalram_pages); 688 signals_init(); 689 /* rootfs populating might need page-writeback */ 690 page_writeback_init(); 691#ifdef CONFIG_PROC_FS 692 proc_root_init(); 693#endif 694 cgroup_init(); 695 cpuset_init(); 696 taskstats_init_early(); 697 delayacct_init(); 698 699 check_bugs(); 700 701 acpi_early_init(); /* before LAPIC and SMP init */ 702 sfi_init_late(); 703 704 ftrace_init(); 705 706 /* Do the rest non-__init'ed, we're now alive */ 707 rest_init(); 708} 709 710/* Call all constructor functions linked into the kernel. */ 711static void __init do_ctors(void) 712{ 713#ifdef CONFIG_CONSTRUCTORS 714 ctor_fn_t *fn = (ctor_fn_t *) __ctors_start; 715 716 for (; fn < (ctor_fn_t *) __ctors_end; fn++) 717 (*fn)(); 718#endif 719} 720 721int initcall_debug; 722core_param(initcall_debug, initcall_debug, bool, 0644); 723 724static char msgbuf[64]; 725 726static int __init_or_module do_one_initcall_debug(initcall_t fn) 727{ 728 ktime_t calltime, delta, rettime; 729 unsigned long long duration; 730 int ret; 731 732 printk(KERN_DEBUG "calling %pF @ %i\n", fn, task_pid_nr(current)); 733 calltime = ktime_get(); 734 ret = fn(); 735 rettime = ktime_get(); 736 delta = ktime_sub(rettime, calltime); 737 duration = (unsigned long long) ktime_to_ns(delta) >> 10; 738 printk(KERN_DEBUG "initcall %pF returned %d after %lld usecs\n", fn, 739 ret, duration); 740 741 return ret; 742} 743 744int __init_or_module do_one_initcall(initcall_t fn) 745{ 746 int count = preempt_count(); 747 int ret; 748 749 if (initcall_debug) 750 ret = do_one_initcall_debug(fn); 751 else 752 ret = fn(); 753 754 msgbuf[0] = 0; 755 756 if (ret && ret != -ENODEV && initcall_debug) 757 sprintf(msgbuf, "error code %d ", ret); 758 759 if (preempt_count() != count) { 760 strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf)); 761 preempt_count() = count; 762 } 763 if (irqs_disabled()) { 764 strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf)); 765 local_irq_enable(); 766 } 767 if (msgbuf[0]) { 768 printk("initcall %pF returned with %s\n", fn, msgbuf); 769 } 770 771 return ret; 772} 773 774 775extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[]; 776 777static void __init do_initcalls(void) 778{ 779 initcall_t *fn; 780 781 for (fn = __early_initcall_end; fn < __initcall_end; fn++) 782 do_one_initcall(*fn); 783 784 /* Make sure there is no pending stuff from the initcall sequence */ 785 flush_scheduled_work(); 786} 787 788/* 789 * Ok, the machine is now initialized. None of the devices 790 * have been touched yet, but the CPU subsystem is up and 791 * running, and memory and process management works. 792 * 793 * Now we can finally start doing some real work.. 794 */ 795static void __init do_basic_setup(void) 796{ 797 cpuset_init_smp(); 798 usermodehelper_init(); 799 init_tmpfs(); 800 driver_init(); 801 init_irq_proc(); 802 do_ctors(); 803 do_initcalls(); 804} 805 806static void __init do_pre_smp_initcalls(void) 807{ 808 initcall_t *fn; 809 810 for (fn = __initcall_start; fn < __early_initcall_end; fn++) 811 do_one_initcall(*fn); 812} 813 814static void run_init_process(const char *init_filename) 815{ 816 argv_init[0] = init_filename; 817 kernel_execve(init_filename, argv_init, envp_init); 818} 819 820/* This is a non __init function. Force it to be noinline otherwise gcc 821 * makes it inline to init() and it becomes part of init.text section 822 */ 823static noinline int init_post(void) 824 __releases(kernel_lock) 825{ 826 /* need to finish all async __init code before freeing the memory */ 827 async_synchronize_full(); 828 free_initmem(); 829 mark_rodata_ro(); 830 system_state = SYSTEM_RUNNING; 831 numa_default_policy(); 832 833 834 current->signal->flags |= SIGNAL_UNKILLABLE; 835 836 if (ramdisk_execute_command) { 837 run_init_process(ramdisk_execute_command); 838 printk(KERN_WARNING "Failed to execute %s\n", 839 ramdisk_execute_command); 840 } 841 842 /* 843 * We try each of these until one succeeds. 844 * 845 * The Bourne shell can be used instead of init if we are 846 * trying to recover a really broken machine. 847 */ 848 if (execute_command) { 849 run_init_process(execute_command); 850 printk(KERN_WARNING "Failed to execute %s. Attempting " 851 "defaults...\n", execute_command); 852 } 853 run_init_process("/sbin/init"); 854 run_init_process("/etc/init"); 855 run_init_process("/bin/init"); 856 run_init_process("/bin/sh"); 857 858 panic("No init found. Try passing init= option to kernel. " 859 "See Linux Documentation/init.txt for guidance."); 860} 861 862static int __init kernel_init(void * unused) 863{ 864 /* 865 * Wait until kthreadd is all set-up. 866 */ 867 wait_for_completion(&kthreadd_done); 868 /* 869 * init can allocate pages on any node 870 */ 871 set_mems_allowed(node_states[N_HIGH_MEMORY]); 872 /* 873 * init can run on any cpu. 874 */ 875 set_cpus_allowed_ptr(current, cpu_all_mask); 876 /* 877 * Tell the world that we're going to be the grim 878 * reaper of innocent orphaned children. 879 * 880 * We don't want people to have to make incorrect 881 * assumptions about where in the task array this 882 * can be found. 883 */ 884 init_pid_ns.child_reaper = current; 885 886 cad_pid = task_pid(current); 887 888 smp_prepare_cpus(setup_max_cpus); 889 890 do_pre_smp_initcalls(); 891 892 smp_init(); 893 sched_init_smp(); 894 895 do_basic_setup(); 896 897 /* Open the /dev/console on the rootfs, this should never fail */ 898 if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) 899 printk(KERN_WARNING "Warning: unable to open an initial console.\n"); 900 901 (void) sys_dup(0); 902 (void) sys_dup(0); 903 /* 904 * check if there is an early userspace init. If yes, let it do all 905 * the work 906 */ 907 908 if (!ramdisk_execute_command) 909 ramdisk_execute_command = "/init"; 910 911 if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { 912 ramdisk_execute_command = NULL; 913 prepare_namespace(); 914 } 915 916 /* 917 * Ok, we have completed the initial bootup, and 918 * we're essentially up and running. Get rid of the 919 * initmem segments and start the user-mode stuff.. 920 */ 921 922 init_post(); 923 return 0; 924} 925