RISC-V 休眠实现分析 1 -- 休眠过程

// kernel/power/hibernate.c : 722

hibernate()
  pr_info("hibernation entry\n");

  pm_prepare_console();  // SUSPEND_CONSOLE
  pm_notifier_call_chain_robust(PM_HIBERNATION_PREPARE, PM_POST_HIBERNATION);
  ksys_sync_helper();   // 文件系统同步
  freeze_processes();   // 冻结进程
  lock_device_hotplug();  // 关闭设备热插拔
  create_basic_memory_bitmaps(); // Create bitmaps to hold basic page information.
                                 // init forbidden_pages_map and free_pages_map

  hibernation_snapshot();
    hibernate_preallocate_memory();  // 为系统要保存到休眠镜像中的内存分配拷贝空间

    freeze_kernel_threads(); // 冻结内核线程
    suspend_console();     // 挂起控制台

    create_image(platform_mode);

    // 1. after the image has been created or failed  2. after a successful restore.

    resume_console();

  if (in_suspend) {
    pm_pr_dbg("Writing hibernation image.\n");
    swsusp_write(flags); && power_down();
  else {
    pm_pr_dbg("Hibernation image restored successfully.\n");
  }

  free_basic_memory_bitmaps();
  unlock_device_hotplug();
  thaw_processes();
  pm_notifier_call_chain(PM_POST_HIBERNATION);
  pm_restore_console();

  pr_info("hibernation exit\n");

// kernel/power/snapshot.c : 1736

hibernate_preallocate_memory()

  memory_bm_create(&orig_bm, GFP_IMAGE, PG_ANY);
  memory_bm_create(&copy_bm, GFP_IMAGE, PG_ANY);

  saveable = count_data_pages();  // 可保存的页
    for_each_populated_zone(zone) {
        mark_free_pages(zone);   // mark zone->free_area in free_pages_map
        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
          if (saveable_page(zone, pfn))  n++;

  count = saveable;

  for_each_populated_zone(zone) {
    size += snapshot_additional_pages(zone); // 基于 `zone->spanned_pages` 计算
    count += zone_page_state(zone, NR_FREE_PAGES); // 可用的页

  avail_normal = count;
  count -= totalreserve_pages; //

  max_size = (count - (size + PAGES_FOR_IO)) / 2 - 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE);

  size = DIV_ROUND_UP(image_size, PAGE_SIZE); // /sys/power/image_size 不能大于 max_size
  if (size > max_size)
    size = max_size;

  if (size >= saveable) {  // 如果镜像大小足以保存可保存的页
    pages += preallocate_image_memory(saveable - pages, avail_normal);
      page = alloc_image_page(mask);
      memory_bm_set_bit(&copy_bm, page_to_pfn(page));
      alloc_normal++;
    goto out;
  // ...
out:
  pr_info("Allocated %lu pages for snapshot\n", pages);

// kernel/power/hibernate.c : 293

create_image()

  pm_sleep_disable_secondary_cpus()  // 关闭其他 CPU
    freeze_secondary_cpus()
        _cpu_down(cpu, 1, CPUHP_OFFLINE);

  local_irq_disable();
  system_state = SYSTEM_SUSPEND;
  syscore_suspend(); // suspend system devices

  in_suspend = 1;
  save_processor_state();  // ARCH
    WARN_ON(num_online_cpus() != 1);

  error = swsusp_arch_suspend();
    __cpu_suspend_enter(hibernate_cpu_context)    // save hibernate_cpu_context
    swsusp_save()
  /* Restore control flow magically appears here */
  restore_processor_state();

  syscore_resume();
  system_state = SYSTEM_RUNNING;
  local_irq_enable();
  pm_sleep_enable_secondary_cpus();   // back to hibernate do swsusp_write

// kernel/power/snapshot.c : 2762

asmlinkage __visible int swsusp_save(void)

  pr_info("Creating image:\n");
  drain_local_pages(NULL);  // 释放 zone 中的可用页

  nr_pages = count_data_pages(); // 重新计算可保存的页
  nr_highmem = count_highmem_pages();
  pr_info("Need to copy %u pages\n", nr_pages + nr_highmem);

  swsusp_alloc(&copy_bm, nr_pages, nr_highmem); // 对比可保存页与之前分配的页的大小，按需分配内存
    nr_pages -= alloc_normal; // alloc_normal 为设备挂起之前分配的内存，如果重新计算的页总数比其小则不用再分配
    while (nr_pages-- > 0)
      page = alloc_image_page(GFP_ATOMIC);
      memory_bm_set_bit(copy_bm, page_to_pfn(page));

  copy_data_pages(&copy_bm, &orig_bm);  // 将系统要保存的页保存在 `copy_bm` 分配的内存中
    for_each_populated_zone(zone) {       // 设置要保存的页到 orig_bm
        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
          if (page_is_saveable(zone, pfn))
            memory_bm_set_bit(orig_bm, pfn);

    copy_data_page(memory_bm_next_pfn(copy_bm), pfn);  // 拷贝 orig_bm 记录的内存页到 copy_bm 分配的拷贝页
      safe_copy_page(page_address(pfn_to_page(dst_pfn)), pfn_to_page(src_pfn)); // (void *dst, struct page *s_page)
       if kernel_page_present(s_page)  // else： hibernate_*map_page then do_copy_page
         do_copy_page(dst, page_address(s_page));

  nr_pages += nr_highmem;
  nr_copy_pages = nr_pages;   // Total number of saveable pages
  nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
  pr_info("Image created (%d pages copied)\n", nr_pages);

  return 0 ;

// 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;
}

(gdb) disassemble swsusp_arch_suspend
   ...
   0xffffffff800095bc <+24>:    auipc   ra,0xfffff
   0xffffffff800095c0 <+28>:    jalr    1168(ra) # 0xffffffff80008a4c <__cpu_suspend_enter>  // call __cpu_suspend_enter
   0xffffffff800095c4 <+32>:    beqz    a0,0xffffffff800095f6 <swsusp_arch_suspend+82>
   ...

hibernate => hibernation_snapshot         => hibernate_preallocate_memory
          => swsusp_write && power_down   => create_image                  => swsusp_arch_suspend => swsusp_save => copy_data_pages