[PATCH 2/2] selftests: Remove Error/Failed prefix from ksft_exit_fail*() usages

From: Muhammad Usama Anjum
Date: Fri Apr 05 2024 - 09:18:40 EST

Next message: Andrew Jones: "Re: [PATCH v5 22/22] KVM: riscv: selftests: Add a test for counter overflow"
Previous message: Muhammad Usama Anjum: "[PATCH 1/2] selftests: Replace "Bail out" with "Error""
In reply to: Kees Cook: "Re: [PATCH 1/2] selftests: Replace "Bail out" with "Error""
Next in thread: Kees Cook: "Re: [PATCH 2/2] selftests: Remove Error/Failed prefix from ksft_exit_fail*() usages"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

Remove Error/Failed prefix from ksft_exit_fail*() usages as prefix is
already present in the ksft_exit_fail*().

Signed-off-by: Muhammad Usama Anjum <usama.anjum@xxxxxxxxxxxxx>
---
tools/testing/selftests/exec/load_address.c | 8 +-
.../testing/selftests/exec/recursion-depth.c | 10 +-
.../selftests/mm/map_fixed_noreplace.c | 24 +--
tools/testing/selftests/mm/map_populate.c | 2 +-
tools/testing/selftests/mm/mremap_dontunmap.c | 2 +-
tools/testing/selftests/mm/pagemap_ioctl.c | 166 +++++++++---------
.../selftests/mm/split_huge_page_test.c | 2 +-
7 files changed, 107 insertions(+), 107 deletions(-)

diff --git a/tools/testing/selftests/exec/load_address.c b/tools/testing/selftests/exec/load_address.c
index 17e3207d34ae7..438856b07260c 100644
--- a/tools/testing/selftests/exec/load_address.c
+++ b/tools/testing/selftests/exec/load_address.c
@@ -47,16 +47,16 @@ int main(int argc, char **argv)

ret = dl_iterate_phdr(ExtractStatistics, &extracted);
if (ret != 1)
- ksft_exit_fail_msg("FAILED: dl_iterate_phdr\n");
+ ksft_exit_fail_msg("dl_iterate_phdr\n");

if (extracted.alignment == 0)
- ksft_exit_fail_msg("FAILED: No alignment found\n");
+ ksft_exit_fail_msg("No alignment found\n");
else if (extracted.alignment & (extracted.alignment - 1))
- ksft_exit_fail_msg("FAILED: Alignment is not a power of 2\n");
+ ksft_exit_fail_msg("Alignment is not a power of 2\n");

misalign = extracted.load_address & (extracted.alignment - 1);
if (misalign)
- ksft_exit_fail_msg("FAILED: alignment = %llu, load_address = %llu\n",
+ ksft_exit_fail_msg("alignment = %llu, load_address = %llu\n",
extracted.alignment, extracted.load_address);

ksft_test_result_pass("Completed\n");
diff --git a/tools/testing/selftests/exec/recursion-depth.c b/tools/testing/selftests/exec/recursion-depth.c
index 438c8ff2fd260..9dd20251dc7eb 100644
--- a/tools/testing/selftests/exec/recursion-depth.c
+++ b/tools/testing/selftests/exec/recursion-depth.c
@@ -37,25 +37,25 @@ int main(void)
ksft_test_result_skip("error: unshare, errno %d\n", errno);
ksft_finished();
}
- ksft_exit_fail_perror("error: unshare");
+ ksft_exit_fail_perror("unshare");
}

if (mount(NULL, "/", NULL, MS_PRIVATE | MS_REC, NULL) == -1)
- ksft_exit_fail_perror("error: mount '/'");
+ ksft_exit_fail_perror("mount '/'");

/* Require "exec" filesystem. */
if (mount(NULL, "/tmp", "ramfs", 0, NULL) == -1)
- ksft_exit_fail_perror("error: mount ramfs");
+ ksft_exit_fail_perror("mount ramfs");

#define FILENAME "/tmp/1"

fd = creat(FILENAME, 0700);
if (fd == -1)
- ksft_exit_fail_perror("error: creat");
+ ksft_exit_fail_perror("creat");

#define S "#!" FILENAME "\n"
if (write(fd, S, strlen(S)) != strlen(S))
- ksft_exit_fail_perror("error: write");
+ ksft_exit_fail_perror("write");

close(fd);

diff --git a/tools/testing/selftests/mm/map_fixed_noreplace.c b/tools/testing/selftests/mm/map_fixed_noreplace.c
index b74813fdc9514..58fb562efe25b 100644
--- a/tools/testing/selftests/mm/map_fixed_noreplace.c
+++ b/tools/testing/selftests/mm/map_fixed_noreplace.c
@@ -30,10 +30,10 @@ static unsigned long find_base_addr(unsigned long size)
flags = MAP_PRIVATE | MAP_ANONYMOUS;
addr = mmap(NULL, size, PROT_NONE, flags, -1, 0);
if (addr == MAP_FAILED)
- ksft_exit_fail_msg("Error: couldn't map the space we need for the test\n");
+ ksft_exit_fail_msg("couldn't map the space we need for the test\n");

if (munmap(addr, size) != 0)
- ksft_exit_fail_msg("Error: munmap failed\n");
+ ksft_exit_fail_msg("munmap failed\n");

return (unsigned long)addr;
}
@@ -61,11 +61,11 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p == MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error: couldn't map the space we need for the test\n");
+ ksft_exit_fail_msg("couldn't map the space we need for the test\n");
}
if (munmap((void *)addr, 5 * page_size) != 0) {
dump_maps();
- ksft_exit_fail_msg("Error: munmap failed!?\n");
+ ksft_exit_fail_msg("munmap failed!?\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -74,7 +74,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p == MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error: first mmap() failed unexpectedly\n");
+ ksft_exit_fail_msg("first mmap() failed unexpectedly\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -91,7 +91,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p != MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:1: mmap() succeeded when it shouldn't have\n");
+ ksft_exit_fail_msg("1: mmap() succeeded when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -109,7 +109,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p != MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:2: mmap() succeeded when it shouldn't have\n");
+ ksft_exit_fail_msg("2: mmap() succeeded when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -126,7 +126,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p != MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:3: mmap() succeeded when it shouldn't have\n");
+ ksft_exit_fail_msg("3: mmap() succeeded when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -143,7 +143,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p != MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:4: mmap() succeeded when it shouldn't have\n");
+ ksft_exit_fail_msg("4: mmap() succeeded when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -160,7 +160,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p == MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:5: mmap() failed when it shouldn't have\n");
+ ksft_exit_fail_msg("5: mmap() failed when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -177,7 +177,7 @@ int main(void)
p = mmap((void *)addr, size, PROT_NONE, flags, -1, 0);
if (p == MAP_FAILED) {
dump_maps();
- ksft_exit_fail_msg("Error:6: mmap() failed when it shouldn't have\n");
+ ksft_exit_fail_msg("6: mmap() failed when it shouldn't have\n");
}
ksft_test_result_pass("mmap() @ 0x%lx-0x%lx p=%p result=%m\n", addr, addr + size, p);

@@ -185,7 +185,7 @@ int main(void)
size = 5 * page_size;
if (munmap((void *)addr, size) != 0) {
dump_maps();
- ksft_exit_fail_msg("Error: munmap failed!?\n");
+ ksft_exit_fail_msg("munmap failed!?\n");
}
ksft_test_result_pass("Base Address unmap() successful\n");

diff --git a/tools/testing/selftests/mm/map_populate.c b/tools/testing/selftests/mm/map_populate.c
index 5c8a53869b1bd..8254f80da376b 100644
--- a/tools/testing/selftests/mm/map_populate.c
+++ b/tools/testing/selftests/mm/map_populate.c
@@ -23,7 +23,7 @@
#define BUG_ON(condition, description) \
do { \
if (condition) \
- ksft_exit_fail_msg("[FAIL]\t%s:%d\t%s:%s\n", \
+ ksft_exit_fail_msg("%s:%d\t%s:%s\n", \
__func__, __LINE__, (description), \
strerror(errno)); \
} while (0)
diff --git a/tools/testing/selftests/mm/mremap_dontunmap.c b/tools/testing/selftests/mm/mremap_dontunmap.c
index 1d75084b9ca56..bb5c878059fa0 100644
--- a/tools/testing/selftests/mm/mremap_dontunmap.c
+++ b/tools/testing/selftests/mm/mremap_dontunmap.c
@@ -31,7 +31,7 @@ static void dump_maps(void)
do { \
if (condition) { \
dump_maps(); \
- ksft_exit_fail_msg("[FAIL]\t%s:%d\t%s:%s\n", \
+ ksft_exit_fail_msg("%s:%d\t%s:%s\n", \
__func__, __LINE__, (description), \
strerror(errno)); \
} \
diff --git a/tools/testing/selftests/mm/pagemap_ioctl.c b/tools/testing/selftests/mm/pagemap_ioctl.c
index d59517ed3d48b..da90948f5dcc5 100644
--- a/tools/testing/selftests/mm/pagemap_ioctl.c
+++ b/tools/testing/selftests/mm/pagemap_ioctl.c
@@ -153,7 +153,7 @@ int wp_addr_range(void *lpBaseAddress, int dwRegionSize)
if (pagemap_ioctl(lpBaseAddress, dwRegionSize, NULL, 0,
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN) < 0)
- ksft_exit_fail_msg("error %d %d %s\n", 1, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", 1, errno, strerror(errno));

return 0;
}
@@ -190,7 +190,7 @@ int userfaultfd_tests(void)
mem_size = num_pages * page_size;
mem = mmap(NULL, mem_size, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);

@@ -213,7 +213,7 @@ int userfaultfd_tests(void)
written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
vec_size - 2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 0, "%s all new pages must not be written (dirty)\n", __func__);

@@ -246,15 +246,15 @@ int sanity_tests_sd(void)

vec = malloc(sizeof(struct page_region) * vec_size);
if (!vec)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

vec2 = malloc(sizeof(struct page_region) * vec_size);
if (!vec2)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);
@@ -321,7 +321,7 @@ int sanity_tests_sd(void)
ret = pagemap_ioctl(mem, mem_size, vec, vec_size, 0, 0, PAGE_IS_WRITTEN, 0,
0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == mem_size/(page_size * 2),
"%s Repeated pattern of written and non-written pages\n", __func__);
@@ -331,18 +331,18 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
num_pages/2 - 2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ret2 = pagemap_ioctl(mem, mem_size, vec, 2, 0, 0, PAGE_IS_WRITTEN, 0, 0,
PAGE_IS_WRITTEN);
if (ret2 < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret2, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret2, errno, strerror(errno));

ret3 = pagemap_ioctl(mem, mem_size, vec, vec_size,
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret3 < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret3, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret3, errno, strerror(errno));

ksft_test_result((ret + ret3) == num_pages/2 && ret2 == 2,
"%s Repeated pattern of written and non-written pages in parts %d %d %d\n",
@@ -357,13 +357,13 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
num_pages/2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ret2 = pagemap_ioctl(mem, mem_size, vec, vec_size,
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret2 < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret2, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret2, errno, strerror(errno));

ksft_test_result(ret == num_pages/2 && ret2 == 1,
"%s Repeated pattern of written and non-written pages max_pages\n",
@@ -378,12 +378,12 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ret2 = pagemap_ioctl(mem, mem_size, vec2, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret2 < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret2, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret2, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == 2 &&
vec[0].start == (uintptr_t)(mem + page_size) &&
@@ -398,10 +398,10 @@ int sanity_tests_sd(void)
/* 7. Two regions */
m[0] = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (m[0] == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
m[1] = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (m[1] == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(m[0], mem_size);
wp_init(m[1], mem_size);
@@ -416,7 +416,7 @@ int sanity_tests_sd(void)
ret = pagemap_ioctl(m[1], mem_size, vec, 1, 0, 0, PAGE_IS_WRITTEN, 0, 0,
PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == mem_size/page_size,
"%s Two regions\n", __func__);
@@ -435,11 +435,11 @@ int sanity_tests_sd(void)

vec = malloc(sizeof(struct page_region) * vec_size);
if (!vec)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);
@@ -448,7 +448,7 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

for (i = 0; i < mem_size/page_size; i += 2)
mem[i * page_size]++;
@@ -457,7 +457,7 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

total_pages += ret;

@@ -465,7 +465,7 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

total_pages += ret;

@@ -473,7 +473,7 @@ int sanity_tests_sd(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

total_pages += ret;

@@ -490,11 +490,11 @@ int sanity_tests_sd(void)

vec = malloc(sizeof(struct page_region) * vec_size);
if (!vec)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);
@@ -515,7 +515,7 @@ int sanity_tests_sd(void)
vec_size, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

if (ret > vec_size)
break;
@@ -540,11 +540,11 @@ int sanity_tests_sd(void)

vec = malloc(sizeof(struct page_region) * vec_size);
if (!vec)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);
@@ -554,63 +554,63 @@ int sanity_tests_sd(void)
ret = pagemap_ioc(mem, 0, vec, vec_size, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 0 && walk_end == (long)mem,
"Walk_end: Same start and end address\n");

ret = pagemap_ioc(mem, 0, vec, vec_size, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 0 && walk_end == (long)mem,
"Walk_end: Same start and end with WP\n");

ret = pagemap_ioc(mem, 0, vec, 0, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 0 && walk_end == (long)mem,
"Walk_end: Same start and end with 0 output buffer\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + mem_size),
"Walk_end: Big vec\n");

ret = pagemap_ioc(mem, mem_size, vec, 1, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + mem_size),
"Walk_end: vec of minimum length\n");

ret = pagemap_ioc(mem, mem_size, vec, 1, 0,
vec_size, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + mem_size),
"Walk_end: Max pages specified\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
vec_size/2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + mem_size/2),
"Walk_end: Half max pages\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
1, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size),
"Walk_end: 1 max page\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
-1, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + mem_size),
"Walk_end: max pages\n");

@@ -621,49 +621,49 @@ int sanity_tests_sd(void)
ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == vec_size/2 && walk_end == (long)(mem + mem_size),
"Walk_end sparse: Big vec\n");

ret = pagemap_ioc(mem, mem_size, vec, 1, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),
"Walk_end sparse: vec of minimum length\n");

ret = pagemap_ioc(mem, mem_size, vec, 1, 0,
vec_size, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),
"Walk_end sparse: Max pages specified\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size/2, 0,
vec_size, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == vec_size/2 && walk_end == (long)(mem + mem_size),
"Walk_end sparse: Max pages specified\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
vec_size, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == vec_size/2 && walk_end == (long)(mem + mem_size),
"Walk_end sparse: Max pages specified\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
vec_size/2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == vec_size/2 && walk_end == (long)(mem + mem_size),
"Walk_endsparse : Half max pages\n");

ret = pagemap_ioc(mem, mem_size, vec, vec_size, 0,
1, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN, &walk_end);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));
ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),
"Walk_end: 1 max page\n");

@@ -698,7 +698,7 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
vec_size - 2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 0, "%s all new pages must not be written (dirty)\n", prefix);

@@ -708,7 +708,7 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, 0, 0, PAGE_IS_WRITTEN, 0, 0,
PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 1 && LEN(vec[0]) == mem_size/page_size,
"%s all pages must be written (dirty)\n", prefix);
@@ -717,14 +717,14 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

memset(mem + page_size, 0, mem_size - (2 * page_size));

written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 1 && LEN(vec[0]) >= vec_size - 2 && LEN(vec[0]) <= vec_size,
"%s all pages dirty other than first and the last one\n", prefix);
@@ -732,7 +732,7 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 0,
"%s PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC\n", prefix);
@@ -741,14 +741,14 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

mem[vec_size/2 * page_size]++;

written = pagemap_ioctl(mem, mem_size, vec, vec_size, 0, 0, PAGE_IS_WRITTEN,
0, 0, PAGE_IS_WRITTEN);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 1 && LEN(vec[0]) >= 1,
"%s only middle page dirty\n", prefix);
@@ -757,7 +757,7 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(mem, mem_size, vec, 1, PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN | PAGE_IS_HUGE);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

mem[vec_size/2 * page_size]++;
mem[(vec_size/2 + 1) * page_size]++;
@@ -765,7 +765,7 @@ int base_tests(char *prefix, char *mem, int mem_size, int skip)
written = pagemap_ioctl(&mem[vec_size/2 * page_size], 2 * page_size, vec, 1, 0,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN | PAGE_IS_HUGE);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written == 1 && vec[0].start == (uintptr_t)(&mem[vec_size/2 * page_size])
&& LEN(vec[0]) == 2,
@@ -818,7 +818,7 @@ int hpage_unit_tests(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 0, "%s all new huge page must not be written (dirty)\n",
__func__);
@@ -827,7 +827,7 @@ int hpage_unit_tests(void)
ret = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 0, "%s all the huge page must not be written\n", __func__);

@@ -837,7 +837,7 @@ int hpage_unit_tests(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
0, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && vec[0].start == (uintptr_t)map &&
LEN(vec[0]) == vec_size && vec[0].categories == PAGE_IS_WRITTEN,
@@ -854,7 +854,7 @@ int hpage_unit_tests(void)
ret = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) > 0,
"%s only middle page written\n", __func__);
@@ -881,7 +881,7 @@ int hpage_unit_tests(void)
ret = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == vec_size/2 &&
vec[0].start == (uintptr_t)(map + map_size/2),
@@ -904,12 +904,12 @@ int hpage_unit_tests(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC,
vec_size/2, PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ret = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == vec_size/2 &&
vec[0].start == (uintptr_t)(map + map_size/2),
@@ -934,12 +934,12 @@ int hpage_unit_tests(void)
PM_SCAN_WP_MATCHING | PM_SCAN_CHECK_WPASYNC, vec_size/2,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ret = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == vec_size/2,
"%s clear second half huge page\n", __func__);
@@ -963,7 +963,7 @@ int hpage_unit_tests(void)
hpage_size/(2*page_size), PAGE_IS_WRITTEN, 0, 0,
PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec[0]) == hpage_size/(2*page_size),
"%s get half huge page\n", __func__);
@@ -971,7 +971,7 @@ int hpage_unit_tests(void)
ret2 = pagemap_ioctl(map, map_size, vec, vec_size, 0, 0,
PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);
if (ret2 < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret2, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret2, errno, strerror(errno));

ksft_test_result(ret2 == 1 && LEN(vec[0]) == (map_size - hpage_size/2)/page_size,
"%s get half huge page\n", __func__);
@@ -999,7 +999,7 @@ int unmapped_region_tests(void)
written = pagemap_ioctl(start, len, vec, vec_size, 0, 0,
PAGEMAP_NON_WRITTEN_BITS, 0, 0, PAGEMAP_NON_WRITTEN_BITS);
if (written < 0)
- ksft_exit_fail_msg("error %d %d %s\n", written, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", written, errno, strerror(errno));

ksft_test_result(written >= 0, "%s Get status of pages\n", __func__);

@@ -1060,7 +1060,7 @@ int sanity_tests(void)
vec = malloc(sizeof(struct page_region) * vec_size);
mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED || vec == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");

wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);
@@ -1088,7 +1088,7 @@ int sanity_tests(void)
/* 2. Get sd and present pages with anyof_mask */
mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);

@@ -1134,7 +1134,7 @@ int sanity_tests(void)
/* 8. Find written present pages with return mask */
mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);

@@ -1156,11 +1156,11 @@ int sanity_tests(void)

ret = stat(progname, &sbuf);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

fmem = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (fmem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem %d %s\n", errno, strerror(errno));
+ ksft_exit_fail_msg("nomem %d %s\n", errno, strerror(errno));

tmp_buf = malloc(sbuf.st_size);
memcpy(tmp_buf, fmem, sbuf.st_size);
@@ -1190,7 +1190,7 @@ int sanity_tests(void)

fmem = mmap(NULL, buf_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (fmem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem %d %s\n", errno, strerror(errno));
+ ksft_exit_fail_msg("nomem %d %s\n", errno, strerror(errno));

wp_init(fmem, buf_size);
wp_addr_range(fmem, buf_size);
@@ -1232,7 +1232,7 @@ int mprotect_tests(void)
/* 1. Map two pages */
mem = mmap(0, 2 * page_size, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem, 2 * page_size);
wp_addr_range(mem, 2 * page_size);

@@ -1242,7 +1242,7 @@ int mprotect_tests(void)
ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,
0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec) == 2, "%s Both pages written\n", __func__);

@@ -1257,7 +1257,7 @@ int mprotect_tests(void)
mem2 = mmap(mem + page_size, page_size, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANON|MAP_FIXED, -1, 0);
if (mem2 == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem2, page_size);
wp_addr_range(mem2, page_size);

@@ -1277,7 +1277,7 @@ int mprotect_tests(void)
ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,
0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec) == 2,
"%s Both pages written after remap and mprotect\n", __func__);
@@ -1290,7 +1290,7 @@ int mprotect_tests(void)
ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,
0, 0, PAGE_IS_WRITTEN);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

ksft_test_result(ret == 1 && LEN(vec) == 2,
"%s Clear and make the pages written\n", __func__);
@@ -1397,7 +1397,7 @@ static void transact_test(int page_size)
mem = mmap(NULL, 0x1000 * nthreads * pages_per_thread, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("Error mmap %s.\n", strerror(errno));
+ ksft_exit_fail_msg("mmap %s.\n", strerror(errno));

wp_init(mem, 0x1000 * nthreads * pages_per_thread);
wp_addr_range(mem, 0x1000 * nthreads * pages_per_thread);
@@ -1502,7 +1502,7 @@ int main(int argc, char *argv[])
mem_size = 10 * page_size;
mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);

@@ -1515,7 +1515,7 @@ int main(int argc, char *argv[])
mem_size = 512 * 10 * page_size;
mem = mmap(NULL, mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (mem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem\n");
+ ksft_exit_fail_msg("nomem\n");
wp_init(mem, mem_size);
wp_addr_range(mem, mem_size);

@@ -1595,11 +1595,11 @@ int main(int argc, char *argv[])

ret = stat(__FILE__".tmp0", &sbuf);
if (ret < 0)
- ksft_exit_fail_msg("error %d %d %s\n", ret, errno, strerror(errno));
+ ksft_exit_fail_msg("%d %d %s\n", ret, errno, strerror(errno));

fmem = mmap(NULL, sbuf.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (fmem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem %d %s\n", errno, strerror(errno));
+ ksft_exit_fail_msg("nomem %d %s\n", errno, strerror(errno));

wp_init(fmem, sbuf.st_size);
wp_addr_range(fmem, sbuf.st_size);
@@ -1619,7 +1619,7 @@ int main(int argc, char *argv[])
strerror(errno));

if (ftruncate(fd, buf_size))
- ksft_exit_fail_msg("Error ftruncate\n");
+ ksft_exit_fail_msg("ftruncate\n");

for (i = 0; i < buf_size; i++)
if (write(fd, "c", 1) < 0)
@@ -1627,7 +1627,7 @@ int main(int argc, char *argv[])

fmem = mmap(NULL, buf_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (fmem == MAP_FAILED)
- ksft_exit_fail_msg("error nomem %d %s\n", errno, strerror(errno));
+ ksft_exit_fail_msg("nomem %d %s\n", errno, strerror(errno));

wp_init(fmem, buf_size);
wp_addr_range(fmem, buf_size);
diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c
index 6c988bd2f3356..f0a400f196956 100644
--- a/tools/testing/selftests/mm/split_huge_page_test.c
+++ b/tools/testing/selftests/mm/split_huge_page_test.c
@@ -264,7 +264,7 @@ void split_file_backed_thp(void)
cleanup:
umount(tmpfs_loc);
rmdir(tmpfs_loc);
- ksft_exit_fail_msg("Error occurred\n");
+ ksft_exit_fail_msg("occurred\n");
}

bool prepare_thp_fs(const char *xfs_path, char *thp_fs_template,
--
2.39.2

Next message: Andrew Jones: "Re: [PATCH v5 22/22] KVM: riscv: selftests: Add a test for counter overflow"
Previous message: Muhammad Usama Anjum: "[PATCH 1/2] selftests: Replace "Bail out" with "Error""
In reply to: Kees Cook: "Re: [PATCH 1/2] selftests: Replace "Bail out" with "Error""
Next in thread: Kees Cook: "Re: [PATCH 2/2] selftests: Remove Error/Failed prefix from ksft_exit_fail*() usages"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]