github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-24 23:22:31 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

kselftest/arm64/mte: Refactor check_mmap_option test

Browse Source 
Before add mtefar testcase on check_mmap_option.c,
refactor check_mmap_option:
  - make testcase suite array with test options (mem_type, mte_sync type and etc)
    to use general testcase pattern

  - generate each test case name acoording to test options.

Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
Reviewed-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/20250618084513.1761345-10-yeoreum.yun@arm.com
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
This commit is contained in:
Yeoreum Yun 2025-06-18 09:45:12 +01:00 committed by Catalin Marinas
parent 49cee364c8
commit 64a64e5d12
1 changed files with 311 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
tools/testing/selftests/arm64/mte/check_mmap_options.c
View File

@ -3,6 +3,7 @@
#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
@ -24,6 +25,23 @@
#define TAG_CHECK_ON 0
#define TAG_CHECK_OFF 1
#define TEST_NAME_MAX 256
enum mte_mem_check_type {
CHECK_ANON_MEM = 0,
CHECK_FILE_MEM = 1,
CHECK_CLEAR_PROT_MTE = 2,
};
struct check_mmap_testcase {
int check_type;
int mem_type;
int mte_sync;
int mapping;
int tag_check;
bool enable_tco;
};
static size_t page_size;
static int sizes[] = {
1, 537, 989, 1269, MT_GRANULE_SIZE - 1, MT_GRANULE_SIZE,
@ -183,10 +201,271 @@ static int check_clear_prot_mte_flag(int mem_type, int mode, int mapping)
return KSFT_PASS;
}
const char *format_test_name(struct check_mmap_testcase *tc)
{
static char test_name[TEST_NAME_MAX];
const char *check_type_str;
const char *mem_type_str;
const char *sync_str;
const char *mapping_str;
const char *tag_check_str;
switch (tc->check_type) {
case CHECK_ANON_MEM:
check_type_str = "anonymous memory";
break;
case CHECK_FILE_MEM:
check_type_str = "file memory";
break;
case CHECK_CLEAR_PROT_MTE:
check_type_str = "clear PROT_MTE flags";
break;
default:
assert(0);
break;
}
switch (tc->mem_type) {
case USE_MMAP:
mem_type_str = "mmap";
break;
case USE_MPROTECT:
mem_type_str = "mmap/mprotect";
break;
default:
assert(0);
break;
}
switch (tc->mte_sync) {
case MTE_NONE_ERR:
sync_str = "no error";
break;
case MTE_SYNC_ERR:
sync_str = "sync error";
break;
case MTE_ASYNC_ERR:
sync_str = "async error";
break;
default:
assert(0);
break;
}
switch (tc->mapping) {
case MAP_SHARED:
mapping_str = "shared";
break;
case MAP_PRIVATE:
mapping_str = "private";
break;
default:
assert(0);
break;
}
switch (tc->tag_check) {
case TAG_CHECK_ON:
tag_check_str = "tag check on";
break;
case TAG_CHECK_OFF:
tag_check_str = "tag check off";
break;
default:
assert(0);
break;
}
snprintf(test_name, sizeof(test_name),
"Check %s with %s mapping, %s mode, %s memory and %s\n",
check_type_str, mapping_str, sync_str, mem_type_str,
tag_check_str);
return test_name;
}
int main(int argc, char *argv[])
{
int err;
int err, i;
int item = ARRAY_SIZE(sizes);
struct check_mmap_testcase test_cases[]= {
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_OFF,
.enable_tco = true,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_OFF,
.enable_tco = true,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_NONE_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_OFF,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_NONE_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_OFF,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_ANON_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MMAP,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_FILE_MEM,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_ASYNC_ERR,
.mapping = MAP_SHARED,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_CLEAR_PROT_MTE,
.mem_type = USE_MMAP,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
{
.check_type = CHECK_CLEAR_PROT_MTE,
.mem_type = USE_MPROTECT,
.mte_sync = MTE_SYNC_ERR,
.mapping = MAP_PRIVATE,
.tag_check = TAG_CHECK_ON,
.enable_tco = false,
},
};
err = mte_default_setup();
if (err)
@ -205,59 +484,39 @@ int main(int argc, char *argv[])
mte_register_signal(SIGSEGV, mte_default_handler, false);
/* Set test plan */
ksft_set_plan(22);
ksft_set_plan(ARRAY_SIZE(test_cases));
mte_enable_pstate_tco();
for (i = 0 ; i < ARRAY_SIZE(test_cases); i++) {
if (test_cases[i].enable_tco)
mte_enable_pstate_tco();
else
mte_disable_pstate_tco();
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
"Check anonymous memory with private mapping, sync error mode, mmap memory and tag check off\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
"Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check off\n");
mte_disable_pstate_tco();
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
"Check anonymous memory with private mapping, no error mode, mmap memory and tag check off\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
"Check file memory with private mapping, no error mode, mmap/mprotect memory and tag check off\n");
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check anonymous memory with private mapping, sync error mode, mmap memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check anonymous memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check anonymous memory with shared mapping, sync error mode, mmap memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check anonymous memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check anonymous memory with private mapping, async error mode, mmap memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check anonymous memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check anonymous memory with shared mapping, async error mode, mmap memory and tag check on\n");
evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check anonymous memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check file memory with private mapping, sync error mode, mmap memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check file memory with shared mapping, sync error mode, mmap memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check file memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check file memory with private mapping, async error mode, mmap memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
"Check file memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check file memory with shared mapping, async error mode, mmap memory and tag check on\n");
evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
"Check file memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");
evaluate_test(check_clear_prot_mte_flag(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE),
"Check clear PROT_MTE flags with private mapping, sync error mode and mmap memory\n");
evaluate_test(check_clear_prot_mte_flag(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE),
"Check clear PROT_MTE flags with private mapping and sync error mode and mmap/mprotect memory\n");
switch (test_cases[i].check_type) {
case CHECK_ANON_MEM:
evaluate_test(check_anonymous_memory_mapping(test_cases[i].mem_type,
test_cases[i].mte_sync,
test_cases[i].mapping,
test_cases[i].tag_check),
format_test_name(&test_cases[i]));
break;
case CHECK_FILE_MEM:
evaluate_test(check_file_memory_mapping(test_cases[i].mem_type,
test_cases[i].mte_sync,
test_cases[i].mapping,
test_cases[i].tag_check),
format_test_name(&test_cases[i]));
break;
case CHECK_CLEAR_PROT_MTE:
evaluate_test(check_clear_prot_mte_flag(test_cases[i].mem_type,
test_cases[i].mte_sync,
test_cases[i].mapping),
format_test_name(&test_cases[i]));
break;
default:
exit(KSFT_FAIL);
}
}
mte_restore_setup();
ksft_print_cnts();