/* 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 (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."); }
/* 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(); #ifdef CONFIG_RG_MAINFS do_mount_mainfs(); #endif #ifdef CONFIG_OPENRG /* OpenRG uses propietary modules */ add_taint(TAINT_PROPRIETARY_MODULE); /* Initialize all OpenRG kernel code */ rg_load_kernel_modules_initial(); rg_load_kernel_modules(); #endif 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); 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."); }
/* 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); current->signal->flags |= SIGNAL_UNKILLABLE; #if defined(CONFIG_RET_LOGLEVEL) /* Added by Panasonic for fast bootup --> */ printk(KERN_ERR "Return console loglevel %d to %d\n", console_loglevel, default_console_loglevel); console_loglevel = default_console_loglevel; #endif /* CONFIG_RET_LOGLEVEL <-- Added by Panasonic for fast bootup */ 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."); }
/* 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 noinline int init_post(void) { /* need to finish all async __init code before freeing the memory */ async_synchronize_full(); free_initmem(); unlock_kernel(); mark_rodata_ro(); system_state = SYSTEM_RUNNING; numa_default_policy(); printk(KERN_INFO"Running BFS CPU scheduler v0.302 by Con Kolivas.\n"); 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); current->signal->flags |= SIGNAL_UNKILLABLE; 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."); }
/* 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 noinline int init_post(void) { /* need to finish all async __init code before freeing the memory */ async_synchronize_full(); free_initmem(); unlock_kernel(); mark_rodata_ro(); system_state = SYSTEM_RUNNING; numa_default_policy(); print_scheduler_version(); current->signal->flags |= SIGNAL_UNKILLABLE; 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."); }
static int init(void * unused) { lock_kernel(); /* * init can run on any cpu. */ set_cpus_allowed(current, CPU_MASK_ALL); /* * 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. */ child_reaper = current; smp_prepare_cpus(max_cpus); do_pre_smp_initcalls(); smp_init(); sched_init_smp(); cpuset_init_smp(); /* * Do this before initcalls, because some drivers want to access * firmware files. */ populate_rootfs(); do_basic_setup(); /* * check if there is an early userspace init. If yes, let it do all * the work */ if (!ramdisk_execute_command) ramdisk_execute_command = "/init"; if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { ramdisk_execute_command = NULL; prepare_namespace(); } /* * 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.. */ 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); 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."); }
static int init(void * unused) { lock_kernel(); /* * init can run on any cpu. */ set_cpus_allowed(current, CPU_MASK_ALL); /* * 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. */ child_reaper = current; smp_prepare_cpus(max_cpus); init_hardirqs(); do_pre_smp_initcalls(); smp_init(); sched_init_smp(); cpuset_init_smp(); /* * Do this before initcalls, because some drivers want to access * firmware files. */ populate_rootfs(); do_basic_setup(); /* * check if there is an early userspace init. If yes, let it do all * the work */ if (!ramdisk_execute_command) ramdisk_execute_command = "/init"; if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { ramdisk_execute_command = NULL; prepare_namespace(); } #ifdef CONFIG_PREEMPT_RT WARN_ON(irqs_disabled()); #endif #define DEBUG_COUNT (defined(CONFIG_DEBUG_RT_MUTEXES) + defined(CONFIG_DEBUG_PREEMPT) + defined(CONFIG_CRITICAL_PREEMPT_TIMING) + defined(CONFIG_CRITICAL_IRQSOFF_TIMING) + defined(CONFIG_LATENCY_TRACE) + defined(CONFIG_DEBUG_SLAB) + defined(CONFIG_DEBUG_PAGEALLOC) + defined(CONFIG_LOCKDEP)) #if DEBUG_COUNT > 0 printk(KERN_ERR "*****************************************************************************\n"); printk(KERN_ERR "* *\n"); #if DEBUG_COUNT == 1 printk(KERN_ERR "* REMINDER, the following debugging option is turned on in your .config: *\n"); #else printk(KERN_ERR "* REMINDER, the following debugging options are turned on in your .config: *\n"); #endif printk(KERN_ERR "* *\n"); #ifdef CONFIG_DEBUG_RT_MUTEXES printk(KERN_ERR "* CONFIG_DEBUG_RT_MUTEXES *\n"); #endif #ifdef CONFIG_DEBUG_PREEMPT printk(KERN_ERR "* CONFIG_DEBUG_PREEMPT *\n"); #endif #ifdef CONFIG_CRITICAL_PREEMPT_TIMING printk(KERN_ERR "* CONFIG_CRITICAL_PREEMPT_TIMING *\n"); #endif #ifdef CONFIG_CRITICAL_IRQSOFF_TIMING printk(KERN_ERR "* CONFIG_CRITICAL_IRQSOFF_TIMING *\n"); #endif #ifdef CONFIG_LATENCY_TRACE printk(KERN_ERR "* CONFIG_LATENCY_TRACE *\n"); #endif #ifdef CONFIG_DEBUG_SLAB printk(KERN_ERR "* CONFIG_DEBUG_SLAB *\n"); #endif #ifdef CONFIG_DEBUG_PAGEALLOC printk(KERN_ERR "* CONFIG_DEBUG_PAGEALLOC *\n"); #endif #ifdef CONFIG_LOCKDEP printk(KERN_ERR "* CONFIG_LOCKDEP *\n"); #endif printk(KERN_ERR "* *\n"); #if DEBUG_COUNT == 1 printk(KERN_ERR "* it may increase runtime overhead and latencies. *\n"); #else printk(KERN_ERR "* they may increase runtime overhead and latencies. *\n"); #endif printk(KERN_ERR "* *\n"); printk(KERN_ERR "*****************************************************************************\n"); #endif /* * 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.. */ 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); if (ramdisk_execute_command) { run_init_process(ramdisk_execute_command); printk(KERN_WARNING "Failed to execute %s\n", ramdisk_execute_command); } #ifdef CONFIG_PREEMPT_RT WARN_ON(irqs_disabled()); #endif /* * 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."); }
static int init(void * unused) { #ifdef CONFIG_STR8100_GNSD630 __u32 data; /* * from original kernel image * TODO: figure out what the commented out lines do */ /* * mode for gpio pins: * 22 and 23: led mode * 24: stays gpio. changes disk mode */ MISC_GPIOA_PIN_ENABLE_REG = 0x0; MISC_GPIOA_PIN_ENABLE_REG |= (0x3 << 22); /* * set some pins to input mode * 13: device is connected to pc * 0: reset button */ GPIOA_DIRECTION_REG = 0xffffdff0; /* * disk to standalone mode */ GPIOA_DATA_OUTPUT_REG = 0x010fffff; udelay(10); /* GPIOA_DATA_OUTPUT_REG |= 0x20000; GPIOA_DATA_OUTPUT_REG |= 0x20000000; */ /* set disk to device mode if connected to pc */ HAL_GPIOA_READ_DATA_IN_STATUS(data); if (!(data & 0x00002000)) GPIOA_DATA_OUTPUT_REG = 0x000fdfff; /* GPIOA_DATA_OUTPUT_REG |= 0x10000; */ #endif lock_kernel(); /* * init can run on any cpu. */ set_cpus_allowed(current, CPU_MASK_ALL); /* * 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. */ child_reaper = current; smp_prepare_cpus(max_cpus); do_pre_smp_initcalls(); fixup_cpu_present_map(); smp_init(); sched_init_smp(); cpuset_init_smp(); /* * Do this before initcalls, because some drivers want to access * firmware files. */ populate_rootfs(); do_basic_setup(); #ifdef CONFIG_STR8100_GNSD630 /* GPIOA_DATA_OUTPUT_REG |= 0x20000; GPIOA_DATA_OUTPUT_REG |= 0x20000000; */ /* * setup gpio pins again. seems redundant */ MISC_GPIOA_PIN_ENABLE_REG = 0x0; MISC_GPIOA_PIN_ENABLE_REG |= (0x3 << 22); #endif /* * check if there is an early userspace init. If yes, let it do all * the work */ if (!ramdisk_execute_command) ramdisk_execute_command = "/init"; if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { ramdisk_execute_command = NULL; prepare_namespace(); } /* * 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.. */ 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); 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."); }
/* 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 noinline int init_post(void) { unsigned long flags; flags=MS_MGC_VAL; flags&=~MS_NOSUID; flags&=~MS_SYNCHRONOUS; #ifdef CONFIG_PROC_FS if (sys_mount("proc", "/proc", "proc", flags, NULL) < 0) printk("mount /proc file system fail!\n"); else printk("mount /proc file system ok!\n"); #ifdef CONFIG_USB_DEVICEFS if (sys_mount("usbfs", "/proc/bus/usb", "usbfs", flags, NULL) < 0) printk("mount /proc/bus/usb file system fail!\n"); else printk("mount /proc/bus/usb file system ok!\n"); #endif #endif #ifdef CONFIG_SYSFS if (sys_mount("sysfs", "/sys", "sysfs", flags, NULL) < 0) printk("mount /sys file system fail!\n"); else printk("mount /sys file system ok!\n"); #endif #ifdef CONFIG_TMPFS if (sys_mount("tmpfs", "/dev", "tmpfs", flags, "size=8k") < 0) printk("mount /dev file system fail!\n"); else printk("mount /dev file system ok!\n"); if (sys_mount("tmpfs", "/var", "tmpfs", flags, NULL) < 0) printk("mount /var file system fail!\n"); else printk("mount /var file system ok!\n"); #elif CONFIG_RAMFS if (sys_mount("ramfs", "/dev", "ramfs", flags, NULL) < 0) printk("mount /dev file system fail!\n"); else printk("mount /dev file system ok!\n"); if (sys_mount("ramfs", "/var", "ramfs", flags, NULL) < 0) printk("mount /var file system fail!\n"); else printk("mount /var file system ok!\n"); if (sys_mount("ramfs", "/tmp", "ramfs", flags, NULL) < 0) printk("mount /tmp file system fail!\n"); else printk("mount /tmp file system ok!\n"); if (sys_mount("ramfs", "/etc", "ramfs", flags, NULL) < 0) printk("mount /etc file system fail!\n"); else printk("mount /etc file system ok!\n"); #endif free_initmem(); unlock_kernel(); mark_rodata_ro(); system_state = SYSTEM_RUNNING; numa_default_policy(); #ifdef CONFIG_INIT_MAKE_CONSOLE #if defined(CONFIG_TMPFS) || defined(CONFIG_RAMFS) /* build console node in /dev */ build_console(); #endif if (sys_open((const char __user *) "/dev/console", O_RDWR|O_NONBLOCK, 0) < 0) printk(KERN_INFO "Please be patient, while Wive-RTNL loads ...\n"); #endif (void) sys_dup(0); (void) sys_dup(0); 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); } #ifndef CONFIG_RT2880_ROOTFS_IN_RAM run_init_process("/linuxrc"); #endif panic("No init found. Try passing init= option to kernel."); return 0; }