swsusp: support creating bigger images
Subsystems (7)
PATCH 1/1 swsusp: support creating bigger images
Currently swsusp is only capable of creating suspend images that are not bigger than 1/2 of the normal zone, because it needs to create a copy of every page which should be included in the image. This may hurt the system responsiveness after resume, especially on systems with less that 1 GB of RAM.
To allow swsusp to create bigger images we can use the observation that if some pages don't change after the snapshot image of the system has been created and before the image is entirely saved, they can be included in the image without copying. Now if the mapped pages that are not mapped by the current task are considered, it turns out that they would change only if they were reclaimed by try_to_free_pages(). Thus if we take them out of reach of try_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
If these pages are included in the image without copying, the amount of free memory needed by swsusp is usually much less than otherwise, so the size of the image may be bigger. This also makes swsusp use less memory during suspend and saves us quite a lot of memory allocations and copyings.
--- 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 | 2 mm/rmap.c | 40 ++++++++ mm/vmscan.c | 63 +++++++++++++ 8 files changed, 291 insertions(+), 76 deletions(-)
mm/rmap.c +40 -0
@@ -857,3 +857,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 +2 -0
@@ -153,6 +153,8 @@ static int snapshot_ioctl(struct inode *case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready) +swsusp_free ();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 *); +extern void restore_active_inactive_lists (void );extern int vm_swappiness;extern int remove_mapping (struct address_space *mapping,struct page *page);
Quoted 16 lines · Rafael J. Wysocki
Currently swsusp is only capable of creating suspend images that are not bigger than 1/2 of the normal zone, because it needs to create a copy of every page which should be included in the image. This may hurt the system responsiveness after resume, especially on systems with less that 1 GB of RAM.
To allow swsusp to create bigger images we can use the observation that if some pages don't change after the snapshot image of the system has been created and before the image is entirely saved, they can be included in the image without copying. Now if the mapped pages that are not mapped by the current task are considered, it turns out that they would change only if they were reclaimed by
try_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
Quoted 5 lines
If these pages are included in the image without copying, the amount of free memory needed by swsusp is usually much less than otherwise, so the size of the image may be bigger. This also makes swsusp use less memory during suspend and saves us quite a lot of memory allocations and copyings.
I have a host of minor problems with this patch.
Quoted 11 lines
mm/rmap.c +8
-0+#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); +
mm/rmap.c int try_to_unmap(struct page *page, int · line 877
Quoted 10 lines
mm/rmap.c +10
-0+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; +}
task_struct.mm can sometimes be NULL. This function assumes that it will never be NULL. That makes it a somewhat risky interface. Are we sure it can never be NULL?
Quoted 10 lines
mm/rmap.c +10
-0+/** +* 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). +*/
mm/rmap.c int try_to_unmap(struct page *page, int · line 898
Quoted 10 lines
mm/rmap.c +10
-0+ +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 ; +}
a) This is a poorly-chosen name for a globally-scoped function. There's no indication in its name that it is a swsusp thing.
b) It hurts my brain. "determine X and return false if it's true (!)", where "X" means "can it be included" whereas the name "page_to_copy" implies something seemingly unrelated - some semantic caller-defined consequence of X.
Shudder. Please try again.
Quoted 6 lines
+#endif /*
CONFIG_SOFTWARE_SUSPEND*/
Index:linux-2.6.17-rc3-mm1/include/linux/rmap.h
===================================================================
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 113
Quoted 10 lines
include/linux/rmap.h +7
-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
Please remove the ifdef here.
include/linux/rmap.h pte_t *page_check_address(struct page *,
Quoted 11 lines
include/linux/rmap.h +5
-2+++ linux-2.6.17-rc3-mm1/kernel/power/snapshot.c --- linux-2.6.17-rc3-mm1.orig/kernel/power/snapshot.c + +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 ;
Please avoid the multiple assignment. Kernel coding style is super-simple
- no tricksy stuff.
unsigned int n = 0; unsigned int m = 0;
See, if we put each declaration on its own line we get a little bit of room for a comment explaining what it does. Which is pretty much compulsory if one insists on using identifiers like m' and n'.
Quoted 1 line
for_each_zone(zone) {
Might as well remove the extranous space here.
Quoted 11 lines
include/linux/rmap.h +6
-2if (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 (!page_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; }
See, I think n' should be renamed to pages_to_copy'.
I don't know what m' should be renamed to, because that would require me to understand page_to_copy()', and I'm not smart enough for that.
Quoted 11 lines
/**
+ *protect_data_pages- move data pages that need to be protected from
+ * being reclaimed (ie. those included in the suspend image without
+ * copying) out of their respective LRU lists. This is done after the
+ * image has been created so the LRU lists only have to be restored if
+ * the suspend fails.
+ *
+ * This function is only called from the critical section, ie. when
+ * processes are frozen, there's only one CPU online and local IRQs
+ * are disabled on it.
+ */
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+ +static void protect_data_pages (struct pbe *pblist) +{ +struct pbe *p; + +for_each_pbe (p, pblist)
extraneous space.
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +2
-2-static int enough_free_mem (unsigned int nr_pages) +static int enough_free_mem (unsigned int nr_pages,unsigned int copy_pages) {struct zone *zone; -unsigned int n =0 ; +long n =0 ;
Suggest you rename `n' to something useful while you're there.
include/linux/rmap.h
Quoted 4 lines
include/linux/rmap.h +4
-0+pr_debug ("swsusp: pages needed: %u + %lu + %lu\n" , + copy_pages, + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE , +EXTRA_PAGES );
Use DIV_ROUND_UP() here.
Quoted 19 lines
include/linux/rmap.h +8
-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; +/* +* We're going to use atomic allocations, so we +* shouldn't count the lowmem reserves in the lower +* zones as available to us +*/ + n -= zone->lowmem_reserve[ZONE_NORMAL ]; + }
include/linux/rmap.h
Quoted 10 lines
include/linux/rmap.h +3
-6- for_each_pbe (p, pblist) { - p->address = (unsigned long )alloc_image_page (gfp_mask, safe_needed); -if (!p->address) -return -ENOMEM ; - } -return 0 ; +pr_debug ("swsusp: available memory: %ld pages\n" , n); +return n > (long )(copy_pages +EXTRA_PAGES + + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE );
DIV_ROUND_UP().
include/linux/rmap.h
Quoted 4 lines
asmlinkage int
swsusp_save(void)
{include/linux/rmap.h +1
-1-unsigned int nr_pages; +unsigned int nr_pages, copy_pages;
unsigned int nr_pages; unsigned int pages_to_copy;
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+#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
What is the significance of the ramdisk to the swsusp code? (Need commenting).
EXTRA_PAGES is not a well-chosen identifier. Please choose something within the swsusp "namespace", if there's such a thing.
kernel/power/swsusp.c int swsusp_shrink_memory(void) · line 180
Quoted 9 lines
===================================================================
kernel/power/swsusp.c +1
-1@@ -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 ;
unsigned int pages_to_save; unsigned int i = 0; /* Maybe a comment */
Quoted 16 lines
===================================================================
mm/vmscan.c +8
-1@@ -1437,7 +1437,68 @@ out:return ret; } -#endif + +static LIST_HEAD (saved_active_pages); +static LIST_HEAD (saved_inactive_pages); + +/** +* move_out_of_lru - software suspend includes some pages in the +* suspend snapshot image without copying and these pages should be +* procected from being reclaimed, which can be done by (temporarily)
mm/vmscan.c out: · line 1457
Quoted 10 lines
mm/vmscan.c +10
-0+* moving them out of their respective LRU lists +* +* It is to be called with local IRQs disabled. +*/ + +void move_out_of_lru (struct page *page) +{ +struct zone *zone =page_zone (page); + +spin_lock (&zone->lru_lock);
Normally we'd check that PageLRU() is still true after acquiring the lock.
Quoted 14 lines
mm/vmscan.c +14
-0+if (PageActive (page)) { +del_page_from_active_list (zone, page); +list_add (&page->lru, &saved_active_pages); + }else { +del_page_from_inactive_list (zone, page); +list_add (&page->lru, &saved_inactive_pages); + } +ClearPageLRU (page); +spin_unlock (&zone->lru_lock); +} + + +/** +* restore_active_inactive_lists - used by the software suspend to move
mm/vmscan.c out: · line 1481
Quoted 10 lines
mm/vmscan.c +10
-0+* the pages taken out of the LRU by take_page_out_of_lru() back to +* their respective active/inactive lists (if the suspend fails) +*/ + +void restore_active_inactive_lists (void ) +{ +struct page *page; +struct zone *zone; + +while (!list_empty (&saved_active_pages)) {
Add a space after `while'.
mm/vmscan.c out: · line 1491
Quoted 10 lines
mm/vmscan.c +10
-0+ page =lru_to_page (&saved_active_pages); + zone =page_zone (page); +list_del (&page->lru); +spin_lock_irq (&zone->lru_lock); +SetPageLRU (page); +add_page_to_active_list (zone, page); +spin_unlock_irq (&zone->lru_lock); + } + +while (!list_empty (&saved_inactive_pages)) {
Ditto.
mm/vmscan.c out: · line 1501
Quoted 10 lines
mm/vmscan.c +10
-0+ page =lru_to_page (&saved_inactive_pages); + zone =page_zone (page); +list_del (&page->lru); +spin_lock_irq (&zone->lru_lock); +SetPageLRU (page); +add_page_to_inactive_list (zone, page); + spin_unlock_irq(&zone->lru_lock); + } +} +#endif /* CONFIG_PM */
All the above code is inside CONFIG_PM, but afaik it's only used by CONFIG_SOFTWARE_SUSPEND.
Quoted 42 lines · you
Quoted 16 lines · Rafael J. Wysocki
Currently swsusp is only capable of creating suspend images that are not bigger than 1/2 of the normal zone, because it needs to create a copy of every page which should be included in the image. This may hurt the system responsiveness after resume, especially on systems with less that 1 GB of RAM.
To allow swsusp to create bigger images we can use the observation that if some pages don't change after the snapshot image of the system has been created and before the image is entirely saved, they can be included in the image without copying. Now if the mapped pages that are not mapped by the current task are considered, it turns out that they would change only if they were reclaimed by
try_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 5 lines
If these pages are included in the image without copying, the amount of free memory needed by swsusp is usually much less than otherwise, so the size of the image may be bigger. This also makes swsusp use less memory during suspend and saves us quite a lot of memory allocations and copyings.
I have a host of minor problems with this patch.
Quoted 17 lines
mm/rmap.c +14
-0+#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 ; + } +
Quoted 8 lines
mm/rmap.c int try_to_unmap(struct page *page, int · line 877
Quoted 4 lines
mm/rmap.c +4
-0+spin_unlock (&task->mm->page_table_lock); + +return ret; +}task_struct.mm can sometimes be NULL. This function assumes that it will never be NULL. That makes it a somewhat risky interface. Are we sure it can never be NULL?
Well, now it's only called for task == current, but I can add a check.
Quoted 24 lines
Quoted 10 lines
mm/rmap.c +10
-0+/** +* 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). +*/ mm/rmap.c int try_to_unmap(struct page *page, int · line 898
Quoted 10 lines
mm/rmap.c +10
-0+ +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 ; +}a) This is a poorly-chosen name for a globally-scoped function. There's no indication in its name that it is a swsusp thing.
Quoted 6 lines
b) It hurts my brain. "determine X and return false if it's true (!)", where "X" means "can it be included" whereas the name "
page_to_copy" implies something seemingly unrelated - some semantic caller-defined consequence of X.Shudder. Please try again.
OK (although it's not that easy ;-))
Quoted 9 lines
Quoted 9 lines
+#endif /*
CONFIG_SOFTWARE_SUSPEND*/
Index:linux-2.6.17-rc3-mm1/include/linux/rmap.h
===================================================================include/linux/rmap.h +0
-0@@ -104,6 +104,14 @@ pte_t *page_check_address(struct page *,*/ unsigned long page_address_in_vma (struct page *,struct vm_area_struct *);
Quoted 9 lines
include/linux/rmap.h pte_t *page_check_address(struct page *, · line 113
Quoted 7 lines
include/linux/rmap.h +7
-0+#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 Please remove the ifdef here.
OK
Quoted 10 lines
Quoted 10 lines
include/linux/rmap.h +4
-2+++ linux-2.6.17-rc3-mm1/kernel/power/snapshot.c --- linux-2.6.17-rc3-mm1.orig/kernel/power/snapshot.c + +unsigned int count_data_pages (unsigned int *total) {struct zone *zone;unsigned long zone_pfn; -unsigned int n =0 ; +unsigned int n, m;
Quoted 4 lines
include/linux/rmap.h
Quoted 1 line
include/linux/rmap.h +1
-0+ n = m =0 ;Please avoid the multiple assignment. Kernel coding style is super-simple
- no tricksy stuff.
OK
Quoted 7 lines
unsigned int n = 0; unsigned int m = 0;See, if we put each declaration on its own line we get a little bit of room for a comment explaining what it does. Which is pretty much compulsory if one insists on using identifiers like
m' andn'.
OK, I'll change the names.
Quoted 4 lines
Quoted 2 lines
for_each_zone(zone) {Might as well remove the extranous space here.
OK
Quoted 15 lines
Quoted 15 lines
include/linux/rmap.h +9
-2if (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 (!page_to_copy (pfn_to_page (pfn))) + m++; + } + } }
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +4
-1-return n; +if (total) + *total = n; + +return n - m; }See, I think
n' should be renamed topages_to_copy'.
Actually 'n' is the total number of data pages, and (n - m) is the number of pages to copy ...
Quoted 2 lines
I don't know what
m' should be renamed to, because that would require me to understandpage_to_copy()', and I'm not smart enough for that.
... so 'm' is the number of pages we don't want to be copied. :-)
Quoted 11 lines
Quoted 11 lines
/**
+ *protect_data_pages- move data pages that need to be protected from
+ * being reclaimed (ie. those included in the suspend image without
+ * copying) out of their respective LRU lists. This is done after the
+ * image has been created so the LRU lists only have to be restored if
+ * the suspend fails.
+ *
+ * This function is only called from the critical section, ie. when
+ * processes are frozen, there's only one CPU online and local IRQs
+ * are disabled on it.
+ */
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+ +static void protect_data_pages (struct pbe *pblist) +{ +struct pbe *p; + +for_each_pbe (p, pblist)extraneous space.
Will fix.
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +2
-2-static int enough_free_mem (unsigned int nr_pages) +static int enough_free_mem (unsigned int nr_pages,unsigned int copy_pages) {struct zone *zone; -unsigned int n =0 ; +long n =0 ;Suggest you rename `n' to something useful while you're there.
OK
Quoted 6 lines
include/linux/rmap.h
Quoted 4 lines
include/linux/rmap.h +4
-0+pr_debug ("swsusp: pages needed: %u + %lu + %lu\n" , + copy_pages, + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE , +EXTRA_PAGES );Use
DIV_ROUND_UP()here.
OK
Quoted 20 lines
Quoted 20 lines
include/linux/rmap.h +8
-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; +/* +* We're going to use atomic allocations, so we +* shouldn't count the lowmem reserves in the lower +* zones as available to us +*/ + n -= zone->lowmem_reserve[ZONE_NORMAL ]; + }
Quoted 11 lines
include/linux/rmap.h
Quoted 9 lines
include/linux/rmap.h +3
-6- for_each_pbe (p, pblist) { - p->address = (unsigned long )alloc_image_page (gfp_mask, safe_needed); -if (!p->address) -return -ENOMEM ; - } -return 0 ; +pr_debug ("swsusp: available memory: %ld pages\n" , n); +return n > (long )(copy_pages +EXTRA_PAGES + + (nr_pages +PBES_PER_PAGE -1 ) /PBES_PER_PAGE );
DIV_ROUND_UP().
OK
Quoted 7 lines
include/linux/rmap.h
Quoted 4 lines
asmlinkage int
swsusp_save(void)
{include/linux/rmap.h +1
-1-unsigned int nr_pages; +unsigned int nr_pages, copy_pages;unsigned int nr_pages; unsigned int pages_to_copy;
OK
Quoted 8 lines
include/linux/rmap.h
Quoted 6 lines
include/linux/rmap.h +6
-0+#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 What is the significance of the ramdisk to the swsusp code? (Need commenting).
Well, yes. If the userland suspend is used, it needs the extra space for itself and the initrd on resume (I'll add a comment).
Quoted 2 lines
EXTRA_PAGESis not a well-chosen identifier. Please choose something within the swsusp "namespace", if there's such a thing.
Unfortunately there's not any, but I'll try to invent a better name. :-)
Quoted 33 lines
kernel/power/swsusp.c int swsusp_shrink_memory(void) · line 180
Quoted 9 lines
===================================================================
kernel/power/swsusp.c +1
-1@@ -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 ;unsigned int pages_to_save; unsigned int i = 0; /* Maybe a comment */Quoted 20 lines
===================================================================
mm/vmscan.c +12
-1@@ -1437,7 +1437,68 @@ out:return ret; } -#endif + +static LIST_HEAD (saved_active_pages); +static LIST_HEAD (saved_inactive_pages); + +/** +* move_out_of_lru - software suspend includes some pages in the +* suspend snapshot image without copying and these pages should be +* procected from being reclaimed, which can be done by (temporarily) +* moving them out of their respective LRU lists +* +* It is to be called with local IRQs disabled. +*/
Quoted 8 lines
mm/vmscan.c out: · line 1457
Quoted 6 lines
mm/vmscan.c +6
-0+ +void move_out_of_lru (struct page *page) +{ +struct zone *zone =page_zone (page); + +spin_lock (&zone->lru_lock);Normally we'd check that
PageLRU()is still true after acquiring the lock.
OK
Quoted 18 lines
Quoted 18 lines
mm/vmscan.c +18
-0+if (PageActive (page)) { +del_page_from_active_list (zone, page); +list_add (&page->lru, &saved_active_pages); + }else { +del_page_from_inactive_list (zone, page); +list_add (&page->lru, &saved_inactive_pages); + } +ClearPageLRU (page); +spin_unlock (&zone->lru_lock); +} + + +/** +* restore_active_inactive_lists - used by the software suspend to move +* the pages taken out of the LRU by take_page_out_of_lru() back to +* their respective active/inactive lists (if the suspend fails) +*/ +
Quoted 8 lines
mm/vmscan.c out: · line 1481
Quoted 6 lines
mm/vmscan.c +6
-0+void restore_active_inactive_lists (void ) +{ +struct page *page; +struct zone *zone; + +while (!list_empty (&saved_active_pages)) {Add a space after `while'.
OK
Quoted 4 lines
Quoted 4 lines
mm/vmscan.c +4
-0+ page =lru_to_page (&saved_active_pages); + zone =page_zone (page); +list_del (&page->lru); +spin_lock_irq (&zone->lru_lock);
Quoted 8 lines
mm/vmscan.c out: · line 1491
Quoted 6 lines
mm/vmscan.c +6
-0+SetPageLRU (page); +add_page_to_active_list (zone, page); +spin_unlock_irq (&zone->lru_lock); + } + +while (!list_empty (&saved_inactive_pages)) {Ditto.
OK
Quoted 5 lines
Quoted 5 lines
mm/vmscan.c +5
-0+ page =lru_to_page (&saved_inactive_pages); + zone =page_zone (page); +list_del (&page->lru); +spin_lock_irq (&zone->lru_lock); +SetPageLRU (page);
Quoted 8 lines
mm/vmscan.c out: · line 1501
Quoted 5 lines
mm/vmscan.c +5
-0+add_page_to_inactive_list (zone, page); + spin_unlock_irq(&zone->lru_lock); + } +} +#endif /* CONFIG_PM */ All the above code is inside
CONFIG_PM, but afaik it's only used byCONFIG_SOFTWARE_SUSPEND.
Yes, but CONFIG_PM has been used here for quite some time and I wanted to change that in a separate patch, along with some header clean-ups. Still I can do it in this patch if that's better.
Thanks for the comments. I'll do my best to fix all of the issues in the next version.
Greetings,
Rafael
Hi!
Quoted 5 lines
Quoted 2 lines
EXTRA_PAGESis not a well-chosen identifier. Please choose something within the swsusp "namespace", if there's such a thing.Unfortunately there's not any, but I'll try to invent a better name. :-)
PM_EXTRA_PAGES would probably be acceptable, as would SUSPEND_EXTRA_PAGES be...
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Hi,
Quoted 10 lines · Pavel Machek
Hi!
Quoted 5 lines
Quoted 2 lines
EXTRA_PAGESis not a well-chosen identifier. Please choose something within the swsusp "namespace", if there's such a thing.Unfortunately there's not any, but I'll try to invent a better name. :-)
PM_EXTRA_PAGESwould probably be acceptable, as wouldSUSPEND_EXTRA_PAGESbe...
Thanks, SUSPEND_EXTRA_PAGES sounds better to me.
Greetings,
Rafael
PATCH 1/1 swsusp: support creating bigger images (rev. 2)
In reply to Rafael J. WysockiQuoted 2 lines · Rafael J. Wysocki
Quoted 1 line · you
"Rafael J. Wysocki" <[email protected]> wrote:
}-- snip --{
Quoted 3 lines
Thanks for the comments. I'll do my best to fix all of the issues in the next version.
Corrected patch follows.
---
Currently swsusp is only capable of creating suspend images that are not bigger than 1/2 of the normal zone, because it needs to create a copy of every page which should be included in the image. This may hurt the system responsiveness after resume, especially on systems with less that 1 GB of RAM.
To allow swsusp to create bigger images we can use the observation that if some pages don't change after the snapshot image of the system has been created and before the image is entirely saved, they can be included in the image without copying. Now if the mapped pages that are not mapped by the current task are considered, it turns out that they would change only if they were reclaimed by try_to_free_pages(). Thus if we take them out of reach of try_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
If these pages are included in the image without copying, the amount of free memory needed by swsusp is usually much less than otherwise, so the size of the image may be bigger. This also makes swsusp use less memory during suspend and saves us quite a lot of memory allocations and copyings.
--- include/linux/rmap.h | 6 + include/linux/swap.h | 4 kernel/power/power.h | 14 ++ kernel/power/snapshot.c | 230 +++++++++++++++++++++++++++++++++--------------- kernel/power/swsusp.c | 16 +-- kernel/power/user.c | 2 mm/rmap.c | 44 +++++++++ mm/vmscan.c | 68 +++++++++++++- 8 files changed, 306 insertions(+), 78 deletions(-)
mm/rmap.c +44 -0
@@ -857,3 +857,47 @@ 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 ; + +if (!task) +return 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; +} + +/** +* suspend_safe_page - determine if a page can be included in the +* suspend image without copying (returns true if so). +* +* 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 suspend_safe_page (struct page *page) +{ +if (!PageLRU (page) ||PageCompound (page)) +return 0 ; + +if (page_mapped (page)) +return !page_mapped_by_task (page, current); + +return 0 ; +} +#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 *); +/* +* Used to determine if the page can be included in the suspend image without +* copying +*/ +int suspend_safe_page (struct page *); +#else /* !CONFIG_MMU */ #define anon_vma_init () do {} while (0)
kernel/power/snapshot.c +162 -68
402 lines not on this page · raw message
kernel/power/power.h +13 -1
@@ -48,7 +48,18 @@ 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 the userland suspend is used, some extra space will be needed during +* resume for the initrd, the resume binary and its data +*/ +#if (defined(CONFIG_BLK_DEV_INITRD ) && defined(CONFIG_BLK_DEV_RAM )) +#define SUSPEND_EXTRA_PAGES (PAGES_FOR_IO + \ + (2 * CONFIG_BLK_DEV_RAM_SIZE * 1024) / PAGE_SIZE) +#else +#define SUSPEND_EXTRA_PAGES PAGES_FOR_IO +#endif + +extern unsigned int count_data_pages (unsigned int *total);struct snapshot_handle {loff_t offset;
@@ -111,6 +122,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 +9 -7
@@ -177,28 +177,30 @@ int swsusp_shrink_memory(void)long size, tmp;struct zone *zone;unsigned long pages =0 ; -unsigned int i =0 ; +unsigned int pages_to_save; +unsigned int i =0 ;/* for the progress meter */ 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(&pages_to_save); + size += DIV_ROUND_UP(pages_to_save, PBES_PER_PAGE) + + SUSPEND_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 = pages_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 +263,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 +2 -0
@@ -153,6 +153,8 @@ static int snapshot_ioctl(struct inode *case SNAPSHOT_UNFREEZE :if (!data->frozen)break ; +if (data->ready) +swsusp_free ();down (&pm_sem);thaw_processes ();enable_nonboot_cpus ();
mm/vmscan.c +67 -1
74 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 *); +extern void restore_active_inactive_lists (void );extern int vm_swappiness;extern int remove_mapping (struct address_space *mapping,struct page *page);
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets, schedule_work(), etc, etc.
So... could we check your homework on this please? How come only page reclaim can disturb these pages?
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.
AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen. Theoretically we may have a problem if there's an interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)]
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 11 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)]
hm. It's all a bit of a worry. I don't understand what swsusp is trying to do here sufficiently well to be able to advise, sorry. I was rather surprised to learn that it's presently taking copies of all these pages...
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hi Andrew et al.
Quoted 19 lines · Andrew Morton
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change
only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
Quoted 6 lines
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
Quoted 6 lines
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
Bdev freezing helps here too, right?
Quoted 6 lines
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)]
(For Rafael/Pavel): The swsusp version of the refrigerator signals these processes to enter the freezer too, just in case the uninterruptible task does continue, right?
Regards,
Nigel
Quoted 8 lines
hm. It's all a bit of a worry. I don't understand what swsusp is trying to do here sufficiently well to be able to advise, sorry. I was rather surprised to learn that it's presently taking copies of all these pages... -
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hi,
Quoted 33 lines · Nigel Cunningham
Hi Andrew et al.
Quoted 19 lines · Andrew Morton
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change
only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
Quoted 6 lines
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
Quoted 8 lines
Quoted 6 lines
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
Bdev freezing helps here too, right?
Well, I'm not sure. How exactly?
Quoted 10 lines
Quoted 6 lines
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)](For Rafael/Pavel): The swsusp version of the refrigerator signals these processes to enter the freezer too, just in case the uninterruptible task does continue, right?
Uninterruptible tasks are not freezable with the swsusp's freezer at all. The other tasks are signaled to enter the refrigerator - first user space, then we sync filesystems and finally we freeze kernel threads.
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hello.
Quoted 46 lines · Rafael J. Wysocki
Hi,
Quoted 43 lines · Nigel Cunningham
Hi Andrew et al.
Quoted 20 lines · Andrew Morton
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change
only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 8 lines
Quoted 5 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
Quoted 6 lines
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
Quoted 7 lines
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
Quoted 3 lines
Quoted 1 line
Bdev freezing helps here too, right?
Well, I'm not sure. How exactly?
I believe it will ensure that both operations will be completed and the waiter woken.
Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)]
Quoted 7 lines
Quoted 3 lines
(For Rafael/Pavel): The swsusp version of the refrigerator signals these processes to enter the freezer too, just in case the uninterruptible task does continue, right?
Uninterruptible tasks are not freezable with the swsusp's freezer at all. The other tasks are signaled to enter the refrigerator - first user space, then we sync filesystems and finally we freeze kernel threads.
Oooh. It would probably be good if you signalled them to enter the freezer, just in case, and had the freezer code handle a process entering the path when we no longer want to freeze.
Regards,
Nigel
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 9 lines · Nigel Cunningham
Quoted 8 lines · Rafael J. Wysocki
Quoted 7 lines · Nigel Cunningham
Quoted 6 lines · Andrew Morton
Quoted 1 line · Rafael J. Wysocki
On Wednesday 10 May 2006 00:27, Andrew Morton wrote:
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
[just came across this, missed it before, sorry]
The above is correct - sync means get current state safe ondisk, it doesn't mean flush all dirty metadata to its final resting place (subtle difference). XFS will flush and wait on its journal on sync, which means theres a reconstructable state for all of the currently-incore-dirty-metadata ondisk, so it does not also flush and wait on that currently-incore-dirty-metadata. It doesn't need to, it has already ensured thats written elsewhere on disk, in the journal. And should the unthinkable happen, that metadata will be correctly recovered on the next mount when the journal is replayed.
Block device freeze, unmount and/or remount,ro will all ensure that all incore-dirty-metadata is also flushed and waited on.
cheers.
Signature · 1 line
Nathan
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hi!
Quoted 31 lines · Nathan Scott
Quoted 9 lines · Nigel Cunningham
Quoted 8 lines · Rafael J. Wysocki
Quoted 7 lines · Nigel Cunningham
Quoted 6 lines · Andrew Morton
Quoted 1 line · Rafael J. Wysocki
On Wednesday 10 May 2006 00:27, Andrew Morton wrote:
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
[just came across this, missed it before, sorry]
The above is correct - sync means get current state safe ondisk, it doesn't mean flush all dirty metadata to its final resting place (subtle difference). XFS will flush and wait on its journal on sync, which means theres a reconstructable state for all of the currently-incore-dirty-metadata ondisk, so it does not also flush and wait on that currently-incore-dirty-metadata. It doesn't need to, it has already ensured thats written elsewhere on disk, in the journal. And should the unthinkable happen, that metadata will be correctly recovered on the next mount when the journal is replayed.
Quoted 2 lines
Block device freeze, unmount and/or remount,ro will all ensure that all incore-dirty-metadata is also flushed and waited on.
Who does the background writing? I'd prefer not to do blockdev freezing in swsusp (and we do not currently do it).
Simple fix is probably to put proper refrigerator support into that particular background writing thread.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
In reply to Nigel CunninghamHi,
Sorry for the slow response, I've had a lot of work to do recently.
Quoted 26 lines · Nigel Cunningham
Quoted 25 lines · Rafael J. Wysocki
Quoted 24 lines · Nigel Cunningham
Quoted 23 lines · Andrew Morton
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change
only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 8 lines
Quoted 5 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
I believe more than a sync is needed in at least some cases. I've seen XFS continue to submit I/O (presumably on the sb or such like) after everything else has been frozen and data has been synced. Freezing bdevs addressed this.
Do you know any other examples?
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
In this particular case we are saved by the fact that the snapshotted kernel memory reflects the state from before the operation, so the kernel will perform it again after resume. However if the suspend failed we'd add the freed page to the LRU which would be a mistake (I think it might be prevented by checking the page's refcount before putting in back on the LRU).
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
Bdev freezing helps here too, right?
Well, I'm not sure. How exactly?
I believe it will ensure that both operations will be completed and the waiter woken.
We're talking about the situation in which no one waits on the I/O that's completed asynchronously in interrupt context.
I assume that the freezing of bdevs makes this impossible with respect to filesystems, but there are other types of I/O, like the networking, which are independent of that. Also, if someone uses a block device or a partition directly, will the freezing of bdevs save us?
Quoted 11 lines
Quoted 11 lines
Quoted 10 lines
Quoted 6 lines
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)](For Rafael/Pavel): The swsusp version of the refrigerator signals these processes to enter the freezer too, just in case the uninterruptible task does continue, right?
Quoted 7 lines
Quoted 3 lines
Uninterruptible tasks are not freezable with the swsusp's freezer at all. The other tasks are signaled to enter the refrigerator - first user space, then we sync filesystems and finally we freeze kernel threads.
Oooh. It would probably be good if you signalled them to enter the freezer, just in case, and had the freezer code handle a process entering the path when we no longer want to freeze.
Could you please explain why you think so? We just fail the suspend if there still are any uninterruptible tasks after the timeout, so I don't see the reason why these tasks should enter the refrigerator.
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
In reply to Andrew MortonQuoted 27 lines · Andrew Morton
Quoted 11 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible tasks cannot be frozen.
There can be situations where we won't be waiting on this IO at all. Network zero-copy transmit, for example.
Or maybe there's some async writeback going on against pagecache - we'll end up looking at the page's LRU state within interrupt context at IO completion. (A sync would prevent this from happening).
Quoted 6 lines
One possibly problematic scenario is where task A is doing a direct-IO read and task B truncates the same file - here, the page will be actually removed from the LRU and freed in interrupt context. The direct-IO read process will be waiting on the IO in D state though. It it was a synchronous read - if it was an AIO read then it won't be waiting on the IO. Something else might save us here, but it's fragile.
Yes, that's one situation to be considered in detail (which I evidently failed to do :-().
I think the problem is whether any modification agains these pages can be triggered from interrupt context _after_ we have snapshotted the system and resumed devices (in order to write the image).
Quoted 10 lines
Quoted 6 lines
Theoretically we may have a problem if there's an
interruptible task that waits for the completion of an operation that gets finished after snapshotting the system. However that would have to survive the syncing of filesystems, freezing of kernel threads, freeing of memory as well as suspending and resuming all devices. [In which case it would be starving to death. :-)]hm. It's all a bit of a worry. I don't understand what swsusp is trying to do here sufficiently well to be able to advise, sorry. I was rather surprised to learn that it's presently taking copies of all these pages...
Well, I'm trying to avoid copying every single page in the system in the process of creating the snapshot image. The idea behind the patch was to select a susbset of pages that could be safely included in the image without copying and such that we could identify them easily. [The LRU pages obviously come to mind here.]
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
In reply to Rafael J. WysockiQuoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.
Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible
Well, "many of these things" makes me nervous.
Quoted 3 lines
tasks cannot be frozen. Theoretically we may have a problem if there's an interruptible task that waits for the completion of an operation that gets finished after snapshotting the system.
I'd prefer not to have even theoretical problems. If we don't _know_ why patch is safe, I'd prefer not to have it.
Needing bdev freezing is bad sign, too.
We are talking 10% speedup here (on low-mem-machines, IIRC), but whole design has just got way more complex. Previous snapshot was really atomic, and apart from NMI, it was "independend" from the rest of the system.
New design depends on bdev freezing (depending on XFS details we do not understand), and depends on all the other parts of kernel using uninteruptible (when we know that networking sleeps interruptibly).
Too much uncertainity for 10% speedup, I'm afraid. Yes, it was really clever to get this fundamental change down to few hundred lines, but design complexity remains. Could we drop that patch?
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 19 lines · Pavel Machek
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible
Quoted 8 lines
Well, "many of these things" makes me nervous.
Quoted 3 lines
tasks cannot be frozen. Theoretically we may have a problem if there's an interruptible task that waits for the completion of an operation that gets finished after snapshotting the system.
I'd prefer not to have even theoretical problems. If we don't _know_ why patch is safe, I'd prefer not to have it.
OK (still I think I'll be able to provide some more precise arguments for it, but I'll need some more time).
Quoted 1 line
Needing bdev freezing is bad sign, too.
Well, acutually we should understand why it helps I think, which makes it interesting anyway, because in theory even without the patch we may be vulnerable to a leftover "completion" that causes data to be written to a storage.
Quoted 11 lines
We are talking 10% speedup here (on low-mem-machines, IIRC), but whole design has just got way more complex. Previous snapshot was really atomic, and apart from NMI, it was "independend" from the rest of the system.
New design depends on bdev freezing (depending on XFS details we do not understand), and depends on all the other parts of kernel using uninteruptible (when we know that networking sleeps interruptibly).
Too much uncertainity for 10% speedup, I'm afraid. Yes, it was really clever to get this fundamental change down to few hundred lines,
:-)
Quoted 1 line
but design complexity remains. Could we drop that patch?
Yes, Andrew please drop it.
[Nonetheless I'd appreciate it if someone could suggest a specific failing scenario to me.]
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
In reply to Pavel MachekHi.
Quoted 35 lines · Pavel Machek
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Andrew Morton
Quoted 7 lines · Rafael J. Wysocki
Now if the mapped pages that are not mapped by the
current task are considered, it turns out that they would change
only if they were reclaimed bytry_to_free_pages(). Thus if we take them out of reach oftry_to_free_pages(), for example by (temporarily) moving them out of their respective LRU lists after creating the image, we will be able to include them in the image without copying.Quoted 7 lines
Quoted 4 lines
I'm a bit curious about how this is true. There are all sorts of way in which there could be activity against these pages - interrupt-time asynchronous network Tx completion, async interrupt-time direct-io completion, tasklets,
schedule_work(), etc, etc.AFAIK, many of these things are waited for uninterruptibly, and uninterruptible
Well, "many of these things" makes me nervous.
Quoted 3 lines
tasks cannot be frozen. Theoretically we may have a problem if there's an interruptible task that waits for the completion of an operation that gets finished after snapshotting the system.
I'd prefer not to have even theoretical problems. If we don't _know_ why patch is safe, I'd prefer not to have it.
Needing bdev freezing is bad sign, too.
We are talking 10% speedup here (on low-mem-machines, IIRC), but whole design has just got way more complex. Previous snapshot was really atomic, and apart from NMI, it was "independend" from the rest of the system.
Quoted 7 lines
New design depends on bdev freezing (depending on XFS details we do not understand), and depends on all the other parts of kernel using uninteruptible (when we know that networking sleeps interruptibly).
Too much uncertainity for 10% speedup, I'm afraid. Yes, it was really clever to get this fundamental change down to few hundred lines, but design complexity remains. Could we drop that patch?
Could you provide justification for your claim that the speedup is only 10%?
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Regards,
Nigel
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 6 lines
Quoted 3 lines
Too much uncertainity for 10% speedup, I'm afraid. Yes, it was really clever to get this fundamental change down to few hundred lines, but design complexity remains. Could we drop that patch?
Could you provide justification for your claim that the speedup is only 10%?
10% was number Rafael provided, IIRC.
Quoted 3 lines
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Well, swap prefetching is useful for other workloads, too; so it gets developed/tested outside swsusp.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hi,
Sorry for the slow response, I've had a lot of work to do recently.
Quoted 3 lines · Pavel Machek
Quoted 3 lines
Quoted 3 lines
Too much uncertainity for 10% speedup, I'm afraid. Yes, it was really clever to get this fundamental change down to few hundred lines, but design complexity remains. Could we drop that patch?
I think the main problem with the patch was that the criterion by which the pages were included in the image without copying appeared to be too simple and therefore too general. It well might be correct, but that's yet to be shown. OTOH it probably is possible to use a criterion that everybody will agree with. For example, we could chose pages that would be reclaimed if there were memory pressure (the pages with I/O operations pending should not belong to this class).
Quoted 4 lines
Quoted 2 lines
Could you provide justification for your claim that the speedup is only 10%?
10% was number Rafael provided, IIRC.
That's true, but I only measured the short-time effect of the suspend on the system responsiveness.
Apart from this without the patch swsusp tends to leave quite o lot of data in the swap and IMO this effect should not be neglected. Currently we only have a very general idea about what these data are and why it happens actually and there's no warranty it wouldn't hamper performance in the long run.
Quoted 6 lines
Quoted 3 lines
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Well, swap prefetching is useful for other workloads, too; so it gets developed/tested outside swsusp.
Still my experience indicates that it doesn't play very nice with swsusp and unfortunately it hogs the I/O.
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 11 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 4 lines
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Well, swap prefetching is useful for other workloads, too; so it gets developed/tested outside swsusp.
Still my experience indicates that it doesn't play very nice with swsusp and unfortunately it hogs the I/O.
There is no swap prefetching code linked in any way to swsusp suspend or resume on mainline or -mm. It was a preliminary experiment and Rafael lost interest in it so I never bothered pursuing it.
Signature · 1 line
-ck
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Hi,
Quoted 10 lines · Con Kolivas
Quoted 9 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 4 lines
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Well, swap prefetching is useful for other workloads, too; so it gets developed/tested outside swsusp.
Quoted 6 lines
Quoted 2 lines
Still my experience indicates that it doesn't play very nice with swsusp and unfortunately it hogs the I/O.
There is no swap prefetching code linked in any way to swsusp suspend or resume on mainline or -mm. It was a preliminary experiment and Rafael lost interest in it so I never bothered pursuing it.
I'm referring to the code currently in -mm, where kprefetchd sometimes starts prefetching like mad after resume which hurts the disk I/O really badly (unless I set /proc/sys/vm/swap_prefetch to 0, that is).
I think the problem is related to the fact that swsusp tends to leave quite a lot of pages in the swap, if they had to be swapped out before suspend, and that makes kprefetchd believe it should get these pages back into RAM, which usually is not the greatest idea.
The above is only a speculation, however, and I'd have to investigate it a bit more to say something more certain. Anyway, my experience indicates that it usually is better to set /proc/sys/vm/swap_prefetch to 0 after resume, but YMMV.
Greetings,
Rafael
Re: [PATCH -mm] swsusp: support creating bigger images (rev. 2)
Quoted 16 lines · Rafael J. Wysocki
Hi,
Quoted 13 lines · Con Kolivas
Quoted 11 lines · Rafael J. Wysocki
Quoted 7 lines · Pavel Machek
Quoted 4 lines
Please also remember that you are introducing complexity in other ways, with that swap prefetching code and so on. Any comparison in speed should include the time to fault back in pages that have been discarded.
Well, swap prefetching is useful for other workloads, too; so it gets developed/tested outside swsusp.
Still my experience indicates that it doesn't play very nice with swsusp and unfortunately it hogs the I/O.
Quoted 7 lines
Quoted 3 lines
There is no swap prefetching code linked in any way to swsusp suspend or resume on mainline or -mm. It was a preliminary experiment and Rafael lost interest in it so I never bothered pursuing it.
I'm referring to the code currently in -mm, where kprefetchd sometimes starts prefetching like mad after resume which hurts the disk I/O really badly (unless I set
/proc/sys/vm/swap_prefetchto 0, that is).
Not my experience. It does lots of disk I/O after resume because as you say yourself there is heaps in swap, but I haven't seen that I/O hurt as it simply stops the instant I do anything with the machine even as trivial as moving the mouse.
Quoted 9 lines
I think the problem is related to the fact that swsusp tends to leave quite a lot of pages in the swap, if they had to be swapped out before suspend, and that makes kprefetchd believe it should get these pages back into RAM, which usually is not the greatest idea.
The above is only a speculation, however, and I'd have to investigate it a bit more to say something more certain. Anyway, my experience indicates that it usually is better to set
/proc/sys/vm/swap_prefetchto 0 after resume, but YMMV.
My mileage definitely varies here. I don't concentrate on examining the fact that the machine is doing any I/O, but how usable the machine is and it's my experience that it is much better as about 1/3 of my applications are not floundering entirely on swap. Fortunately there's a tunable there and it allows you to set and unset it how you see fit.
Anyway the original point of my response was to point out to Nigel that there is no added complexity on behalf of swsusp in the swap prefetch code.
Signature · 1 line
-ck
Quoted 31 lines · Rafael J. Wysocki
Quoted 21 lines · Andrew Morton
"Rafael J. Wysocki" <[email protected]> wrote:
I have a host of minor problems with this patch.
Quoted 17 lines
mm/rmap.c +14
-0+#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 ; + } +Quoted 8 lines
mm/rmap.c int try_to_unmap(struct page *page, int · line 877
Quoted 4 lines
mm/rmap.c +4
-0+spin_unlock (&task->mm->page_table_lock); + +return ret; +}task_struct.mm can sometimes be NULL. This function assumes that it will never be NULL. That makes it a somewhat risky interface. Are we sure it can never be NULL?
Quoted 1 line
Well, now it's only called for task == current, but I can add a check.
Better fold it into the (renamed and recommented) page_to_copy, applying only to current.
The "use" of page_table_lock there is totally bogus. Normally you need down_read(¤t->mm->mmap_sem) to walk that vma chain; but I'm guessing you have everything sufficiently frozen here that you don't need that.
But if it is sufficiently frozen, I'm puzzled as to why pages mapped into the current process are (potentially) unsafe, while those mapped into others are safe. If the current process can get back to messing with its mapped pages, what if it maps a page you earlier judged safe?
Hugh
Quoted 12 lines · Hugh Dickins
Quoted 9 lines · Rafael J. Wysocki
Quoted 4 lines · Andrew Morton
task_struct.mm can sometimes be NULL. This function assumes that it will never be NULL. That makes it a somewhat risky interface. Are we sure it can never be NULL?
Well, now it's only called for task == current, but I can add a check.
Quoted 8 lines
Better fold it into the (renamed and recommented)
page_to_copy, applying only to current.The "use" of
page_table_lockthere is totally bogus. Normally you needdown_read(¤t->mm->mmap_sem)to walk that vma chain; but I'm guessing you have everything sufficiently frozen here that you don't need that.
I have to admit that I suggested making this change, because the function was sufficently generic looking. I guess the mm == NULL case should logically return 0... unless you did that, making page_mapped_by_task use current still leaves the burden of ensuring ->mm != NULL on the caller.
But I don't much mind which way the consensus goes.
---
Send instant messages to your online friends http://au.messenger.yahoo.com
Quoted 34 lines · Hugh Dickins
Quoted 31 lines · Rafael J. Wysocki
Quoted 21 lines · Andrew Morton
"Rafael J. Wysocki" <[email protected]> wrote:
I have a host of minor problems with this patch.
Quoted 17 lines
mm/rmap.c +14
-0+#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 ; + } +Quoted 8 lines
mm/rmap.c
Quoted 4 lines
mm/rmap.c +4
-0+spin_unlock (&task->mm->page_table_lock); + +return ret; +}task_struct.mm can sometimes be NULL. This function assumes that it will never be NULL. That makes it a somewhat risky interface. Are we sure it can never be NULL?
Quoted 1 line
Well, now it's only called for task == current, but I can add a check.
Quoted 7 lines
Better fold it into the (renamed and recommented)
page_to_copy, applying only to current.The "use" of
page_table_lockthere is totally bogus. Normally you needdown_read(¤t->mm->mmap_sem)to walk that vma chain; but I'm guessing you have everything sufficiently frozen here that you don't need that.
So I think it can be changed into something like this:
mm/rmap.c +35 -0
@@ -857,3 +857,38 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +/** +* suspend_safe_page - determine if a page can be included in the +* suspend image without copying (returns true if so). +* +* 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 suspend_safe_page (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +if (!PageLRU (page) ||PageCompound (page)) +return 0 ; + +if (page_mapped (page)) { + ret =1 ; +down_read (¤t->mm->mmap_sem); +/* Return 0 if the page is mapped by the current task */ +for (vma = current->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =0 ; +break ; + } +up_read (¤t->mm->mmap_sem); + } + +return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
I've left the locking, because the functions is called when we're freeing memory and I'm not 100% sure it's safe to drop it.
Quoted 4 lines
But if it is sufficiently frozen, I'm puzzled as to why pages mapped into the current process are (potentially) unsafe, while those mapped into others are safe. If the current process can get back to messing with its mapped pages, what if it maps a page you earlier judged safe?
The current task is forbidden to map anything at this point.
Greetings,
Rafael
mm/rmap.c int try_to_unmap(struct page *page, int · line 862
Quoted 11 lines · Rafael J. Wysocki
On Tuesday 09 May 2006 14:30, Hugh Dickins wrote:
mm/rmap.c +3
-0@@ -857,3 +857,38 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +/** +* suspend_safe_page - determine if a page can be included in the
suspend_safe_page sounds like it's suspending a safe page, and safe is unclear: suspend_knows_page_is_frozen?
mm/rmap.c int try_to_unmap(struct page *page, int · line 866
Quoted 4 lines
mm/rmap.c +4
-0+* suspend image without copying (returns true if so). +* +* 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
That's not quite what the code checks:
(b) it's mapped but not by the the current task
(Actually, page_address_in_vma doesn't really say whether the page is mapped by the task, but -EFAULT does tell you that it can't be.)
I still find its checks very obscure: am I right to think that most pages are "frozen" at this point, that it's very hard to determine which are and which are not, but there happens to be this "little" category of pages which you can be damn sure are frozen - and on most active systems, this "little" category actually covers a large number of pages which it's well worth avoiding copying?
A very loose heuristic which works well enough to make a big difference.
Quoted 29 lines
mm/rmap.c +28
-0+* (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 suspend_safe_page (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +if (!PageLRU (page) ||PageCompound (page)) +return 0 ; + +if (page_mapped (page)) { + ret =1 ; +down_read (¤t->mm->mmap_sem); +/* Return 0 if the page is mapped by the current task */ +for (vma = current->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =0 ; +break ; + } +up_read (¤t->mm->mmap_sem); + } + +return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
Quoted 2 lines
I've left the locking, because the functions is called when we're freeing memory and I'm not 100% sure it's safe to drop it.
If the locking is necessary, then that down_read is liable to schedule and wait for mmap_sem to be released. But you have interrupts disabled? And everything which might release mmap_sem already frozen? My guess is that it's a lot safer _not_ to lock here than to lock; but just how safe that is I'm not at all sure.
Quoted 6 lines
Quoted 4 lines
But if it is sufficiently frozen, I'm puzzled as to why pages mapped into the current process are (potentially) unsafe, while those mapped into others are safe. If the current process can get back to messing with its mapped pages, what if it maps a page you earlier judged safe?
The current task is forbidden to map anything at this point.
Too bald a statement for me to judge (and by forbidden to map, do you mean forbidden to mmap, or forbidden to fault?).
Perhaps I'd understand better if you explain why pages mapped into the current task have to be excluded? It just seems to me that if it can interfere with those pages, then it is liable to interfere with other pages too, including some mapped into other processes which you've already judged to be safe/frozen.
Sorry if I'm wasting your time, forcing you to spell things out to someone who hasn't a clue what you're up to; but it all smells a little fishy to me.
Hugh
Quoted 27 lines · Hugh Dickins
mm/rmap.c int try_to_unmap(struct page *page, int · line 862
Quoted 11 lines · Rafael J. Wysocki
On Tuesday 09 May 2006 14:30, Hugh Dickins wrote:
mm/rmap.c +3
-0@@ -857,3 +857,38 @@ int try_to_unmap(struct page *page, intreturn ret; } +#ifdef CONFIG_SOFTWARE_SUSPEND +/** +* suspend_safe_page - determine if a page can be included in the
suspend_safe_pagesounds like it's suspending a safe page, and safe is unclear:suspend_knows_page_is_frozen?mm/rmap.c int try_to_unmap(struct page *page, int · line 866
Quoted 4 lines
mm/rmap.c +4
-0+* suspend image without copying (returns true if so). +* +* 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 That's not quite what the code checks:
(b) it's mapped but not by the the current task(Actually,
page_address_in_vmadoesn't really say whether the page is mapped by the task, but-EFAULTdoes tell you that it can't be.)
Quoted 6 lines
I still find its checks very obscure: am I right to think that most pages are "frozen" at this point, that it's very hard to determine which are and which are not, but there happens to be this "little" category of pages which you can be damn sure are frozen - and on most active systems, this "little" category actually covers a large number of pages which it's well worth avoiding copying?
Yes. Still I'm struggling to find some reliable+fast method of determining which pages belong to this category.
Quoted 1 line
A very loose heuristic which works well enough to make a big difference.
I think so. :-)
Quoted 29 lines
Quoted 29 lines
mm/rmap.c +28
-0+* (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 suspend_safe_page (struct page *page) +{ +struct vm_area_struct *vma; +int ret =0 ; + +if (!PageLRU (page) ||PageCompound (page)) +return 0 ; + +if (page_mapped (page)) { + ret =1 ; +down_read (¤t->mm->mmap_sem); +/* Return 0 if the page is mapped by the current task */ +for (vma = current->mm->mmap; vma; vma = vma->vm_next) +if (page_address_in_vma (page, vma) != -EFAULT ) { + ret =0 ; +break ; + } +up_read (¤t->mm->mmap_sem); + } + +return ret; +} +#endif /* CONFIG_SOFTWARE_SUSPEND */
Quoted 5 lines
Quoted 2 lines
I've left the locking, because the functions is called when we're freeing memory and I'm not 100% sure it's safe to drop it.
If the locking is necessary, then that
down_readis liable to schedule and wait formmap_semto be released. But you have interrupts disabled?
It also needs to be called with interrupts enabled, unfortunately.
Quoted 3 lines
And everything which might release
mmap_semalready frozen? My guess is that it's a lot safer _not_ to lock here than to lock; but just how safe that is I'm not at all sure.
Well, me too. :-)
Quoted 9 lines
Quoted 6 lines
Quoted 4 lines
But if it is sufficiently frozen, I'm puzzled as to why pages mapped into the current process are (potentially) unsafe, while those mapped into others are safe. If the current process can get back to messing with its mapped pages, what if it maps a page you earlier judged safe?
The current task is forbidden to map anything at this point.
Too bald a statement for me to judge (and by forbidden to map, do you mean forbidden to mmap, or forbidden to fault?).
It's forbiddent to refer to any filesystems at all or else it could corrupt them.
Quoted 5 lines
Perhaps I'd understand better if you explain why pages mapped into the current task have to be excluded? It just seems to me that if it can interfere with those pages, then it is liable to interfere with other pages too, including some mapped into other processes which you've already judged to be safe/frozen.
The current task may be a userland process that saves the image, ie. calls write() to save the data. It reads the image data from the kernel, it can compress and/or encrypt them, compute checksums etc. and then it saves the (possibly processed) data using write() directly to a disk partition (ie. without touching any filesystems). However it only is allowed to (directly) modify its own memory.
This is a very special userland process which must adhere to some strict rules (please have a look at Documentation/power/userland-swsusp.txt).
Quoted 3 lines
Sorry if I'm wasting your time, forcing you to spell things out to someone who hasn't a clue what you're up to; but it all smells a little fishy to me.
You're absolutely right to do so, and it's a tricky stuff. :-)
Greetings,
Rafael