lkml.org 
[lkml]   [2010]   [Aug]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH]: Compress hibernation image with LZO (in-kernel)
    On Mon, 02 Aug 2010 10:54:13 +1000
    Bojan Smojver <bojan@rexursive.com> wrote:

    > On Mon, 2010-08-02 at 09:17 +0900, KAMEZAWA Hiroyuki wrote:
    > > Now, vmallc() is used here. Then, following will happen.
    > >
    > > 1. vmalloc()
    > > -> vmalloc adds vmap objects and set page table entries.
    > >
    > > 2. saving image
    > > -> At taking snapshot of memory to the disk, above vmalloc() area
    > > is
    > > saved to disk as it is.
    > > ...
    > > 3. At restore
    > > Because you dont't remember which vmalloc() area was used for
    > > creating
    > > snapshot, you can't free it at swsusp_free().
    > >
    > > memory leak ?
    >
    > To be honest, I'm not sure.
    >
    > However, I thought that by the time save_image() is called, snapshot has
    > already been taken, no?
    > ------------------
    > error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
    > if (error)
    > goto Thaw;
    >
    > if (in_suspend) {
    > unsigned int flags = 0;
    >
    > if (hibernation_mode == HIBERNATION_PLATFORM)
    > flags |= SF_PLATFORM_MODE;
    > pr_debug("PM: writing image.\n");
    > error = swsusp_write(flags); <--- this calls save_image()
    > ------------------
    >
    > So, me thinks that these allocations will not be in the snapshot image.
    >
    I'm a very newbie to snapshot ...(I'm now studying it because I got a report
    that my patch corrupts it.) So, don't trust my words.

    Looking into swsusp_write().
    ==
    swsusp_write()
    -> save_image()
    ->
    while () {
    snapshot_read_next()
    swap_write_page()
    }
    ==
    This routine writes a buffer which is gotten by snapshot_read_next() to the disk.

    Then, what snapshot_read_next() pass is.
    ==
    } else {
    struct page *page;

    page = pfn_to_page(memory_bm_next_pfn(&copy_bm));
    if (PageHighMem(page)) {
    /* Highmem pages are copied to the buffer,
    * because we can't return with a kmapped
    * highmem page (we may not be called again).
    */
    void *kaddr;

    kaddr = kmap_atomic(page, KM_USER0);
    memcpy(buffer, kaddr, PAGE_SIZE);
    kunmap_atomic(kaddr, KM_USER0);
    handle->buffer = buffer;
    } else {
    handle->buffer = page_address(page);
    }
    }
    ==
    The physical memory address of a page to be saved.

    So, I thought "system memory image" itself is not a snapshot but it's changing
    while it runs. Why swsusp can avoid memory leak is that it records which
    pages should be freed after resume in the bitmap, which will be saved to
    image header(?) And, even if this snapshot saves the image of buddy-allocator,
    the save routine itself uses a fixed buffer which can be freed after restore.

    Thanks,
    -Kame














    \
     
     \ /
      Last update: 2010-08-02 03:17    [W:7.564 / U:0.324 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site