static int __init kernel_init(void * unused)
{
/*
* Wait until kthreadd is all set-up.
*/
wait_for_completion(&kthreadd_done);
lock_kernel();
/*
* init can allocate pages on any node
*/
set_mems_allowed(node_states[N_HIGH_MEMORY]);
/*
* init can run on any cpu.
*/
set_cpus_allowed_ptr(current, cpu_all_mask);
/*
* 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.
*/
init_pid_ns.child_reaper = current;
cad_pid = task_pid(current);
smp_prepare_cpus(setup_max_cpus);
do_pre_smp_initcalls();
start_boot_trace();
smp_init();
sched_init_smp();
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..
*/
init_post();
return 0;
}
static int __init kernel_init(void * unused)
{
#ifndef __LINSCHED__
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.
*/
init_pid_ns.child_reaper = current;
__set_special_pids(1, 1);
cad_pid = task_pid(current);
smp_prepare_cpus(max_cpus);
do_pre_smp_initcalls();
smp_init();
#endif /* __LINSCHED__ */
sched_init_smp();
#ifndef __LINSCHED__
cpuset_init_smp();
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..
*/
init_post();
#endif /* __LINSCHED__ */
return 0;
}
static int __init 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..
*/
init_post();
return 0;
}
static int __init kernel_init(void * unused)
{
lock_kernel();
/*
* init can allocate pages on any node
*/
set_mems_allowed(node_possible_map);
/*
* init can run on any cpu.
*/
set_cpus_allowed_ptr(current, cpu_all_mask);
/*
* 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.
*/
init_pid_ns.child_reaper = current;
cad_pid = task_pid(current);
smp_prepare_cpus(setup_max_cpus);
do_pre_smp_initcalls();
start_boot_trace();
smp_init();
sched_init_smp();
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_IRQSOFF_TRACER) + defined(CONFIG_PREEMPT_TRACER) + defined(CONFIG_STACK_TRACER) + defined(CONFIG_INTERRUPT_OFF_HIST) + defined(CONFIG_PREEMPT_OFF_HIST) + defined(CONFIG_WAKEUP_LATENCY_HIST) + defined(CONFIG_DEBUG_SLAB) + defined(CONFIG_DEBUG_PAGEALLOC) + defined(CONFIG_LOCKDEP) + (defined(CONFIG_FTRACE) - defined(CONFIG_FTRACE_MCOUNT_RECORD)))
#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_IRQSOFF_TRACER
printk(KERN_ERR "* CONFIG_IRQSOFF_TRACER *\n");
#endif
#ifdef CONFIG_PREEMPT_TRACER
printk(KERN_ERR "* CONFIG_PREEMPT_TRACER *\n");
#endif
#if defined(CONFIG_FTRACE) && !defined(CONFIG_FTRACE_MCOUNT_RECORD)
printk(KERN_ERR "* CONFIG_FTRACE *\n");
#endif
#ifdef CONFIG_INTERRUPT_OFF_HIST
printk(KERN_ERR "* CONFIG_INTERRUPT_OFF_HIST *\n");
#endif
#ifdef CONFIG_PREEMPT_OFF_HIST
printk(KERN_ERR "* CONFIG_PREEMPT_OFF_HIST *\n");
#endif
#ifdef CONFIG_WAKEUP_LATENCY_HIST
printk(KERN_ERR "* CONFIG_WAKEUP_LATENCY_HIST *\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..
*/
init_post();
return 0;
}
static int __init kernel_init(void * unused)
{
/*
* Wait until kthreadd is all set-up.
*/
wait_for_completion(&kthreadd_done);
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.
*/
init_pid_ns.child_reaper = current;
__set_special_pids(1, 1);
cad_pid = task_pid(current);
smp_prepare_cpus(max_cpus);
do_pre_smp_initcalls();
smp_init();
sched_init_smp();
cpuset_init_smp();
do_basic_setup();
/* 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);
/*
* 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..
*/
init_post();
return 0;
}
static int init(void * unused)
{
int fdin, fdout, fderr;
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;
/* Sets up cpus_possible() */
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();
/*
* check if there is an early userspace init. If yes, let it do all
* the work
*/
if (sys_access((const char __user *) "/init", 0) == 0)
execute_command = "/init";
else
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();
system_state = SYSTEM_RUNNING;
numa_default_policy();
fdin = sys_open((const char __user *) "/dev/console", O_RDWR, 0);
if (fdin < 0) {
printk(KERN_WARNING "Warning: unable to open /dev/console as initial console, res=%d.\n", fdin);
fdin = sys_open((const char __user *) "/dev/null", O_RDWR, 0);
if (fdin < 0) {
panic("unable to open /dev/null as initial console, res=%d.\n", fdin);
}
}
if (fdin != 0) {
panic("initial console's stdin fd is not 0, but %d\n", fdin);
}
fdout = sys_dup(fdin);
if (fdout < 0) {
panic("can't dup initial console's stdout, res=%d\n", fdout);
} else if (fdout != 1) {
panic("initial console's stdout fd is not 1, but %d\n", fdout);
}
fderr = sys_dup(fdin);
if (fderr < 0) {
panic("can't dup initial console's stderr, res=%d\n", fderr);
} else if (fderr != 2) {
panic("initial console's stderr fd is not 2, but %d\n", fderr);
}
/*
* 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);
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 ATTRIB_NORET init(void * unused)
{
#ifdef TARGET_OS2
LX_ReschedWaitOn();
while(kernel_flag.lock<=0)
schedule();
#endif
lock_kernel();
/*
* 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;
/* Sets up cpus_possible() */
smp_prepare_cpus(max_cpus);
do_pre_smp_initcalls();
smp_init();
/*
* 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 (sys_access("/init", 0) == 0)
execute_command = "/init";
else
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();
system_state = SYSTEM_RUNNING;
#ifdef TARGET_OS2
lx_sysstate|=LXSYSSTATE_SYSTEM_RUNNING;
#endif
if (sys_open("/dev/console", O_RDWR, 0) < 0)
printk("Warning: unable to open an initial console.\n");
(void) sys_dup(0);
(void) sys_dup(0);
#ifdef TARGET_OS2
LX_set_sysstate(LXSYSSTATE_KERNEL_BOOT_FINISHED,0);
#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);
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.");
}
/* C entry point for boot CPU */
void __init start_xen(unsigned long boot_phys_offset,
unsigned long fdt_paddr,
unsigned long cpuid)
{
size_t fdt_size;
int cpus, i;
const char *cmdline;
setup_cache();
percpu_init_areas();
set_processor_id(0); /* needed early, for smp_processor_id() */
smp_clear_cpu_maps();
/* This is mapped by head.S */
device_tree_flattened = (void *)BOOT_FDT_VIRT_START
+ (fdt_paddr & ((1 << SECOND_SHIFT) - 1));
fdt_size = device_tree_early_init(device_tree_flattened, fdt_paddr);
cmdline = device_tree_bootargs(device_tree_flattened);
early_printk("Command line: %s\n", cmdline);
cmdline_parse(cmdline);
setup_pagetables(boot_phys_offset, get_xen_paddr());
setup_mm(fdt_paddr, fdt_size);
vm_init();
dt_unflatten_host_device_tree();
dt_irq_xlate = gic_irq_xlate;
dt_uart_init();
console_init_preirq();
system_state = SYS_STATE_boot;
processor_id();
platform_init();
smp_init_cpus();
cpus = smp_get_max_cpus();
init_xen_time();
gic_init();
set_current((struct vcpu *)0xfffff000); /* debug sanity */
idle_vcpu[0] = current;
init_traps();
setup_virt_paging();
p2m_vmid_allocator_init();
softirq_init();
tasklet_subsys_init();
init_IRQ();
gic_route_ppis();
gic_route_spis();
init_maintenance_interrupt();
init_timer_interrupt();
timer_init();
init_idle_domain();
rcu_init();
arch_init_memory();
local_irq_enable();
local_abort_enable();
smp_prepare_cpus(cpus);
initialize_keytable();
console_init_postirq();
do_presmp_initcalls();
for_each_present_cpu ( i )
{
if ( (num_online_cpus() < cpus) && !cpu_online(i) )
{
int ret = cpu_up(i);
if ( ret != 0 )
printk("Failed to bring up CPU %u (error %d)\n", i, ret);
}
}
printk("Brought up %ld CPUs\n", (long)num_online_cpus());
/* TODO: smp_cpus_done(); */
do_initcalls();
/* Create initial domain 0. */
dom0 = domain_create(0, 0, 0);
if ( IS_ERR(dom0) || (alloc_dom0_vcpu0() == NULL) )
panic("Error creating domain 0");
dom0->is_privileged = 1;
dom0->target = NULL;
if ( construct_dom0(dom0) != 0)
panic("Could not set up DOM0 guest OS");
/* Scrub RAM that is still free and so may go to an unprivileged domain. */
scrub_heap_pages();
init_constructors();
console_endboot();
/* Hide UART from DOM0 if we're using it */
serial_endboot();
system_state = SYS_STATE_active;
domain_unpause_by_systemcontroller(dom0);
/* Switch on to the dynamically allocated stack for the idle vcpu
* since the static one we're running on is about to be freed. */
memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(),
sizeof(struct cpu_info));
switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done);
}
/* C entry point for boot CPU */
void __init start_xen(unsigned long boot_phys_offset,
unsigned long fdt_paddr,
unsigned long cpuid)
{
size_t fdt_size;
int cpus, i;
paddr_t xen_paddr;
const char *cmdline;
struct bootmodule *xen_bootmodule;
struct domain *dom0;
struct xen_arch_domainconfig config;
setup_cache();
percpu_init_areas();
set_processor_id(0); /* needed early, for smp_processor_id() */
set_current((struct vcpu *)0xfffff000); /* debug sanity */
idle_vcpu[0] = current;
setup_virtual_regions(NULL, NULL);
/* Initialize traps early allow us to get backtrace when an error occurred */
init_traps();
smp_clear_cpu_maps();
/* This is mapped by head.S */
device_tree_flattened = (void *)BOOT_FDT_VIRT_START
+ (fdt_paddr & ((1 << SECOND_SHIFT) - 1));
fdt_size = boot_fdt_info(device_tree_flattened, fdt_paddr);
cmdline = boot_fdt_cmdline(device_tree_flattened);
printk("Command line: %s\n", cmdline);
cmdline_parse(cmdline);
/* Register Xen's load address as a boot module. */
xen_bootmodule = add_boot_module(BOOTMOD_XEN,
(paddr_t)(uintptr_t)(_start + boot_phys_offset),
(paddr_t)(uintptr_t)(_end - _start + 1), NULL);
BUG_ON(!xen_bootmodule);
xen_paddr = get_xen_paddr();
setup_pagetables(boot_phys_offset, xen_paddr);
/* Update Xen's address now that we have relocated. */
printk("Update BOOTMOD_XEN from %"PRIpaddr"-%"PRIpaddr" => %"PRIpaddr"-%"PRIpaddr"\n",
xen_bootmodule->start, xen_bootmodule->start + xen_bootmodule->size,
xen_paddr, xen_paddr + xen_bootmodule->size);
xen_bootmodule->start = xen_paddr;
setup_mm(fdt_paddr, fdt_size);
/* Parse the ACPI tables for possible boot-time configuration */
acpi_boot_table_init();
end_boot_allocator();
vm_init();
dt_unflatten_host_device_tree();
init_IRQ();
platform_init();
preinit_xen_time();
gic_preinit();
arm_uart_init();
console_init_preirq();
console_init_ring();
system_state = SYS_STATE_boot;
processor_id();
smp_init_cpus();
cpus = smp_get_max_cpus();
init_xen_time();
gic_init();
p2m_vmid_allocator_init();
softirq_init();
tasklet_subsys_init();
xsm_dt_init();
init_maintenance_interrupt();
init_timer_interrupt();
timer_init();
init_idle_domain();
rcu_init();
arch_init_memory();
local_irq_enable();
local_abort_enable();
smp_prepare_cpus(cpus);
initialize_keytable();
console_init_postirq();
do_presmp_initcalls();
for_each_present_cpu ( i )
{
if ( (num_online_cpus() < cpus) && !cpu_online(i) )
{
int ret = cpu_up(i);
if ( ret != 0 )
printk("Failed to bring up CPU %u (error %d)\n", i, ret);
}
}
printk("Brought up %ld CPUs\n", (long)num_online_cpus());
/* TODO: smp_cpus_done(); */
setup_virt_paging();
iommu_setup();
do_initcalls();
/*
* It needs to be called after do_initcalls to be able to use
* stop_machine (tasklets initialized via an initcall).
*/
apply_alternatives_all();
/* Create initial domain 0. */
/* The vGIC for DOM0 is exactly emulating the hardware GIC */
config.gic_version = XEN_DOMCTL_CONFIG_GIC_NATIVE;
config.nr_spis = gic_number_lines() - 32;
dom0 = domain_create(0, 0, 0, &config);
if ( IS_ERR(dom0) || (alloc_dom0_vcpu0(dom0) == NULL) )
panic("Error creating domain 0");
dom0->is_privileged = 1;
dom0->target = NULL;
if ( construct_dom0(dom0) != 0)
panic("Could not set up DOM0 guest OS");
/* Scrub RAM that is still free and so may go to an unprivileged domain. */
scrub_heap_pages();
init_constructors();
console_endboot();
/* Hide UART from DOM0 if we're using it */
serial_endboot();
system_state = SYS_STATE_active;
/* Must be done past setting system_state. */
unregister_init_virtual_region();
domain_unpause_by_systemcontroller(dom0);
/* Switch on to the dynamically allocated stack for the idle vcpu
* since the static one we're running on is about to be freed. */
memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(),
sizeof(struct cpu_info));
switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done);
}
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.");
}
static int init(void * unused)
{
lock_kernel();
/*
* 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;
/* Sets up cpus_possible() */
smp_prepare_cpus(max_cpus);
init_hardirqs();
do_pre_smp_initcalls();
fixup_cpu_present_map();
smp_init();
sched_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 (sys_access((const char __user *) "/init", 0) == 0)
execute_command = "/init";
else
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();
system_state = SYSTEM_RUNNING;
numa_default_policy();
if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
printk("Warning: unable to open an initial console.\n");
(void) sys_dup(0);
(void) sys_dup(0);
/*
* 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.
*/
#ifdef CONFIG_KFI_BOOT_TIMING
to_userspace();
#endif
if (execute_command)
run_init_process(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 kernel_init(void * unused)
{
lock_kernel();
/*
* init can allocate pages on any node
*/
set_mems_allowed(node_possible_map);
#ifdef CONFIG_SYS_HAS_CONTROL_CPU
/*
* init can run on cpu0 only .
*/
set_cpus_allowed_ptr(current, cpumask_of(0));
#else
/*
* init can run on any cpu .
*/
set_cpus_allowed_ptr(current, cpu_all_mask);
#endif
/*
* 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.
*/
init_pid_ns.child_reaper = current;
cad_pid = task_pid(current);
smp_prepare_cpus(setup_max_cpus);
do_pre_smp_initcalls();
start_boot_trace();
smp_init();
sched_init_smp();
#ifdef CONFIG_SYS_HAS_CONTROL_CPU
/* HeJianjun modified for bug 148,
* we run linux local processes on only cpu0, other cpu's are just for running dapp */
set_cpus_allowed_ptr(current, cpumask_of(0));
#endif
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..
*/
init_post();
return 0;
}
