Hugetlb:Migrating the libhugetlbfs tests
v7 cover Hugetlb:Migrating the libhugetlbfs tests
Hi,
Libhugetlbfs is not being maintained actively, and some distro is dropping support for it. There are some tests that are good for testing hugetlb functionality in kernel.
As per previous dicussion in RFC[1], Here, this patch series consists of hugetlb tests taken from libhugetlbfs modified to work in ltp environment.
Based on suggestion[2], I am reposting the patches again. Also, I added suggested changes at [3].
ref:
1:https://lore.kernel.org/all/[email protected]/ 2:https://lore.kernel.org/all/[email protected]/ 3:https://lore.kernel.org/all/[email protected]/
v1 -> v2
1. In (brk near huge) test [PATCH 1/3] removed unused library function test_addr_huge() and read_maps().
v2 -> v3
1. Added a new patch commit for two new flags "needs_hugetlbfs" & "needs_unlinked_hugetlb_file" in tst_test and modified tests to use these flags.
2. Added taint check in test [PATCH 1/3].
3. Removed redundant Hopt and nr_opt option.
4. Corrected pre-processor ARCH based conditional flags in test [PATCH 1/3]
v3 -> v4
1. Removed the needs_unlinked_hugetlb_file option in PATCH[1/4].
2. Removed the redundant saved_oc_hugepages checks in PATCH[3/4].
3. Updated the mntpoint checks in PATCH[1/4].
v4 -> v5
1. Removed the needs_hugetlbfs check from needs_tmpdir function, because mntpoint is now mandatory option with needs_hugetlbfs. (PATCH[1/4])
v5 -> v6
1. Edited the comment for needs_hugetlbfs PATCH[1/4].
2. Changed TCID to tid and removed __func__ from tst_brk PATCH[1/4].
3. Removed SAFE_UMOUNT in do_cleanup PATCH[1/4].
4. Added the ARCH definition in Makefile PATCH[2/4].
5. Removed ALIGN and use LTP_ALIGN PATCH[2/4].
v6 -> v7
1. Removed ppc32 check from makefile, and checked for ppc32 system at runtime in PATCH[2/4]
2. Updated the test description in PATCH[2,3,4/4].
3. Defined macros for Hugepage related strings.
Tarun Sahu (4):
Hugetlb: Add new tst_test options for hugeltb test support
Hugetlb: Migrating libhugetlbfs brk_near_huge
Hugetlb: Migrating libhugetlbfs chunk-overcommit
Hugetlb: Migrating libhugetlbfs corrupt-by-cow-opt
include/tst_hugepage.h | 7 + include/tst_test.h | 10 ++ lib/tst_test.c | 32 +++- runtest/hugetlb | 3 + testcases/kernel/mem/.gitignore | 3 + .../kernel/mem/hugetlb/hugemmap/hugemmap07.c | 140 +++++++++++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap08.c | 146 ++++++++++++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap09.c | 79 ++++++++++ testcases/kernel/mem/hugetlb/lib/hugetlb.h | 2 + 9 files changed, 419 insertions(+), 3 deletions(-) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap07.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap09.c
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v7 1/4 Hugetlb: Add new tst_test options for hugeltb test support
Most of libhugetlbfs test require mounted hugetlbfs.
Here, this patch adds a new field in tst_test struct(include/tst_test.h) which user can set if the test requires mounted hugetlbfs. Also, this patch added support to create the unlinked file in the provided dirpath.
--- include/tst_hugepage.h | 7 +++++++ include/tst_test.h | 10 ++++++++++ lib/tst_test.c | 32 +++++++++++++++++++++++++++++--- 3 files changed, 46 insertions(+), 3 deletions(-)
include/tst_hugepage.h +7 -0
@@ -8,6 +8,13 @@#define PATH_HUGEPAGES "/sys/kernel/mm/hugepages/"#define PATH_NR_HPAGES "/proc/sys/vm/nr_hugepages" +#define PATH_OC_HPAGES "/proc/sys/vm/nr_overcommit_hugepages" + +#define MEMINFO_HPAGE_TOTAL "HugePages_Total:" +#define MEMINFO_HPAGE_FREE "HugePages_Free:" +#define MEMINFO_HPAGE_RSVD "HugePages_Rsvd:" +#define MEMINFO_HPAGE_SURP "HugePages_Surp:" +#define MEMINFO_HPAGE_SIZE "Hugepagesize:"extern char *nr_opt;/* -s num Set the number of the been allocated hugepages */ extern char *Hopt;/* -H /.. Location of hugetlbfs, i.e. -H /var/hugetlbfs */
include/tst_test.h +10 -0
@@ -176,6 +176,10 @@ struct tst_test { int all_filesystems:1; int skip_in_lockdown:1; int skip_in_compat:1; +/* +* If set, the hugetlbfs will be mounted at .mntpoint. +*/ + int needs_hugetlbfs:1;/* * The skip_filesystems is a NULL terminated list of filesystems the
@@ -357,6 +361,12 @@ unsigned int tst_remaining_runtime(void);*/ void tst_set_max_runtime (int max_runtime); +/* +* Create and open a random file inside the given dir path. +* It unlinks the file after opening and return file descriptor. +*/ +int tst_creat_unlinked (const char *path); +/* * Returns path to the test temporary directory in a newly allocated buffer. */
lib/tst_test.c +29 -3
@@ -1021,6 +1021,28 @@ static void prepare_and_mount_dev_fs(const char *mntpoint) } } +static void prepare_and_mount_hugetlb_fs (void ) +{ +SAFE_MOUNT ("none" , tst_test->mntpoint,"hugetlbfs" ,0 ,NULL ); + mntpoint_mounted =1 ; +} + +int tst_creat_unlinked (const char *path) +{ +char template[PATH_MAX ]; +int fd; + +snprintf (template,PATH_MAX ,"%s/ltp_%.3sXXXXXX" , + path, tid); + + fd =mkstemp (template); +if (fd <0 ) +tst_brk (TBROK |TERRNO ,"mkstemp(%s) failed" , template); + +SAFE_UNLINK (template); +return fd; +} +static const char *limit_tmpfs_mount_size (const char *mnt_data,char *buf,size_t buf_size,const char *fs_type) {
@@ -1191,15 +1213,16 @@ static void do_setup(int argc, char *argv[])SAFE_MKDIR (tst_test->mntpoint,0777 );if ((tst_test->needs_devfs || tst_test->needs_rofs || - tst_test->mount_device || tst_test->all_filesystems) && + tst_test->mount_device || tst_test->all_filesystems || + tst_test->needs_hugetlbfs) && !tst_test->mntpoint) {tst_brk (TBROK ,"tst_test->mntpoint must be set!" ); }if (!!tst_test->needs_rofs + !!tst_test->needs_devfs + - !!tst_test->needs_device >1 ) { + !!tst_test->needs_device + !!tst_test->needs_hugetlbfs >1 ) {tst_brk (TBROK , -"Two or more of needs_{rofs, devfs, device} are set" ); +"Two or more of needs_{rofs, devfs, device, hugetlbfs} are set" ); }if (tst_test->needs_devfs)
@@ -1217,6 +1240,9 @@ static void do_setup(int argc, char *argv[]) } } +if (tst_test->needs_hugetlbfs) +prepare_and_mount_hugetlb_fs (); +if (tst_test->needs_device && !mntpoint_mounted) { tdev.dev =tst_acquire_device_ (NULL , tst_test->dev_min_size);
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v7 2/4 Hugetlb: Migrating libhugetlbfs brk_near_huge
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/brk_near_huge.c test
Test Description:
Certain kernels have a bug where brk() does not perform the same checks that a MAP_FIXED mmap() will, allowing brk() to create a normal page VMA in a hugepage only address region. This can lead to oopses or other badness.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap07.c | 140 ++++++++++++++++++ testcases/kernel/mem/hugetlb/lib/hugetlb.h | 2 + 4 files changed, 144 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap07.c
runtest/hugetlb +1 -0
@@ -3,6 +3,7 @@ hugemmap02 hugemmap02 hugemmap04 hugemmap04 hugemmap05 hugemmap05 hugemmap06 hugemmap06 +hugemmap07 hugemmap07 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -4,6 +4,7 @@ /hugetlb/hugemmap/hugemmap04 /hugetlb/hugemmap/hugemmap05 /hugetlb/hugemmap/hugemmap06 +/hugetlb/hugemmap/hugemmap07 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap07.c new file +140 -0
140 lines not on this page · raw message
testcases/kernel/mem/hugetlb/lib/hugetlb.h +2 -0
@@ -20,6 +20,8 @@#include "old_tmpdir.h" #include "mem.h" +#define PALIGN (p, a) ((void *)LTP_ALIGN((unsigned long)(p), (a))) +#define SHM_RD 0400#define SHM_WR 0200#define SHM_RW (SHM_RD|SHM_WR)
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v7 2/4] Hugetlb: Migrating libhugetlbfs brk_near_huge
Hi!
testcases/kernel/mem/hugetlb/hugemmap/hugemmap07.c line 43
Quoted 13 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap07.c new file +13
-0+#ifdef __powerpc64__ +static int arch_has_slice_support (void ) +{ +char mmu_type[16 ]; +FILE *fp; +int ret; + + fp =SAFE_POPEN ("cat /proc/cpuinfo | grep MMU | awk '{ print $3}'" ,"r" ); + ret =fscanf (fp,"%s" , mmu_type); +pclose (fp); + +if (ret <0 ) +tst_brk (TBROK ,"Failed to determine MMU type" );
We do have SAFE_FILE_LINES_SCANF() that simplifies all this to a single line;
SAFE_FILE_LINES_SCANF("/proc/cpuinfo", "MMU : %16s", mmu_type);Signature · 5 lines
Cyril Hrubis [email protected] -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v7 3/4 Hugetlb: Migrating libhugetlbfs chunk-overcommit
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/chunk-overcommit.c test
Test Description: Some kernel versions after hugepage demand allocation was added used a dubious heuristic to check if there was enough hugepage space available for a given mapping. The number of not-already-instantiated pages in the mapping was compared against the total hugepage free pool. It was very easy to confuse this heuristic into overcommitting by allocating hugepage memory in chunks, each less than the total available pool size but together more than available. This would generally lead to OOM SIGKILLs of one process or another when it tried to instantiate pages beyond the available pool.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap08.c | 146 ++++++++++++++++++ 3 files changed, 148 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c
runtest/hugetlb +1 -0
@@ -4,6 +4,7 @@ hugemmap04 hugemmap04 hugemmap05 hugemmap05 hugemmap06 hugemmap06 hugemmap07 hugemmap07 +hugemmap08 hugemmap08 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -5,6 +5,7 @@ /hugetlb/hugemmap/hugemmap05 /hugetlb/hugemmap/hugemmap06 /hugetlb/hugemmap/hugemmap07 +/hugetlb/hugemmap/hugemmap08 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +146 -0
146 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v7 3/4] Hugetlb: Migrating libhugetlbfs chunk-overcommit
Hi!
Quoted 16 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +10
-0@@ -0,0 +1,146 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* +* Copyright (C) 2005-2006 David Gibson & Adam Litke, IBM Corporation. +* Author: David Gibson & Adam Litke +*/ + +/*\ +* [Description] +* +* Some kernel versions after hugepage demand allocation was added used a
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c line 20
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +10
-0+* dubious heuristic to check if there was enough hugepage space available +* for a given mapping. The number of not-already-instantiated pages in +* the mapping was compared against the total hugepage free pool. It was +* very easy to confuse this heuristic into overcommitting by allocating +* hugepage memory in chunks, each less than the total available pool size +* but together more than available. This would generally lead to OOM +* SIGKILLs of one process or another when it tried to instantiate pages +* beyond the available pool. +* +* HISTORY
This looks like a leftover.
Quoted 93 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +93
-0+* +*/ + +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include <sys/mount.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <signal.h> + +#include "hugetlb.h" + +#define MNTPOINT "hugetlbfs/" +#define WITH_OVERCOMMIT 0 +#define WITHOUT_OVERCOMMIT 1 + +static long hpage_size; +static int huge_fd =-1 ; + +static void test_chunk_overcommit (void ) +{ +unsigned long totpages, chunk1, chunk2; +void *p, *q; +pid_t child; +int status; + + totpages =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE ); + + chunk1 = (totpages /2 ) +1 ; + chunk2 = totpages - chunk1 +1 ; + +tst_res (TINFO ,"Free: %ld hugepages available: " +"chunk1=%ld chunk2=%ld" , totpages, chunk1, chunk2); + + p =SAFE_MMAP (NULL , chunk1*hpage_size,PROT_READ |PROT_WRITE ,MAP_SHARED , + huge_fd,0 ); + + q =mmap (NULL , chunk2*hpage_size,PROT_READ |PROT_WRITE ,MAP_SHARED , + huge_fd, chunk1*hpage_size); +if (q ==MAP_FAILED ) { +if (errno !=ENOMEM ) { +tst_res (TFAIL |TERRNO ,"mmap() chunk2" ); + goto cleanup1; + }else { +tst_res (TPASS ,"Successful without overcommit pages" ); + goto cleanup1; + } + } + +tst_res (TINFO ,"Looks like we've overcommitted, testing..." ); +/* Looks like we're overcommited, but we need to confirm that +* this is bad. We touch it all in a child process because an +* overcommit will generally lead to a SIGKILL which we can't +* handle, of course. +*/ + child =SAFE_FORK (); + +if (child ==0 ) { +memset (p,0 , chunk1*hpage_size); +memset (q,0 , chunk2*hpage_size); +exit (0 ); + } + +SAFE_WAITPID (child, &status,0 ); + +if (WIFSIGNALED (status)) { +tst_res (TFAIL ,"Killed by signal '%s' due to overcommit" , +tst_strsig (WTERMSIG (status))); + goto cleanup2; + } + +tst_res (TPASS ,"Successful with overcommit pages" ); + +cleanup2: +SAFE_MUNMAP (q, chunk2*hpage_size); + +cleanup1: +SAFE_MUNMAP (p, chunk1*hpage_size); +SAFE_FTRUNCATE (huge_fd,0 ); +} + +static void run_test (unsigned int test_type) +{ +switch (test_type) { +case WITHOUT_OVERCOMMIT : +tst_res (TINFO ,"Without overcommit testing..." ); +SAFE_FILE_PRINTF (PATH_OC_HPAGES ,"%d" ,0 ); +break ; +case WITH_OVERCOMMIT : +tst_res (TINFO ,"With overcommit testing..." );
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c line 123
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +10
-0+SAFE_FILE_PRINTF (PATH_OC_HPAGES ,"%d" ,2 ); +break ; + } +test_chunk_overcommit (); +} + +static void setup (void ) +{ + hpage_size =SAFE_READ_MEMINFO (MEMINFO_HPAGE_SIZE )*1024 ; + huge_fd =tst_creat_unlinked (MNTPOINT );
Shouldn't we open a file under the MNTPOINT?
Something as:
#define HUGEFILE MNTPOINT "hugefile"
...
huge_fd = tst_creat_unlinked(HUGEFILE);
...
The rest looks good to me.
Signature · 5 lines
Cyril Hrubis [email protected] -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v7 3/4] Hugetlb: Migrating libhugetlbfs chunk-overcommit
Quoted 21 lines · Cyril Hrubis
Hi!
Quoted 20 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +14
-0@@ -0,0 +1,146 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* +* Copyright (C) 2005-2006 David Gibson & Adam Litke, IBM Corporation. +* Author: David Gibson & Adam Litke +*/ + +/*\ +* [Description] +* +* Some kernel versions after hugepage demand allocation was added used a +* dubious heuristic to check if there was enough hugepage space available +* for a given mapping. The number of not-already-instantiated pages in +* the mapping was compared against the total hugepage free pool. It was +* very easy to confuse this heuristic into overcommitting by allocating
Quoted 8 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c line 20
Quoted 6 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +6
-0+* hugepage memory in chunks, each less than the total available pool size +* but together more than available. This would generally lead to OOM +* SIGKILLs of one process or another when it tried to instantiate pages +* beyond the available pool. +* +* HISTORY This looks like a leftover.
Ok.
Quoted 107 lines
Quoted 94 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +93
-0+* +*/ + +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include <sys/mount.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <signal.h> + +#include "hugetlb.h" + +#define MNTPOINT "hugetlbfs/" +#define WITH_OVERCOMMIT 0 +#define WITHOUT_OVERCOMMIT 1 + +static long hpage_size; +static int huge_fd =-1 ; + +static void test_chunk_overcommit (void ) +{ +unsigned long totpages, chunk1, chunk2; +void *p, *q; +pid_t child; +int status; + + totpages =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE ); + + chunk1 = (totpages /2 ) +1 ; + chunk2 = totpages - chunk1 +1 ; + +tst_res (TINFO ,"Free: %ld hugepages available: " +"chunk1=%ld chunk2=%ld" , totpages, chunk1, chunk2); + + p =SAFE_MMAP (NULL , chunk1*hpage_size,PROT_READ |PROT_WRITE ,MAP_SHARED , + huge_fd,0 ); + + q =mmap (NULL , chunk2*hpage_size,PROT_READ |PROT_WRITE ,MAP_SHARED , + huge_fd, chunk1*hpage_size); +if (q ==MAP_FAILED ) { +if (errno !=ENOMEM ) { +tst_res (TFAIL |TERRNO ,"mmap() chunk2" ); + goto cleanup1; + }else { +tst_res (TPASS ,"Successful without overcommit pages" ); + goto cleanup1; + } + } + +tst_res (TINFO ,"Looks like we've overcommitted, testing..." ); +/* Looks like we're overcommited, but we need to confirm that +* this is bad. We touch it all in a child process because an +* overcommit will generally lead to a SIGKILL which we can't +* handle, of course. +*/ + child =SAFE_FORK (); + +if (child ==0 ) { +memset (p,0 , chunk1*hpage_size); +memset (q,0 , chunk2*hpage_size); +exit (0 ); + } + +SAFE_WAITPID (child, &status,0 ); + +if (WIFSIGNALED (status)) { +tst_res (TFAIL ,"Killed by signal '%s' due to overcommit" , +tst_strsig (WTERMSIG (status))); + goto cleanup2; + } + +tst_res (TPASS ,"Successful with overcommit pages" ); + +cleanup2: +SAFE_MUNMAP (q, chunk2*hpage_size); + +cleanup1: +SAFE_MUNMAP (p, chunk1*hpage_size); +SAFE_FTRUNCATE (huge_fd,0 ); +} + +static void run_test (unsigned int test_type) +{ +switch (test_type) { +case WITHOUT_OVERCOMMIT : +tst_res (TINFO ,"Without overcommit testing..." ); +SAFE_FILE_PRINTF (PATH_OC_HPAGES ,"%d" ,0 ); +break ; +case WITH_OVERCOMMIT : +tst_res (TINFO ,"With overcommit testing..." );testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c line 123
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap08.c new file +10
-0+SAFE_FILE_PRINTF (PATH_OC_HPAGES ,"%d" ,2 ); +break ; + } +test_chunk_overcommit (); +} + +static void setup (void ) +{ + hpage_size =SAFE_READ_MEMINFO (MEMINFO_HPAGE_SIZE )*1024 ; + huge_fd =tst_creat_unlinked (MNTPOINT );Shouldn't we open a file under the MNTPOINT?
Quoted 8 lines
Something as:
#define HUGEFILE MNTPOINT "hugefile"
...
huge_fd = tst_creat_unlinked(HUGEFILE);...
This function creat a file with random name, so that one test can call this function multiple times to creat multple files whenever required. So it will just take the path inside which it will creat all these files. To keep hugetlb test file with ditinguisable name, the path is sufficient, no need to take hugefile as argument.
So file is: hugetlbfs/ltp_xxxxxx_<tid>
Quoted 9 lines
The rest looks good to me.
Signature · 5 lines
Cyril Hrubis [email protected] -- Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v7 3/4] Hugetlb: Migrating libhugetlbfs chunk-overcommit
Hi!
Quoted 6 lines
Quoted 6 lines
#define HUGEFILE MNTPOINT "hugefile"
...
huge_fd = tst_creat_unlinked(HUGEFILE);...
Quoted 7 lines
This function creat a file with random name, so that one test can call this function multiple times to creat multple files whenever required. So it will just take the path inside which it will creat all these files. To keep hugetlb test file with ditinguisable name, the path is sufficient, no need to take hugefile as argument.
So file is: hugetlbfs/ltp_xxxxxx_<tid>
Sorry, I got somehow confused in the morning, of course the code is correct.
Signature · 5 lines
Cyril Hrubis [email protected] -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v7 4/4 Hugetlb: Migrating libhugetlbfs corrupt-by-cow-opt
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/corrupt-by-cow-opt.c test
Test Description: Test sanity of cow optimization on page cache. If a page in page cache has only 1 ref count, it is mapped for a private mapping directly and is overwritten freely, so next time we access the page, we can see corrupt data.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap09.c | 79 +++++++++++++++++++ 3 files changed, 81 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap09.c
runtest/hugetlb +1 -0
@@ -5,6 +5,7 @@ hugemmap05 hugemmap05 hugemmap06 hugemmap06 hugemmap07 hugemmap07 hugemmap08 hugemmap08 +hugemmap09 hugemmap09 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -6,6 +6,7 @@ /hugetlb/hugemmap/hugemmap06 /hugetlb/hugemmap/hugemmap07 /hugetlb/hugemmap/hugemmap08 +/hugetlb/hugemmap/hugemmap09 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap09.c new file +79 -0
79 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v7 4/4] Hugetlb: Migrating libhugetlbfs corrupt-by-cow-opt
Hi!
testcases/kernel/mem/hugetlb/hugemmap/hugemmap09.c line 63
Quoted 4 lines
testcases/kernel/mem/hugetlb/hugemmap/hugemmap09.c new file +4
-0+static void setup (void ) +{ + hpage_size =SAFE_READ_MEMINFO (MEMINFO_HPAGE_SIZE )*1024 ; + huge_fd =tst_creat_unlinked (MNTPOINT );
Same here, HUGEFILE instead MNTPOINT?
The rest looks good.
Signature · 5 lines
Cyril Hrubis [email protected] -- Mailing list info: https://lists.linux.it/listinfo/ltp