Skip to contentSkip to conversation

Hugetlb:Migrating the libhugetlbfs tests

PATCH In review Tarun Sahu 2 participants 15 messages Jan 4, 2023 – Jan 6, 2023

lore
Share & tools
lore

Tarun Sahu

author
#0 lore raw

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
author
#1 lore raw

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
index 4da1525a7..2dffa8421 100644
@@ -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
index b6b3e5ddd..dfd372892 100644
@@ -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
author
#2 lore raw

PATCH v2 2/13 Hugetlb: Migrating libhugetlbfs mmap-cow

In reply to Tarun Sahu

Migrating 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
index 2dffa8421..71b4d57e4 100644
@@ -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
index dfd372892..74edfa392 100644
@@ -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
author
#3 lore raw

PATCH v2 3/13 Hugetlb: Migrating libhugetlbfs mmap-gettest

In reply to Tarun Sahu

Migrating 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
index 71b4d57e4..8e80db140 100644
@@ -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
index 74edfa392..0fd01dbce 100644
@@ -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
author
#4 lore raw

PATCH v2 4/13 Hugetlb: Migrating libhugetlbfs mprotect

In reply to Tarun Sahu

Migrating 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
index 8e80db140..8ade3c9ec 100644
@@ -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
index 0fd01dbce..ffd831f2e 100644
@@ -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
index a4300f40f..efca65cd6 100644
@@ -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
author
#5 lore raw

PATCH v2 5/13 Hugetlb: Migrating libhugetlbfs mremap-fixed-huge-near-normal

In reply to Tarun Sahu

Migrating 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
index 8ade3c9ec..65265b0fe 100644
@@ -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
index ffd831f2e..c865a1e55 100644
@@ -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
index 1204f21d2..43a677ce9 100644
@@ -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
index efca65cd6..241dab708 100644
@@ -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
author
#6 lore raw

PATCH v2 6/13 Hugetlb: Migrating libhugetlbfs mremap-fixed-normal-near-huge

In reply to Tarun Sahu

Migrating 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
index 65265b0fe..55185f2f7 100644
@@ -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
index c865a1e55..4886c6a5f 100644
@@ -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
author
#7 lore raw

PATCH v2 7/13 Hugetlb: Migrating libhugetlbfs noresv-reserve-resv-page

In reply to Tarun Sahu

Migrating 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
index 55185f2f7..d108542d2 100644
@@ -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
index 4886c6a5f..9862414c6 100644
@@ -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
author
#8 lore raw

PATCH v2 8/13 Hugetlb: Migrating libhugetlbfs noresv-regarded-as-resv

In reply to Tarun Sahu

Migrating 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
index d108542d2..95afe009e 100644
@@ -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
index 9862414c6..2f8ed0df0 100644
@@ -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
author
#9 lore raw

PATCH v2 9/13 Hugetlb: Migrating libhugetlbfs private

In reply to Tarun Sahu

Migrating 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
index 95afe009e..6ec8d1018 100644
@@ -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
index 2f8ed0df0..fef0a76d6 100644
@@ -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
author
#10 lore raw

PATCH v2 10/13 Hugetlb: Migrating libhugetlbfs readahead_reserve

In reply to Tarun Sahu

Migrating 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
index 6ec8d1018..60cca4eb7 100644
@@ -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
index fef0a76d6..bb9720452 100644
@@ -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
author
#11 lore raw

PATCH v2 11/13 Hugetlb: Migrating libhugetlbfs shared

In reply to Tarun Sahu

Migrating 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
index 60cca4eb7..33fd384b4 100644
@@ -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
index bb9720452..8375389cd 100644
@@ -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
author
#12 lore raw

PATCH v2 12/13 Hugetlb: Migrating libhugetlbfs shm-fork

In reply to Tarun Sahu

Migrating 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
index 33fd384b4..6d63fec5d 100644
@@ -2,6 +2,7 @@ hugefallocate01 hugefallocate01
 hugefallocate02 hugefallocate02
 
 hugefork01 hugefork01
+hugefork02 hugefork02
 
 hugemmap01 hugemmap01
 hugemmap02 hugemmap02
testcases/kernel/mem/.gitignore +1 -0
index 8375389cd..0c1311303 100644
@@ -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
author
#13 lore raw

PATCH v2 13/13 Hugetlb: Migrating libhugetlbfs mremap-expand-slice-collision

In reply to Tarun Sahu

Kernel 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
index 6d63fec5d..feb5dec32 100644
@@ -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
index 0c1311303..06e125d03 100644
@@ -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
#14 lore raw
In reply to Tarun Sahu

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