Hi.

On 04/08/10 12:02, KAMEZAWA Hiroyuki wrote:
quoted text
> On Wed, 04 Aug 2010 11:50:41 +1000
> Nigel Cunningham<nigel@tuxonice.net>  wrote:
>
>> Hi.
>>
>> Sorry for the delay in replying.
>>
>> On 03/08/10 11:59, Bojan Smojver wrote:
>>>>  From all this, I only got "In swsusp_free()" printed on resume. So, it
>>> seems that save_image() does indeed free those vmalloc()-ed buffers and
>>> they are not saved in the image.
>>>
>>> I even put this in hibernate.c:
>>> ---------------------
>>>           /* Restore control flow magically appears here */
>>>           restore_processor_state();
>>>           if (!in_suspend)
>>>                   platform_leave(platform_mode);
>>>
>>>           printk(KERN_ERR "Resumed, checking swsusp_lzo_buffers.\n");
>>>           if (swsusp_lzo_buffers) {
>>>                   printk (KERN_ERR "Setting vmalloc() buffers.\n");
>>>                   memset(swsusp_lzo_buffers, 0, 80 * PAGE_SIZE);
>>>           }
>>> ---------------------
>>>
>>> This printed just "Resumed, checking swsusp_lzo_buffers.", meaning it
>>> was already set to NULL.
>>>
>>> Any further comments on this? Nigel, what do you reckon?
>>
>> I don't see what all the fuss was about. save_image is called after the
>> snapshot is made (hibernate called hibernation_snapshot to create the
>> image, then swsusp_write which in turn calls save_image), so there's no
>> possibility of the memory allocated by it being included in the image or
>> of a memory leak ocuring as a result.
>>
>
> I'm sorry if I'm wrong. Here is logic in my mind. (I'm reading hibernate(void).
> not sure about user.c )
> (linenumber is from 2.6.34 global, plz ignore)

Yeah, I'm ignoring uswsusp too. That shouldn't matter.

quoted text
>   624         error = hibernation_snapshot(hibernation_mode == HIBERNATION_PLATFORM);
>   625         if (error)
>   626                 goto Thaw;
>   627
>   628         if (in_suspend) {
>   629                 unsigned int flags = 0;
>   630
>   631                 if (hibernation_mode == HIBERNATION_PLATFORM)
>   632                         flags |= SF_PLATFORM_MODE;
>   633                 pr_debug("PM: writing image.\n");
>   634                 error = swsusp_write(flags);
>
> Then, swsusp_write() actually writes image to the disk. Right ?

Yes

quoted text
> It finally calls save_image(). save_image() executes following loop.
>
>   433         while (1) {
>   434                 ret = snapshot_read_next(snapshot, PAGE_SIZE);
>   435                 if (ret<= 0)
>   436                         break;
>   437                 ret = swap_write_page(handle, data_of(*snapshot),&bio);
>   438                 if (ret)
>   439                         break;
>   440                 if (!(nr_pages % m))
>   441                         printk(KERN_CONT "\b\b\b\b%3d%%", nr_pages / m);
>   442                 nr_pages++;
>   443         }
>
> Ok, here, the image written to disk is got by snapshot_read_next().
> Then, what it does ?
>
> ==
> 1650                         page = pfn_to_page(memory_bm_next_pfn(&copy_bm));
> 1651                         if (PageHighMem(page)) {
> 1652                                 /* Highmem pages are copied to the buffer,
> 1653                                  * because we can't return with a kmapped
> 1654                                  * highmem page (we may not be called again).
> 1655                                  */
> 1656                                 void *kaddr;
> 1657
> 1658                                 kaddr = kmap_atomic(page, KM_USER0);
> 1659                                 memcpy(buffer, kaddr, PAGE_SIZE);
> 1660                                 kunmap_atomic(kaddr, KM_USER0);
> 1661                                 handle->buffer = buffer;
> 1662                         } else {
> 1663                                 handle->buffer = page_address(page);
> 1664                         }
> ==
>
> Ok, what actually written to disk is an image of memory at save_image() is
> called.
>
> What happens at vmalloc ?
> 	1. page tabels for vmalloc() is set up.
> 	2. vm_struct object is allocated.
> 	3. vmap is allcoated.
>
> Above "3" states are all saved into the disk image, as "used".
>
> Then, after resume, all vmalloc() area is resumed as "allocated".
>
> Wrong ?

Yes, because what's being written is the snapshot that was created in 
hibernation_snapshot. Any memory you allocate afterwards is irrelevant 
because it's not part of that snapshot that was made earlier and is now 
being written to disk. Think of the point where hibernation_snapshot is 
called as being like taking a photo, and this later part as like 
printing the photo. Once you've taken the photo, people in the photo can 
move around without making any difference to the photo you've taken. So 
here. Our vmallocs and so on after the snapshot don't affect it.

Regards,

Nigel
--
unsubscribe notice
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/