RISC-V 休眠实现分析 3 -- 恢复系统

// kernel/power/hibernate.c : 1367

hibernation_restore()
      suspend_console();

      resume_target_kernel()
        hibernate_resume_nonboot_cpu_disable(); // disable nonboot_cpu  call freeze_secondary_cpus
          freeze_secondary_cpus(sleep_cpu);
        local_irq_disable();
        system_state = SYSTEM_SUSPEND;
        save_processor_state();

        swsusp_arch_resume // execution continues at the place where * swsusp_arch_suspend() was called.

        swsusp_free();
        restore_processor_state();
        system_state = SYSTEM_RUNNING;

// arch/riscv/kernel/hibernate.c : 394

swsusp_arch_resume()

  unsigned long end = (unsigned long)pfn_to_virt(max_low_pfn);
  unsigned long start = PAGE_OFFSET;

  resume_pg_dir = (pgd_t *)get_safe_page(GFP_ATOMIC);

  // remap whole linear region
  temp_pgtable_mapping(resume_pg_dir, start, end, __pgprot(_PAGE_WRITE | _PAGE_EXEC));
    pgd_t *dst_pgdp = pgd_offset_pgd(pgdp, start);
    pgd_t *src_pgdp = pgd_offset_k(start);

    if (pgd_leaf(pgd))
      set_pgd(dst_pgdp, __pgd(pgd_val(pgd) | pgprot_val(prot))); // 如果当前根页表是叶子（物理地址直接存放在 pgd 中），则复制表项到当前虚拟地址在 resume_pg_dir 对应的表项 -- `dst_pgdp`
    else
      ret = temp_pgtable_map_p4d(dst_pgdp, src_pgdp, start, next, prot); // 否则递归设置 p4d/pud/pmd/pte

  /* Move the restore code to a new page so that it doesn't get overwritten by itself. */

  relocated_restore_code = relocate_restore_code();  // 拷贝 hibernate_core_restore_code 到唤醒镜像的 `safe_pages_list`
    void *page = (void *)get_safe_page(GFP_ATOMIC);
    copy_page(page, hibernate_core_restore_code);
    return page;

  start = (unsigned long)resume_hdr.restore_cpu_addr; // __hibernate_cpu_resume
  end = start + PAGE_SIZE;
  temp_pgtable_mapping(resume_pg_dir, start, end, __pgprot(_PAGE_WRITE));

// arch/riscv/kernel/hibernate-asm.S" 76L

  hibernate_restore_image(resume_hdr.saved_satp, (PFN_DOWN(__pa(resume_pg_dir)) | satp_mode), resume_hdr.restore_cpu_addr);
    mv      s0, a0  // resume_hdr.saved_satp
    mv      s1, a1  // resumepg_dir with satp_mod
    mv      s2, a2  // __hibernate_cpu_resume
    REG_L   s4, restore_pblist
    REG_L   a1, relocated_restore_code  // goto hibernate_core_restore_code
    jalr    a1

// arch/riscv/kernel/hibernate-asm.S : 61

ENTRY(hibernate_core_restore_code)
        /* switch to temp page table. */
        csrw satp, s1
        sfence.vma
.Lcopy:
        /* The below code will restore the hibernated image. */
        REG_L   a1, HIBERN_PBE_ADDR(s4)   // restore_pblist struct pbe
        REG_L   a0, HIBERN_PBE_ORIG(s4)

        copy_page a0, a1

        REG_L   s4, HIBERN_PBE_NEXT(s4)
        bnez    s4, .Lcopy

        jalr    s2  // goto __hibernate_cpu_resume
END(hibernate_core_restore_code)

// arch/riscv/kernel/hibernate-asm.S : 76

ENTRY(__hibernate_cpu_resume)
        /* switch to hibernated image's page table. */
        csrw CSR_SATP, s0  // saved_satp
        sfence.vma

        REG_L   a0, hibernate_cpu_context

        suspend_restore_csrs  // 多余的
        suspend_restore_regs

        /* Return zero value. */
        mv      a0, zero

        ret  // ra is the else in swsusp_arch_suspend()
END(__hibernate_cpu_resume)

// arch/riscv/kernel/hibernate.c : 468

int swsusp_arch_suspend(void)
{
        int ret = 0;

        if (__cpu_suspend_enter(hibernate_cpu_context)) {  // save hibernate_cpu_context->regs return 1
                sleep_cpu = smp_processor_id();
                suspend_save_csrs(hibernate_cpu_context);  // save hibernate_cpu_context->{scratch,tvec,ie,satp}
                ret = swsusp_save();
        } else {                                           // 系统恢复，跳转到这里执行
                suspend_restore_csrs(hibernate_cpu_context); // restore hibernate_cpu_context->{scratch,tvec,ie,satp}
                flush_tlb_all();
                flush_icache_all();

                /*
                 * Tell the hibernation core that we've just restored the memory.
                 */
                in_suspend = 0;
                sleep_cpu = -EINVAL;
        }

        return ret;
}

      hibernate <=> hibernation_snapshot       <=> create_image         <=> swsusp_arch_suspend.if <=> swsusp_save
                 => swsusp_write && power_down                          ^
                                                                        |
                                                                        -------------------------------------------------------
software_resume => swsusp_read                                                                                                |
                => hibernation_restore          => resume_target_kernel  => swsusp_arch_resume =>  __hibernate_cpu_resume => swsusp_arch_suspend.else