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 #define __KERNEL_SYSCALLS__ 13 14 #include <linux/config.h> 15 #include <linux/types.h> 16 #include <linux/module.h> 17 #include <linux/proc_fs.h> 18 #include <linux/devfs_fs_kernel.h> 19 #include <linux/kernel.h> 20 #include <linux/syscalls.h> 21 #include <linux/string.h> 22 #include <linux/ctype.h> 23 #include <linux/delay.h> 24 #include <linux/utsname.h> 25 #include <linux/ioport.h> 26 #include <linux/init.h> 27 #include <linux/smp_lock.h> 28 #include <linux/initrd.h> 29 #include <linux/hdreg.h> 30 #include <linux/bootmem.h> 31 #include <linux/tty.h> 32 #include <linux/gfp.h> 33 #include <linux/percpu.h> 34 #include <linux/kmod.h> 35 #include <linux/kernel_stat.h> 36 #include <linux/security.h> 37 #include <linux/workqueue.h> 38 #include <linux/profile.h> 39 #include <linux/rcupdate.h> 40 #include <linux/moduleparam.h> 41 #include <linux/kallsyms.h> 42 #include <linux/writeback.h> 43 #include <linux/cpu.h> 44 #include <linux/cpuset.h> 45 #include <linux/efi.h> 46 #include <linux/unistd.h> 47 #include <linux/rmap.h> 48 #include <linux/mempolicy.h> 49 #include <linux/key.h> 50 #include <net/sock.h> 51 52 #include <asm/io.h> 53 #include <asm/bugs.h> 54 #include <asm/setup.h> 55 #include <asm/sections.h> 56 57 /* 58 * This is one of the first .c files built. Error out early 59 * if we have compiler trouble.. 60 */ 61 #if __GNUC__ == 2 && __GNUC_MINOR__ == 96 62 #ifdef CONFIG_FRAME_POINTER 63 #error This compiler cannot compile correctly with frame pointers enabled 64 #endif 65 #endif 66 67 #ifdef CONFIG_X86_LOCAL_APIC 68 #include <asm/smp.h> 69 #endif 70 71 /* 72 * Versions of gcc older than that listed below may actually compile 73 * and link okay, but the end product can have subtle run time bugs. 74 * To avoid associated bogus bug reports, we flatly refuse to compile 75 * with a gcc that is known to be too old from the very beginning. 76 */ 77 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 95) 78 #error Sorry, your GCC is too old. It builds incorrect kernels. 79 #endif 80 81 static int init(void *); 82 83 extern void init_IRQ(void); 84 extern void fork_init(unsigned long); 85 extern void mca_init(void); 86 extern void sbus_init(void); 87 extern void sysctl_init(void); 88 extern void signals_init(void); 89 extern void buffer_init(void); 90 extern void pidhash_init(void); 91 extern void pidmap_init(void); 92 extern void prio_tree_init(void); 93 extern void radix_tree_init(void); 94 extern void free_initmem(void); 95 extern void populate_rootfs(void); 96 extern void driver_init(void); 97 extern void prepare_namespace(void); 98 #ifdef CONFIG_ACPI 99 extern void acpi_early_init(void); 100 #else 101 static inline void acpi_early_init(void) { } 102 #endif 103 104 #ifdef CONFIG_TC 105 extern void tc_init(void); 106 #endif 107 108 enum system_states system_state; 109 EXPORT_SYMBOL(system_state); 110 111 /* 112 * Boot command-line arguments 113 */ 114 #define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT 115 #define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT 116 117 extern void time_init(void); 118 /* Default late time init is NULL. archs can override this later. */ 119 void (*late_time_init)(void); 120 extern void softirq_init(void); 121 122 /* Untouched command line (eg. for /proc) saved by arch-specific code. */ 123 char saved_command_line[COMMAND_LINE_SIZE]; 124 125 static char *execute_command; 126 static char *ramdisk_execute_command; 127 128 /* Setup configured maximum number of CPUs to activate */ 129 static unsigned int max_cpus = NR_CPUS; 130 131 /* 132 * Setup routine for controlling SMP activation 133 * 134 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP 135 * activation entirely (the MPS table probe still happens, though). 136 * 137 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer 138 * greater than 0, limits the maximum number of CPUs activated in 139 * SMP mode to <NUM>. 140 */ 141 static int __init nosmp(char *str) 142 { 143 max_cpus = 0; 144 return 1; 145 } 146 147 __setup("nosmp", nosmp); 148 149 static int __init maxcpus(char *str) 150 { 151 get_option(&str, &max_cpus); 152 return 1; 153 } 154 155 __setup("maxcpus=", maxcpus); 156 157 static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, }; 158 char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, }; 159 static const char *panic_later, *panic_param; 160 161 extern struct obs_kernel_param __setup_start[], __setup_end[]; 162 163 static int __init obsolete_checksetup(char *line) 164 { 165 struct obs_kernel_param *p; 166 167 p = __setup_start; 168 do { 169 int n = strlen(p->str); 170 if (!strncmp(line, p->str, n)) { 171 if (p->early) { 172 /* Already done in parse_early_param? (Needs 173 * exact match on param part) */ 174 if (line[n] == '\0' || line[n] == '=') 175 return 1; 176 } else if (!p->setup_func) { 177 printk(KERN_WARNING "Parameter %s is obsolete," 178 " ignored\n", p->str); 179 return 1; 180 } else if (p->setup_func(line + n)) 181 return 1; 182 } 183 p++; 184 } while (p < __setup_end); 185 return 0; 186 } 187 188 /* 189 * This should be approx 2 Bo*oMips to start (note initial shift), and will 190 * still work even if initially too large, it will just take slightly longer 191 */ 192 unsigned long loops_per_jiffy = (1<<12); 193 194 EXPORT_SYMBOL(loops_per_jiffy); 195 196 static int __init debug_kernel(char *str) 197 { 198 if (*str) 199 return 0; 200 console_loglevel = 10; 201 return 1; 202 } 203 204 static int __init quiet_kernel(char *str) 205 { 206 if (*str) 207 return 0; 208 console_loglevel = 4; 209 return 1; 210 } 211 212 __setup("debug", debug_kernel); 213 __setup("quiet", quiet_kernel); 214 215 static int __init loglevel(char *str) 216 { 217 get_option(&str, &console_loglevel); 218 return 1; 219 } 220 221 __setup("loglevel=", loglevel); 222 223 /* 224 * Unknown boot options get handed to init, unless they look like 225 * failed parameters 226 */ 227 static int __init unknown_bootoption(char *param, char *val) 228 { 229 /* Change NUL term back to "=", to make "param" the whole string. */ 230 if (val) { 231 /* param=val or param="val"? */ 232 if (val == param+strlen(param)+1) 233 val[-1] = '='; 234 else if (val == param+strlen(param)+2) { 235 val[-2] = '='; 236 memmove(val-1, val, strlen(val)+1); 237 val--; 238 } else 239 BUG(); 240 } 241 242 /* Handle obsolete-style parameters */ 243 if (obsolete_checksetup(param)) 244 return 0; 245 246 /* 247 * Preemptive maintenance for "why didn't my mispelled command 248 * line work?" 249 */ 250 if (strchr(param, '.') && (!val || strchr(param, '.') < val)) { 251 printk(KERN_ERR "Unknown boot option `%s': ignoring\n", param); 252 return 0; 253 } 254 255 if (panic_later) 256 return 0; 257 258 if (val) { 259 /* Environment option */ 260 unsigned int i; 261 for (i = 0; envp_init[i]; i++) { 262 if (i == MAX_INIT_ENVS) { 263 panic_later = "Too many boot env vars at `%s'"; 264 panic_param = param; 265 } 266 if (!strncmp(param, envp_init[i], val - param)) 267 break; 268 } 269 envp_init[i] = param; 270 } else { 271 /* Command line option */ 272 unsigned int i; 273 for (i = 0; argv_init[i]; i++) { 274 if (i == MAX_INIT_ARGS) { 275 panic_later = "Too many boot init vars at `%s'"; 276 panic_param = param; 277 } 278 } 279 argv_init[i] = param; 280 } 281 return 0; 282 } 283 284 static int __init init_setup(char *str) 285 { 286 unsigned int i; 287 288 execute_command = str; 289 /* 290 * In case LILO is going to boot us with default command line, 291 * it prepends "auto" before the whole cmdline which makes 292 * the shell think it should execute a script with such name. 293 * So we ignore all arguments entered _before_ init=... [MJ] 294 */ 295 for (i = 1; i < MAX_INIT_ARGS; i++) 296 argv_init[i] = NULL; 297 return 1; 298 } 299 __setup("init=", init_setup); 300 301 static int __init rdinit_setup(char *str) 302 { 303 unsigned int i; 304 305 ramdisk_execute_command = str; 306 /* See "auto" comment in init_setup */ 307 for (i = 1; i < MAX_INIT_ARGS; i++) 308 argv_init[i] = NULL; 309 return 1; 310 } 311 __setup("rdinit=", rdinit_setup); 312 313 extern void setup_arch(char **); 314 315 #ifndef CONFIG_SMP 316 317 #ifdef CONFIG_X86_LOCAL_APIC 318 static void __init smp_init(void) 319 { 320 APIC_init_uniprocessor(); 321 } 322 #else 323 #define smp_init() do { } while (0) 324 #endif 325 326 static inline void setup_per_cpu_areas(void) { } 327 static inline void smp_prepare_cpus(unsigned int maxcpus) { } 328 329 #else 330 331 #ifdef __GENERIC_PER_CPU 332 unsigned long __per_cpu_offset[NR_CPUS]; 333 334 EXPORT_SYMBOL(__per_cpu_offset); 335 336 static void __init setup_per_cpu_areas(void) 337 { 338 unsigned long size, i; 339 char *ptr; 340 341 /* Copy section for each CPU (we discard the original) */ 342 size = ALIGN(__per_cpu_end - __per_cpu_start, SMP_CACHE_BYTES); 343 #ifdef CONFIG_MODULES 344 if (size < PERCPU_ENOUGH_ROOM) 345 size = PERCPU_ENOUGH_ROOM; 346 #endif 347 348 ptr = alloc_bootmem(size * NR_CPUS); 349 350 for (i = 0; i < NR_CPUS; i++, ptr += size) { 351 __per_cpu_offset[i] = ptr - __per_cpu_start; 352 memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start); 353 } 354 } 355 #endif /* !__GENERIC_PER_CPU */ 356 357 /* Called by boot processor to activate the rest. */ 358 static void __init smp_init(void) 359 { 360 unsigned int i; 361 362 /* FIXME: This should be done in userspace --RR */ 363 for_each_present_cpu(i) { 364 if (num_online_cpus() >= max_cpus) 365 break; 366 if (!cpu_online(i)) 367 cpu_up(i); 368 } 369 370 /* Any cleanup work */ 371 printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus()); 372 smp_cpus_done(max_cpus); 373 #if 0 374 /* Get other processors into their bootup holding patterns. */ 375 376 smp_commence(); 377 #endif 378 } 379 380 #endif 381 382 /* 383 * We need to finalize in a non-__init function or else race conditions 384 * between the root thread and the init thread may cause start_kernel to 385 * be reaped by free_initmem before the root thread has proceeded to 386 * cpu_idle. 387 * 388 * gcc-3.4 accidentally inlines this function, so use noinline. 389 */ 390 391 static void noinline rest_init(void) 392 __releases(kernel_lock) 393 { 394 kernel_thread(init, NULL, CLONE_FS | CLONE_SIGHAND); 395 numa_default_policy(); 396 unlock_kernel(); 397 preempt_enable_no_resched(); 398 399 /* 400 * The boot idle thread must execute schedule() 401 * at least one to get things moving: 402 */ 403 schedule(); 404 405 cpu_idle(); 406 } 407 408 /* Check for early params. */ 409 static int __init do_early_param(char *param, char *val) 410 { 411 struct obs_kernel_param *p; 412 413 for (p = __setup_start; p < __setup_end; p++) { 414 if (p->early && strcmp(param, p->str) == 0) { 415 if (p->setup_func(val) != 0) 416 printk(KERN_WARNING 417 "Malformed early option '%s'\n", param); 418 } 419 } 420 /* We accept everything at this stage. */ 421 return 0; 422 } 423 424 /* Arch code calls this early on, or if not, just before other parsing. */ 425 void __init parse_early_param(void) 426 { 427 static __initdata int done = 0; 428 static __initdata char tmp_cmdline[COMMAND_LINE_SIZE]; 429 430 if (done) 431 return; 432 433 /* All fall through to do_early_param. */ 434 strlcpy(tmp_cmdline, saved_command_line, COMMAND_LINE_SIZE); 435 parse_args("early options", tmp_cmdline, NULL, 0, do_early_param); 436 done = 1; 437 } 438 439 /* 440 * Activate the first processor. 441 */ 442 443 asmlinkage void __init start_kernel(void) 444 { 445 char * command_line; 446 extern struct kernel_param __start___param[], __stop___param[]; 447 /* 448 * Interrupts are still disabled. Do necessary setups, then 449 * enable them 450 */ 451 lock_kernel(); 452 page_address_init(); 453 printk(KERN_NOTICE); 454 printk(linux_banner); 455 setup_arch(&command_line); 456 setup_per_cpu_areas(); 457 458 /* 459 * Mark the boot cpu "online" so that it can call console drivers in 460 * printk() and can access its per-cpu storage. 461 */ 462 smp_prepare_boot_cpu(); 463 464 /* 465 * Set up the scheduler prior starting any interrupts (such as the 466 * timer interrupt). Full topology setup happens at smp_init() 467 * time - but meanwhile we still have a functioning scheduler. 468 */ 469 sched_init(); 470 /* 471 * Disable preemption - early bootup scheduling is extremely 472 * fragile until we cpu_idle() for the first time. 473 */ 474 preempt_disable(); 475 build_all_zonelists(); 476 page_alloc_init(); 477 printk(KERN_NOTICE "Kernel command line: %s\n", saved_command_line); 478 parse_early_param(); 479 parse_args("Booting kernel", command_line, __start___param, 480 __stop___param - __start___param, 481 &unknown_bootoption); 482 sort_main_extable(); 483 trap_init(); 484 rcu_init(); 485 init_IRQ(); 486 pidhash_init(); 487 init_timers(); 488 softirq_init(); 489 time_init(); 490 491 /* 492 * HACK ALERT! This is early. We're enabling the console before 493 * we've done PCI setups etc, and console_init() must be aware of 494 * this. But we do want output early, in case something goes wrong. 495 */ 496 console_init(); 497 if (panic_later) 498 panic(panic_later, panic_param); 499 profile_init(); 500 local_irq_enable(); 501 #ifdef CONFIG_BLK_DEV_INITRD 502 if (initrd_start && !initrd_below_start_ok && 503 initrd_start < min_low_pfn << PAGE_SHIFT) { 504 printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - " 505 "disabling it.\n",initrd_start,min_low_pfn << PAGE_SHIFT); 506 initrd_start = 0; 507 } 508 #endif 509 vfs_caches_init_early(); 510 mem_init(); 511 kmem_cache_init(); 512 setup_per_cpu_pageset(); 513 numa_policy_init(); 514 if (late_time_init) 515 late_time_init(); 516 calibrate_delay(); 517 pidmap_init(); 518 pgtable_cache_init(); 519 prio_tree_init(); 520 anon_vma_init(); 521 #ifdef CONFIG_X86 522 if (efi_enabled) 523 efi_enter_virtual_mode(); 524 #endif 525 fork_init(num_physpages); 526 proc_caches_init(); 527 buffer_init(); 528 unnamed_dev_init(); 529 key_init(); 530 security_init(); 531 vfs_caches_init(num_physpages); 532 radix_tree_init(); 533 signals_init(); 534 /* rootfs populating might need page-writeback */ 535 page_writeback_init(); 536 #ifdef CONFIG_PROC_FS 537 proc_root_init(); 538 #endif 539 cpuset_init(); 540 541 check_bugs(); 542 543 acpi_early_init(); /* before LAPIC and SMP init */ 544 545 /* Do the rest non-__init'ed, we're now alive */ 546 rest_init(); 547 } 548 549 static int __initdata initcall_debug; 550 551 static int __init initcall_debug_setup(char *str) 552 { 553 initcall_debug = 1; 554 return 1; 555 } 556 __setup("initcall_debug", initcall_debug_setup); 557 558 struct task_struct *child_reaper = &init_task; 559 560 extern initcall_t __initcall_start[], __initcall_end[]; 561 562 static void __init do_initcalls(void) 563 { 564 initcall_t *call; 565 int count = preempt_count(); 566 567 for (call = __initcall_start; call < __initcall_end; call++) { 568 char *msg; 569 570 if (initcall_debug) { 571 printk(KERN_DEBUG "Calling initcall 0x%p", *call); 572 print_fn_descriptor_symbol(": %s()", (unsigned long) *call); 573 printk("\n"); 574 } 575 576 (*call)(); 577 578 msg = NULL; 579 if (preempt_count() != count) { 580 msg = "preemption imbalance"; 581 preempt_count() = count; 582 } 583 if (irqs_disabled()) { 584 msg = "disabled interrupts"; 585 local_irq_enable(); 586 } 587 if (msg) { 588 printk(KERN_WARNING "error in initcall at 0x%p: " 589 "returned with %s\n", *call, msg); 590 } 591 } 592 593 /* Make sure there is no pending stuff from the initcall sequence */ 594 flush_scheduled_work(); 595 } 596 597 /* 598 * Ok, the machine is now initialized. None of the devices 599 * have been touched yet, but the CPU subsystem is up and 600 * running, and memory and process management works. 601 * 602 * Now we can finally start doing some real work.. 603 */ 604 static void __init do_basic_setup(void) 605 { 606 /* drivers will send hotplug events */ 607 init_workqueues(); 608 usermodehelper_init(); 609 driver_init(); 610 611 #ifdef CONFIG_SYSCTL 612 sysctl_init(); 613 #endif 614 615 /* Networking initialization needs a process context */ 616 sock_init(); 617 618 do_initcalls(); 619 } 620 621 static void do_pre_smp_initcalls(void) 622 { 623 extern int spawn_ksoftirqd(void); 624 #ifdef CONFIG_SMP 625 extern int migration_init(void); 626 627 migration_init(); 628 #endif 629 spawn_ksoftirqd(); 630 spawn_softlockup_task(); 631 } 632 633 static void run_init_process(char *init_filename) 634 { 635 argv_init[0] = init_filename; 636 execve(init_filename, argv_init, envp_init); 637 } 638 639 static inline void fixup_cpu_present_map(void) 640 { 641 #ifdef CONFIG_SMP 642 int i; 643 644 /* 645 * If arch is not hotplug ready and did not populate 646 * cpu_present_map, just make cpu_present_map same as cpu_possible_map 647 * for other cpu bringup code to function as normal. e.g smp_init() etc. 648 */ 649 if (cpus_empty(cpu_present_map)) { 650 for_each_cpu(i) { 651 cpu_set(i, cpu_present_map); 652 } 653 } 654 #endif 655 } 656 657 static int init(void * unused) 658 { 659 lock_kernel(); 660 /* 661 * init can run on any cpu. 662 */ 663 set_cpus_allowed(current, CPU_MASK_ALL); 664 /* 665 * Tell the world that we're going to be the grim 666 * reaper of innocent orphaned children. 667 * 668 * We don't want people to have to make incorrect 669 * assumptions about where in the task array this 670 * can be found. 671 */ 672 child_reaper = current; 673 674 /* Sets up cpus_possible() */ 675 smp_prepare_cpus(max_cpus); 676 677 do_pre_smp_initcalls(); 678 679 fixup_cpu_present_map(); 680 smp_init(); 681 sched_init_smp(); 682 683 cpuset_init_smp(); 684 685 /* 686 * Do this before initcalls, because some drivers want to access 687 * firmware files. 688 */ 689 populate_rootfs(); 690 691 do_basic_setup(); 692 693 /* 694 * check if there is an early userspace init. If yes, let it do all 695 * the work 696 */ 697 698 if (!ramdisk_execute_command) 699 ramdisk_execute_command = "/init"; 700 701 if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { 702 ramdisk_execute_command = NULL; 703 prepare_namespace(); 704 } 705 706 /* 707 * Ok, we have completed the initial bootup, and 708 * we're essentially up and running. Get rid of the 709 * initmem segments and start the user-mode stuff.. 710 */ 711 free_initmem(); 712 unlock_kernel(); 713 system_state = SYSTEM_RUNNING; 714 numa_default_policy(); 715 716 if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) 717 printk(KERN_WARNING "Warning: unable to open an initial console.\n"); 718 719 (void) sys_dup(0); 720 (void) sys_dup(0); 721 722 if (ramdisk_execute_command) { 723 run_init_process(ramdisk_execute_command); 724 printk(KERN_WARNING "Failed to execute %s\n", 725 ramdisk_execute_command); 726 } 727 728 /* 729 * We try each of these until one succeeds. 730 * 731 * The Bourne shell can be used instead of init if we are 732 * trying to recover a really broken machine. 733 */ 734 if (execute_command) { 735 run_init_process(execute_command); 736 printk(KERN_WARNING "Failed to execute %s. Attempting " 737 "defaults...\n", execute_command); 738 } 739 run_init_process("/sbin/init"); 740 run_init_process("/etc/init"); 741 run_init_process("/bin/init"); 742 run_init_process("/bin/sh"); 743 744 panic("No init found. Try passing init= option to kernel."); 745 } 746