swsusp: support creating bigger images
Subsystems (7)
RFC PATCH 1/1 swsusp: support creating bigger images
Hi,
The appended patch allows swsusp to break the "50% of the normal zone" limit. This is achieved by using the observation that pages mapped by frozen userland tasks need not be copied before saving.
The pages mapped by the frozen tasks are selected by checking if page_mapped(page) returns true for them and whether they are not mapped by the current task. These pages are included in the snapshot image without copying, because we wouldn't be able to rollback the suspend if they were modified before or in the process of saving the image.
[I'm tempted to treat the page cache pages in a similar way, for the following
reason: AFAIK the page cache pages are only modified during block I/O operations (or when they are reclaimed, but that's covered below). The only process that can perform such operations after the suspend image has been created is the current task (ie. the suspending process). However, the current task must not perform any filesystem operations after creating the image or it would probably corrupt some filesystems and thus its page cache pages related to filesystems are not modified during suspend. Of course it may perform block I/O operations using block devices directly (eg. it does this to save the image), but then such operations cannot be started _before_ creating the image and _continued_ after the image has been created or there's a risk of leaving the block device in an inconsistent state if the suspend is successful.]
Still, it seems to be possible, although very unlikely, that these pages will be reclaimed by try_to_free_pages() if there's not enough memory while saving the image (at least I couldn't convince myself that it was impossible). Therefore the patch takes these pages out of reach of try_to_free_pages() by (temporarily) moving them out of their respective LRU lists. This is done after the image has been created so the LRU lists have to be restored only if the suspend fails.
With this patch applied I was able to save (and restore ;-)) ~800 MB suspend images on a box with 1 GB of RAM.
[Please don't beat me very hard, just couldn't resist. ;-)]
Greetings,
Rafael
--- include/linux/rmap.h | 6 + kernel/power/power.h | 10 + kernel/power/snapshot.c | 259 +++++++++++++++++++++++++++++++++++------------- kernel/power/swsusp.c | 15 +- kernel/power/user.c | 4 mm/rmap.c | 19 +++ 6 files changed, 238 insertions(+), 75 deletions(-)
mm/rmap.c +19 -0
@@ -851,3 +851,22 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +spin_lock (¤t->mm->page_table_lock); + +for (vma = current->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =1 ; +break ; + } + +spin_unlock (¤t->mm->page_table_lock); + +return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
include/linux/rmap.h +6 -0
@@ -104,6 +104,12 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *); +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *); +#else +static inline int page_mapped_by_current (struct page *page) {return 0 ; } +#endif /* CONFIG_SOFTWARE_SUSPEND */ +#else /* !CONFIG_MMU */ #define anon_vma_init () do {} while (0)
kernel/power/snapshot.c +192 -67
440 lines not on this page · raw message
kernel/power/power.h +9 -1
@@ -48,7 +48,14 @@ extern dev_t swsusp_resume_device; extern asmlinkage int swsusp_arch_suspend(void); extern asmlinkage int swsusp_arch_resume(void); -extern unsigned int count_data_pages (void ); +#ifdef CONFIG_BLK_DEV_INITRD +#define EXTRA_PAGES (PAGES_FOR_IO + \ + (2 * CONFIG_BLK_DEV_RAM_SIZE * 1024) / PAGE_SIZE) +#else +#define EXTRA_PAGES PAGES_FOR_IO +#endif /* CONFIG_BLK_DEV_INITRD */ + +extern unsigned int count_data_pages (unsigned int *total);struct snapshot_handle {loff_t offset;
@@ -111,6 +118,7 @@ extern int restore_special_mem(void);extern int swsusp_check (void );extern int swsusp_shrink_memory (void ); +extern void free_image (void );extern void swsusp_free (void );extern int swsusp_suspend (void );extern int swsusp_resume (void );
kernel/power/swsusp.c +8 -7
@@ -177,28 +177,29 @@ int swsusp_shrink_memory(void)long size, tmp;struct zone *zone;unsigned long pages =0 ; -unsigned int i =0 ; +unsigned int to_save, i =0 ;char *p ="-\\|/" ;printk ("Shrinking memory... " ); do { size = 2 * count_special_pages(); - size += size / 50 + count_data_pages(); - size += (size + PBES_PER_PAGE - 1) / PBES_PER_PAGE + - PAGES_FOR_IO; + size += size / 50 + count_data_pages(&to_save); + size += (to_save + PBES_PER_PAGE - 1) / PBES_PER_PAGE + + EXTRA_PAGES; tmp = size; for_each_zone (zone) if (!is_highmem(zone) && populated_zone(zone)) { tmp -= zone->free_pages; tmp += zone->lowmem_reserve[ZONE_NORMAL]; } + size = to_save * (PAGE_SIZE + sizeof(long)); if (tmp > 0) { tmp = __shrink_memory(tmp); if (!tmp) return -ENOMEM; pages += tmp; - } else if (size > image_size / PAGE_SIZE) { - tmp = __shrink_memory(size - (image_size / PAGE_SIZE)); + } else if (size > image_size) { + tmp = __shrink_memory(size - image_size); pages += tmp; } printk("\b%c", p[i++%4]);
@@ -261,7 +262,7 @@ int swsusp_resume(void)* very tight, so we have to free it as soon as we can to avoid * subsequent failures */ -swsusp_free (); +free_image ();restore_processor_state ();restore_special_mem ();touch_softlockup_watchdog ();
kernel/power/user.c +4 -0
@@ -153,6 +153,10 @@ static int snapshot_ioctl(struct inode *case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready) { + error = -EPERM ; +break ; + }down (&pm_sem);thaw_processes ();enable_nonboot_cpus ();
Hi!
Quoted 3 lines
The appended patch allows swsusp to break the "50% of the normal zone" limit. This is achieved by using the observation that pages mapped by frozen userland tasks need not be copied before saving.
I've not followed the patch too carefully, but it is not as bad as I expected...
Quoted 2 lines
With this patch applied I was able to save (and restore ;-)) ~800 MB suspend images on a box with 1 GB of RAM.
And did it also work second time? ;-).
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
I guess we can revert to old behaviour by simply returning 1 from need_to_copy, right?
I assume that need_to_copy returns 1 in case page is shared by current and some other process?
Quoted 1 line
[Please don't beat me very hard, just couldn't resist. ;-)]
Well, you are about to force me to learn about mm internals. Plus you force everyone who tries to modify swsusp. ... it may be okay if benefit is great enough and if it gets proper testing. Not 2.6.17 material.
Is benefit worth it?
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 111
Quoted 11 lines
include/linux/rmap.h +5
-0@@ -104,6 +104,12 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *); +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *); +#else +static inline int page_mapped_by_current (struct page *page) {return 0 ; } +#endif /* CONFIG_SOFTWARE_SUSPEND */
I'd leave it undefined. That will prevent nasty surprise when someone tries to use it w/o CONFIG_SOFTWARE_SUSPEND set.
Quoted 15 lines
include/linux/rmap.h +8
-0@@ -251,6 +253,14 @@ int restore_special_mem(void)return ret; } +/* Represents a stacked allocated page to be used in the future */ +struct res_page { +struct res_page *next; +char padding[PAGE_SIZE -sizeof (void *)]; +}; + +static struct res_page *page_list; +static int pfn_is_nosave (unsigned long pfn) { unsigned long nosave_begin_pfn = __pa(&__nosave_begin) >>
Quoted 1 line
PAGE_SHIFT;
Is this part of some other patch?
include/linux/rmap.h void swsusp_free(void) · line 620
Quoted 9 lines
include/linux/rmap.h +5
-0@@ -490,6 +613,11 @@ void swsusp_free(void) buffer =NULL ; } +void swsusp_free (void ) +{ +free_image (); +restore_active_inactive_lists (); +}
This still scares me. Nice test would be to save/restore_active_inactive_lists repeatedly in a loop ... on running system ... aha, but it probably can't work outside of refrigerator?
include/linux/rmap.h void swsusp_free(void)
Quoted 10 lines
include/linux/rmap.h +4
-0case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready) { + error = -EPERM ; +break ; + }down (&pm_sem);thaw_processes ();enable_nonboot_cpus ();
Error from UNFREEZE is not nice:
Unfreeze:
unfreeze(snapshot_fd);
return error;
}... we don't handle it. OTOH I guess it will be all fixed on exit()?
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Hi,
Quoted 11 lines · Pavel Machek
Quoted 3 lines
The appended patch allows swsusp to break the "50% of the normal zone" limit. This is achieved by using the observation that pages mapped by frozen userland tasks need not be copied before saving.
I've not followed the patch too carefully, but it is not as bad as I expected...
Quoted 2 lines
With this patch applied I was able to save (and restore ;-)) ~800 MB suspend images on a box with 1 GB of RAM.
And did it also work second time? ;-).
Yes, somethinkg like 10 times in a row. :-)
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Apart from this we save some memory allocations and copyings during suspend.
Quoted 2 lines
I guess we can revert to old behaviour by simply returning 1 from
need_to_copy, right?
Yes.
Quoted 2 lines
I assume that
need_to_copyreturns 1 in case page is shared by current and some other process?
Yes. [If the page is shared with the current task it has to mapped by it, in which case it will be copied.]
Quoted 6 lines
Quoted 1 line
[Please don't beat me very hard, just couldn't resist. ;-)]
Well, you are about to force me to learn about mm internals. Plus you force everyone who tries to modify swsusp. ... it may be okay if benefit is great enough and if it gets proper testing. Not 2.6.17 material.
Obviously not, and yes it requires a _lot_ of testing especially on boxes with 512 meg of RAM or less.
Quoted 1 line
Is benefit worth it?
Well, that depends. I think for boxes with 1 GB of RAM or more it's just unnecessary (as of today, but this may change if faster disks are available). On boxes with 512 MB of RAM or less it may change a lot as far as the responsiveness after resume is concerned.
Anyway do you think it may go into -mm (unless Andrew shoots it down, that is ;-))?
Quoted 6 lines
Quoted 6 lines
include/linux/rmap.h +0
-0@@ -104,6 +104,12 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *);
Quoted 8 lines
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 111
Quoted 5 lines
include/linux/rmap.h +5
-0+#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *); +#else +static inline int page_mapped_by_current (struct page *page) {return 0 ; } +#endif /* CONFIG_SOFTWARE_SUSPEND */ I'd leave it undefined. That will prevent nasty surprise when someone tries to use it w/o
CONFIG_SOFTWARE_SUSPENDset.
OK
Quoted 4 lines
Quoted 4 lines
include/linux/rmap.h +0
-0@@ -251,6 +253,14 @@ int restore_special_mem(void)return ret; }
Quoted 14 lines
Quoted 11 lines
include/linux/rmap.h +8
-0+/* Represents a stacked allocated page to be used in the future */ +struct res_page { +struct res_page *next; +char padding[PAGE_SIZE -sizeof (void *)]; +}; + +static struct res_page *page_list; +static int pfn_is_nosave (unsigned long pfn) { unsigned long nosave_begin_pfn = __pa(&__nosave_begin) >>Quoted 1 line
PAGE_SHIFT;Is this part of some other patch?
No. That's because I use a linked list of allocated pages that has been defined in a slightly different way in swsusp-use-less-memory-during-resume.patch,
so I just redefine and reuse it.
Quoted 4 lines
Quoted 4 lines
include/linux/rmap.h +0
-0@@ -490,6 +613,11 @@ void swsusp_free(void) buffer =NULL ; }
Quoted 9 lines
include/linux/rmap.h void swsusp_free(void) · line 620
Quoted 5 lines
include/linux/rmap.h +5
-0+void swsusp_free (void ) +{ +free_image (); +restore_active_inactive_lists (); +}This still scares me. Nice test would be to save/restore_active_inactive_lists repeatedly in a loop ... on running system ... aha, but it probably can't work outside of refrigerator?
restore_active_inactive_lists() only does something if suspend fails (otherwise the lists active_pages and inactive_pages are empty).
The suspend failure may be simulated by running swapoff and suspendig with "echo disk > /sys/power/state". However it wouldn't be interesting to do this in a loop because it will make the same set of pages go out of the LRU lists and back in a round robin fashion.
I did the the following test:
- ran swapoff
- tried to suspend with "echo disk > /sys/power/state" (which failed, obviously)
- checked the numbers of active/inactive pages in /proc/meminfo
- ran swapon
- set image_size to 0
- suspended with "echo disk > /sys/power/state" to verify if the right number of pages would be reclaimed
- resumed
at it worked, apparently.
Quoted 13 lines
include/linux/rmap.h void swsusp_free(void)
Quoted 10 lines
include/linux/rmap.h +4
-0case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready) { + error = -EPERM ; +break ; + }down (&pm_sem);thaw_processes ();enable_nonboot_cpus ();Error from UNFREEZE is not nice:
Quoted 5 lines
Unfreeze:
unfreeze(snapshot_fd); return error; }... we don't handle it.
It will only occur if we don't call free_snapshot() before unfreeze() which is a bug anyway. We prevent it from occuring by always calling free_snapshot() before unfreeze(). :-)
Quoted 1 line
OTOH I guess it will be all fixed on
exit()?
Well, sort of, but I think the LRU lists always have to be restored before thawing processes (eg. kswapd).
Greetings,
Rafael
Hi!
Quoted 8 lines
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Could we get few people trying it on such small machines to see if it is really that noticeable?
Quoted 9 lines
Quoted 1 line
Is benefit worth it?
Well, that depends. I think for boxes with 1 GB of RAM or more it's just unnecessary (as of today, but this may change if faster disks are available). On boxes with 512 MB of RAM or less it may change a lot as far as the responsiveness after resume is concerned.
Anyway do you think it may go into -mm (unless Andrew shoots it down, that is ;-))?
I'd really like to hear that it helps someone before going to -mm. It looks clean enough but still it is 300 lines...
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Hi,
Quoted 11 lines · Pavel Machek
Quoted 8 lines
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Could we get few people trying it on such small machines to see if it is really that noticeable?
OK, I'll try to run some tests on a machine with smaller RAM (and slower CPU).
Quoted 7 lines
Quoted 7 lines
Quoted 1 line
Is benefit worth it?
Well, that depends. I think for boxes with 1 GB of RAM or more it's just unnecessary (as of today, but this may change if faster disks are available). On boxes with 512 MB of RAM or less it may change a lot as far as the responsiveness after resume is concerned.
Quoted 5 lines
Quoted 2 lines
Anyway do you think it may go into -mm (unless Andrew shoots it down, that is ;-))?
I'd really like to hear that it helps someone before going to -mm. It looks clean enough but still it is 300 lines...
Oh, it's not that bad. Adds ~240 lines and removes 75. :-)
Greetings,
Rafael
Quoted 2 lines
Pavel
Signature · 1 line
Beer is proof that God loves us and wants us to be happy - Benjamin Franklin
Hi,
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Pavel Machek
Quoted 8 lines
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Quoted 4 lines
Quoted 2 lines
Could we get few people trying it on such small machines to see if it is really that noticeable?
OK, I'll try to run some tests on a machine with smaller RAM (and slower CPU).
Done, although it was not so easy to find the box. This was a PII 350MHz w/ 256 MB of RAM.
I invented the following test:
- ran KDE with 4 desktops,
- ran Firefox, OpenOffice.org 1.1 (with a simple spreadsheet), and GIMP (with 2 pictures) each on its own desktop,
- ran the memory meter from the KDE's Info Center and two konsoles on the remaining desktop - one konsole with a kernel compilation and the other with a root session used for suspending the box (the built-in swsusp was used),
so the box's RAM was almost fully occupied with ~30% taken by the page cache.
Then I suspended the box and measured the time from the start of resume (ie. leaving GRUB) to the point at which I had all of the application windows fully rendered on their respective desktops (I always switched the desktops in the same order, starting from the memory meter's one, through the OOo's and Firefox's, finishing on the GIMP's one and I always switched the desktop as soon as the window(s) on it were fully rendered).
I ran it a couple of times on the 2.6.17-rc1-mm2 kernel with and without the patch and the results (on the average) are the following:
(a) 25-28s with the patch
(b) 30-33s without it
Moreover, with the patch the image size was about 49000 of pages (only ~7000 - 12000 pages had to be copied during suspend) and without the patch it was about 30000 of pages, so with the patch much smaller number of pages was in the swap after resume.
Greetings,
Rafael
Hi!
Quoted 36 lines · Rafael J. Wysocki
Quoted 10 lines · Pavel Machek
Quoted 9 lines
Quoted 8 lines
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Quoted 4 lines
Quoted 2 lines
Could we get few people trying it on such small machines to see if it is really that noticeable?
OK, I'll try to run some tests on a machine with smaller RAM (and slower CPU).
Done, although it was not so easy to find the box. This was a PII 350MHz w/ 256 MB of RAM.
I invented the following test:
- ran KDE with 4 desktops,
- ran Firefox, OpenOffice.org 1.1 (with a simple spreadsheet), and GIMP (with 2 pictures) each on its own desktop,
- ran the memory meter from the KDE's Info Center and two konsoles on the remaining desktop - one konsole with a kernel compilation and the other with a root session used for suspending the box (the built-in swsusp was used),
so the box's RAM was almost fully occupied with ~30% taken by the page cache.Then I suspended the box and measured the time from the start of resume (ie. leaving GRUB) to the point at which I had all of the application windows fully rendered on their respective desktops (I always switched the desktops in the same order, starting from the memory meter's one, through the OOo's and Firefox's, finishing on the GIMP's one and I always switched the desktop as soon as the window(s) on it were fully rendered).
Quoted 5 lines
I ran it a couple of times on the 2.6.17-rc1-mm2 kernel with and without the patch and the results (on the average) are the following:
(a) 25-28s with the patch
(b) 30-33s without it
Ook, thanks for testing. I guess it is ready for -mm when Nick is happy with it ...
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Hi,
Quoted 36 lines · Pavel Machek
Quoted 36 lines · Rafael J. Wysocki
Quoted 10 lines · Pavel Machek
Quoted 9 lines
Quoted 8 lines
Quoted 2 lines
Okay, so it can be done, and patch does not look too bad. It still scares me. Is 800MB image more responsive than 500MB after resume?
Yes, it is, slightly, but I think 800 meg images are impractical for performance reasons (like IMO everything above 500 meg with the current hardware). However this means we can save 80% of RAM with the patch and that should be 400 meg instead of 250 on a 500 meg machine, or 200 meg instead of 125 on a 250 meg machine.
Quoted 4 lines
Quoted 2 lines
Could we get few people trying it on such small machines to see if it is really that noticeable?
OK, I'll try to run some tests on a machine with smaller RAM (and slower CPU).
Done, although it was not so easy to find the box. This was a PII 350MHz w/ 256 MB of RAM.
I invented the following test:
- ran KDE with 4 desktops,
- ran Firefox, OpenOffice.org 1.1 (with a simple spreadsheet), and GIMP (with 2 pictures) each on its own desktop,
- ran the memory meter from the KDE's Info Center and two konsoles on the remaining desktop - one konsole with a kernel compilation and the other with a root session used for suspending the box (the built-in swsusp was used),
so the box's RAM was almost fully occupied with ~30% taken by the page cache.Then I suspended the box and measured the time from the start of resume (ie. leaving GRUB) to the point at which I had all of the application windows fully rendered on their respective desktops (I always switched the desktops in the same order, starting from the memory meter's one, through the OOo's and Firefox's, finishing on the GIMP's one and I always switched the desktop as soon as the window(s) on it were fully rendered).
Quoted 8 lines
Quoted 5 lines
I ran it a couple of times on the 2.6.17-rc1-mm2 kernel with and without the patch and the results (on the average) are the following:
(a) 25-28s with the patch
(b) 30-33s without itOok, thanks for testing. I guess it is ready for -mm when Nick is happy with it ...
OK, I'm waiting for Nick to respond, then. :-)
Still I'd like to change one more thing in the final patch. Namely, instead of this:
@@ -153,6 +153,10 @@ static int snapshot_ioctl(struct inode * case SNAPSHOT_UNFREEZE:
if (!data->frozen)
break;
+ if (data->ready && in_suspend) {
+ error = -EPERM;
+ break;
+ }
down(&pm_sem);
thaw_processes(); enable_nonboot_cpus();
I'd like to do:
case SNAPSHOT_UNFREEZE:
if (!data->frozen)
break;
+ if (data->ready)
+ swsusp_free();
down(&pm_sem); thaw_processes(); enable_nonboot_cpus();
so unfreeze() won't return the error.
Greetings,
Rafael
Hi!
Quoted 28 lines
OK, I'm waiting for Nick to respond, then. :-)
Still I'd like to change one more thing in the final patch. Namely, instead of this:
(quoted diff) +0
-0@@ -153,6 +153,10 @@ static int snapshot_ioctl(struct inode *case
SNAPSHOT_UNFREEZE:
if (!data->frozen)
break;
+ if (data->ready&&in_suspend) {
+ error =-EPERM;
+ break;
+ }
down(&pm_sem);
thaw_processes();
enable_nonboot_cpus();I'd like to do:
(quoted diff) +2
-0case SNAPSHOT_UNFREEZE: if (!data->frozen) break; + if (data->ready) + swsusp_free(); down(&pm_sem);thaw_processes(); enable_nonboot_cpus();
Quoted 1 line
so
unfreeze()won't return the error.
Seems okay to me...
Pavel
Signature · 5 lines
Thanks for all the (sleeping) penguins. _______________________________________________ linux-pm mailing list [email protected] https://lists.osdl.org/mailman/listinfo/linux-pm
Quoted 17 lines · pageRafael J. Wysocki
Index:
linux-2.6.17-rc1-mm3/mm/rmap.c
===================================================================mm/rmap.c +9
-0@@ -851,3 +851,22 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +spin_lock (¤t->mm->page_table_lock); + +for (vma = current->mm->mmap; vma; vma = vma->vm_next)
mm/rmap.c int try_to_unmap(struct page *page, int · line 872
Quoted 10 lines
mm/rmap.c +10
-0+if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =1 ; +break ; + } + +spin_unlock (¤t->mm->page_table_lock); + + return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
Why not just pass in the task struct? It might make the interface more useful elsewhere.
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 111
Quoted 13 lines
Index:
linux-2.6.17-rc1-mm3/include/linux/rmap.h
===================================================================include/linux/rmap.h +5
-0@@ -104,6 +104,12 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *); +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *); +#else +static inline int page_mapped_by_current (struct page *page) {return 0 ; } +#endif /* CONFIG_SOFTWARE_SUSPEND */
This just wrong. What if some random unrelated code calls page_mapped_by_current? You should only fold inlines if their result folds accordingly.
For now just leave it out completely if !CONFIG_SOFTWARE_SUSPEND.
Quoted 5 lines
include/linux/rmap.h +4
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. +* Returns false if the page can be saved without copying. +*/
include/linux/rmap.h pte_t *page_check_address(struct page *,
Quoted 10 lines
include/linux/rmap.h +10
-0+ +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page)) +return 1 ; +if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}
I'd much rather VM internal type stuff get moved *out* of kernel/power :(
It needs more comments too. Also, how important is it for the page to be off the LRU? What if kswapd has taken it off the LRU temporarily (or is it guanteed not to at this point)? What if it is in an lru_add pagevec?
Quoted 21 lines
include/linux/rmap.h +10
-3+ +unsigned int count_data_pages (unsigned int *total) {struct zone *zone;unsigned long zone_pfn; -unsigned int n =0 ; +unsigned int n, m; + n = m =0 ;for_each_zone (zone) {if (is_highmem (zone))continue ;mark_free_pages (zone); -for (zone_pfn =0 ; zone_pfn < zone->spanned_pages; ++zone_pfn) - n +=saveable (zone, &zone_pfn); +for (zone_pfn =0 ; zone_pfn < zone->spanned_pages; ++zone_pfn) { +unsigned long pfn = zone_pfn + zone->zone_start_pfn; + +if (saveable (pfn)) { + n++; +if (!need_to_copy (pfn_to_page (pfn)))
include/linux/rmap.h
Quoted 10 lines
include/linux/rmap.h +7
-1+ m++; + } + } } -return n; +if (total) + *total = n; + +return n - m; }
Maybe we could add some commenting to these functions while changing them around.
Quoted 19 lines
include/linux/rmap.h +19
-0+static LIST_HEAD (active_pages); +static LIST_HEAD (inactive_pages); + +/** +* protect_data_pages - move data pages that need to be protected from +* being reclaimed out of their respective LRU lists +*/ + +static void protect_data_pages (struct pbe *pblist) +{ +struct pbe *p; + + for_each_pbe (p, pblist) +if (p->address == p->orig_address) { +struct page *page =virt_to_page (p->address); +struct zone *zone =page_zone (page); + +spin_lock (&zone->lru_lock); +if (PageActive (page)) {
include/linux/rmap.h
Quoted 10 lines
include/linux/rmap.h +10
-0+del_page_from_active_list (zone, page); +list_add (&page->lru, &active_pages); + }else { +del_page_from_inactive_list (zone, page); +list_add (&page->lru, &inactive_pages); + } +spin_unlock (&zone->lru_lock); +ClearPageLRU (page); + } +}
a) How do you know the page is on the LRU?
b) Why are you clearing PageLRU outside the spinlock?
c) This code isn't going outside mm/ even if it is correct.
d) swsusp seems to be quite under documented as far as race conditions vs the rest of the kernel go. In some places only a single CPU is running with interrupts off, in other places all processes have frozen, etc. etc. So it is hard to even know if synchronisation is correct or not.
Suggest more documentation goes into this.
include/linux/rmap.h
Quoted 8 lines
include/linux/rmap.h +8
-0+ +/** +* restore_active_inactive_lists - if suspend fails, the pages protected +* with protect_data_pages() have to be moved back to their respective +* lists +*/ + +static void restore_active_inactive_lists (void )
Ditto, mostly.
Quoted 14 lines
include/linux/rmap.h +8
-2+static int enough_free_mem (unsigned int nr_pages,unsigned int copy_pages) {struct zone *zone; -unsigned int n =0 ; +long n =0 ; + +pr_debug ("swsusp: pages needed: %u + %lu + %lu, free: %u\n" , + copy_pages, + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE , +EXTRA_PAGES ,nr_free_pages ());for_each_zone (zone) - if (!is_highmem(zone)) + if (!is_highmem(zone) && populated_zone(zone)) {
include/linux/rmap.h
Quoted 10 lines
include/linux/rmap.h +1
-8n += zone->free_pages; -pr_debug ("swsusp: available memory: %u pages\n" , n); -return n > (nr_pages +PAGES_FOR_IO + - (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE ); -} - -static int alloc_data_pages (struct pbe *pblist,gfp_t gfp_mask,int safe_needed) -{ -struct pbe *p; + n -= zone->lowmem_reserve[ZONE_NORMAL ];
Comment for this? Eg. why are you taking the ZONE_NORMAL watermark in particular?
Signature · 2 lines
SUSE Labs, Novell Inc. Send instant messages to your online friends http://au.messenger.yahoo.com
Hi,
First, thanks for reviewing.
Quoted 24 lines · Nick Piggin
Quoted 22 lines · pageRafael J. Wysocki
Index:
linux-2.6.17-rc1-mm3/mm/rmap.c
===================================================================mm/rmap.c +14
-0@@ -851,3 +851,22 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +spin_lock (¤t->mm->page_table_lock); + +for (vma = current->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =1 ; +break ; + } +
Quoted 8 lines
mm/rmap.c int try_to_unmap(struct page *page, int · line 872
Quoted 5 lines
mm/rmap.c +5
-0+spin_unlock (¤t->mm->page_table_lock); + + return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */ Why not just pass in the task struct? It might make the interface more useful elsewhere.
Good idea, I'll do that.
Quoted 18 lines
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 111
Quoted 13 lines
Index:
linux-2.6.17-rc1-mm3/include/linux/rmap.h
===================================================================include/linux/rmap.h +5
-0@@ -104,6 +104,12 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *); +#ifdef CONFIG_SOFTWARE_SUSPEND +int page_mapped_by_current (struct page *); +#else +static inline int page_mapped_by_current (struct page *page) {return 0 ; } +#endif /* CONFIG_SOFTWARE_SUSPEND */ This just wrong. What if some random unrelated code calls
page_mapped_by_current? You should only fold inlines if their result folds accordingly.
Quoted 1 line
For now just leave it out completely if !CONFIG_SOFTWARE_SUSPEND.
OK
Quoted 9 lines
Quoted 9 lines
include/linux/rmap.h +8
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. +* Returns false if the page can be saved without copying. +*/ + +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page))
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+return 1 ; +if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under mm/.
Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and
(b) not mapped by the current task.
Quoted 2 lines
What if kswapd has taken it off the LRU temporarily (or is it guanteed not to at this point)? What if it is in an
lru_addpagevec?
At this point kswapd is frozen as well as everything else except for the current task (ie. us). IOW no one is expected to process the LRU lists.
Quoted 26 lines
Quoted 26 lines
include/linux/rmap.h +13
-4+ +unsigned int count_data_pages (unsigned int *total) {struct zone *zone;unsigned long zone_pfn; -unsigned int n =0 ; +unsigned int n, m; + n = m =0 ;for_each_zone (zone) {if (is_highmem (zone))continue ;mark_free_pages (zone); -for (zone_pfn =0 ; zone_pfn < zone->spanned_pages; ++zone_pfn) - n +=saveable (zone, &zone_pfn); +for (zone_pfn =0 ; zone_pfn < zone->spanned_pages; ++zone_pfn) { +unsigned long pfn = zone_pfn + zone->zone_start_pfn; + +if (saveable (pfn)) { + n++; +if (!need_to_copy (pfn_to_page (pfn))) + m++; + } + } } -return n;
Quoted 8 lines
include/linux/rmap.h
Quoted 5 lines
include/linux/rmap.h +4
-0+if (total) + *total = n; + +return n - m; }Maybe we could add some commenting to these functions while changing them around.
OK, I will.
Quoted 23 lines
Quoted 23 lines
include/linux/rmap.h +23
-0+static LIST_HEAD (active_pages); +static LIST_HEAD (inactive_pages); + +/** +* protect_data_pages - move data pages that need to be protected from +* being reclaimed out of their respective LRU lists +*/ + +static void protect_data_pages (struct pbe *pblist) +{ +struct pbe *p; + + for_each_pbe (p, pblist) +if (p->address == p->orig_address) { +struct page *page =virt_to_page (p->address); +struct zone *zone =page_zone (page); + +spin_lock (&zone->lru_lock); +if (PageActive (page)) { +del_page_from_active_list (zone, page); +list_add (&page->lru, &active_pages); + }else { +del_page_from_inactive_list (zone, page);
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+list_add (&page->lru, &inactive_pages); + } +spin_unlock (&zone->lru_lock); +ClearPageLRU (page); + } +}a) How do you know the page is on the LRU?
Because in copy_data_pages() p->address is only set to p->orig_address for pages that are on the LRU. No one can change the state of the pages in between because everyone else is frozen and we have local IRQs disabled.
Quoted 1 line
b) Why are you clearing PageLRU outside the spinlock?
Well, good question. ;-) Moreover it seems I don't need to acquire the spinlock at all, because this is done on one CPU with IRQs disabled and the other tasks frozen.
Quoted 1 line
c) This code isn't going outside
mm/even if it is correct.
OK, so could you please suggest me where to put it (or a corrected version) under mm/?
Quoted 7 lines
d) swsusp seems to be quite under documented as far as race conditions vs the rest of the kernel go. In some places only a single CPU is running with interrupts off, in other places all processes have frozen, etc. etc. So it is hard to even know if synchronisation is correct or not.
Suggest more documentation goes into this.
OK
Quoted 22 lines
include/linux/rmap.h
Quoted 8 lines
include/linux/rmap.h +8
-0+ +/** +* restore_active_inactive_lists - if suspend fails, the pages protected +* with protect_data_pages() have to be moved back to their respective +* lists +*/ + +static void restore_active_inactive_lists (void )Ditto, mostly.
Quoted 11 lines
include/linux/rmap.h +7
-1+static int enough_free_mem (unsigned int nr_pages,unsigned int copy_pages) {struct zone *zone; -unsigned int n =0 ; +long n =0 ; + +pr_debug ("swsusp: pages needed: %u + %lu + %lu, free: %u\n" , + copy_pages, + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE , +EXTRA_PAGES ,nr_free_pages ());
Quoted 16 lines
include/linux/rmap.h
Quoted 13 lines
include/linux/rmap.h +2
-9for_each_zone (zone) - if (!is_highmem(zone)) + if (!is_highmem(zone) && populated_zone(zone)) { n += zone->free_pages; -pr_debug ("swsusp: available memory: %u pages\n" , n); -return n > (nr_pages +PAGES_FOR_IO + - (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE ); -} - -static int alloc_data_pages (struct pbe *pblist,gfp_t gfp_mask,int safe_needed) -{ -struct pbe *p; + n -= zone->lowmem_reserve[ZONE_NORMAL ];Comment for this? Eg. why are you taking the
ZONE_NORMALwatermark in particular?
This is to sync enough_free_mem() with swsusp_shrink_memory() (in swsusp.c). [We allocate with GFP_ATOMIC ie. from the normal zone and the lowmem reserves in the lower zones are effectively unavailable to us because of the check in zone_watermark_ok().]
Thanks a lot for the comments. I'll do my best to follow your suggestions in the next version of the patch.
Greetings,
Rafael
Hi!
Quoted 20 lines
Quoted 9 lines
Quoted 9 lines
kernel/power/snapshot.c +8
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. +* Returns false if the page can be saved without copying. +*/ + +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page))Quoted 8 lines
kernel/power/snapshot.c static int saveable(struct zone *zone, u · line 311
Quoted 6 lines
kernel/power/snapshot.c +6
-0+return 1 ; +if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.
Quoted 8 lines
Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and
(b) not mapped by the current task.
Why do you _want_ them mapped by someone?
Quoted 5 lines
Quoted 1 line
b) Why are you clearing PageLRU outside the spinlock?
Well, good question. ;-) Moreover it seems I don't need to acquire the spinlock at all, because this is done on one CPU with IRQs disabled and the other tasks frozen.
Well, it is probably better to still take the spinlock. That way, if something goes wrong we get deadlock, not anything worse.
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Hi,
Quoted 23 lines · Pavel Machek
Quoted 23 lines
Quoted 9 lines
Quoted 9 lines
kernel/power/snapshot.c +8
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. +* Returns false if the page can be saved without copying. +*/ + +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page))Quoted 8 lines
kernel/power/snapshot.c static int saveable(struct zone *zone, u · line 311
Quoted 6 lines
kernel/power/snapshot.c +6
-0+return 1 ; +if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Quoted 7 lines
Quoted 5 lines
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and
(b) not mapped by the current task.Why do you _want_ them mapped by someone?
Because this means they belong to a task that is frozen and won't touch them (of course unless it's us). The kernel has no reason to access them either (even after we resume devices) except for reclaiming, but that's handled explicitly. Thus it's safe to include them in the image without copying.
As I said before, I think the page cache pages may be treated this way too. It probably applies to all of the LRU pages, but there may be some corner cases. The mapped pages are just easy to single out.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
b) Why are you clearing PageLRU outside the spinlock?
Well, good question. ;-) Moreover it seems I don't need to acquire the spinlock at all, because this is done on one CPU with IRQs disabled and the other tasks frozen.
Well, it is probably better to still take the spinlock. That way, if something goes wrong we get deadlock, not anything worse.
OK, so I'll just clear/set the LRU flag under the spinlock.
Greetings,
Rafael
Hi.
Quoted 42 lines · Rafael J. Wysocki
Hi,
Quoted 25 lines · Pavel Machek
Quoted 25 lines
Quoted 11 lines
Quoted 11 lines
kernel/power/snapshot.c +2
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. + * Returns false if the page can be saved without copying.
+ */kernel/power/snapshot.c +5
-0+ +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page)) +return 1 ;Quoted 8 lines
kernel/power/snapshot.c static int saveable(struct zone *zone, u · line 311
Quoted 5 lines
kernel/power/snapshot.c +5
-0+if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Quoted 7 lines
Quoted 5 lines
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and (b) not mapped by the current task.
Why do you _want_ them mapped by someone?
Because this means they belong to a task that is frozen and won't touch them (of course unless it's us). The kernel has no reason to access them either (even after we resume devices) except for reclaiming, but that's handled explicitly. Thus it's safe to include them in the image without copying.
Quoted 3 lines
As I said before, I think the page cache pages may be treated this way too. It probably applies to all of the LRU pages, but there may be some corner cases. The mapped pages are just easy to single out.
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Regards,
Nigel
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Hi,
Quoted 45 lines · Nigel Cunningham
Quoted 40 lines · Rafael J. Wysocki
Quoted 25 lines · Pavel Machek
Quoted 25 lines
Quoted 11 lines
Quoted 11 lines
kernel/power/snapshot.c +2
-1-unsigned int count_data_pages (void ) +/** +* need_to_copy - determine if a page needs to be copied before saving. + * Returns false if the page can be saved without copying.
+ */kernel/power/snapshot.c +5
-0+ +static int need_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page)) +return 1 ;Quoted 8 lines
kernel/power/snapshot.c static int saveable(struct zone *zone, u · line 311
Quoted 5 lines
kernel/power/snapshot.c +5
-0+if (page_mapped (page)) +return page_mapped_by_current (page); + +return 1 ; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Quoted 7 lines
Quoted 5 lines
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and (b) not mapped by the current task.
Why do you _want_ them mapped by someone?
Because this means they belong to a task that is frozen and won't touch them (of course unless it's us). The kernel has no reason to access them either (even after we resume devices) except for reclaiming, but that's handled explicitly. Thus it's safe to include them in the image without copying.
Quoted 3 lines
As I said before, I think the page cache pages may be treated this way too. It probably applies to all of the LRU pages, but there may be some corner cases. The mapped pages are just easy to single out.
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Greetings,
Rafael
Hi.
Quoted 53 lines · Rafael J. Wysocki
Quoted 46 lines · Nigel Cunningham
Quoted 41 lines · Rafael J. Wysocki
Quoted 26 lines · Pavel Machek
Quoted 26 lines
Quoted 11 lines
Quoted 11 lines
(quoted diff) +2
-1-unsigned int count_data_pages(void) +/** + * need_to_copy - determine if a page needs to be copiedbefore saving. + * Returns false if the page can be saved
without copying. + */(quoted diff) +5
-0+ +static int need_to_copy(struct page *page) +{ + if (!PageLRU(page) || PageCompound(page)) + return 1;Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ if (page_mapped(page)) + return page_mapped_by_current(page); + + return 1; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Quoted 7 lines
Quoted 5 lines
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and (b) not mapped by the current task.
Why do you _want_ them mapped by someone?
Because this means they belong to a task that is frozen and won't touch them (of course unless it's us). The kernel has no reason to access them either (even after we resume devices) except for reclaiming, but that's handled explicitly. Thus it's safe to include them in the image without copying.
Quoted 3 lines
As I said before, I think the page cache pages may be treated this way too. It probably applies to all of the LRU pages, but there may be some corner cases. The mapped pages are just easy to single out.
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Isn't that a coincidence? I just happen to have the code right here! Not in a patch form that you'd want though - do you have any refrigerator changes in mm at the moment, or can I use vanilla 2.6.17-rc2 process.c?
Regards,
Nigel
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Hi,
Quoted 54 lines · Nigel Cunningham
Quoted 53 lines · Rafael J. Wysocki
Quoted 51 lines · Nigel Cunningham
Quoted 41 lines · Rafael J. Wysocki
Quoted 26 lines · Pavel Machek
Quoted 26 lines
Quoted 11 lines
Quoted 11 lines
(quoted diff) +2
-1-unsigned int count_data_pages(void) +/** + * need_to_copy - determine if a page needs to be copiedbefore saving. + * Returns false if the page can be saved
without copying. + */(quoted diff) +5
-0+ +static int need_to_copy(struct page *page) +{ + if (!PageLRU(page) || PageCompound(page)) + return 1;Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ if (page_mapped(page)) + return page_mapped_by_current(page); + + return 1; +}I'd much rather VM internal type stuff get moved *out* of kernel/power :(
Well, I kind of agree, but I don't know where to place it under
mm/.Quoted 2 lines
It needs more comments too. Also, how important is it for the page to be off the LRU?
Quoted 7 lines
Quoted 5 lines
Hm, I'm not sure if that's what you're asking about, but the pages off the LRU are handled in a usual way, ie. copied when snapshotting the system. The pages _on_ the LRU may be included in the snapshot image without copying, but I require them additionally to be (a) mapped by someone and (b) not mapped by the current task.
Why do you _want_ them mapped by someone?
Because this means they belong to a task that is frozen and won't touch them (of course unless it's us). The kernel has no reason to access them either (even after we resume devices) except for reclaiming, but that's handled explicitly. Thus it's safe to include them in the image without copying.
Quoted 3 lines
As I said before, I think the page cache pages may be treated this way too. It probably applies to all of the LRU pages, but there may be some corner cases. The mapped pages are just easy to single out.
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 8 lines
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Isn't that a coincidence? I just happen to have the code right here! Not in a patch form that you'd want though - do you have any refrigerator changes in mm at the moment, or can I use vanilla 2.6.17-rc2
process.c?
I think you can use the 2.6.17-rc2 one safely.
Greetings,
Rafael
Hi!
Quoted 9 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
HI.
Quoted 8 lines · Pavel Machek
Hi!
Quoted 6 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 7 lines
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
You assume too much. This is just using existing code.
Regards,
Nigel
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Quoted 16 lines · Nigel Cunningham
HI.
Quoted 13 lines · Pavel Machek
Hi!
Quoted 10 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Quoted 4 lines
Quoted 2 lines
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
You assume too much. This is just using existing code.
Let's see the patch, then.
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Hi,
Quoted 6 lines · Pavel Machek
Quoted 6 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 6 lines
Quoted 3 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
Greetings,
Rafael
Hi.
Quoted 14 lines · Rafael J. Wysocki
Hi,
Quoted 11 lines · Pavel Machek
Quoted 10 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Quoted 5 lines
Quoted 2 lines
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
In Suspend2, I'm still using a different version of process.c to what you guys have. In my version, I thaw kernelspace, then thaw bdevs, then thaw userspace. The version below just thaws bdevs after thawing all processes. I think that might need modification, but thought I'd post this now so you can see how complicated or otherwise it is.
Regards,
Nigel
kernel/power/process.c +57 -0
@@ -19,6 +19,56 @@*/ #define TIMEOUT (20 * HZ) +struct frozen_fs +{ +struct list_head fsb_list; +struct super_block *sb; +}; + +LIST_HEAD (frozen_fs_list); + +void freezer_make_fses_rw (void ) +{ +struct frozen_fs *fs, *next_fs; + +list_for_each_entry_safe (fs, next_fs, &frozen_fs_list, fsb_list) { +thaw_bdev (fs->sb->s_bdev, fs->sb); + +list_del (&fs->fsb_list); +kfree (fs); + } +} + +/* +* Done after userspace is frozen, so there should be no danger of +* fses being unmounted while we're in here. +*/ +int freezer_make_fses_ro (void ) +{ +struct frozen_fs *fs; +struct super_block *sb; + +/* Generate the list */ +list_for_each_entry (sb, &super_blocks, s_list) { +if (!sb->s_root || !sb->s_bdev || + (sb->s_frozen ==SB_FREEZE_TRANS ) || + (sb->s_flags &MS_RDONLY )) +continue ; + + fs =kmalloc (sizeof (struct frozen_fs ),GFP_ATOMIC ); + fs->sb = sb; +list_add_tail (&fs->fsb_list, &frozen_fs_list); + }; + +/* Do the freezing in reverse order so filesystems dependant +* upon others are frozen in the right order. (Eg loopback +* on ext3). */ +list_for_each_entry_reverse (fs, &frozen_fs_list, fsb_list) +freeze_bdev (fs->sb->s_bdev); + +return 0 ; +} +static inline int freezeable (struct task_struct * p) {
@@ -77,6 +127,7 @@printk ("Stopping tasks: " ); start_time = jiffies; user_frozen =0 ; + bdevs_frozen =0 ; do { nr_user = todo = 0; read_lock(&tasklist_lock);
@@ -107,6 +158,10 @@ start_time = jiffies; } user_frozen = !nr_user; + +if (user_frozen && !bdevs_frozen) +freezer_make_fses_ro (); +yield ();/* Yield is okay here */ if (todo &&time_after (jiffies, start_time +TIMEOUT ))break ;
@@ -156,6 +211,8 @@printk (KERN_INFO " Strange, %s not stopped\n" , p->comm ); }while_each_thread (g, p); +freezer_make_fses_rw (); +read_unlock (&tasklist_lock);schedule ();printk (" done\n" );
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Hi,
Quoted 16 lines · Nigel Cunningham
Quoted 15 lines · Rafael J. Wysocki
Quoted 13 lines · Pavel Machek
Quoted 10 lines
Quoted 5 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Quoted 8 lines
Quoted 2 lines
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
In Suspend2, I'm still using a different version of
process.cto what you guys have. In my version, I thaw kernelspace, then thaw bdevs, then thaw userspace. The version below just thaws bdevs after thawing all processes. I think that might need modification, but thought I'd post this now so you can see how complicated or otherwise it is.
IMHO it doesn't look so scary. :-)
Quoted 34 lines
diff -ruN
linux-2.6.17-rc2/kernel/power/process.cbdev-freeze/kernel/power/process.ckernel/power/process.c +27
-0@@ -19,6 +19,56 @@*/ #define TIMEOUT (20 * HZ) +struct frozen_fs +{ +struct list_head fsb_list; +struct super_block *sb; +}; + +LIST_HEAD (frozen_fs_list); + +void freezer_make_fses_rw (void ) +{ +struct frozen_fs *fs, *next_fs; + +list_for_each_entry_safe (fs, next_fs, &frozen_fs_list, fsb_list) { +thaw_bdev (fs->sb->s_bdev, fs->sb); + +list_del (&fs->fsb_list); +kfree (fs); + } +} + +/* +* Done after userspace is frozen, so there should be no danger of +* fses being unmounted while we're in here. +*/ +int freezer_make_fses_ro (void ) +{ +struct frozen_fs *fs;
kernel/power/process.c line 58
Quoted 10 lines
kernel/power/process.c +10
-0+struct super_block *sb; + +/* Generate the list */ +list_for_each_entry (sb, &super_blocks, s_list) { +if (!sb->s_root || !sb->s_bdev || + (sb->s_frozen ==SB_FREEZE_TRANS ) || + (sb->s_flags &MS_RDONLY )) +continue ; + + fs =kmalloc (sizeof (struct frozen_fs ),GFP_ATOMIC );
Shouldn't we check for kmalloc() failures here?
Quoted 36 lines
kernel/power/process.c +18
-0+ fs->sb = sb; +list_add_tail (&fs->fsb_list, &frozen_fs_list); + }; + +/* Do the freezing in reverse order so filesystems dependant +* upon others are frozen in the right order. (Eg loopback +* on ext3). */ +list_for_each_entry_reverse (fs, &frozen_fs_list, fsb_list) +freeze_bdev (fs->sb->s_bdev); + +return 0 ; +} +static inline int freezeable (struct task_struct * p) {@@ -77,6 +127,7 @@printk ("Stopping tasks: " ); start_time = jiffies; user_frozen =0 ; + bdevs_frozen =0 ; do { nr_user = todo = 0; read_lock(&tasklist_lock);@@ -107,6 +158,10 @@ start_time = jiffies; } user_frozen = !nr_user; + +if (user_frozen && !bdevs_frozen) +freezer_make_fses_ro (); +yield ();/* Yield is okay here */ if (todo &&time_after (jiffies, start_time +TIMEOUT ))break ;
kernel/power/process.c line 218
Quoted 8 lines
kernel/power/process.c +2
-0@@ -156,6 +211,8 @@printk (KERN_INFO " Strange, %s not stopped\n" , p->comm ); }while_each_thread (g, p); +freezer_make_fses_rw (); +read_unlock (&tasklist_lock);schedule ();printk (" done\n" );
Greetings,
Rafael
Hi.
Sorry for the slow response - I only have internet access at work now. This is going to be a pattern for the next few weeks - I'm off work next week and.the week after I'll also be off apart from Monday and Tuesday (those are my last two days working for Cyclades - I then get my sweetheart and little one back, and we drive down to Victoria over the rest of the week).
Quoted 23 lines · Rafael J. Wysocki
Hi,
Quoted 20 lines · Nigel Cunningham
Quoted 18 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 7 lines
Quoted 6 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 7 lines
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
Quoted 7 lines
Quoted 5 lines
In Suspend2, I'm still using a different version of
process.cto what you guys have. In my version, I thaw kernelspace, then thaw bdevs, then thaw userspace. The version below just thaws bdevs after thawing all processes. I think that might need modification, but thought I'd post this now so you can see how complicated or otherwise it is.IMHO it doesn't look so scary. :-)
:)
Quoted 39 lines
Quoted 39 lines
diff -ruN
linux-2.6.17-rc2/kernel/power/process.cbdev-freeze/kernel/power/process.c---linux-2.6.17-rc2/kernel/power/process.c2006-04-19 14:27:36.000000000
+1000 +++bdev-freeze/kernel/power/process.c2006-04-26
10:44:56.000000000 +1000 @@ -19,6 +19,56 @@
*/
#define TIMEOUT (20 * HZ)kernel/power/process.c +31
-0+struct frozen_fs +{ +struct list_head fsb_list; +struct super_block *sb; +}; + +LIST_HEAD (frozen_fs_list); + +void freezer_make_fses_rw (void ) +{ +struct frozen_fs *fs, *next_fs; + +list_for_each_entry_safe (fs, next_fs, &frozen_fs_list, fsb_list) { +thaw_bdev (fs->sb->s_bdev, fs->sb); + +list_del (&fs->fsb_list); +kfree (fs); + } +} + +/* +* Done after userspace is frozen, so there should be no danger of +* fses being unmounted while we're in here. +*/ +int freezer_make_fses_ro (void ) +{ +struct frozen_fs *fs; +struct super_block *sb; + +/* Generate the list */ +list_for_each_entry (sb, &super_blocks, s_list) {
Quoted 8 lines
kernel/power/process.c line 58
Quoted 6 lines
kernel/power/process.c +6
-0+if (!sb->s_root || !sb->s_bdev || + (sb->s_frozen ==SB_FREEZE_TRANS ) || + (sb->s_flags &MS_RDONLY )) +continue ; + + fs =kmalloc (sizeof (struct frozen_fs ),GFP_ATOMIC );Shouldn't we check for
kmalloc()failures here?
Good point. Just because I've never seen it fail, doesn't mean it can't :)
Before I roll a new version, what did you think splitting the thawing and thawing bdevs in the middle? I think it's the right thing (TM) to do :>
Nigel
Quoted 47 lines
Quoted 36 lines
kernel/power/process.c +18
-0+ fs->sb = sb; +list_add_tail (&fs->fsb_list, &frozen_fs_list); + }; + +/* Do the freezing in reverse order so filesystems dependant +* upon others are frozen in the right order. (Eg loopback +* on ext3). */ +list_for_each_entry_reverse (fs, &frozen_fs_list, fsb_list) +freeze_bdev (fs->sb->s_bdev); + +return 0 ; +} +static inline int freezeable (struct task_struct * p) {@@ -77,6 +127,7 @@printk ("Stopping tasks: " ); start_time = jiffies; user_frozen =0 ; + bdevs_frozen =0 ; do { nr_user = todo = 0; read_lock(&tasklist_lock);@@ -107,6 +158,10 @@ start_time = jiffies; } user_frozen = !nr_user; + +if (user_frozen && !bdevs_frozen) +freezer_make_fses_ro (); +yield ();/* Yield is okay here */ if (todo &&time_after (jiffies, start_time +TIMEOUT ))break ;kernel/power/process.c line 218
Quoted 8 lines
kernel/power/process.c +2
-0@@ -156,6 +211,8 @@printk (KERN_INFO " Strange, %s not stopped\n" , p->comm ); }while_each_thread (g, p); +freezer_make_fses_rw (); +read_unlock (&tasklist_lock);schedule ();printk (" done\n" );Greetings,
Rafael
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
[Dropped Nick and LKML from the Cc list.]
Hi,
Quoted 3 lines · Nigel Cunningham
Hi.
Sorry for the slow response - I only have internet access at work now.
No problem at all. :-)
Quoted 85 lines
This is going to be a pattern for the next few weeks - I'm off work next week and.the week after I'll also be off apart from Monday and Tuesday (those are my last two days working for Cyclades - I then get my sweetheart and little one back, and we drive down to Victoria over the rest of the week).
Quoted 21 lines · Rafael J. Wysocki
Quoted 20 lines · Nigel Cunningham
Quoted 18 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 7 lines
Quoted 6 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 7 lines
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
Quoted 7 lines
Quoted 5 lines
In Suspend2, I'm still using a different version of
process.cto what you guys have. In my version, I thaw kernelspace, then thaw bdevs, then thaw userspace. The version below just thaws bdevs after thawing all processes. I think that might need modification, but thought I'd post this now so you can see how complicated or otherwise it is.IMHO it doesn't look so scary. :-)
:)
Quoted 39 lines
Quoted 39 lines
diff -ruN
linux-2.6.17-rc2/kernel/power/process.cbdev-freeze/kernel/power/process.c---linux-2.6.17-rc2/kernel/power/process.c2006-04-19 14:27:36.000000000
+1000 +++bdev-freeze/kernel/power/process.c2006-04-26
10:44:56.000000000 +1000 @@ -19,6 +19,56 @@
*/
#define TIMEOUT (20 * HZ)kernel/power/process.c +31
-0+struct frozen_fs +{ +struct list_head fsb_list; +struct super_block *sb; +}; + +LIST_HEAD (frozen_fs_list); + +void freezer_make_fses_rw (void ) +{ +struct frozen_fs *fs, *next_fs; + +list_for_each_entry_safe (fs, next_fs, &frozen_fs_list, fsb_list) { +thaw_bdev (fs->sb->s_bdev, fs->sb); + +list_del (&fs->fsb_list); +kfree (fs); + } +} + +/* +* Done after userspace is frozen, so there should be no danger of +* fses being unmounted while we're in here. +*/ +int freezer_make_fses_ro (void ) +{ +struct frozen_fs *fs; +struct super_block *sb; + +/* Generate the list */ +list_for_each_entry (sb, &super_blocks, s_list) {Quoted 8 lines
kernel/power/process.c line 58
Quoted 6 lines
kernel/power/process.c +6
-0+if (!sb->s_root || !sb->s_bdev || + (sb->s_frozen ==SB_FREEZE_TRANS ) || + (sb->s_flags &MS_RDONLY )) +continue ; + + fs =kmalloc (sizeof (struct frozen_fs ),GFP_ATOMIC );Shouldn't we check for
kmalloc()failures here?
Quoted 4 lines
Good point. Just because I've never seen it fail, doesn't mean it can't :)
Before I roll a new version, what did you think splitting the thawing and thawing bdevs in the middle? I think it's the right thing (TM) to do :>
Do you mean to thaw kernel threads first, thaw bdevs next and thaw user space processes at the end? I think it should be done in that order if the bdevs are frozen.
Greetings,
Rafael
Hi.
Quoted 100 lines · Rafael J. Wysocki
[Dropped Nick and LKML from the Cc list.]
Hi,
Quoted 3 lines · Nigel Cunningham
Hi.
Sorry for the slow response - I only have internet access at work now.
No problem at all. :-)
Quoted 89 lines
This is going to be a pattern for the next few weeks - I'm off work next week and.the week after I'll also be off apart from Monday and Tuesday (those are my last two days working for Cyclades - I then get my sweetheart and little one back, and we drive down to Victoria over the rest of the week).
Quoted 21 lines · Rafael J. Wysocki
Quoted 20 lines · Nigel Cunningham
Quoted 18 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 7 lines
Quoted 6 lines
It does apply to all of the LRU pages. This is what I've been doing for years now. The only corner case I've come across is XFS. It still wants to write data even when there's nothing to do and it's threads are frozen (IIRC - haven't looked at it for a while). I got around that by freezing bdevs when freezing processes.
Quoted 7 lines
Quoted 4 lines
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
...adding more dependencies to how vm/blockdevs work. I'd say current code is complex enough...
Well, why don't we see the patch? If it's too complex, we can just decide not to use it. :-)
Quoted 8 lines
Quoted 5 lines
In Suspend2, I'm still using a different version of
process.cto what you guys have. In my version, I thaw kernelspace, then thaw bdevs, then thaw userspace. The version below just thaws bdevs after thawing all processes. I think that might need modification, but thought I'd post this now so you can see how complicated or otherwise it is.IMHO it doesn't look so scary. :-)
:)
:Quoted 39 lines
Quoted 39 lines
diff -ruN
linux-2.6.17-rc2/kernel/power/process.cbdev-freeze/kernel/power/process.c---linux-2.6.17-rc2/kernel/power/process.c2006-04-19 14:27:36.000000000
+1000 +++bdev-freeze/kernel/power/process.c2006-04-26
10:44:56.000000000 +1000 @@ -19,6 +19,56 @@
*/
#define TIMEOUT (20 * HZ)kernel/power/process.c +31
-0+struct frozen_fs +{ +struct list_head fsb_list; +struct super_block *sb; +}; + +LIST_HEAD (frozen_fs_list); + +void freezer_make_fses_rw (void ) +{ +struct frozen_fs *fs, *next_fs; + +list_for_each_entry_safe (fs, next_fs, &frozen_fs_list, fsb_list) { +thaw_bdev (fs->sb->s_bdev, fs->sb); + +list_del (&fs->fsb_list); +kfree (fs); + } +} + +/* +* Done after userspace is frozen, so there should be no danger of +* fses being unmounted while we're in here. +*/ +int freezer_make_fses_ro (void ) +{ +struct frozen_fs *fs; +struct super_block *sb; + +/* Generate the list */ +list_for_each_entry (sb, &super_blocks, s_list) {Quoted 8 lines
kernel/power/process.c line 58
Quoted 6 lines
kernel/power/process.c +6
-0+if (!sb->s_root || !sb->s_bdev || + (sb->s_frozen ==SB_FREEZE_TRANS ) || + (sb->s_flags &MS_RDONLY )) +continue ; + + fs =kmalloc (sizeof (struct frozen_fs ),GFP_ATOMIC );Shouldn't we check for
kmalloc()failures here?Good point. Just because I've never seen it fail, doesn't mean it can't :)
Quoted 6 lines
Quoted 2 lines
Before I roll a new version, what did you think splitting the thawing and thawing bdevs in the middle? I think it's the right thing (TM) to do :>
Do you mean to thaw kernel threads first, thaw bdevs next and thaw user space processes at the end? I think it should be done in that order if the bdevs are frozen.
Ok. Will seek to find time to prepare a patch to do that.
Regards,
Nigel
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Quoted 4 lines · Rafael J. Wysocki
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Why not the current task? Does it exit the kernel? Or go through some get_uesr_pages path?
--
Send instant messages to your online friends http://au.messenger.yahoo.com
Hi Nick.
Quoted 8 lines · Nick Piggin
Quoted 4 lines · Rafael J. Wysocki
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Why not the current task? Does it exit the kernel? Or go through some
get_uesr_pagespath?
I think Rafael is asleep at the mo, so I'll answer for him - he's wanting it to be compatible with using userspace to control what happens (uswsusp). In that case, current will be the userspace program that's calling the ioctls to get processes frozen etc.
Regards,
Nigel
Signature · 2 lines
See our web page for Howtos, FAQs, the Wiki and mailing list info. http://www.suspend2.net IRC: #suspend2 on Freenode
Hi Nigel,
thanks
Quoted 11 lines · Nigel Cunningham
Hi Nick.
Quoted 7 lines · Nick Piggin
Quoted 4 lines · Rafael J. Wysocki
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Quoted 5 lines
Quoted 2 lines
Why not the current task? Does it exit the kernel? Or go through some
get_uesr_pagespath?I think Rafael is asleep at the mo, so I'll answer for him - he's wanting it to be compatible with using userspace to control what happens (uswsusp). In that case, current will be the userspace program that's calling the ioctls to get processes frozen etc.
OK, so what happens if, upon exit from kernel, that userspace task subsequently changes some pagecache but doesn't have that mapped? Or mmaps something then changes it?
Signature · 2 lines
SUSE Labs, Novell Inc. Send instant messages to your online friends http://au.messenger.yahoo.com
Hi,
Quoted 10 lines · Nick Piggin
Quoted 9 lines · Nigel Cunningham
Quoted 7 lines · Nick Piggin
Quoted 4 lines · Rafael J. Wysocki
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)
Quoted 8 lines
Quoted 8 lines
Quoted 2 lines
Why not the current task? Does it exit the kernel? Or go through some
get_uesr_pagespath?I think Rafael is asleep at the mo, so I'll answer for him - he's wanting it to be compatible with using userspace to control what happens (uswsusp). In that case, current will be the userspace program that's calling the ioctls to get processes frozen etc.
Thanks Nigel. :-)
Quoted 3 lines
OK, so what happens if, upon exit from kernel, that userspace task subsequently changes some pagecache but doesn't have that mapped? Or mmaps something then changes it?
The page cache that is not mapped by anyone is copied before creating the image and the copy is included in the image. However there would be a problem if some page cache mapped by someone else were mapped by the suspending task after it had exited the kernel.
Fortunately this task is forbidden to open() or mmap() any files at that time anyway, because it would be likely to corrupt some filesystems if it did. In fact it must not _touch_ any filesystems after the image has been created.
Greetings,
Rafael
Quoted 11 lines · Nick Piggin
Quoted 6 lines · Rafael J. Wysocki
This means if we freeze bdevs, we'll be able to save all of the LRU pages, except for the pages mapped by the current task, without copying. I think we
can try to do this, but we'll need a patch to freeze bdevs for this purpose. ;-)Why not the current task? Does it exit the kernel? Or go through some
get_uesr_pagespath?
It does exit kernel, and does writing to devices in userspace (so it can compress, etc).
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
RFC PATCH 1/1 swsusp: support creating bigger images (rev. 2)
In reply to Rafael J. WysockiHi,
On Tuesday 25 April 2006 17:39, Rafael J. Wysocki wrote:
}-- snip --{
Quoted 3 lines
Thanks a lot for the comments. I'll do my best to follow your suggestions in the next version of the patch.
The corrected version of the patch is appended.
A short summary of changes:
- the code that refers to the mm internals moved to mm/rmap.c and mm/vmscan.c
- added some comments (if you think more are needed or the existing ones should be clarified, please let me know)
- the PageLRU flags are set/reset under spinlocks
Could you please have a look at it?
Greetings,
Rafael
--- include/linux/rmap.h | 8 + include/linux/swap.h | 4 kernel/power/power.h | 10 +- kernel/power/snapshot.c | 225 +++++++++++++++++++++++++++++++++--------------- kernel/power/swsusp.c | 15 +-- kernel/power/user.c | 4 mm/rmap.c | 40 ++++++++ mm/vmscan.c | 63 +++++++++++++ 8 files changed, 293 insertions(+), 76 deletions(-)
mm/rmap.c +40 -0
@@ -851,3 +851,43 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +static int page_mapped_by_task (struct page *page,struct task_struct *task) +{ +struct vm_area_struct *vma; +int ret =0 ; + +spin_lock (&task->mm->page_table_lock); + +for (vma = task->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =1 ; +break ; + } + +spin_unlock (&task->mm->page_table_lock); + +return ret; +} + +/** +* page_to_copy - determine if a page can be included in the +* suspend image without copying (returns false if that's the case). +* +* It is safe to include the page in the suspend image without +* copying if (a) it's on the LRU and (b) it's mapped by a frozen task +* (all tasks except for the current task should be frozen when it's +* called). Otherwise the page should be copied for this purpose +* (compound pages are avoided for simplicity). +*/ + +int page_to_copy (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page)) +return 1 ; +if (page_mapped (page)) +return page_mapped_by_task (page, current); + +return 1 ; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
include/linux/rmap.h +8 -0
@@ -104,6 +104,14 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *); +#ifdef CONFIG_SOFTWARE_SUSPEND +/* +* Used to determine if the page can be included in the suspend image without +* copying +*/ +int page_to_copy (struct page *); +#endif +#else /* !CONFIG_MMU */ #define anon_vma_init () do {} while (0)
kernel/power/snapshot.c +159 -66
400 lines not on this page · raw message
kernel/power/power.h +9 -1
@@ -48,7 +48,14 @@ extern dev_t swsusp_resume_device; extern asmlinkage int swsusp_arch_suspend(void); extern asmlinkage int swsusp_arch_resume(void); -extern unsigned int count_data_pages (void ); +#if (defined(CONFIG_BLK_DEV_INITRD ) && defined(CONFIG_BLK_DEV_RAM )) +#define EXTRA_PAGES (PAGES_FOR_IO + \ + (2 * CONFIG_BLK_DEV_RAM_SIZE * 1024) / PAGE_SIZE) +#else +#define EXTRA_PAGES PAGES_FOR_IO +#endif + +extern unsigned int count_data_pages (unsigned int *total);struct snapshot_handle {loff_t offset;
@@ -111,6 +118,7 @@ extern int restore_special_mem(void);extern int swsusp_check (void );extern int swsusp_shrink_memory (void ); +extern void free_image (void );extern void swsusp_free (void );extern int swsusp_suspend (void );extern int swsusp_resume (void );
kernel/power/swsusp.c +8 -7
@@ -177,28 +177,29 @@ int swsusp_shrink_memory(void)long size, tmp;struct zone *zone;unsigned long pages =0 ; -unsigned int i =0 ; +unsigned int to_save, i =0 ;char *p ="-\\|/" ;printk ("Shrinking memory... " ); do { size = 2 * count_special_pages(); - size += size / 50 + count_data_pages(); - size += (size + PBES_PER_PAGE - 1) / PBES_PER_PAGE + - PAGES_FOR_IO; + size += size / 50 + count_data_pages(&to_save); + size += (to_save + PBES_PER_PAGE - 1) / PBES_PER_PAGE + + EXTRA_PAGES; tmp = size; for_each_zone (zone) if (!is_highmem(zone) && populated_zone(zone)) { tmp -= zone->free_pages; tmp += zone->lowmem_reserve[ZONE_NORMAL]; } + size = to_save * (PAGE_SIZE + sizeof(long)); if (tmp > 0) { tmp = __shrink_memory(tmp); if (!tmp) return -ENOMEM; pages += tmp; - } else if (size > image_size / PAGE_SIZE) { - tmp = __shrink_memory(size - (image_size / PAGE_SIZE)); + } else if (size > image_size) { + tmp = __shrink_memory(size - image_size); pages += tmp; } printk("\b%c", p[i++%4]);
@@ -261,7 +262,7 @@ int swsusp_resume(void)* very tight, so we have to free it as soon as we can to avoid * subsequent failures */ -swsusp_free (); +free_image ();restore_processor_state ();restore_special_mem ();touch_softlockup_watchdog ();
kernel/power/user.c +4 -0
@@ -153,6 +153,10 @@ static int snapshot_ioctl(struct inode *case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready && in_suspend) { + error = -EPERM ; +break ; + }down (&pm_sem);thaw_processes ();enable_nonboot_cpus ();
mm/vmscan.c +62 -1
69 lines not on this page · raw message
include/linux/swap.h +3 -1
@@ -184,7 +184,9 @@ extern void swap_setup(void);/* linux/mm/vmscan.c */ extern unsigned long try_to_free_pages (struct zone **,gfp_t ); -extern unsigned long shrink_all_memory (unsigned long nr_pages); +extern unsigned long shrink_all_memory (unsigned long ); +extern void move_out_of_lru (struct page *page); +extern void restore_active_inactive_lists (void );extern int vm_swappiness;extern int remove_mapping (struct address_space *mapping,struct page *page);