Skip to contentSkip to conversation

lib: adding .supported_archs field in tst_test structure

PATCH Superseded Li Wang 2 participants 11 messages Nov 8, 2021 – Nov 9, 2021 Library code

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Li Wang

author
#0 lore raw

PATCH v3 1/3 lib: adding .supported_archs field in tst_test structure

Testcases for specific arch should be limited on that only being supported platform to run, we now involve a .supported_archs to achieve this feature in LTP library. All you need to run a test on the expected arch is to set the '.supported_archs' array in the 'struct tst_test' to choose the required arch list. e.g.

    .supported_archs = (const char *const []){"x86_64", "ppc64", NULL}

This helps move the TCONF info from code to tst_test metadata as well.

And, we also export a struct tst_arch to save the system architecture for using in the whole test cases.

    extern struct arch {
             char name[16];
             enum tst_arch_type type;
    } tst_arch;
---
 doc/c-test-api.txt |  36 +++++++++++++++
 include/tst_arch.h |  39 ++++++++++++++++
 include/tst_test.h |  10 +++++
 lib/tst_arch.c     | 108 +++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 193 insertions(+)
 create mode 100644 include/tst_arch.h
 create mode 100644 lib/tst_arch.c
doc/c-test-api.txt +36 -0
index 3127018a4..5e32b7075 100644
@@ -2261,6 +2261,42 @@ struct tst_test test = {
 };
 -------------------------------------------------------------------------------
 
+1.39 Testing on the specific architecture
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Testcases for specific arch should be limited on that only being supported
+platform to run, we now involve a .supported_archs to achieve this feature
+in LTP library. All you need to run a test on the expected arch is to set
+the '.supported_archs' array in the 'struct tst_test' to choose the required
+arch list. e.g.
+
+    .supported_archs = (const char *const []){"x86_64", "ppc64", NULL}
+
+This helps move the TCONF info from code to tst_test metadata as well.
+
+And, we also export a struct tst_arch to save the system architecture for
+using in the whole test cases.
+
+    extern struct arch {
+             char name[16];
+             enum tst_arch_type type;
+    } tst_arch;
+
+[source,c]
+-------------------------------------------------------------------------------
+#include "tst_test.h"
+
+static struct tst_test test = {
+       ...
+       .setup = setup,
+       .supported_archs = (const char *const []) {
+                 "x86_64",
+                 "ppc64",
+                 "s390x",
+                 NULL
+       },
+};
+-------------------------------------------------------------------------------
+
 2. Common problems
 ------------------
 
include/tst_arch.h new file +39 -0
new file mode 100644
index 000000000..784c3093b
@@ -0,0 +1,39 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright (c) 2021 Li Wang <[email protected]>
+ */
+
+#ifndef TST_ARCH_H__
+#define TST_ARCH_H__
+
+enum tst_arch_type {
+	TST_I386,
+	TST_X86,
+	TST_X86_64,
+	TST_IA64,
+	TST_PPC,
+	TST_PPC64,
+	TST_S390,
+	TST_S390X,
+	TST_ARM,
+	TST_AARCH64,
+	TST_SPARC,
+};
+
+/*
+ * This tst_arch is to save the system architecture for
+ * using in the whole testcase.
+ */
+extern struct arch {
+	char name[16];
+	enum tst_arch_type type;
+} tst_arch;
+
+/*
+ * Check if test platform is in the given arch list. If yes return 1,
+ * otherwise return 0.
+ *
+ * @archlist A NULL terminated array of architectures to support.
+ */
+int tst_is_on_arch(const char *const *archlist);
+
+#endif /* TST_ARCH_H__ */
include/tst_test.h +10 -0
index 3dcb45de0..7611520ee 100644
@@ -43,6 +43,7 @@
 #include "tst_fips.h"
 #include "tst_taint.h"
 #include "tst_memutils.h"
+#include "tst_arch.h"
 
 /*
  * Reports testcase result.
@@ -139,6 +140,12 @@ struct tst_test {
 
 	const char *min_kver;
 
+	/*
+	 * The supported_archs is a NULL terminated list of archs the test
+	 * does support.
+	 */
+	const char *const *supported_archs;
+
 	/* If set the test is compiled out */
 	const char *tconf_msg;
 
@@ -316,6 +323,9 @@ static struct tst_test test;
 
 int main(int argc, char *argv[])
 {
+	if (!tst_is_on_arch(test.supported_archs))
+		tst_brk(TCONF, "This arch '%s' is not supported for test!", tst_arch.name);
+
 	tst_run_tcases(argc, argv, &test);
 }
 
lib/tst_arch.c new file +108 -0

108 lines not on this page · raw message

Signature · 5 lines
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#1 lore raw

PATCH v3 2/3 testcase: make use of .supported_archs

In some places, we have to keep ifdefs to make the compiler work with unportable code.

---
 configure.ac                                  |  1 +
 testcases/cve/meltdown.c                      | 16 ++++++-----
 testcases/kernel/syscalls/ptrace/ptrace07.c   | 11 ++++----
 testcases/kernel/syscalls/ptrace/ptrace08.c   | 22 ++++++++-------
 testcases/kernel/syscalls/ptrace/ptrace09.c   | 11 +++++---
 testcases/kernel/syscalls/ptrace/ptrace10.c   | 12 +++++----
 .../syscalls/set_mempolicy/set_mempolicy05.c  | 27 +++++++++----------
 7 files changed, 54 insertions(+), 46 deletions(-)
configure.ac +1 -0
index 5bf3c52ec..7efd9df87 100644
@@ -42,6 +42,7 @@ AC_CHECK_DECLS([SEM_STAT_ANY],,,[#include <sys/sem.h>])
 
 AC_CHECK_HEADERS_ONCE([ \
     asm/ldt.h \
+    emmintrin.h \
     ifaddrs.h \
     keyutils.h \
     linux/can.h \
testcases/cve/meltdown.c +9 -7
index 5a984aba3..2577c1a80 100644
@@ -6,8 +6,6 @@
 #include "config.h"
 #include "tst_test.h"
 
-#if defined(__x86_64__) || defined(__i386__)
-
 #include <stdio.h>
 #include <string.h>
 #include <signal.h>
@@ -17,6 +15,7 @@
 #include <ctype.h>
 #include <sys/utsname.h>
 
+#ifdef HAVE_EMMINTRIN_H
 #include <emmintrin.h>
 
 #include "tst_tsc.h"
@@ -378,14 +377,17 @@ static struct tst_test test = {
 	.test_all = run,
 	.cleanup = cleanup,
 	.min_kver = "2.6.32",
+	.supported_archs = (const char *const []) {
+		"i386",
+		"x86_64",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"CVE", "2017-5754"},
 		{}
 	}
 };
 
-#else /* #if defined(__x86_64__) || defined(__i386__) */
-
-TST_TEST_TCONF("not x86_64 or i386");
-
-#endif /* #else #if defined(__x86_64__) || defined(__i386__) */
+#else /* HAVE_EMMINTRIN_H */
+	TST_TEST_TCONF("<emmintrin.h> is not supported");
+#endif
testcases/kernel/syscalls/ptrace/ptrace07.c +6 -5
index 9e3f7511d..da62cadb0 100644
@@ -48,13 +48,13 @@
 # define NT_X86_XSTATE 0x202
 #endif
 
-#ifdef __x86_64__
 static void check_regs_loop(uint32_t initval)
 {
 	const unsigned long num_iters = 1000000000;
 	uint32_t xmm0[4] = { initval, initval, initval, initval };
 	int status = 1;
 
+#ifdef __x86_64__
 	asm volatile("   movdqu %0, %%xmm0\n"
 		     "   mov %0, %%rbx\n"
 		     "1: dec %2\n"
@@ -68,6 +68,7 @@ static void check_regs_loop(uint32_t initval)
 		     "3:\n"
 		     : "+m" (xmm0), "+r" (status)
 		     : "r" (num_iters) : "rax", "rbx", "xmm0");
+#endif
 
 	if (status) {
 		tst_res(TFAIL,
@@ -178,6 +179,10 @@ static struct tst_test test = {
 	.test_all = do_test,
 	.forks_child = 1,
 	.needs_checkpoints = 1,
+	.supported_archs = (const char *const []) {
+		"x86_64",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "814fb7bb7db5"},
 		{"CVE", "2017-15537"},
@@ -185,7 +190,3 @@ static struct tst_test test = {
 	}
 
 };
-
-#else /* !__x86_64__ */
-	TST_TEST_TCONF("this test is only supported on x86_64");
-#endif /* __x86_64__ */
testcases/kernel/syscalls/ptrace/ptrace08.c +12 -10
index f86f69a9c..77c4c10c3 100644
@@ -43,18 +43,16 @@
 #include "tst_test.h"
 #include "tst_safe_stdio.h"
 
-#if defined(__i386__) || defined(__x86_64__)
-
 static pid_t child_pid;
 
-#if defined(__x86_64__)
-# define KERN_ADDR_MIN 0xffff800000000000
-# define KERN_ADDR_MAX 0xffffffffffffffff
-# define KERN_ADDR_BITS 64
-#elif defined(__i386__)
+#if defined(__i386__)
 # define KERN_ADDR_MIN 0xc0000000
 # define KERN_ADDR_MAX 0xffffffff
 # define KERN_ADDR_BITS 32
+#else
+# define KERN_ADDR_MIN 0xffff800000000000
+# define KERN_ADDR_MAX 0xffffffffffffffff
+# define KERN_ADDR_BITS 64
 #endif
 
 static int deffered_check;
@@ -106,6 +104,7 @@ static void ptrace_try_kern_addr(unsigned long kern_addr)
 	if (SAFE_WAITPID(child_pid, &status, WUNTRACED) != child_pid)
 		tst_brk(TBROK, "Received event from unexpected PID");
 
+#if defined(__i386__) || defined(__x86_64__)
 	SAFE_PTRACE(PTRACE_ATTACH, child_pid, NULL, NULL);
 	SAFE_PTRACE(PTRACE_POKEUSER, child_pid,
 		(void *)offsetof(struct user, u_debugreg[0]), (void *)1);
@@ -135,6 +134,7 @@ static void ptrace_try_kern_addr(unsigned long kern_addr)
 
 	addr = ptrace(PTRACE_PEEKUSER, child_pid,
 	              (void*)offsetof(struct user, u_debugreg[0]), NULL);
+#endif
 
 	if (!deffered_check && addr == kern_addr)
 		tst_res(TFAIL, "Was able to set breakpoint on kernel addr");
@@ -164,6 +164,11 @@ static struct tst_test test = {
 	.setup = setup,
 	.cleanup = cleanup,
 	.forks_child = 1,
+	.supported_archs = (const char *const []) {
+		"i386",
+		"x86_64",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "f67b15037a7a"},
 		{"CVE", "2018-1000199"},
@@ -171,6 +176,3 @@ static struct tst_test test = {
 		{}
 	}
 };
-#else
-TST_TEST_TCONF("This test is only supported on x86 systems");
-#endif
testcases/kernel/syscalls/ptrace/ptrace09.c +7 -4
index 85875ce65..8ccdfcc4b 100644
@@ -22,7 +22,6 @@
 #include <signal.h>
 #include "tst_test.h"
 
-#if defined(__i386__) || defined(__x86_64__)
 static short watchpoint;
 static pid_t child_pid;
 
@@ -46,6 +45,7 @@ static void run(void)
 {
 	int status;
 
+#if defined(__i386__) || defined(__x86_64__)
 	child_pid = SAFE_FORK();
 
 	if (!child_pid) {
@@ -60,6 +60,7 @@ static void run(void)
 	SAFE_PTRACE(PTRACE_POKEUSER, child_pid,
 		(void *)offsetof(struct user, u_debugreg[7]), (void *)0x30001);
 	SAFE_PTRACE(PTRACE_CONT, child_pid, NULL, NULL);
+#endif
 
 	while (1) {
 		if (SAFE_WAITPID(child_pid, &status, 0) != child_pid)
@@ -92,12 +93,14 @@ static struct tst_test test = {
 	.test_all = run,
 	.cleanup = cleanup,
 	.forks_child = 1,
+	.supported_archs = (const char *const []) {
+		"i386",
+		"x86_64",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "d8ba61ba58c8"},
 		{"CVE", "2018-8897"},
 		{}
 	}
 };
-#else
-TST_TEST_TCONF("This test is only supported on x86 systems");
-#endif
testcases/kernel/syscalls/ptrace/ptrace10.c +7 -5
index b5d6b9f8f..3bd8ca1a9 100644
@@ -22,8 +22,6 @@
 #include <signal.h>
 #include "tst_test.h"
 
-#if defined(__i386__) || defined(__x86_64__)
-
 static pid_t child_pid;
 
 static void child_main(void)
@@ -45,6 +43,7 @@ static void run(void)
 	if (SAFE_WAITPID(child_pid, &status, WUNTRACED) != child_pid)
 		tst_brk(TBROK, "Received event from unexpected PID");
 
+#if defined(__i386__) || defined(__x86_64__)
 	SAFE_PTRACE(PTRACE_ATTACH, child_pid, NULL, NULL);
 	SAFE_PTRACE(PTRACE_POKEUSER, child_pid,
 		(void *)offsetof(struct user, u_debugreg[0]), (void *)1);
@@ -53,6 +52,7 @@ static void run(void)
 
 	addr = ptrace(PTRACE_PEEKUSER, child_pid,
 	              (void*)offsetof(struct user, u_debugreg[0]), NULL);
+#endif
 
 	if (addr == 2)
 		tst_res(TPASS, "The rd0 was set on second PTRACE_POKEUSR");
@@ -76,11 +76,13 @@ static struct tst_test test = {
 	.test_all = run,
 	.cleanup = cleanup,
 	.forks_child = 1,
+	.supported_archs = (const char *const []) {
+		"i386",
+		"x86_64",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "bd14406b78e6"},
 		{}
 	}
 };
-#else
-TST_TEST_TCONF("This test is only supported on x86 systems");
-#endif
testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c +12 -15
index 86f6a95dc..f56b7b26f 100644
@@ -37,18 +37,10 @@
 #include "config.h"
 #include "tst_test.h"
 
-#if defined(__i386__) || defined(__powerpc__)
-
 #include <string.h>
 
 static unsigned int i;
 static int sys_ret;
-#ifdef __i386__
-static const int sys_num = 276;
-static const int mode;
-static const int node_mask_ptr = UINT_MAX;
-static const int node_mask_sz = UINT_MAX;
-#endif
 static volatile char *stack_ptr;
 
 static void run(void)
@@ -58,6 +50,11 @@ static void run(void)
 	register long mode __asm__("r3");
 	register long node_mask_ptr __asm__("r4");
 	register long node_mask_sz __asm__("r5");
+#else
+	static const int sys_num = 276;
+	static const int mode;
+	static const int node_mask_ptr = UINT_MAX;
+	static const int node_mask_sz = UINT_MAX;
 #endif
 	char stack_pattern[0x400];
 
@@ -78,7 +75,8 @@ static void run(void)
 		:
 		"memory", "cr0", "r6", "r7", "r8", "r9", "r10", "r11", "r12");
 	sys_ret = mode;
-#else /* __i386__ */
+#endif
+#ifdef __i386__
 	asm volatile (
 		"add $0x400, %%esp\n\t"
 		"int $0x80\n\t"
@@ -114,15 +112,14 @@ static void run(void)
 
 static struct tst_test test = {
 	.test_all = run,
+	.supported_archs = (const char *const []) {
+		"i386",
+		"ppc",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "cf01fb9985e8"},
 		{"CVE", "CVE-2017-7616"},
 		{}
 	}
 };
-
-#else /* #if defined(__x86_64__) || defined(__powerpc__) */
-
-TST_TEST_TCONF("not i386 or powerpc");
-
-#endif /* #else #if defined(__x86_64__) || defined(__powerpc__) */
Signature · 5 lines
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#2 lore raw

Re: [LTP] [PATCH v3 2/3] testcase: make use of .supported_archs

Hi!

Quoted 14 lines
testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c +5 -0
 	asm volatile (
 		"add $0x400, %%esp\n\t"
 		"int $0x80\n\t"
@@ -114,15 +112,14 @@ static void run(void)
 
 static struct tst_test test = {
 	.test_all = run,
+	.supported_archs = (const char *const []) {
+		"i386",
+		"ppc",
+		NULL
+	},
 	.tags = (const struct tst_tag[]) {
 		{"linux-git", "cf01fb9985e8"},

testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c static void run(void) · line 128

Quoted 10 lines
testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c +0 -6
 		{"CVE", "CVE-2017-7616"},
 		{}
 	}
 };
-
-#else /* #if defined(__x86_64__) || defined(__powerpc__) */
-
-TST_TEST_TCONF("not i386 or powerpc");
-
-#endif /* #else #if defined(__x86_64__) || defined(__powerpc__) */

Accordingly to this table:

https://wiki.debian.org/ArchitectureSpecificsMemo

__powerpc__ matches both 32bit and 64bit variants.

I guess that we would have to change the checks in the library as:

#ifdef __powerpc__

# ifdef __powerpc64__ || __ppc64__
.arch = "ppc64",
.type = TST_PPC64,
# else
.arch = "ppc",
.type = "TST_PPC"
# endif
#endif

Also I guess that gcc does not define __x86__ for historical reasons and __i386__ really means __x86__, but I haven't checked that one.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#3 lore raw

Re: [LTP] [PATCH v3 2/3] testcase: make use of .supported_archs

Quoted 28 lines · Cyril Hrubis

Hi!

Quoted 14 lines
      asm volatile (
              "add $0x400, %%esp\n\t"
              "int $0x80\n\t"
testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c +5 -0
@@ -114,15 +112,14 @@ static void run(void)
 
 static struct tst_test test = {
      .test_all = run,
+     .supported_archs = (const char *const []) {
+             "i386",
+             "ppc",
+             NULL
+     },
      .tags = (const struct tst_tag[]) {
              {"linux-git", "cf01fb9985e8"},

testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c static void run(void) · line 128

Quoted 10 lines
testcases/kernel/syscalls/set_mempolicy/set_mempolicy05.c +0 -6
              {"CVE", "CVE-2017-7616"},
              {}
      }
 };
-
-#else /* #if defined(__x86_64__) || defined(__powerpc__) */
-
-TST_TEST_TCONF("not i386 or powerpc");
-
-#endif /* #else #if defined(__x86_64__) || defined(__powerpc__) */

Accordingly to this table:

Quoted 6 lines

https://wiki.debian.org/ArchitectureSpecificsMemo

__powerpc__ matches both 32bit and 64bit variants.

I guess that we would have to change the checks in the library as:

Yes, but I think we can simply reverse the order to solve this. It will try to match 64bit firstly otherwise 32bit. The s390 does as well.

....
#elif defined(__powerpc64__ || __ppc64__)

        .name = "ppc64",
        .type = TST_PPC64,

#elif defined(__powerpc__ || __ppc__)
.name = "ppc",
.type = TST_PPC,
#elif defined(__s390x__)

        .name = "s390x",
        .type = TST_S390X,
#elif defined(__s390__)
        .name = "s390",
        .type = TST_S390,

....

Quoted 11 lines

#ifdef __powerpc__

# ifdef __powerpc64__ || __ppc64__
.arch = "ppc64",
.type = TST_PPC64,
# else
.arch = "ppc",
.type = "TST_PPC"
# endif
#endif
Quoted 3 lines

Also I guess that gcc does not define __x86__ for historical reasons and __i386__ really means __x86__, but I haven't checked that one.

You are right. And next we have to get rid of __x86__ from ltp testcase.

Signature · 2 lines
Regards,
Li Wang
Signature · 2 lines
-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#4 lore raw

PATCH v3 3/3 max_map_count: replace ifdefs by tst_arch

In reply to Li Wang
---
 testcases/kernel/mem/tunable/max_map_count.c | 41 +++++++++++---------
 1 file changed, 23 insertions(+), 18 deletions(-)
testcases/kernel/mem/tunable/max_map_count.c +23 -18
index 4f0ad0037..9da67520c 100644
@@ -91,24 +91,29 @@ static bool filter_map(const char *line)
 	if (ret != 1)
 		return false;
 
-#if defined(__x86_64__) || defined(__x86__)
-	/* On x86, there's an old compat vsyscall page */
-	if (!strcmp(buf, "[vsyscall]"))
-		return true;
-#elif defined(__ia64__)
-	/* On ia64, the vdso is not a proper mapping */
-	if (!strcmp(buf, "[vdso]"))
-		return true;
-#elif defined(__arm__)
-	/* Skip it when run it in aarch64 */
-	if ((!strcmp(un.machine, "aarch64"))
-	|| (!strcmp(un.machine, "aarch64_be")))
-		return false;
-
-	/* Older arm kernels didn't label their vdso maps */
-	if (!strncmp(line, "ffff0000-ffff1000", 17))
-		return true;
-#endif
+	switch (tst_arch.type) {
+	case TST_X86:
+	case TST_X86_64:
+		/* On x86, there's an old compat vsyscall page */
+		if (!strcmp(buf, "[vsyscall]"))
+			return true;
+	break;
+	case TST_IA64:
+		/* On ia64, the vdso is not a proper mapping */
+		if (!strcmp(buf, "[vdso]"))
+			return true;
+	break;
+	case TST_ARM:
+		/* Skip it when run it in aarch64 */
+		if ((!strcmp(un.machine, "aarch64"))
+				|| (!strcmp(un.machine, "aarch64_be")))
+			return false;
+
+		/* Older arm kernels didn't label their vdso maps */
+		if (!strncmp(line, "ffff0000-ffff1000", 17))
+			return true;
+	break;
+	};
 
 	return false;
 }
Signature · 5 lines
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#5 lore raw

Re: [LTP] [PATCH v3 3/3] max_map_count: replace ifdefs by tst_arch

Quoted 38 lines · Li Wang
---
 testcases/kernel/mem/tunable/max_map_count.c | 41 +++++++++++---------
 1 file changed, 23 insertions(+), 18 deletions(-)
testcases/kernel/mem/tunable/max_map_count.c +7 -18
index 4f0ad0037..9da67520c 100644
@@ -91,24 +91,29 @@ static bool filter_map(const char *line)
 	if (ret != 1)
 		return false;
 
-#if defined(__x86_64__) || defined(__x86__)
-	/* On x86, there's an old compat vsyscall page */
-	if (!strcmp(buf, "[vsyscall]"))
-		return true;
-#elif defined(__ia64__)
-	/* On ia64, the vdso is not a proper mapping */
-	if (!strcmp(buf, "[vdso]"))
-		return true;
-#elif defined(__arm__)
-	/* Skip it when run it in aarch64 */
-	if ((!strcmp(un.machine, "aarch64"))
-	|| (!strcmp(un.machine, "aarch64_be")))
-		return false;
-
-	/* Older arm kernels didn't label their vdso maps */
-	if (!strncmp(line, "ffff0000-ffff1000", 17))
-		return true;
-#endif
+	switch (tst_arch.type) {
+	case TST_X86:
+	case TST_X86_64:
+		/* On x86, there's an old compat vsyscall page */
+		if (!strcmp(buf, "[vsyscall]"))
+			return true;
+	break;

testcases/kernel/mem/tunable/max_map_count.c static bool filter_map(const char *line) · line 110

Quoted 10 lines
testcases/kernel/mem/tunable/max_map_count.c +10 -0
+	case TST_IA64:
+		/* On ia64, the vdso is not a proper mapping */
+		if (!strcmp(buf, "[vdso]"))
+			return true;
+	break;
+	case TST_ARM:
+		/* Skip it when run it in aarch64 */
+		if ((!strcmp(un.machine, "aarch64"))
+				|| (!strcmp(un.machine, "aarch64_be")))
+			return false;
		I wonder if this would be better as:

		if (tst_kernel_bits() == 64)
			return false;

Other than this the code looks actually better this way.

Quoted 14 lines
testcases/kernel/mem/tunable/max_map_count.c +5 -0
+		/* Older arm kernels didn't label their vdso maps */
+		if (!strncmp(line, "ffff0000-ffff1000", 17))
+			return true;
+	break;
+	};
 
 	return false;
 }
Signature · 5 lines
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#6 lore raw

Re: [LTP] [PATCH v3 3/3] max_map_count: replace ifdefs by tst_arch

Quoted 18 lines
Quoted 7 lines
testcases/kernel/mem/tunable/max_map_count.c +7 -0
+     switch (tst_arch.type) {
+     case TST_X86:
+     case TST_X86_64:
+             /* On x86, there's an old compat vsyscall page */
+             if (!strcmp(buf, "[vsyscall]"))
+                     return true;
+     break;

testcases/kernel/mem/tunable/max_map_count.c static bool filter_map(const char *line) · line 110

Quoted 10 lines
testcases/kernel/mem/tunable/max_map_count.c +10 -0
+     case TST_IA64:
+             /* On ia64, the vdso is not a proper mapping */
+             if (!strcmp(buf, "[vdso]"))
+                     return true;
+     break;
+     case TST_ARM:
+             /* Skip it when run it in aarch64 */
+             if ((!strcmp(un.machine, "aarch64"))
+                             || (!strcmp(un.machine, "aarch64_be")))
+                     return false;
Quoted 5 lines
                I wonder if this would be better as:

                if (tst_kernel_bits() == 64)
                        return false;

Actually, we have TST_AARCH64 already, I'd go with switch to that.

Signature · 2 lines
Regards,
Li Wang
Signature · 2 lines
-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#7 lore raw

Re: [LTP] [PATCH v3 3/3] max_map_count: replace ifdefs by tst_arch

Hi!

Quoted 18 lines
Quoted 18 lines
Quoted 17 lines
testcases/kernel/mem/tunable/max_map_count.c +17 -0
+     switch (tst_arch.type) {
+     case TST_X86:
+     case TST_X86_64:
+             /* On x86, there's an old compat vsyscall page */
+             if (!strcmp(buf, "[vsyscall]"))
+                     return true;
+     break;
+     case TST_IA64:
+             /* On ia64, the vdso is not a proper mapping */
+             if (!strcmp(buf, "[vdso]"))
+                     return true;
+     break;
+     case TST_ARM:
+             /* Skip it when run it in aarch64 */
+             if ((!strcmp(un.machine, "aarch64"))
+                             || (!strcmp(un.machine, "aarch64_be")))
+                     return false;
Quoted 7 lines
Quoted 5 lines
                I wonder if this would be better as:

                if (tst_kernel_bits() == 64)
                        return false;

Actually, we have TST_AARCH64 already, I'd go with switch to that.

That wouldn't work right? Since we are checking here if 32bit ARM binary runs on 64bit AARCH64 kernel. The tst_arch defines for which architecture the binary was build while the tst_kernel_bits() checks if the kernel is 32bit or 64bit.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#8 lore raw

Re: [LTP] [PATCH v3 3/3] max_map_count: replace ifdefs by tst_arch

Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
                I wonder if this would be better as:

                if (tst_kernel_bits() == 64)
                        return false;
Quoted 7 lines
Quoted 1 line

Actually, we have TST_AARCH64 already, I'd go with switch to that.

That wouldn't work right? Since we are checking here if 32bit ARM binary runs on 64bit AARCH64 kernel. The tst_arch defines for which architecture the binary was build while the tst_kernel_bits() checks if the kernel is 32bit or 64bit.

Right, I didn't realize that situation. Thanks for the reminder~

Signature · 2 lines
Regards,
Li Wang
Signature · 2 lines
-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#9 lore raw
In reply to Li Wang

Hi!

Quoted 81 lines

Testcases for specific arch should be limited on that only being supported platform to run, we now involve a .supported_archs to achieve this feature in LTP library. All you need to run a test on the expected arch is to set the '.supported_archs' array in the 'struct tst_test' to choose the required arch list. e.g.

    .supported_archs = (const char *const []){"x86_64", "ppc64", NULL}

This helps move the TCONF info from code to tst_test metadata as well.

And, we also export a struct tst_arch to save the system architecture for using in the whole test cases.

    extern struct arch {
             char name[16];
             enum tst_arch_type type;
    } tst_arch;
---
 doc/c-test-api.txt |  36 +++++++++++++++
 include/tst_arch.h |  39 ++++++++++++++++
 include/tst_test.h |  10 +++++
 lib/tst_arch.c     | 108 +++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 193 insertions(+)
 create mode 100644 include/tst_arch.h
 create mode 100644 lib/tst_arch.c
doc/c-test-api.txt +36 -0
index 3127018a4..5e32b7075 100644
@@ -2261,6 +2261,42 @@ struct tst_test test = {
 };
 -------------------------------------------------------------------------------
 
+1.39 Testing on the specific architecture
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Testcases for specific arch should be limited on that only being supported
+platform to run, we now involve a .supported_archs to achieve this feature
+in LTP library. All you need to run a test on the expected arch is to set
+the '.supported_archs' array in the 'struct tst_test' to choose the required
+arch list. e.g.
+
+    .supported_archs = (const char *const []){"x86_64", "ppc64", NULL}
+
+This helps move the TCONF info from code to tst_test metadata as well.
+
+And, we also export a struct tst_arch to save the system architecture for
+using in the whole test cases.
+
+    extern struct arch {
+             char name[16];
+             enum tst_arch_type type;
+    } tst_arch;
+
+[source,c]
+-------------------------------------------------------------------------------
+#include "tst_test.h"
+
+static struct tst_test test = {
+       ...
+       .setup = setup,
+       .supported_archs = (const char *const []) {
+                 "x86_64",
+                 "ppc64",
+                 "s390x",
+                 NULL
+       },
+};
+-------------------------------------------------------------------------------
+
 2. Common problems
 ------------------
 
include/tst_arch.h new file +0 -0
new file mode 100644
index 000000000..784c3093b

include/tst_arch.h line 10

Quoted 10 lines
include/tst_arch.h new file +10 -0
@@ -0,0 +1,39 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright (c) 2021 Li Wang <[email protected]>
+ */
+
+#ifndef TST_ARCH_H__
+#define TST_ARCH_H__
+
+enum tst_arch_type {
+	TST_I386,
+	TST_X86,

Why do we have both i386 and X86 here? Isn't __i386__ synonymous for __x86__ does gcc even define __x86__?

I doubt that we care about the differencies between i386, i586 and i686 at all. I would just keep TST_X86 in the list for any 32bit intel compatible hardware.

Quoted 9 lines
include/tst_arch.h new file +9 -0
+	TST_X86_64,
+	TST_IA64,
+	TST_PPC,
+	TST_PPC64,
+	TST_S390,
+	TST_S390X,
+	TST_ARM,
+	TST_AARCH64,
+	TST_SPARC,

include/tst_arch.h line 29

Quoted 10 lines
include/tst_arch.h new file +10 -0
+};
+
+/*
+ * This tst_arch is to save the system architecture for
+ * using in the whole testcase.
+ */
+extern struct arch {
+	char name[16];
+	enum tst_arch_type type;
+} tst_arch;

the struct should be prefixed with tst_ as well. i.e.

extern struct tst_arch {
	...
Quoted 35 lines
include/tst_arch.h new file +9 -0
+/*
+ * Check if test platform is in the given arch list. If yes return 1,
+ * otherwise return 0.
+ *
+ * @archlist A NULL terminated array of architectures to support.
+ */
+int tst_is_on_arch(const char *const *archlist);
+
+#endif /* TST_ARCH_H__ */
include/tst_test.h +7 -0
index 3dcb45de0..7611520ee 100644
@@ -43,6 +43,7 @@
 #include "tst_fips.h"
 #include "tst_taint.h"
 #include "tst_memutils.h"
+#include "tst_arch.h"
 
 /*
  * Reports testcase result.
@@ -139,6 +140,12 @@ struct tst_test {
 
 	const char *min_kver;
 
+	/*
+	 * The supported_archs is a NULL terminated list of archs the test
+	 * does support.
+	 */
+	const char *const *supported_archs;
+
 	/* If set the test is compiled out */
 	const char *tconf_msg;
 

include/tst_test.h static struct tst_test test; · line 327

Quoted 5 lines
include/tst_test.h +2 -0
@@ -316,6 +323,9 @@ static struct tst_test test;
 
 int main(int argc, char *argv[])
 {
+	if (!tst_is_on_arch(test.supported_archs))
+		tst_brk(TCONF, "This arch '%s' is not supported for test!", tst_arch.name);

Why are you putting this check into the header? All the other checks are in the do_setup() in lib/tst_test.c

Quoted 84 lines
include/tst_test.h +0 -0
 	tst_run_tcases(argc, argv, &test);
 }
 
lib/tst_arch.c new file +75 -0
new file mode 100644
index 000000000..ae5817075
@@ -0,0 +1,108 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright (c) 2021 Li Wang <[email protected]>
+ */
+
+#include <string.h>
+#include <stdlib.h>
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_arch.h"
+#include "tst_test.h"
+
+struct arch tst_arch;
+
+static const char *const arch_type_list[] = {
+	"i386",
+	"x86",
+	"x86_64",
+	"ia64",
+	"ppc",
+	"ppc64",
+	"s390",
+	"s390x",
+	"arm",
+	"aarch64",
+	"sparc",
+	NULL
+};
+
+static int is_matched_arch(const char *arch, const char *name)
+{
+	if (strcmp(arch, name) == 0)
+		return 1;
+
+	return 0;
+}
+
+static int is_valid_arch_name(const char *name)
+{
+	unsigned int i;
+
+	for (i = 0; arch_type_list[i]; i++) {
+		if (is_matched_arch(arch_type_list[i], name))
+			return 1;
+	}
+
+	return 0;
+}
+
+static void get_system_arch(void)
+{
+#if defined(__i386__)
+	strcpy(tst_arch.name, "i386");
+	tst_arch.type = TST_I386;
+#elif defined(__x86__)
+	strcpy(tst_arch.name, "x86");
+	tst_arch.type = TST_X86;
+#elif defined(__x86_64__)
+	strcpy(tst_arch.name, "x86_64");
+	tst_arch.type = TST_X86_64;
+#elif defined(__ia64__)
+	strcpy(tst_arch.name, "ia64");
+	tst_arch.type = TST_IA64;
+#elif defined(__powerpc__)
+	strcpy(tst_arch.name, "ppc");
+	tst_arch.type = TST_PPC;
+#elif defined(__powerpc64__)
+	strcpy(tst_arch.name, "ppc64");
+	tst_arch.type = TST_PPC64;
+#elif defined(__s390x__)
+	strcpy(tst_arch.name, "s390x");
+	tst_arch.type = TST_S390X;
+#elif defined(__s390__)
+	strcpy(tst_arch.name, "s390");
+	tst_arch.type = TST_S390;
+#elif defined(__arm__)

lib/tst_arch.c line 85

Quoted 10 lines
lib/tst_arch.c new file +10 -0
+	strcpy(tst_arch.name, "s390x");
+	tst_arch.type = TST_ARM;
+#elif defined(__aarch64__)
+	strcpy(tst_arch.name, "aarch64");
+	tst_arch.type = TST_AARCH64;
+#elif defined(__sparc__)
+	strcpy(tst_arch.name, "sparc");
+	tst_arch.type = TST_SPARC;
+#endif
+}

Actually we can initialize this staically as:

const struct arch tst_arch = {

#if defined(__x86_64__)
	.name = "x86_64",
	.type = TST_X86_64,
#elif
...
#else
	.name = "unknown",
	.type = TST_ARCH_UNKNOWN,

#endif
};

lib/tst_arch.c line 94

Quoted 8 lines
lib/tst_arch.c new file +8 -0
+int tst_is_on_arch(const char *const *archlist)
+{
+	unsigned int i;
+
+	get_system_arch();
+
+	if (archlist == NULL)
+		return 1;

Just if (!archlist)

lib/tst_arch.c line 98

Quoted 3 lines
lib/tst_arch.c new file +3 -0
+	for (i = 0; archlist[i]; i++) {
+		if (!is_valid_arch_name(archlist[i]))
+			tst_brk(TBROK, "%s is invalid arch, please reset!",
                                                                   ^
								   fix?

lib/tst_arch.c line 103

Quoted 5 lines
lib/tst_arch.c new file +5 -0
+					archlist[i]);
+	}
+
+	for (i = 0; archlist[i]; i++) {
+		if (is_matched_arch(tst_arch.name, archlist[i]))

I would just do !strcmp() here, there is no point in havin a function that just calls strcmp() and returns the result.

Quoted 11 lines
lib/tst_arch.c new file +5 -0
+			return 1;
+	}
+
+	return 0;
+}
Signature · 5 lines
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
author
#10 lore raw
Quoted 11 lines
Quoted 11 lines
include/tst_arch.h new file +5 -0
new file mode 100644
index 000000000..784c3093b
@@ -0,0 +1,39 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright (c) 2021 Li Wang <[email protected]>
+ */
+
+#ifndef TST_ARCH_H__
Quoted 9 lines

include/tst_arch.h line 10

Quoted 5 lines
include/tst_arch.h new file +5 -0
+#define TST_ARCH_H__
+
+enum tst_arch_type {
+     TST_I386,
+     TST_X86,

Why do we have both i386 and X86 here? Isn't __i386__ synonymous for __x86__ does gcc even define __x86__?

My fault, I just copy that from testcase defines and didn't check if __x86__ validatable or not.

Quoted 5 lines

I doubt that we care about the differencies between i386, i586 and i686 at all. I would just keep TST_X86 in the list for any 32bit intel compatible hardware.

I prefer to only keep TST_I386 and TST_X86_64 for use. Becuase so far I didn't see there is a requirement on i[4|5|6]86 in LTP at all. And, we can add that if we really need it in the future.

The rest of the comments looks good, thanks.

Signature · 2 lines
Regards,
Li Wang
Signature · 2 lines
-- 
Mailing list info: https://lists.linux.it/listinfo/ltp