RISC-V 休眠实现分析 2 -- 加载 swap 镜像

// kernel/power/hibernate.c : 914

late_initcall_sync(software_resume);

software_resume()
  //... 处理 swap 分区和文件
  swsusp_resume_device = name_to_dev_t(resume_file);

Check_image:
  swsusp_check(); // 校验 swap 头
  pr_info("resume from hibernation\n");

  pm_prepare_console();
  freeze_processes();
  freeze_kernel_threads();

  load_image_and_restore()
    pm_pr_dbg("Loading hibernation image.\n");

    swsusp_read(&flags);

    hibernation_restore(flags & SF_PLATFORM_MODE);

   thaw_processes();
   pm_restore_console();
   pr_info("resume failed (%d)\n", error);
   pm_pr_dbg("Hibernation image not present or could not be loaded.\n");

// kernel/power/swap.c : 96

struct swap_map_handle {
        struct swap_map_page *cur;
        struct swap_map_page_list *maps;
        sector_t cur_swap;
        sector_t first_sector;
        unsigned int k;
        unsigned long reqd_free_pages;
        u32 crc32;
};
struct swap_map_page_list {
        struct swap_map_page *map;
        struct swap_map_page_list *next;
};
struct swap_map_page {
        sector_t entries[MAP_PAGE_ENTRIES];
        sector_t next_swap;
};

static int get_swap_reader(struct swap_map_handle *handle, unsigned int *flags_p);
static int swap_read_page(struct swap_map_handle *handle, void *buf, struct hib_bio_batch *hb);
static void release_swap_reader(struct swap_map_handle *handle);

// kernel/power/power.h : 134

struct snapshot_handle {
        unsigned int    cur;    /* number of the block of PAGE_SIZE bytes the
                                 * next operation will refer to (ie. current)
                                 */
        void            *buffer;        /* address of the block to read from
                                         * or write to
                                         */
        int             sync_read;      /* Set to one to notify the caller of
                                         * snapshot_write_next() that it may
                                         * need to call wait_on_bio_chain()
                                         */
};

int snapshot_write_next(struct snapshot_handle *handle);

// hibernation/resuming image
| snapshot header | meta pages | data pages |

// kernel/power/swap.c : 1619

int swsusp_read(unsigned int *flags_p)

  get_swap_reader(&handle, flags_p);      // get swap handle

  error = snapshot_write_next(&snapshot); // get header buffer
  header = (struct swsusp_info *)data_of(snapshot); // data_of(snapshot) => snapshot->buffer
  swap_read_page(&handle, header, NULL);          // read a page from swap to header

  load_image(&handle, &snapshot, header->pages - 1) : // now we have header->page
    for ( ; ; ) {
        snapshot_write_next(snapshot);
        swap_read_page(handle, data_of(*snapshot), &hb);

  swap_reader_finish(&handle); // release swap handle

  pr_debug("Image successfully loaded\n");

// kernel/power/power.h : 10
struct swsusp_info { // 镜像头信息
        struct new_utsname      uts;
        u32                     version_code;
        unsigned long           num_physpages;
        int                     cpus;
        unsigned long           image_pages; // swap 镜像中的数据页
        unsigned long           pages;  // 此 swap 镜像中的总页数 = 数据页 + meta 页
        unsigned long           size;
} __aligned(PAGE_SIZE);

struct new_utsname {
        char sysname[__NEW_UTS_LEN + 1];
        char nodename[__NEW_UTS_LEN + 1];
        char release[__NEW_UTS_LEN + 1];
        char version[__NEW_UTS_LEN + 1];
        char machine[__NEW_UTS_LEN + 1];
        char domainname[__NEW_UTS_LEN + 1];
};

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

static struct arch_hibernate_hdr {
        struct arch_hibernate_hdr_invariants invariants;
        unsigned long   hartid;
        unsigned long   saved_satp;
        unsigned long   restore_cpu_addr;
} resume_hdr;

struct arch_hibernate_hdr_invariants {
        char            uts_version[__NEW_UTS_LEN + 1];
};

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

int arch_hibernation_header_restore(void *addr)

  arch_hdr_invariants(&invariants);
  memcmp(&hdr->invariants, &invariants, sizeof(invariants))

  sleep_cpu = riscv_hartid_to_cpuid(hdr->hartid);

  ret = bringup_hibernate_cpu(sleep_cpu);

  resume_hdr = *hdr;

// kernel/power/snapshot.c : 2629

snapshot_write_next(&snapshot);  // Get the address to store the next image page.

    if (!handle->cur) {       // 为 header page 分配空间                         // ---------  A
        buffer = get_image_page(GFP_ATOMIC, PG_ANY);
        handle->buffer = buffer;

    } else if (handle->cur == 1) // 处理 header，创建 copy_bm 用于记录            // ------------ B

      load_header(buffer);
        check_header(info)
          check_image_kernel(info)
            arch_hibernation_header_restore(info) // RISC-V restore struct arch_hibernate_hdr
        nr_copy_pages = info->image_pages;
        nr_meta_pages = info->pages - info->image_pages - 1;
      memory_bm_create(&copy_bm, GFP_ATOMIC, PG_ANY); // create copy_bm for restore meta page

    else if (handle->cur <= nr_meta_pages + 1) // 处理 meta pages               // ----------- C

      unpack_orig_pfns(buffer, &copy_bm);  // set the pfn from meta pages in copy_bm

      if (handle->cur == nr_meta_pages + 1) {  // image meta pages 读取结束
         prepare_image(&orig_bm, &copy_bm);   // 为 data pages 分配内存

         handle->buffer = get_buffer(&orig_bm, &ca);  // 从分配的内存中获取一页，以供 swap 写入

         return PTR_ERR(handle->buffer);

    else {
        handle->buffer = get_buffer(&orig_bm, &ca); // 从分配的内存中获取一页，以供 swap 写入
        return PTR_ERR(handle->buffer);
    handle->cur++;
    return PAGE_SIZE;

// kernel/power/snapshot.c : 2500

prepare_image(&orig_bm, &copy_bm); // Make room for loading hibernation image. 创建 orig_bm，分配 safe_pages_list 以及预分配内存

           duplicate_memory_bitmap(free_pages_map, bm); // free_pages_map 中标记 meta pages 中记录的页

           duplicate_memory_bitmap(new_bm, bm);       // copy copy_bm to orig_bm
           memory_bm_free(bm, PG_UNSAFE_KEEP);

           // Reserve some safe pages for potential later use.
           nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages;
           nr_pages = DIV_ROUND_UP(nr_pages, PBES_PER_LINKED_PAGE); //  需要多少个页来管理 pbe（对应一页 nr_copy_pages）
           while (nr_pages > 0) {
              lp = get_image_page(GFP_ATOMIC, PG_SAFE); // 这里基于 `free_pages_map` 保证用于唤醒镜像的内存页不与 swap 镜像中页冲突
              lp->next = safe_pages_list;
              safe_pages_list = lp;

           // Preallocate memory for the image   // 为唤醒镜像预分配内存
           nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages; // allocated_unsafe_pages：之前分配到的页是 meta pages 中的页，这里就不用分配了
           while (nr_pages > 0) {
              lp = (struct linked_page *)get_zeroed_page(GFP_ATOMIC);
              swsusp_set_page_forbidden(virt_to_page(lp));
              swsusp_set_page_free(virt_to_page(lp));

// kernel/power/snapshot.c : 177

static void *get_image_page(gfp_t gfp_mask, int safe_needed)
{
        void *res;

        res = (void *)get_zeroed_page(gfp_mask);
        if (safe_needed)
                while (res && swsusp_page_is_free(virt_to_page(res))) {  // 当前分配的页，与 meta pages 中描述的页冲突了
                        /* The page is unsafe, mark it for swsusp_free() */
                        swsusp_set_page_forbidden(virt_to_page(res));    // 标记该页
                        allocated_unsafe_pages++;
                        res = (void *)get_zeroed_page(gfp_mask);        // 为 safe_pages_list 重新分配
                }
        if (res) {
                swsusp_set_page_forbidden(virt_to_page(res));
                swsusp_set_page_free(virt_to_page(res));
        }
        return res;
}

// kernel/power/snapshot.c : 2762

get_buffer(&orig_bm, &ca); // Get the address to store the next image data page.
           pfn = memory_bm_next_pfn(bm);
           page = pfn_to_page(pfn);

           if swsusp_page_is_forbidden(page) && swsusp_page_is_free(page) // 命中预分配内存，直接返回该页的地址
             return page_address(page);

           pbe = chain_alloc(ca, sizeof(struct pbe)); // 从 `safe_pages_list` 链表中分配

           pbe->orig_address = page_address(page);  // 保存该页在当前系统中的地址

           pbe->address = safe_pages_list; safe_pages_list = safe_pages_list->next; // pbe->address 被 swap 填充，也就休眠时的内存页

           pbe->next = restore_pblist; restore_pblist = pbe; // 插入 restore_pblist
           return pbe->address;

// include/linux/suspend.h : 616

struct pbe {
        void *address;          /* address of the copy */
        void *orig_address;     /* original address of a page */
        struct pbe *next;
};

struct pbe *restore_pblist;