RISC-V SMP Linux boot process

// arch/riscv/kernel/head.S : 196

_start_kernel:
        csrw CSR_IE, zero
        csrw CSR_IP, zero
        ...
        /* Save hart ID and DTB physical address */
        mv s0, a0
        mv s1, a1

        la a2, boot_cpu_hartid
        REG_S a0, (a2)
        ...
        mv a0, s1
        call setup_vm
        ...
        la a0, early_pg_dir
        call relocate_enable_mmu
        ...
        call setup_trap_vector
            CSR_TVEC handle_exception

        la tp, init_task
        la sp, init_thread_union + THREAD_SIZE
        ...
        tail start_kernel

// include/linux/cpumask.h : 97

#define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask)
#define cpu_online_mask   ((const struct cpumask *)&__cpu_online_mask)
#define cpu_present_mask  ((const struct cpumask *)&__cpu_present_mask)
#define cpu_active_mask   ((const struct cpumask *)&__cpu_active_mask)

// init/main.c : 936

start_kernel()
    smp_setup_processor_id();
    boot_cpu_init();
    setup_arch();
        setup_smp();
    ...
    smp_prepare_boot_cpu();
    boot_cpu_hotplug_init();
    ...
    sched_init();
    ...
    arch_call_rest_init();
        rest_init();

// init/main.c : 772

smp_setup_processor_id();
    __cpuid_to_hartid_map[0] = boot_cpu_hartid;

// kernel/cpu.c : 2667

boot_cpu_init()
    int cpu = smp_processor_id();
        raw_smp_processor_id()
            (current_thread_info()->cpu)
            (struct task_info *)riscv_current_is_tp->cpu // 0
    //  Mark the boot cpu "present", "online" etc
    set_cpu_online(cpu, true);
    set_cpu_active(cpu, true);
    set_cpu_present(cpu, true);
    set_cpu_possible(cpu, true);

    __boot_cpu_id = cpu;

// arch/riscv/kernel/smpboot.c : 73

setup_smp()
    for_each_of_cpu_node
        riscv_of_processor_hartid(dn, &hart)
        cpuid_to_hartid_map(cpuid) = hart
        early_map_cpu_to_node(cpuid, of_node_to_nid(dn));
        cpuid++
    for (cpuid = 1; cpuid < nr_cpu_ids; cpuid++)
        cpu_set_ops(cpuid);
            cpu_ops[cpuid] = &cpu_ops_sbi;
        set_cpu_possible(cpuid, true);

// arch/riscv/kernel/cpu_ops_sbi.c : 120

const struct cpu_operations cpu_ops_sbi = {
        .name           = "sbi",
        .cpu_prepare    = sbi_cpu_prepare,
        .cpu_start      = sbi_cpu_start,
#ifdef CONFIG_HOTPLUG_CPU
        .cpu_disable    = sbi_cpu_disable,
        .cpu_stop       = sbi_cpu_stop,
        .cpu_is_stopped = sbi_cpu_is_stopped,
#endif
};

// kernel/cpu.c : 2690

void __init boot_cpu_hotplug_init(void)
{
#ifdef CONFIG_SMP
        cpumask_set_cpu(smp_processor_id(), &cpus_booted_once_mask);
#endif
        this_cpu_write(cpuhp_state.state, CPUHP_ONLINE);
}

        la tp, init_task
        la sp, init_thread_union + THREAD_SIZE

// kernel/sched/core.c : 9613

sched_init()

    init_idle(current, smp_processor_id()) // set up an idle thread for a given CPU
        __sched_fork(0, idle);
        idle->__state = TASK_RUNNING
        idle->flags |= PF_IDLE | PF_KTHREAD | PF_NO_SETAFFINITY;
        kthread_set_per_cpu(idle, cpu)
            kthread->cpu = cpu
        idle->sched_class = &idle_sched_class;
        sprintf(idle->comm, "%s/%d", INIT_TASK_COMM, cpu); // set idle->comm is "swapper"

    idle_thread_set_boot_cpu();

// init/main.c : 681

rest_init()

    pid = user_mode_thread(kernel_init, NULL, CLONE_FS);
        wait_for_completion(&kthreadd_done);
        kernel_init_freeable();

    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);

    system_state = SYSTEM_SCHEDULING;

    complete(&kthreadd_done);

    schedule_preempt_disabled() // scheule once
        schedule()
    cpu_startup_entry(CPUHP_ONLINE); // idle loop
        while (1)
            do_idle();

// include/linux/cpuhotplug.h : 57

enum cpuhp_state {
    CPUHP_OFFLINE = 0, // PREPARE section invoked on a control CPU
    CPUHP_OFFLINE + 1,
    ...
    BRINGUP_CPU,
    CPUHP_AP_IDLE_DEAD, // STARTING section invoked on the hotplugged CPU in low level
    ...
    CPUHP_AP_ONLINE,
    CPUHP_TEARDOWN_CPU,
    CPUHP_AP_ONLINE_IDLE, // Online section invoked on the hotplugged CPU from the hotplug thread
    ...
    CPUHP_ONLINE
};

// kernel/cpu.c : 1565

static struct cpuhp_step cpuhp_hp_states[] =
        ...
        [CPUHP_CREATE_THREADS]= {
                .name                   = "threads:prepare",
                .startup.single         = smpboot_create_threads,
                .teardown.single        = NULL,
                .cant_stop              = true,
        },

        ...
        [CPUHP_BRINGUP_CPU] = {
                .name                   = "cpu:bringup",
                .startup.single         = bringup_cpu,
                .teardown.single        = finish_cpu,
                .cant_stop              = true,
        },
        ...
}

// init/main.c : 1600

kernel_init_freeable()
    smp_prepare_cpus(setup_max_cpus);
        cpu_ops[cpuid]->cpu_prepare(cpuid); // sbi_cpu_prepare
        set_cpu_present(cpuid, true);

    smp_init()
        idle_threads_init();
            for_each_possible_cpu(cpu)
                idle_init(cpu) // 创建 idle 线程

        cpuhp_threads_init();
            cpuhp_init_state() // 初始化热插拔线程唤醒的完成变量
            smpboot_register_percpu_thread(&cpuhp_threads) // 为所有 online cpu 创建 cpuhp 线程

        bringup_nonboot_cpus(setup_max_cpus) // Bringing up secondary CPUs
            for_each_present_cpu(cpu) {
                    cpu_up(cpu, CPUHP_ONLINE)

// kernel/cpu.c : 1395

cpu_up()
    struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
    cpuhp_set_state(cpu, st, target);
        st->target = target;
    target = min((int)target, CPUHP_BRINGUP_CPU);  // do PREPARE section
    cpuhp_up_callbacks(cpu, st, target);
        cpuhp_invoke_callback_range(true, cpu, st, target);
            while (cpuhp_next_state(bringup, &state, st, target))
            cpuhp_invoke_callback(cpu, state, bringup, NULL, NULL);

// kernel/cpu.c : 589

bringup_cpu()
    tidle = idle_thread_get(cpu)
    __cpu_up(cpu, idle);
        start_secondary_cpu(cpu, tidle);
            cpu_ops[cpu]->cpu_start(cpu, tidle); // sbi_cpu_start
        wait_for_completion_timeout(&cpu_running)   // wait for cpu_running
    return bringup_wait_for_ap(cpu);
        wait_for_ap_thread(st, true);               // wait for &st->done_up
        kthread_unpark(st->thread);
        cpuhp_kick_ap(cpu, st, st->target);

// arch/riscv/kernel/cpu_ops_sbi.c : 65

static int sbi_cpu_start(unsigned int cpuid, struct task_struct *tidle)
{
        unsigned long boot_addr = __pa_symbol(secondary_start_sbi); // boot_addr
        unsigned long hartid = cpuid_to_hartid_map(cpuid);
        unsigned long hsm_data;
        struct sbi_hart_boot_data *bdata = &per_cpu(boot_data, cpuid); // per_cpu boot_data

        /* Make sure tidle is updated */
        smp_mb();
        bdata->task_ptr = tidle;
        bdata->stack_ptr = task_stack_page(tidle) + THREAD_SIZE; // setup stack_ptr by tidle
        /* Make sure boot data is updated */
        smp_mb();
        hsm_data = __pa(bdata);
        return sbi_hsm_hart_start(hartid, boot_addr, hsm_data);  // call HSM SBI_EXT_HSM_HART_START
}

// arch/riscv/kernel/head.S : 131

secondary_start_sbi:
        ...
        /* a0 contains the hartid & a1 contains boot data */
        li a2, SBI_HART_BOOT_TASK_PTR_OFFSET
        add a2, a2, a1
        REG_L tp, (a2)   // 设置 tp
        li a3, SBI_HART_BOOT_STACK_PTR_OFFSET
        add a3, a3, a1
        REG_L sp, (a3)  // 设置 sp

        ...

        tail smp_callin

// arch/riscv/kernel/smpboot.c : 155

smp_callin()
    notify_cpu_starting(curr_cpuid);
        target = min((int)st->target, CPUHP_AP_ONLINE); // do STARTING section
        cpuhp_invoke_callback_range_nofail(true, cpu, st, target);

    set_cpu_online(curr_cpuid, 1);          // set online bitmap

    complete(&cpu_running); // wakeup __cpu_up()

    cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
        cpuhp_online_idle()
            st->state = CPUHP_AP_ONLINE_IDLE;
            complete_ap_thread(st, true); // wakeup bringup_wait_for_ap()
        while (1)
            do_idle()
                cpuidle_idle_call
                   if (cpuidle_not_available(drv, dev)) // if no cpuidle framework
                   default_idle_call()
                     arch_cpu_idle() // wfi