ksm: support tracking KSM-placed zero-pages
Subsystems (8)
v10 cover ksm: support tracking KSM-placed zero-pages
From: xu xin <[email protected]>
The core idea of this patch set is to enable users to perceive the number of any pages merged by KSM, regardless of whether use_zero_page switch has been turned on, so that users can know how much free memory increase is really due to their madvise(MERGEABLE) actions. But the problem is, when enabling use_zero_pages, all empty pages will be merged with kernel zero pages instead of with each other as use_zero_pages is disabled, and then these zero-pages are no longer monitored by KSM.
The motivations to do this is seen at:
https://lore.kernel.org/lkml/[email protected]/
In one word, we hope to implement the support for KSM-placed zero pages tracking without affecting the feature of use_zero_pages, so that app developer can also benefit from knowing the actual KSM profit by getting KSM-placed zero pages to optimize applications eventually when /sys/kernel/mm/ksm/use_zero_pages is enabled.
Change log
----------v9->v10:
-------
(1) Fix a compile error due to [PATCH v8 3/5] when CONFIG_KSM is not set.
(2) Rename the function 'ksm_notify_unmap_zero_page' as 'ksm_might_unmap_zero_page'.
(3) In [PATCH 5/5], we get ksm_zero_pages from its own 'mm' instead of the global system.
(4) In [PATCH 5/5], we add a subject task of testing ksm zero pages when unmerging by triggering write fault.
v8->v9:
------
(1) The previous [PATCH v8 4/6] is squashed into the current [PATCH v9 2/5].
(2) Improve the codes as David's suggestions.
v7->v8:
-------
(1) Since [1] which fix the bug of pte_mkdirty on sparc64 that makes pte writable, then we can remove the architechture restrictions of our features.
(2) Improve the scheme of update ksm_zero_pages: add the handling case when khugepaged replaces a shared zeropage by a THP.
[1] https://lore.kernel.org/all/[email protected]/
v6->v7:
-------
This is an all-newed version which is different from v6 which relys on KSM's rmap_item. The patch series don't rely on rmap_item but pte_dirty, so the general handling of tracking KSM-placed zero-pages is simplified a lot.
For safety, we restrict this feature only to the tested and known-working architechtures (ARM, ARM64, and X86) fow now.
xu xin (5):
ksm: support unsharing KSM-placed zero pages
ksm: count all zero pages placed by KSM
ksm: add ksm zero pages for each process
ksm: consider KSM-placed zeropages when calculating KSM profit
selftest: add a testcase of ksm zero pages
Documentation/admin-guide/mm/ksm.rst | 25 ++++-- fs/proc/base.c | 1 + include/linux/ksm.h | 20 +++++ include/linux/mm_types.h | 9 ++- mm/khugepaged.c | 2 + mm/ksm.c | 28 +++++-- mm/memory.c | 5 +- tools/testing/selftests/mm/ksm_functional_tests.c | 98 ++++++++++++++++++++++- 8 files changed, 172 insertions(+), 16 deletions(-)
Signature · 1 line
2.15.2
PATCH v10 1/5 ksm: support unsharing KSM-placed zero pages
From: xu xin <[email protected]>
When use_zero_pages of ksm is enabled, madvise(addr, len, MADV_UNMERGEABLE) and other ways (like write 2 to /sys/kernel/mm/ksm/run) to trigger unsharing will *not* actually unshare the shared zeropage as placed by KSM (which is against the MADV_UNMERGEABLE documentation). As these KSM-placed zero pages are out of the control of KSM, the related counts of ksm pages don't expose how many zero pages are placed by KSM (these special zero pages are different from those initially mapped zero pages, because the zero pages mapped to MADV_UNMERGEABLE areas are expected to be a complete and unshared page).
To not blindly unshare all shared zero_pages in applicable VMAs, the patch use pte_mkdirty (related with architecture) to mark KSM-placed zero pages. Thus, MADV_UNMERGEABLE will only unshare those KSM-placed zero pages.
In addition, we'll reuse this mechanism to reliably identify KSM-placed ZeroPages to properly account for them (e.g., calculating the KSM profit that includes zeropages) in the latter patches.
The patch will not degrade the performance of use_zero_pages as it doesn't change the way of merging empty pages in use_zero_pages's feature.
--- include/linux/ksm.h | 6 ++++++ mm/ksm.c | 11 ++++++++--- 2 files changed, 14 insertions(+), 3 deletions(-)
include/linux/ksm.h +6 -0
@@ -26,6 +26,12 @@ int ksm_disable(struct mm_struct *mm);int __ksm_enter (struct mm_struct *mm);void __ksm_exit (struct mm_struct *mm); +/* +* To identify zeropages that were mapped by KSM, we reuse the dirty bit +* in the PTE. If the PTE is dirty, the zeropage was mapped by KSM when +* deduplicating memory. +*/ +#define is_ksm_zero_pte (pte) (is_zero_pfn(pte_pfn(pte)) && pte_dirty(pte))static inline int ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm) {
mm/ksm.c +8 -3
@@ -447,7 +447,8 @@ static int break_ksm_pmd_entry(pmd_t *pmd, unsigned long addr, unsigned long nexif (is_migration_entry (entry)) page =pfn_swap_entry_to_page (entry); } - ret = page &&PageKsm (page); +/* return 1 if the page is an normal ksm page or KSM-placed zero page */ + ret = (page &&PageKsm (page)) ||is_ksm_zero_pte (*pte);pte_unmap_unlock (pte, ptl);return ret; }
@@ -1220,8 +1221,12 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,page_add_anon_rmap (kpage, vma, addr,RMAP_NONE ); newpte =mk_pte (kpage, vma->vm_page_prot); }else { - newpte =pte_mkspecial (pfn_pte (page_to_pfn (kpage), - vma->vm_page_prot)); +/* +* Use pte_mkdirty to mark the zero page mapped by KSM, and then +* we can easily track all KSM-placed zero pages by checking if +* the dirty bit in zero page's PTE is set. +*/ + newpte =pte_mkdirty (pte_mkspecial (pfn_pte (page_to_pfn (kpage), vma->vm_page_prot)));/* * We're replacing an anonymous page with a zero page, which is * not anonymous. We need to do proper accounting otherwise we
Signature · 1 line
2.15.2
PATCH v10 2/5 ksm: count all zero pages placed by KSM
In reply to [email protected]From: xu xin <[email protected]>
As pages_sharing and pages_shared don't include the number of zero pages merged by KSM, we cannot know how many pages are zero pages placed by KSM when enabling use_zero_pages, which leads to KSM not being transparent with all actual merged pages by KSM. In the early days of use_zero_pages, zero-pages was unable to get unshared by the ways like MADV_UNMERGEABLE so it's hard to count how many times one of those zeropages was then unmerged.
But now, unsharing KSM-placed zero page accurately has been achieved, so we can easily count both how many times a page full of zeroes was merged with zero-page and how many times one of those pages was then unmerged. and so, it helps to estimate memory demands when each and every shared page could get unshared.
So we add ksm_zero_pages under /sys/kernel/mm/ksm/ to show the number of all zero pages placed by KSM. Meanwhile, we update the Documentation.
--- Documentation/admin-guide/mm/ksm.rst | 7 +++++++ include/linux/ksm.h | 12 ++++++++++++ mm/khugepaged.c | 2 ++ mm/ksm.c | 12 ++++++++++++ mm/memory.c | 5 ++++- 5 files changed, 37 insertions(+), 1 deletion(-)
Documentation/admin-guide/mm/ksm.rst +7 -0
@@ -173,6 +173,13 @@ stable_node_chains the number of KSM pages that hit the ``max_page_sharing`` limit stable_node_dups number of duplicated KSM pages +ksm_zero_pages + how many zero pages that are still mapped into processes were mapped by + KSM when deduplicating. + +When ``use_zero_pages`` is/was enabled, the sum of ``pages_sharing`` + +``ksm_zero_pages`` represents the actual number of pages saved by KSM. +if ``use_zero_pages`` has never been enabled, ``ksm_zero_pages`` is 0. A high ratio of ``pages_sharing`` to ``pages_shared`` indicates good sharing, but a high ratio of ``pages_unshared`` to ``pages_sharing``
include/linux/ksm.h +12 -0
@@ -33,6 +33,14 @@ void __ksm_exit(struct mm_struct *mm);*/ #define is_ksm_zero_pte (pte) (is_zero_pfn(pte_pfn(pte)) && pte_dirty(pte)) +extern unsigned long ksm_zero_pages; + +static inline void ksm_might_unmap_zero_page (pte_t pte) +{ +if (is_ksm_zero_pte (pte)) + ksm_zero_pages--; +} +static inline int ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm) {int ret;
@@ -101,6 +109,10 @@ static inline void ksm_exit(struct mm_struct *mm) { } +static inline void ksm_might_unmap_zero_page (pte_t pte) +{ +} +#ifdef CONFIG_MEMORY_FAILURE static inline void collect_procs_ksm (struct page *page,struct list_head *to_kill,int force_early)
mm/khugepaged.c +2 -0
@@ -19,6 +19,7 @@#include <linux/page_table_check.h> #include <linux/swapops.h> #include <linux/shmem_fs.h> +#include <linux/ksm.h> #include <asm/tlb.h> #include <asm/pgalloc.h>
@@ -711,6 +712,7 @@ static void __collapse_huge_page_copy_succeeded(pte_t *pte,spin_lock (ptl);ptep_clear (vma->vm_mm, address, _pte);spin_unlock (ptl); +ksm_might_unmap_zero_page (pteval); } }else { src_page =pte_page (pteval);
mm/ksm.c +12 -0
@@ -278,6 +278,9 @@ static unsigned int zero_checksum __read_mostly;/* Whether to merge empty (zeroed) pages with actual zero pages */ static bool ksm_use_zero_pages__read_mostly ; +/* The number of zero pages which is placed by KSM */ +unsigned long ksm_zero_pages; +#ifdef CONFIG_NUMA /* Zeroed when merging across nodes is not allowed */ static unsigned int ksm_merge_across_nodes =1 ;
@@ -1227,6 +1230,7 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,* the dirty bit in zero page's PTE is set. */ newpte =pte_mkdirty (pte_mkspecial (pfn_pte (page_to_pfn (kpage), vma->vm_page_prot))); + ksm_zero_pages++;/* * We're replacing an anonymous page with a zero page, which is * not anonymous. We need to do proper accounting otherwise we
@@ -3354,6 +3358,13 @@ static ssize_t pages_volatile_show(struct kobject *kobj, }KSM_ATTR_RO (pages_volatile); +static ssize_t ksm_zero_pages_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"%ld\n" , ksm_zero_pages); +} +KSM_ATTR_RO (ksm_zero_pages); +static ssize_t general_profit_show (struct kobject *kobj,struct kobj_attribute *attr,char *buf) {
@@ -3421,6 +3432,7 @@ static struct attribute *ksm_attrs[] = { &pages_sharing_attr.attr, &pages_unshared_attr.attr, &pages_volatile_attr.attr, + &ksm_zero_pages_attr.attr, &full_scans_attr.attr, #ifdef CONFIG_NUMA &merge_across_nodes_attr.attr,
mm/memory.c +4 -1
@@ -1415,8 +1415,10 @@ static unsigned long zap_pte_range(struct mmu_gather *tlb,tlb_remove_tlb_entry (tlb, pte, addr);zap_install_uffd_wp_if_needed (vma, addr, pte, details, ptent); -if (unlikely (!page)) +if (unlikely (!page)) { +ksm_might_unmap_zero_page (ptent);continue ; + } delay_rmap =0 ;if (!PageAnon (page)) {
@@ -3120,6 +3122,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)inc_mm_counter (mm,MM_ANONPAGES ); } }else { +ksm_might_unmap_zero_page (vmf->orig_pte);inc_mm_counter (mm,MM_ANONPAGES ); }flush_cache_page (vma, vmf->address,pte_pfn (vmf->orig_pte));
Signature · 1 line
2.15.2
PATCH v10 3/5 ksm: add ksm zero pages for each process
In reply to [email protected]From: xu xin <[email protected]>
As the number of ksm zero pages is not included in ksm_merging_pages per process when enabling use_zero_pages, it's unclear of how many actual pages are merged by KSM. To let users accurately estimate their memory demands when unsharing KSM zero-pages, it's necessary to show KSM zero- pages per process. In addition, it help users to know the actual KSM profit because KSM-placed zero pages are also benefit from KSM.
since unsharing zero pages placed by KSM accurately is achieved, then tracking empty pages merging and unmerging is not a difficult thing any longer.
Since we already have /proc/<pid>/ksm_stat, just add the information of 'ksm_zero_pages' in it.
--- fs/proc/base.c | 1 + include/linux/ksm.h | 8 +++++--- include/linux/mm_types.h | 9 +++++++-- mm/khugepaged.c | 2 +- mm/ksm.c | 1 + mm/memory.c | 4 ++-- 6 files changed, 17 insertions(+), 8 deletions(-)
fs/proc/base.c +1 -0
@@ -3207,6 +3207,7 @@ static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns, mm =get_task_mm (task);if (mm) {seq_printf (m,"ksm_rmap_items %lu\n" , mm->ksm_rmap_items); +seq_printf (m,"ksm_zero_pages %lu\n" , mm->ksm_zero_pages);seq_printf (m,"ksm_merging_pages %lu\n" , mm->ksm_merging_pages);seq_printf (m,"ksm_process_profit %ld\n" ,ksm_process_profit (mm));mmput (mm);
include/linux/ksm.h +5 -3
@@ -35,10 +35,12 @@ void __ksm_exit(struct mm_struct *mm);extern unsigned long ksm_zero_pages; -static inline void ksm_might_unmap_zero_page (pte_t pte) +static inline void ksm_might_unmap_zero_page (struct mm_struct *mm,pte_t pte) { -if (is_ksm_zero_pte (pte)) +if (is_ksm_zero_pte (pte)) { ksm_zero_pages--; + mm->ksm_zero_pages--; + } }static inline int ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm)
@@ -109,7 +111,7 @@ static inline void ksm_exit(struct mm_struct *mm) { } -static inline void ksm_might_unmap_zero_page (pte_t pte) +static inline void ksm_might_unmap_zero_page (struct mm_struct *mm,pte_t pte) { }
include/linux/mm_types.h +7 -2
@@ -777,7 +777,7 @@ struct mm_struct {#ifdef CONFIG_KSM /* * Represent how many pages of this process are involved in KSM -* merging. +* merging (not including ksm_zero_pages). */ unsigned long ksm_merging_pages;/*
@@ -785,7 +785,12 @@ struct mm_struct {* including merged and not merged. */ unsigned long ksm_rmap_items; -#endif +/* +* Represent how many empty pages are merged with kernel zero +* pages when enabling KSM use_zero_pages. +*/ +unsigned long ksm_zero_pages; +#endif /* CONFIG_KSM */ #ifdef CONFIG_LRU_GEN struct { /* this mm_struct is on lru_gen_mm_list */
mm/khugepaged.c +1 -1
@@ -712,7 +712,7 @@ static void __collapse_huge_page_copy_succeeded(pte_t *pte,spin_lock (ptl);ptep_clear (vma->vm_mm, address, _pte);spin_unlock (ptl); -ksm_might_unmap_zero_page (pteval); +ksm_might_unmap_zero_page (vma->vm_mm, pteval); } }else { src_page =pte_page (pteval);
mm/ksm.c +1 -0
@@ -1231,6 +1231,7 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,*/ newpte =pte_mkdirty (pte_mkspecial (pfn_pte (page_to_pfn (kpage), vma->vm_page_prot))); ksm_zero_pages++; + mm->ksm_zero_pages++;/* * We're replacing an anonymous page with a zero page, which is * not anonymous. We need to do proper accounting otherwise we
mm/memory.c +2 -2
@@ -1416,7 +1416,7 @@ static unsigned long zap_pte_range(struct mmu_gather *tlb,zap_install_uffd_wp_if_needed (vma, addr, pte, details, ptent);if (unlikely (!page)) { -ksm_might_unmap_zero_page (ptent); +ksm_might_unmap_zero_page (mm, ptent);continue ; }
@@ -3122,7 +3122,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)inc_mm_counter (mm,MM_ANONPAGES ); } }else { -ksm_might_unmap_zero_page (vmf->orig_pte); +ksm_might_unmap_zero_page (mm, vmf->orig_pte);inc_mm_counter (mm,MM_ANONPAGES ); }flush_cache_page (vma, vmf->address,pte_pfn (vmf->orig_pte));
Signature · 1 line
2.15.2
PATCH v10 4/5 ksm: consider KSM-placed zeropages when calculating KSM profit
In reply to [email protected]From: xu xin <[email protected]>
When use_zero_pages is enabled, the calculation of ksm profit is not correct because ksm zero pages is not counted in. So update the calculation of KSM profit including the documentation.
--- Documentation/admin-guide/mm/ksm.rst | 18 +++++++++++------- mm/ksm.c | 4 ++-- 2 files changed, 13 insertions(+), 9 deletions(-)
Documentation/admin-guide/mm/ksm.rst +11 -7
@@ -203,21 +203,25 @@ several times, which are unprofitable memory consumed. 1) How to determine whether KSM save memory or consume memory in system-wide range? Here is a simple approximate calculation for reference:: - general_profit =~ pages_sharing * sizeof(page) - (all_rmap_items) * + general_profit =~ ksm_saved_pages * sizeof(page) - (all_rmap_items) * sizeof(rmap_item); - where all_rmap_items can be easily obtained by summing ``pages_sharing``, - ``pages_shared``, ``pages_unshared`` and ``pages_volatile``. + where ksm_saved_pages equals to the sum of ``pages_sharing`` + + ``ksm_zero_pages`` of the system, and all_rmap_items can be easily + obtained by summing ``pages_sharing``, ``pages_shared``, ``pages_unshared`` + and ``pages_volatile``. 2) The KSM profit inner a single process can be similarly obtained by the following approximate calculation:: - process_profit =~ ksm_merging_pages * sizeof(page) - + process_profit =~ ksm_saved_pages * sizeof(page) - ksm_rmap_items * sizeof(rmap_item). - where ksm_merging_pages is shown under the directory ``/proc/<pid>/``, - and ksm_rmap_items is shown in ``/proc/<pid>/ksm_stat``. The process profit - is also shown in ``/proc/<pid>/ksm_stat`` as ksm_process_profit. + where ksm_saved_pages equals to the sum of ``ksm_merging_pages`` and + ``ksm_zero_pages``, both of which are shown under the directory + ``/proc/<pid>/ksm_stat``, and ksm_rmap_items is also shown in + ``/proc/<pid>/ksm_stat``. The process profit is also shown in + ``/proc/<pid>/ksm_stat`` as ksm_process_profit. From the perspective of application, a high ratio of ``ksm_rmap_items`` to ``ksm_merging_pages`` means a bad madvise-applied policy, so developers or
mm/ksm.c +2 -2
@@ -3090,7 +3090,7 @@ static void wait_while_offlining(void)#ifdef CONFIG_PROC_FS long ksm_process_profit (struct mm_struct *mm) { -return mm->ksm_merging_pages *PAGE_SIZE - +return (long )(mm->ksm_merging_pages + mm->ksm_zero_pages) *PAGE_SIZE - mm->ksm_rmap_items *sizeof (struct ksm_rmap_item ); }#endif /* CONFIG_PROC_FS */
@@ -3371,7 +3371,7 @@ static ssize_t general_profit_show(struct kobject *kobj, {long general_profit; - general_profit = ksm_pages_sharing *PAGE_SIZE - + general_profit = (ksm_pages_sharing + ksm_zero_pages) *PAGE_SIZE - ksm_rmap_items *sizeof (struct ksm_rmap_item );return sysfs_emit (buf,"%ld\n" , general_profit);
Signature · 1 line
2.15.2
PATCH v10 5/5 selftest: add a testcase of ksm zero pages
In reply to [email protected]From: xu xin <[email protected]>
Add a function test_unmerge_zero_page() to test the functionality on unsharing and counting ksm-placed zero pages and counting of this patch series.
test_unmerge_zero_page() actually contains four subjct test objects:
(1) whether the count of ksm zero pages can update correctly after merging;
(2) whether the count of ksm zero pages can update correctly after
unmerging by madvise(...MADV_UNMERGEABLE);
(3) whether the count of ksm zero pages can update correctly after unmerging by triggering write fault.
(4) whether ksm zero pages are really unmerged.
--- tools/testing/selftests/mm/ksm_functional_tests.c | 98 ++++++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-)
tools/testing/selftests/mm/ksm_functional_tests.c +97 -1
@@ -29,6 +29,8 @@static int ksm_fd;static int ksm_full_scans_fd; +static int proc_self_ksm_stat_fd; +static int ksm_use_zero_pages_fd;static int pagemap_fd;static size_t pagesize;
@@ -59,6 +61,33 @@ static bool range_maps_duplicates(char *addr, unsigned long size)return false; } +static long get_my_ksm_zero_pages (void ) +{ +char buf[200 ]; +char *substr_ksm_zero; +size_t value_pos; +ssize_t read_size; +unsigned long my_ksm_zero_pages; + +if (!proc_self_ksm_stat_fd) +return 0 ; + + read_size =pread (proc_self_ksm_stat_fd, buf,sizeof (buf) -1 ,0 ); +if (read_size <0 ) +return -errno; + + buf[read_size] =0 ; + + substr_ksm_zero =strstr (buf,"ksm_zero_pages" ); +if (!substr_ksm_zero) +return 0 ; + + value_pos =strcspn (substr_ksm_zero,"0123456789" ); + my_ksm_zero_pages =strtol (substr_ksm_zero + value_pos,NULL ,10 ); + +return my_ksm_zero_pages; +} +static long ksm_get_full_scans (void ) {char buf[10 ];
@@ -159,6 +188,70 @@ static void test_unmerge(void)munmap (map, size); } +static void test_unmerge_zero_pages (void ) +{ +const unsigned int size =2 * MiB; +char *map; +unsigned int offs; +unsigned long pages_expected; + +ksft_print_msg ("[RUN] %s\n" , __func__); + +if (proc_self_ksm_stat_fd <0 ) { +ksft_test_result_skip ("open(\"/proc/self/ksm_stat\") failed\n" ); +return ; + } +if (ksm_use_zero_pages_fd <0 ) { +ksft_test_result_skip ("open \"/sys/kernel/mm/ksm/use_zero_pages\" failed\n" ); +return ; + } +if (write (ksm_use_zero_pages_fd,"1" ,1 ) !=1 ) { +ksft_test_result_skip ("write \"/sys/kernel/mm/ksm/use_zero_pages\" failed\n" ); +return ; + } + +/* Let KSM deduplicate zero pages. */ + map =mmap_and_merge_range (0x00 , size, false); +if (map ==MAP_FAILED ) +return ; + +/* Check if ksm_zero_pages is updated correctly after KSM merging */ + pages_expected = size / pagesize; +if (pages_expected !=get_my_ksm_zero_pages ()) { +ksft_test_result_fail ("'ksm_zero_pages' updated after merging\n" ); + goto unmap; + } + +/* Try to unmerge half of the region */ +if (madvise (map, size /2 ,MADV_UNMERGEABLE )) { +ksft_test_result_fail ("MADV_UNMERGEABLE failed\n" ); + goto unmap; + } + +/* Check if ksm_zero_pages is updated correctly after unmerging */ + pages_expected /=2 ; +if (pages_expected !=get_my_ksm_zero_pages ()) { +ksft_test_result_fail ("'ksm_zero_pages' updated after unmerging\n" ); + goto unmap; + } + +/* Trigger unmerging of the other half by writing to the pages. */ +for (offs = size /2 ; offs < size; offs += pagesize) + *((unsigned int *)&map[offs]) = offs; + +/* Now we should have no zeropages remaining. */ +if (get_my_ksm_zero_pages ()) { +ksft_test_result_fail ("'ksm_zero_pages' updated after write fault\n" ); + goto unmap; + } + +/* Check if ksm zero pages are really unmerged */ +ksft_test_result (!range_maps_duplicates (map, size), +"KSM zero pages were unmerged\n" ); +unmap: +munmap (map, size); +} +static void test_unmerge_discarded (void ) {const unsigned int size =2 * MiB;
@@ -358,7 +451,7 @@ static void test_prctl_unmerge(void)int main (int argc,char **argv) { -unsigned int tests =5 ; +unsigned int tests =6 ;int err;#ifdef __NR_userfaultfd
@@ -379,8 +472,11 @@ int main(int argc, char **argv) pagemap_fd =open ("/proc/self/pagemap" ,O_RDONLY );if (pagemap_fd <0 )ksft_exit_skip ("open(\"/proc/self/pagemap\") failed\n" ); + proc_self_ksm_stat_fd =open ("/proc/self/ksm_stat" ,O_RDONLY ); + ksm_use_zero_pages_fd =open ("/sys/kernel/mm/ksm/use_zero_pages" ,O_RDWR );test_unmerge (); +test_unmerge_zero_pages ();test_unmerge_discarded ();#ifdef __NR_userfaultfdtest_unmerge_uffd_wp ();
Signature · 1 line
2.15.2
Re: [PATCH v10 5/5] selftest: add a testcase of ksm zero pages
Quoted 14 lines · Yang Yang
From: xu xin <[email protected]>
Add a function
test_unmerge_zero_page()to test the functionality on unsharing and counting ksm-placed zero pages and counting of this patch series.
test_unmerge_zero_page()actually contains four subjct test objects:
(1) whether the count of ksm zero pages can update correctly after merging;
(2) whether the count of ksm zero pages can update correctly afterunmerging by madvise(...MADV_UNMERGEABLE);(3) whether the count of ksm zero pages can update correctly after unmerging by triggering write fault.
(4) whether ksm zero pages are really unmerged.
Quoted 7 lines
Signed-off-by xu xin <[email protected]>Reviewed-by Xiaokai Ran <[email protected]>Reviewed-by Yang Yang <[email protected]>Cc Claudio Imbrenda <[email protected]>Cc David Hildenbrand <[email protected]>Cc Xuexin Jiang <[email protected]>---
Thanks!
Signature · 3 lines
Thanks, David / dhildenb