Hugetlb:Migrating the libhugetlbfs tests
v2 cover Hugetlb:Migrating the libhugetlbfs tests
Hi,
This patch series is in continuation to part [1], part [2] and part [3]. This series include 13 more tests taken from libhugetlbfs.
Background:
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. These patches include tests from libhugetlbfs.
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]/
Tarun Sahu (13):
Hugetlb: Migrating libhugetlbfs mlock
Hugetlb: Migrating libhugetlbfs mmap-cow
Hugetlb: Migrating libhugetlbfs mmap-gettest
Hugetlb: Migrating libhugetlbfs mprotect
Hugetlb: Migrating libhugetlbfs mremap-fixed-huge-near-normal
Hugetlb: Migrating libhugetlbfs mremap-fixed-normal-near-huge
Hugetlb: Migrating libhugetlbfs noresv-reserve-resv-page
Hugetlb: Migrating libhugetlbfs noresv-regarded-as-resv
Hugetlb: Migrating libhugetlbfs private
Hugetlb: Migrating libhugetlbfs readahead_reserve
Hugetlb: Migrating libhugetlbfs shared
Hugetlb: Migrating libhugetlbfs shm-fork
Hugetlb: Migrating libhugetlbfs mremap-expand-slice-collision
runtest/hugetlb | 13 + testcases/kernel/mem/.gitignore | 13 + .../kernel/mem/hugetlb/hugefork/hugefork02.c | 90 +++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap20.c | 86 +++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap21.c | 116 +++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap22.c | 89 +++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap23.c | 226 ++++++++++++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap24.c | 186 ++++++++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap25.c | 118 +++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap26.c | 103 ++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap27.c | 121 ++++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap28.c | 66 +++++ .../kernel/mem/hugetlb/hugemmap/hugemmap29.c | 107 +++++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap30.c | 75 ++++++ .../kernel/mem/hugetlb/hugemmap/hugemmap31.c | 76 ++++++ testcases/kernel/mem/hugetlb/lib/hugetlb.c | 19 ++ testcases/kernel/mem/hugetlb/lib/hugetlb.h | 11 +- 17 files changed, 1514 insertions(+), 1 deletion(-) create mode 100644 testcases/kernel/mem/hugetlb/hugefork/hugefork02.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap20.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap21.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap22.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap24.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap25.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap26.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap27.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap28.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap29.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap30.c create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap31.c
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 1/13 Hugetlb: Migrating libhugetlbfs mlock
Migrating the libhugetlbfs/testcases/mlock.c test
Test Description: The test checks that mlocking hugetlb areas works with all combinations of MAP_PRIVATE and MAP_SHARED with and without MAP_LOCKED specified.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap20.c | 86 +++++++++++++++++++ 3 files changed, 88 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap20.c
runtest/hugetlb +1 -0
@@ -21,6 +21,7 @@ hugemmap16 hugemmap16 hugemmap17 hugemmap17 hugemmap18 hugemmap18 hugemmap19 hugemmap19 +hugemmap20 hugemmap20 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -20,6 +20,7 @@ /hugetlb/hugemmap/hugemmap17 /hugetlb/hugemmap/hugemmap18 /hugetlb/hugemmap/hugemmap19 +/hugetlb/hugemmap/hugemmap20 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap20.c new file +86 -0
86 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 2/13 Hugetlb: Migrating libhugetlbfs mmap-cow
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/mmap-cow.c test
Test Description: Tests copy-on-write semantics of large pages where a number of threads map the same file with the MAP_PRIVATE flag. The threads then write into their copy of the mapping and recheck the contents to ensure they were not corrupted by the other threads.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap21.c | 116 ++++++++++++++++++ 3 files changed, 118 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap21.c
runtest/hugetlb +1 -0
@@ -22,6 +22,7 @@ hugemmap17 hugemmap17 hugemmap18 hugemmap18 hugemmap19 hugemmap19 hugemmap20 hugemmap20 +hugemmap21 hugemmap21 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -21,6 +21,7 @@ /hugetlb/hugemmap/hugemmap18 /hugetlb/hugemmap/hugemmap19 /hugetlb/hugemmap/hugemmap20 +/hugetlb/hugemmap/hugemmap21 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap21.c new file +116 -0
116 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 3/13 Hugetlb: Migrating libhugetlbfs mmap-gettest
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/mmap-gettest.c test
Test Description: This baseline test validates that a mapping of a certain size can be created, correctly. Once created, all the pages are filled with a pattern and rechecked to test for corruption. The mapping is then released. This process is repeated for a specified number of iterations.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap22.c | 89 +++++++++++++++++++ 3 files changed, 91 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap22.c
runtest/hugetlb +1 -0
@@ -23,6 +23,7 @@ hugemmap18 hugemmap18 hugemmap19 hugemmap19 hugemmap20 hugemmap20 hugemmap21 hugemmap21 +hugemmap22 hugemmap22 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -22,6 +22,7 @@ /hugetlb/hugemmap/hugemmap19 /hugetlb/hugemmap/hugemmap20 /hugetlb/hugemmap/hugemmap21 +/hugetlb/hugemmap/hugemmap22 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap22.c new file +89 -0
89 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 4/13 Hugetlb: Migrating libhugetlbfs mprotect
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/mprotect.c test
Test Description: This test uses mprotect to change protection of hugepage mapping and perform read/write operation. It checks if the operation results in expected behaviour as per the protection.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap23.c | 226 ++++++++++++++++++ testcases/kernel/mem/hugetlb/lib/hugetlb.h | 9 + 4 files changed, 237 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c
runtest/hugetlb +1 -0
@@ -24,6 +24,7 @@ hugemmap19 hugemmap19 hugemmap20 hugemmap20 hugemmap21 hugemmap21 hugemmap22 hugemmap22 +hugemmap23 hugemmap23 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -23,6 +23,7 @@ /hugetlb/hugemmap/hugemmap20 /hugetlb/hugemmap/hugemmap21 /hugetlb/hugemmap/hugemmap22 +/hugetlb/hugemmap/hugemmap23 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c new file +226 -0
226 lines not on this page · raw message
testcases/kernel/mem/hugetlb/lib/hugetlb.h +9 -0
@@ -30,6 +30,15 @@#define SHM_HUGETLB 04000/* segment is mapped via hugetlb */ #endif +#ifndef barrier +# ifdef mb +/* Redefining the mb() */ +# define barrier () mb() +# else +# define barrier () __asm__ __volatile__ ("" : : : "memory") +# endif +#endif +/* * to get the lower nine permission bits * from shmid_ds.ipc_perm.mode
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 5/13 Hugetlb: Migrating libhugetlbfs mremap-fixed-huge-near-normal
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/mremap-fixed-huge-near-normal.c test
Test Description: The kernel has bug for mremap() on some architecture. mremap() can cause crashes on architectures with holes in the address space (like ia64) and on powerpc with it's distinct page size "slices".
This test get the normal mapping address and mremap() hugepage mapping near to this normal mapping.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap25.c | 118 ++++++++++++++++++ testcases/kernel/mem/hugetlb/lib/hugetlb.c | 19 +++ testcases/kernel/mem/hugetlb/lib/hugetlb.h | 2 +- 5 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap25.c
runtest/hugetlb +1 -0
@@ -25,6 +25,7 @@ hugemmap20 hugemmap20 hugemmap21 hugemmap21 hugemmap22 hugemmap22 hugemmap23 hugemmap23 +hugemmap25 hugemmap25 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -24,6 +24,7 @@ /hugetlb/hugemmap/hugemmap21 /hugetlb/hugemmap/hugemmap22 /hugetlb/hugemmap/hugemmap23 +/hugetlb/hugemmap/hugemmap25 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap25.c new file +118 -0
118 lines not on this page · raw message
testcases/kernel/mem/hugetlb/lib/hugetlb.c +19 -0
@@ -111,3 +111,22 @@ void rm_shm(int shm_id)tst_res (TINFO ,"id = %d" , shm_id); } } + +#define RANDOM_CONSTANT 0x1234ABCD +int do_readback (void *p,size_t size,char *desc) +{ +unsigned int *q = p; +size_t i; + +for (i =0 ; i < (size /sizeof (*q)); i++) + q[i] =RANDOM_CONSTANT ^ i; + +for (i =0 ; i < (size /sizeof (*q)); i++) { +if (q[i] != (RANDOM_CONSTANT ^ i)) { +tst_res (TFAIL ,"At \"%s\": Mismatch at offset 0x%lx: 0x%x " +"instead of 0x%lx" , desc, i, q[i],RANDOM_CONSTANT ^ i); +return -1 ; + } + } +return 0 ; +}
testcases/kernel/mem/hugetlb/lib/hugetlb.h +1 -1
@@ -50,5 +50,5 @@ extern key_t shmkey; /* an IPC key generated by ftok() */int getipckey (void );int getuserid (char *user);void rm_shm (int shm_id); - +int do_readback (void *p,size_t size,char *desc);#endif /* hugetlb.h */
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 6/13 Hugetlb: Migrating libhugetlbfs mremap-fixed-normal-near-huge
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/mremap-fixed-normal-near-huge.c test
Test Description: The kernel has bug for mremap() on some architecture. mremap() can cause crashes on architectures with holes in the address space (like ia64) and on powerpc with it's distinct page size "slices".
This test get the huge mapping address and mremap() normal mapping near to this huge mapping.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap26.c | 103 ++++++++++++++++++ 3 files changed, 105 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap26.c
runtest/hugetlb +1 -0
@@ -26,6 +26,7 @@ hugemmap21 hugemmap21 hugemmap22 hugemmap22 hugemmap23 hugemmap23 hugemmap25 hugemmap25 +hugemmap26 hugemmap26 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -25,6 +25,7 @@ /hugetlb/hugemmap/hugemmap22 /hugetlb/hugemmap/hugemmap23 /hugetlb/hugemmap/hugemmap25 +/hugetlb/hugemmap/hugemmap26 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap26.c new file +103 -0
103 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 7/13 Hugetlb: Migrating libhugetlbfs noresv-reserve-resv-page
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/noresv-preserve-resv-page.c test
Test Description: Test to preserve a reserved page against no-reserved mapping. If all hugepages are reserved, access to no-reserved shared mapping cause a process die, instead of stealing a hugepage which is reserved for other process.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap27.c | 121 ++++++++++++++++++ 3 files changed, 123 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap27.c
runtest/hugetlb +1 -0
@@ -27,6 +27,7 @@ hugemmap22 hugemmap22 hugemmap23 hugemmap23 hugemmap25 hugemmap25 hugemmap26 hugemmap26 +hugemmap27 hugemmap27 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -26,6 +26,7 @@ /hugetlb/hugemmap/hugemmap23 /hugetlb/hugemmap/hugemmap25 /hugetlb/hugemmap/hugemmap26 +/hugetlb/hugemmap/hugemmap27 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap27.c new file +121 -0
121 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 8/13 Hugetlb: Migrating libhugetlbfs noresv-regarded-as-resv
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/noresv-regarded-as-resv.c test
Test Description: Test to correct handling for reserve count. If no reserved mapping is created to reserved file region, it should be considered as reserve mapping. Otherwise, reserve count will be overflowed.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap28.c | 66 +++++++++++++++++++ 3 files changed, 68 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap28.c
runtest/hugetlb +1 -0
@@ -28,6 +28,7 @@ hugemmap23 hugemmap23 hugemmap25 hugemmap25 hugemmap26 hugemmap26 hugemmap27 hugemmap27 +hugemmap28 hugemmap28 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -27,6 +27,7 @@ /hugetlb/hugemmap/hugemmap25 /hugetlb/hugemmap/hugemmap26 /hugetlb/hugemmap/hugemmap27 +/hugetlb/hugemmap/hugemmap28 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap28.c new file +66 -0
66 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 9/13 Hugetlb: Migrating libhugetlbfs private
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/private.c test
Test Description: The test do mmap() with shared mapping and write. It matches the data with private mmap() and then change it with other data. It checks shared mapping data if data is not contaiminated by private mapping.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap29.c | 107 ++++++++++++++++++ 3 files changed, 109 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap29.c
runtest/hugetlb +1 -0
@@ -29,6 +29,7 @@ hugemmap25 hugemmap25 hugemmap26 hugemmap26 hugemmap27 hugemmap27 hugemmap28 hugemmap28 +hugemmap29 hugemmap29 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -28,6 +28,7 @@ /hugetlb/hugemmap/hugemmap26 /hugetlb/hugemmap/hugemmap27 /hugetlb/hugemmap/hugemmap28 +/hugetlb/hugemmap/hugemmap29 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap29.c new file +107 -0
107 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 10/13 Hugetlb: Migrating libhugetlbfs readahead_reserve
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/readahead_reserve.c test
Test Description: readahead() on some kernels can cause the reservation counter to get corrupted. The problem is that the patches are allocated for the reservation but not faulted in at the time of allocation. The counters do not get updated and effectively "leak". This test identifies whether the kernel is vulnerable to the problem or not. It's fixed in kernel by 'commit f2deae9d4e70
("Remove implementation of readpage from the hugetlbfs_aops")'.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap30.c | 75 +++++++++++++++++++ 3 files changed, 77 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap30.c
runtest/hugetlb +1 -0
@@ -30,6 +30,7 @@ hugemmap26 hugemmap26 hugemmap27 hugemmap27 hugemmap28 hugemmap28 hugemmap29 hugemmap29 +hugemmap30 hugemmap30 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -29,6 +29,7 @@ /hugetlb/hugemmap/hugemmap27 /hugetlb/hugemmap/hugemmap28 /hugetlb/hugemmap/hugemmap29 +/hugetlb/hugemmap/hugemmap30 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap30.c new file +75 -0
75 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 11/13 Hugetlb: Migrating libhugetlbfs shared
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/shared.c test
Test Description: This test is basic shared mapping test. Two shared mappings are created with same offset on a file. It checks if writing to one mapping can be seen to other mapping or not?
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap31.c | 76 +++++++++++++++++++ 3 files changed, 78 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap31.c
runtest/hugetlb +1 -0
@@ -31,6 +31,7 @@ hugemmap27 hugemmap27 hugemmap28 hugemmap28 hugemmap29 hugemmap29 hugemmap30 hugemmap30 +hugemmap31 hugemmap31 hugemmap05_1 hugemmap05 -m hugemmap05_2 hugemmap05 -s hugemmap05_3 hugemmap05 -s -m
testcases/kernel/mem/.gitignore +1 -0
@@ -30,6 +30,7 @@ /hugetlb/hugemmap/hugemmap28 /hugetlb/hugemmap/hugemmap29 /hugetlb/hugemmap/hugemmap30 +/hugetlb/hugemmap/hugemmap31 /hugetlb/hugeshmat/hugeshmat01 /hugetlb/hugeshmat/hugeshmat02 /hugetlb/hugeshmat/hugeshmat03
testcases/kernel/mem/hugetlb/hugemmap/hugemmap31.c new file +76 -0
76 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 12/13 Hugetlb: Migrating libhugetlbfs shm-fork
In reply to Tarun SahuMigrating the libhugetlbfs/testcases/shm-fork.c test
Test Description: Test shared memory behavior when multiple threads are Test shared memory behavior when multiple threads are attached to a segment. A segment is created and then children are spawned which attach, write, read (verify), and detach from the shared memory segment.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugefork/hugefork02.c | 90 +++++++++++++++++++ 3 files changed, 92 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugefork/hugefork02.c
runtest/hugetlb +1 -0
@@ -2,6 +2,7 @@ hugefallocate01 hugefallocate01 hugefallocate02 hugefallocate02 hugefork01 hugefork01 +hugefork02 hugefork02 hugemmap01 hugemmap01 hugemmap02 hugemmap02
testcases/kernel/mem/.gitignore +1 -0
@@ -2,6 +2,7 @@ /hugetlb/hugefallocate/hugefallocate01 /hugetlb/hugefallocate/hugefallocate02 /hugetlb/hugefork/hugefork01 +/hugetlb/hugefork/hugefork02 /hugetlb/hugemmap/hugemmap01 /hugetlb/hugemmap/hugemmap02 /hugetlb/hugemmap/hugemmap04
testcases/kernel/mem/hugetlb/hugefork/hugefork02.c new file +90 -0
90 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v2 13/13 Hugetlb: Migrating libhugetlbfs mremap-expand-slice-collision
In reply to Tarun SahuKernel has bug in mremap for some architecture. mremap() can cause crashes on architectures with holes in the address space (like ia64) and on powerpc with it's distict page size slices.
This test perform mremap() with normal and hugepages around powerpc slice boundary.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../kernel/mem/hugetlb/hugemmap/hugemmap24.c | 186 ++++++++++++++++++ 3 files changed, 188 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap24.c
runtest/hugetlb +1 -0
@@ -26,6 +26,7 @@ hugemmap20 hugemmap20 hugemmap21 hugemmap21 hugemmap22 hugemmap22 hugemmap23 hugemmap23 +hugemmap23 hugemmap24 hugemmap25 hugemmap25 hugemmap26 hugemmap26 hugemmap27 hugemmap27
testcases/kernel/mem/.gitignore +1 -0
@@ -25,6 +25,7 @@ /hugetlb/hugemmap/hugemmap21 /hugetlb/hugemmap/hugemmap22 /hugetlb/hugemmap/hugemmap23 +/hugetlb/hugemmap/hugemmap24 /hugetlb/hugemmap/hugemmap25 /hugetlb/hugemmap/hugemmap26 /hugetlb/hugemmap/hugemmap27
testcases/kernel/mem/hugetlb/hugemmap/hugemmap24.c new file +186 -0
186 lines not on this page · raw message
Signature · 5 lines
2.31.1 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Hi Tarrun,
Thanks for your work! I did some cleanup and merged all.
testcases/kernel/mem/hugetlb/hugemmap/hugemmap20.c +11 -10
@@ -14,40 +14,41 @@#include "hugetlb.h" #define MNTPOINT "hugetlbfs/" -static int fd =-1 ; + +static int fd =-1 ;static unsigned long hpage_size; -static struct testcase { + +static struct tcase {int flags;char *flags_str; -} testcases[] = { +} tcases[] = { {MAP_PRIVATE ,"MAP_PRIVATE" }, {MAP_SHARED ,"MAP_SHARED" }, - {MAP_PRIVATE |MAP_LOCKED ,"MAP_PRIVATE|MAP_LOCKED" }, - {MAP_SHARED |MAP_LOCKED ,"MAP_SHARED|MAP_LOCKED" }, + {MAP_PRIVATE |MAP_LOCKED ,"MAP_PRIVATE | MAP_LOCKED" }, + {MAP_SHARED |MAP_LOCKED ,"MAP_SHARED | MAP_LOCKED" }, }; -static void run_test (unsigned int num) +static void run_test (unsigned int i) { -void *p; -int flags = testcases[num].flags; -char *flags_str = testcases[num].flags_str;int ret; +void *p; +struct tcase *tc = &tcases[i]; fd =tst_creat_unlinked (MNTPOINT ,0 ); - p =SAFE_MMAP (0 , hpage_size,PROT_READ |PROT_WRITE , flags, fd,0 ); + p = SAFE_MMAP(0, hpage_size, PROT_READ|PROT_WRITE, tc->flags, fd,
0);
ret = mlock(p, hpage_size);
if (ret) {
- tst_res(TFAIL|TERRNO, "mlock() failed (flags %s)",
flags_str);
+ tst_res(TFAIL|TERRNO, "mlock() failed (flags %s)",
tc->flags_str);
goto cleanup;
}
ret = munlock(p, hpage_size);
if (ret)- tst_res(TFAIL|TERRNO, "munlock() failed (flags %s)",flags_str);
+ tst_res(TFAIL|TERRNO, "munlock() failed (flags %s)",tc->flags_str);
else
- tst_res(TPASS, "mlock/munlock with %s hugetlb mmap",
- flags_str);
+ tst_res(TPASS, "mlock/munlock with %s hugetlb mmap",tc->flags_str);
+
cleanup:
SAFE_MUNMAP(p, hpage_size);
SAFE_CLOSE(fd);@@ -74,7 +75,7 @@ static void cleanup(void)
}
static struct tst_test test = {
- .tcnt = ARRAY_SIZE(testcases),
+ .tcnt = ARRAY_SIZE(tcases),
.needs_root = 1,
.mntpoint = MNTPOINT,
.needs_hugetlbfs = 1,
(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap21.c index ce3c5866e..a8e332ebd 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap21.c +1 -1
@@ -37,16 +37,18 @@ static void do_work(int thread, size_t size, int fd)memcpy ((char *)addr+i, &pattern,1 );if (msync (addr, size,MS_SYNC )) - tst_brk(TBROK|TERRNO, "Thread %d (pid %d): msync() failed", + tst_brk(TBROK | TERRNO, "Thread %d (pid %d): msync()
failed",
thread, getpid());
- for (i = 0; i < size; i++)
+ for (i = 0; i < size; i++) {
if (addr[i] != pattern) {
tst_res(TFAIL, "thread %d (pid: %d): Corruption at
%p; "
"Got %c, Expected %c", thread, getpid(),
&addr[i], addr[i], pattern);
goto cleanup;
}+ }
+
tst_res(TINFO, "Thread %d (pid %d): Pattern verified",
thread, getpid());
@@ -57,21 +59,21 @@ cleanup:
static void run_test(void)
{
+ int i, pid;
char *addr;
size_t size, itr;
- int i, pid;
pid_t *wait_list;
wait_list = SAFE_MALLOC(THREADS * sizeof(pid_t));
size = (NR_HUGEPAGES / (THREADS+1)) * hpage_size;-
- /* First, mmap the file with MAP_SHARED and fill with data
+ /*
+ * First, mmap the file with MAP_SHARED and fill with data
* If this is not done, then the fault handler will not be
* called in the kernel since private mappings will be
* created for the children at prefault time. */
- addr = SAFE_MMAP(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd,
0);
+ addr = SAFE_MMAP(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
fd, 0);
for (itr = 0; itr < size; itr += 8)
memcpy(addr+itr, "deadbeef", 8);(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap22.c index 567d0448c..c2deab477 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap22.c +2 -0
@@ -42,6 +42,7 @@ static void run_test(unsigned int iter) } } } +for (i =0 ; i <NR_HUGEPAGES ; i++) { pattern =65 +(i%26 );memset (m+(i*hpage_size), pattern, hpage_size);
@@ -58,6 +59,7 @@ static void run_test(unsigned int iter) } } } + tst_res(TPASS, "Iter %u: Successfully verified the mmap area.",
iter);
cleanup:
(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c index dcb9abff7..4c1cff325 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c +3 -1
@@ -22,7 +22,8 @@ static sigjmp_buf sig_escape;static void *sig_expected =MAP_FAILED ;static long hpage_size;static void *addr; -static struct testcase { + +static struct tcase { char *tname; unsigned long len1; int prot1;
@@ -53,14 +54,16 @@ static struct testcase {static void sig_handler (int signum,siginfo_t *si,void *uc) { (void )uc; +if (signum ==SIGSEGV ) { tst_res(TINFO, "SIGSEGV at %p (sig_expected=%p)",
si->si_addr,
sig_expected);
if (si->si_addr == sig_expected)
siglongjmp(sig_escape, 1);
tst_res(TFAIL, "SIGSEGV somewhere unexpected");
- } else
+ } else {
tst_res(TFAIL, "Unexpected signal %s", strsignal(signum));+ }
}
static int test_read(void *p)
@@ -118,7 +121,6 @@ static int test_prot(void *p, int prot, char *prot_str)
tst_res(TFAIL, "read failed on mmap(prot %s)",
prot_str);
return -1;
}
-
} else {
if (r != -1) {
tst_res(TFAIL, "read succeeded on mmap(prot %s)",
prot_str);
@@ -155,39 +157,42 @@ static int test_prot(void *p, int prot, char
*prot_str)
break;
}
}
+
return 0;}
-static void run_test(unsigned int num)
+static void run_test(unsigned int i)
{
void *p;
int ret;+ struct tcase *tc = &tcases[i];
- tst_res(TINFO, "Test Name: %s", tcases[num].tname);
+ tst_res(TINFO, "Test Name: %s", tc->tname);
- p = SAFE_MMAP(NULL, tcases[num].len1*hpage_size,
- tcases[num].prot1, MAP_SHARED, fd, 0);
+ p = SAFE_MMAP(NULL, tc->len1*hpage_size, tc->prot1, MAP_SHARED, fd,
0);
- ret = test_prot(p, tcases[num].prot1, tcases[num].prot1_str);
+ ret = test_prot(p, tc->prot1, tc->prot1_str);
if (ret)
goto cleanup;
- ret = mprotect(p, tcases[num].len2*hpage_size, tcases[num].prot2);
+
+ ret = mprotect(p, tc->len2*hpage_size, tc->prot2);
if (ret != 0) {
tst_res(TFAIL|TERRNO, "%s: mprotect(prot %s)",
- tcases[num].tname, tcases[num].prot2_str);
+ tc->tname, tc->prot2_str);
goto cleanup;
}- ret = test_prot(p, tcases[num].prot2, tcases[num].prot2_str);
+ ret = test_prot(p, tc->prot2, tc->prot2_str);
if (ret)
goto cleanup;- if (tcases[num].len2 < tcases[num].len1)
- ret = test_prot(p + tcases[num].len2*hpage_size,
tcases[num].prot1,
- tcases[num].prot1_str);
- tst_res(TPASS, "Successfully tested mprotect %s",
tcases[num].tname);
+ if (tc->len2 < tc->len1)
+ ret = test_prot(p + tc->len2*hpage_size, tc->prot1,tc->prot1_str);
+
+ tst_res(TPASS, "Successfully tested mprotect %s", tc->tname);
+
cleanup:
- SAFE_MUNMAP(p, tcases[num].len1*hpage_size);
+ SAFE_MUNMAP(p, tc->len1*hpage_size);
}
static void setup(void)
(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap24.c index 3316f04c2..a465aadec 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap24.c +0 -0
@@ -65,7 +65,9 @@ static int init_slice_boundary(int fd) tst_res(TFAIL|TERRNO, "couldn't find 2 free neighbour
slices");
return -1;
}
+
tst_res(TINFO, "using slice_boundary: 0x%lx", slice_boundary);
+
return 0;}
@@ -152,7 +154,9 @@ static void run_test(void)
}
if (ret)
goto cleanup;
+
tst_res(TPASS, "Successful");
+
cleanup:
if (p)
SAFE_MUNMAP(p, p_size);(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap25.c index 055a430e2..71beb90d3 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap25.c +6 -1
@@ -33,14 +33,17 @@ static int do_remap(int fd, void *target) ret =do_readback (a, hpage_size,"base huge" );if (ret) goto cleanup; + b =mremap (a, hpage_size, hpage_size,MREMAP_MAYMOVE |MREMAP_FIXED , target);if (b !=MAP_FAILED ) { ret =do_readback (b, hpage_size,"remapped" ); a = b; - }else + }else {tst_res (TINFO |TERRNO ,"mremap(MAYMOVE|FIXED) disallowed" ); + } + cleanup:SAFE_MUNMAP (a, hpage_size);return ret;
@@ -85,12 +88,15 @@ static void run_test(void) ret =do_readback (p, hpage_size,"base normal page" );if (ret) goto cleanup; + ret =do_remap (fd, p - hpage_size);if (ret) goto cleanup; + ret =do_remap (fd, p + hpage_size);if (ret ==0 ) tst_res(TPASS, "Successfully tested mremap hpage near
normal mapping");
+
cleanup:
SAFE_CLOSE(fd);
}
(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap26.c index db2d9ce81..609f2b63b 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap26.c +4 -3
@@ -34,14 +34,16 @@ static int do_remap(void *target) ret =do_readback (a, page_size,"base normal" );if (ret) goto cleanup; + b =mremap (a, page_size, page_size,MREMAP_MAYMOVE |MREMAP_FIXED , target);if (b !=MAP_FAILED ) {do_readback (b, page_size,"remapped" ); a = b; - }else + }else {tst_res (TINFO |TERRNO ,"mremap(MAYMOVE|FIXED) disallowed" ); + } cleanup:SAFE_MUNMAP (a, page_size);
@@ -54,8 +56,7 @@ static void run_test(void)int ret; fd =tst_creat_unlinked (MNTPOINT ,0 ); - p =SAFE_MMAP (NULL ,3 *hpage_size,PROT_READ |PROT_WRITE ,MAP_SHARED , - fd,0 ); + p = SAFE_MMAP(NULL, 3*hpage_size, PROT_READ|PROT_WRITE, MAP_SHARED,
fd, 0);
SAFE_MUNMAP(p, hpage_size);
@@ -68,12 +69,15 @@ static void run_test(void)
ret = do_readback(p, hpage_size, "base hugepage");
if (ret)
goto cleanup;
+
ret = do_remap(p - page_size);
if (ret)
goto cleanup;
+
ret = do_remap(p + hpage_size);
if (ret == 0)
tst_res(TPASS, "Successfully tested mremap normal near
hpage mapping");
+
cleanup:
SAFE_MUNMAP(p, hpage_size);
SAFE_CLOSE(fd);(quoted diff) +0 -0
b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap27.c index 42dc55558..218d9e190 100644
testcases/kernel/mem/hugetlb/hugemmap/hugemmap27.c +1 -1
@@ -14,7 +14,6 @@*/ #include <setjmp.h> -#include "hugetlb.h" #define MNTPOINT "hugetlbfs/"
@@ -26,13 +25,15 @@ static void *sig_expected = MAP_FAILED;static void sig_handler (int signum,siginfo_t *si,void *uc) { (void )uc; +if (signum ==SIGBUS ) {if (si->si_addr == sig_expected)siglongjmp (sig_escape,1 ); tst_res(TFAIL, "SIGBUS somewhere unexpected: %p (expected:
%p)",
si->si_addr, sig_expected);
- } else
+ } else {
tst_res(TFAIL, "Unexpected signal %s", strsignal(signum));+ }
}
static int test_write(void *p)
@@ -81,6 +82,7 @@ static void run_test(void)
tst_res(TPASS, "Successful with SIGSEGV received");
goto cleanup;
}
+
/* Provisioning succeeded because of overcommit */
if (SAFE_READ_MEMINFO(MEMINFO_HPAGE_SURP) ==
surp_hugepages + 1) {Signature · 5 lines
Regards, Li Wang -- Mailing list info: https://lists.linux.it/listinfo/ltp