[v5,6/6] selftest: add testing unsharing and counting ksm zero page

  From: xu xin <xu.xin16@zte.com.cn>

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 three subjct test objects:
	1) whether the count of ksm zero page can react correctly to cow
	   (copy on write);
	2) whether the count of ksm zero page can react correctly to unmerge;
	3) whether ksm zero pages are really unmerged.

Signed-off-by: xu xin <xu.xin16@zte.com.cn>
Cc: Claudio Imbrenda <imbrenda@linux.ibm.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Xuexin Jiang <jiang.xuexin@zte.com.cn>
Reviewed-by: Xiaokai Ran <ran.xiaokai@zte.com.cn>
Reviewed-by: Yang Yang <yang.yang29@zte.com.cn>

v4->v5:
fix error of "} while (end_scans < start_scans + 20);" to
"} while (end_scans < start_scans + 2);" in wait_two_full_scans().
---
 tools/testing/selftests/vm/ksm_functional_tests.c | 103 +++++++++++++++++++++-
 1 file changed, 99 insertions(+), 4 deletions(-)
  

On 30.12.22 02:18, yang.yang29@zte.com.cn wrote:
> From: xu xin <xu.xin16@zte.com.cn>
> 
> 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 three subjct test objects:
> 	1) whether the count of ksm zero page can react correctly to cow
> 	   (copy on write);
> 	2) whether the count of ksm zero page can react correctly to unmerge;
> 	3) whether ksm zero pages are really unmerged.
> 
> Signed-off-by: xu xin <xu.xin16@zte.com.cn>
> Cc: Claudio Imbrenda <imbrenda@linux.ibm.com>
> Cc: David Hildenbrand <david@redhat.com>
> Cc: Xuexin Jiang <jiang.xuexin@zte.com.cn>
> Reviewed-by: Xiaokai Ran <ran.xiaokai@zte.com.cn>
> Reviewed-by: Yang Yang <yang.yang29@zte.com.cn>
> 
> v4->v5:
> fix error of "} while (end_scans < start_scans + 20);" to
> "} while (end_scans < start_scans + 2);" in wait_two_full_scans().
> ---
>   tools/testing/selftests/vm/ksm_functional_tests.c | 103 +++++++++++++++++++++-
>   1 file changed, 99 insertions(+), 4 deletions(-)
> 
> diff --git a/tools/testing/selftests/vm/ksm_functional_tests.c b/tools/testing/selftests/vm/ksm_functional_tests.c
> index b11b7e5115dc..b792798a54c4 100644
> --- a/tools/testing/selftests/vm/ksm_functional_tests.c
> +++ b/tools/testing/selftests/vm/ksm_functional_tests.c
> @@ -27,6 +27,8 @@
> 
>   static int ksm_fd;
>   static int ksm_full_scans_fd;
> +static int ksm_zero_pages_fd;
> +static int ksm_use_zero_pages_fd;

If they are global, open them from main(), not from the test case.

>   static int pagemap_fd;
>   static size_t pagesize;
> 
> @@ -57,6 +59,22 @@ static bool range_maps_duplicates(char *addr, unsigned long size)
>   	return false;
>   }
> 
> +static bool check_ksm_zero_pages_count(unsigned long zero_size)
> +{
> +	unsigned long pages_expected = zero_size / (4 * KiB);
> +	char buf[20];
> +	ssize_t read_size;
> +	unsigned long ksm_zero_pages;
> +
> +	read_size = pread(ksm_zero_pages_fd, buf, sizeof(buf) - 1, 0);
> +	if (read_size < 0)
> +		return -errno;
> +	buf[read_size] = 0;
> +	ksm_zero_pages = strtol(buf, NULL, 10);
> +
> +	return ksm_zero_pages == pages_expected;

Better call this function "ksm_get_zero_pages", do it similarly to 
ksm_get_full_scans() and do the comparison in the kernel.

> +}
> +
>   static long ksm_get_full_scans(void)
>   {
>   	char buf[10];
> @@ -70,15 +88,12 @@ static long ksm_get_full_scans(void)
>   	return strtol(buf, NULL, 10);
>   }
> 
> -static int ksm_merge(void)
> +static int wait_two_full_scans(void)
>   {
>   	long start_scans, end_scans;
> 
> -	/* Wait for two full scans such that any possible merging happened. */
>   	start_scans = ksm_get_full_scans();
>   	if (start_scans < 0)
> -		return start_scans;
> -	if (write(ksm_fd, "1", 1) != 1)
>   		return -errno;

This change might not be required.

>   	do {
>   		end_scans = ksm_get_full_scans();
> @@ -89,6 +104,34 @@ static int ksm_merge(void)
>   	return 0;
>   }
> 
> +static inline int ksm_merge(void)
> +{
> +	/* Wait for two full scans such that any possible merging happened. */
> +	if (write(ksm_fd, "1", 1) != 1)
> +		return -errno;
> +	return wait_two_full_scans();
> +}
> +
> +static inline int make_cow(char *map, char val, unsigned long size)
> +{
> +
> +	memset(map, val, size);
> +	return wait_two_full_scans();

Why is that required?

> +}
> +
> +static int unmerge_zero_page(char *start, unsigned long size)
> +{
> +	int ret;
> +
> +	ret = madvise(start, size, MADV_UNMERGEABLE);
> +	if (ret) {
> +		ksft_test_result_fail("MADV_UNMERGEABLE failed\n");
> +		return ret;
> +	}
> +
> +	return wait_two_full_scans();

Dito, why is that required when unmerging?

> +}
> +
>   static char *mmap_and_merge_range(char val, unsigned long size)
>   {
>   	char *map;
> @@ -146,6 +189,56 @@ static void test_unmerge(void)
>   	munmap(map, size);
>   }
> 
> +static void test_unmerge_zero_pages(void)
> +{
> +	const unsigned int size = 2 * MiB;
> +	char *map;
> +
> +	ksft_print_msg("[RUN] %s\n", __func__);
> +
> +	/* Confirm the interfaces*/
> +	ksm_zero_pages_fd = open("/sys/kernel/mm/ksm/zero_pages_sharing", O_RDONLY);
> +	if (ksm_zero_pages_fd < 0) {
> +		ksft_test_result_skip("open(\"/sys/kernel/mm/ksm/zero_pages_sharing\") failed\n");
> +		return;
> +	}
> +	ksm_use_zero_pages_fd = open("/sys/kernel/mm/ksm/use_zero_pages", O_RDWR);
> +	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;
> +	}
> +
> +	/* Mmap zero pages*/
> +	map = mmap_and_merge_range(0x00, size);

Not checking for map == MAP_FAILED. Best to follow what
test_unmerge() does.


> +
> +	/* Case 1: make Writing on ksm zero pages (COW) */
> +	if (make_cow(map, 0xcf, size / 2)) {
> +		ksft_test_result_fail("COW failed\n");
> +		goto unmap;
> +	}
> +	ksft_test_result(check_ksm_zero_pages_count(size / 2),
> +						"zero page count react to cow\n");
> +

Let's keep COW tests to cow.c and focus on explicit unmerging here. Once 
we add support for KSM in cow.c , we can also test that e.g., long-term 
R/O pinning works as expected. I have that on my todo list but would be 
pleasantly surprised if someone else could tackle it :)

> +	/* Case 2: Call madvise(xxx, MADV_UNMERGEABLE)*/
> +	if (unmerge_zero_page(map + size / 2, size / 4)) {
> +		ksft_test_result_fail("unmerge_zero_page failed\n");
> +		goto unmap;
> +	}

Just avoid that helper and do it like test_unmerge(). Keep it simple.

> +	ksft_test_result(check_ksm_zero_pages_count(size / 4),
> +						"zero page count react to unmerge\n");
> +
> +	/*Check if ksm pages are really unmerged */

Missing space at the beginning. + the comment is superfluous.

> +	ksft_test_result(!range_maps_duplicates(map + size / 2, size / 4),
> +						"KSM zero pages were unmerged\n");
> +
> +unmap:
> +	munmap(map, size);
> +}
> +
>   static void test_unmerge_discarded(void)
>   {
>   	const unsigned int size = 2 * MiB;
> @@ -261,11 +354,13 @@ int main(int argc, char **argv)
>   	ksm_full_scans_fd = open("/sys/kernel/mm/ksm/full_scans", O_RDONLY);
>   	if (ksm_full_scans_fd < 0)
>   		ksft_exit_skip("open(\"/sys/kernel/mm/ksm/full_scans\") failed\n");
> +

Unrelated change.

>   	pagemap_fd = open("/proc/self/pagemap", O_RDONLY);
>   	if (pagemap_fd < 0)
>   		ksft_exit_skip("open(\"/proc/self/pagemap\") failed\n");
> 
>   	test_unmerge();
> +	test_unmerge_zero_pages();
>   	test_unmerge_discarded();
>   #ifdef __NR_userfaultfd
>   	test_unmerge_uffd_wp();