Proxmox-Port/linux-loongson
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson synced 2025-09-01 23:46:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
loongarch-next
linux-loongson/tools/testing/selftests/arm64/mte/check_mmap_options.c
Yeoreum Yun 1f488fb913 kselftest/arm64/mte: Add MTE_STORE_ONLY testcases 
Since ARMv8.9, FEAT_MTE_STORE_ONLY can be used to restrict raise of tag
check fault on store operation only.

Adds new test cases using MTE_STORE_ONLY feature.

Signed-off-by: Yeoreum Yun <yeoreum.yun@arm.com>
Reviewed-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/20250618092957.2069907-9-yeoreum.yun@arm.com
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
2025-07-02 18:50:53 +01:00

1010 lines
25 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 ARM Limited
#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ucontext.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "kselftest.h"
#include "mte_common_util.h"
#include "mte_def.h"
#define RUNS (MT_TAG_COUNT)
#define UNDERFLOW MT_GRANULE_SIZE
#define OVERFLOW MT_GRANULE_SIZE
#define TAG_CHECK_ON 0
#define TAG_CHECK_OFF 1
#define ATAG_CHECK_ON 1
#define ATAG_CHECK_OFF 0
#define TEST_NAME_MAX 256
enum mte_mem_check_type {
CHECK_ANON_MEM = 0,
CHECK_FILE_MEM = 1,
CHECK_CLEAR_PROT_MTE = 2,
};
enum mte_tag_op_type {
TAG_OP_ALL = 0,
TAG_OP_STONLY = 1,
};
struct check_mmap_testcase {
int check_type;
int mem_type;
int mte_sync;
int mapping;
int tag_check;
int atag_check;
int tag_op;
bool enable_tco;
};
#define TAG_OP_ALL 0
#define TAG_OP_STONLY 1
static size_t page_size;
static int sizes[] = {
1, 537, 989, 1269, MT_GRANULE_SIZE - 1, MT_GRANULE_SIZE,
/* page size - 1*/ 0, /* page_size */ 0, /* page size + 1 */ 0
};
static int check_mte_memory(char *ptr, int size, int mode,
int tag_check,int atag_check, int tag_op)
{
char buf[MT_GRANULE_SIZE];
if (!mtefar_support && atag_check == ATAG_CHECK_ON)
return KSFT_SKIP;
if (atag_check == ATAG_CHECK_ON)
ptr = mte_insert_atag(ptr);
mte_initialize_current_context(mode, (uintptr_t)ptr, size);
memset(ptr, '1', size);
mte_wait_after_trig();
if (cur_mte_cxt.fault_valid == true)
return KSFT_FAIL;
mte_initialize_current_context(mode, (uintptr_t)ptr, -UNDERFLOW);
memset(ptr - UNDERFLOW, '2', UNDERFLOW);
mte_wait_after_trig();
if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)
return KSFT_FAIL;
if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)
return KSFT_FAIL;
mte_initialize_current_context(mode, (uintptr_t)ptr, size + OVERFLOW);
memset(ptr + size, '3', OVERFLOW);
mte_wait_after_trig();
if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)
return KSFT_FAIL;
if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)
return KSFT_FAIL;
if (tag_op == TAG_OP_STONLY) {
mte_initialize_current_context(mode, (uintptr_t)ptr, -UNDERFLOW);
memcpy(buf, ptr - UNDERFLOW, MT_GRANULE_SIZE);
mte_wait_after_trig();
if (cur_mte_cxt.fault_valid == true)
return KSFT_FAIL;
mte_initialize_current_context(mode, (uintptr_t)ptr, size + OVERFLOW);
memcpy(buf, ptr + size, MT_GRANULE_SIZE);
mte_wait_after_trig();
if (cur_mte_cxt.fault_valid == true)
return KSFT_FAIL;
}
return KSFT_PASS;
}
static int check_anonymous_memory_mapping(int mem_type, int mode, int mapping,
int tag_check, int atag_check, int tag_op)
{
char *ptr, *map_ptr;
int run, result, map_size;
int item = ARRAY_SIZE(sizes);
if (tag_op == TAG_OP_STONLY && !mtestonly_support)
return KSFT_SKIP;
mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG, tag_op);
for (run = 0; run < item; run++) {
map_size = sizes[run] + OVERFLOW + UNDERFLOW;
map_ptr = (char *)mte_allocate_memory(map_size, mem_type, mapping, false);
if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS)
return KSFT_FAIL;
ptr = map_ptr + UNDERFLOW;
mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);
/* Only mte enabled memory will allow tag insertion */
ptr = mte_insert_tags((void *)ptr, sizes[run]);
if (!ptr || cur_mte_cxt.fault_valid == true) {
ksft_print_msg("FAIL: Insert tags on anonymous mmap memory\n");
munmap((void *)map_ptr, map_size);
return KSFT_FAIL;
}
result = check_mte_memory(ptr, sizes[run], mode, tag_check, atag_check, tag_op);
mte_clear_tags((void *)ptr, sizes[run]);
mte_free_memory((void *)map_ptr, map_size, mem_type, false);
if (result != KSFT_PASS)
return result;
}
return KSFT_PASS;
}
static int check_file_memory_mapping(int mem_type, int mode, int mapping,
int tag_check, int atag_check, int tag_op)
{
char *ptr, *map_ptr;
int run, fd, map_size;
int total = ARRAY_SIZE(sizes);
int result = KSFT_PASS;
if (tag_op == TAG_OP_STONLY && !mtestonly_support)
return KSFT_SKIP;
mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG, tag_op);
for (run = 0; run < total; run++) {
fd = create_temp_file();
if (fd == -1)
return KSFT_FAIL;
map_size = sizes[run] + UNDERFLOW + OVERFLOW;
map_ptr = (char *)mte_allocate_file_memory(map_size, mem_type, mapping, false, fd);
if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS) {
close(fd);
return KSFT_FAIL;
}
ptr = map_ptr + UNDERFLOW;
mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);
/* Only mte enabled memory will allow tag insertion */
ptr = mte_insert_tags((void *)ptr, sizes[run]);
if (!ptr || cur_mte_cxt.fault_valid == true) {
ksft_print_msg("FAIL: Insert tags on file based memory\n");
munmap((void *)map_ptr, map_size);
close(fd);
return KSFT_FAIL;
}
result = check_mte_memory(ptr, sizes[run], mode, tag_check, atag_check, tag_op);
mte_clear_tags((void *)ptr, sizes[run]);
munmap((void *)map_ptr, map_size);
close(fd);
if (result != KSFT_PASS)
return result;
}
return KSFT_PASS;
}
static int check_clear_prot_mte_flag(int mem_type, int mode, int mapping, int atag_check)
{
char *ptr, *map_ptr;
int run, prot_flag, result, fd, map_size;
int total = ARRAY_SIZE(sizes);
prot_flag = PROT_READ | PROT_WRITE;
mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG, false);
for (run = 0; run < total; run++) {
map_size = sizes[run] + OVERFLOW + UNDERFLOW;
ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping,
UNDERFLOW, OVERFLOW);
if (check_allocated_memory_range(ptr, sizes[run], mem_type,
UNDERFLOW, OVERFLOW) != KSFT_PASS)
return KSFT_FAIL;
map_ptr = ptr - UNDERFLOW;
/* Try to clear PROT_MTE property and verify it by tag checking */
if (mprotect(map_ptr, map_size, prot_flag)) {
mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,
UNDERFLOW, OVERFLOW);
ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");
return KSFT_FAIL;
}
result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON, atag_check, TAG_OP_ALL);
mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);
if (result != KSFT_PASS)
return result;
fd = create_temp_file();
if (fd == -1)
return KSFT_FAIL;
ptr = (char *)mte_allocate_file_memory_tag_range(sizes[run], mem_type, mapping,
UNDERFLOW, OVERFLOW, fd);
if (check_allocated_memory_range(ptr, sizes[run], mem_type,
UNDERFLOW, OVERFLOW) != KSFT_PASS) {
close(fd);
return KSFT_FAIL;
}
map_ptr = ptr - UNDERFLOW;
/* Try to clear PROT_MTE property and verify it by tag checking */
if (mprotect(map_ptr, map_size, prot_flag)) {
ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");
mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,
UNDERFLOW, OVERFLOW);
close(fd);
return KSFT_FAIL;
}
result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON, atag_check, TAG_OP_ALL);
mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);
close(fd);
if (result != KSFT_PASS)
return result;
}
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;
const char *atag_check_str;
const char *tag_op_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;
}
switch (tc->atag_check) {
case ATAG_CHECK_ON:
atag_check_str = "with address tag [63:60]";
break;
case ATAG_CHECK_OFF:
atag_check_str = "without address tag [63:60]";
break;
default:
assert(0);
break;
}
snprintf(test_name, sizeof(test_name),
"Check %s with %s mapping, %s mode, %s memory and %s (%s)\n",
check_type_str, mapping_str, sync_str, mem_type_str,
tag_check_str, atag_check_str);
switch (tc->tag_op) {
case TAG_OP_ALL:
tag_op_str = "";
break;
case TAG_OP_STONLY:
tag_op_str = " / store-only";
break;
default:
assert(0);
break;
}
snprintf(test_name, TEST_NAME_MAX,
"Check %s with %s mapping, %s mode, %s memory and %s (%s%s)\n",
check_type_str, mapping_str, sync_str, mem_type_str,
tag_check_str, atag_check_str, tag_op_str);
return test_name;
}
int main(int argc, char *argv[])
{
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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_OFF,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_STONLY,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.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,
.atag_check = ATAG_CHECK_ON,
.tag_op = TAG_OP_ALL,
.enable_tco = false,
},
};
err = mte_default_setup();
if (err)
return err;
page_size = getpagesize();
if (!page_size) {
ksft_print_msg("ERR: Unable to get page size\n");
return KSFT_FAIL;
}
sizes[item - 3] = page_size - 1;
sizes[item - 2] = page_size;
sizes[item - 1] = page_size + 1;
/* Set test plan */
ksft_set_plan(ARRAY_SIZE(test_cases));
for (i = 0 ; i < ARRAY_SIZE(test_cases); i++) {
/* Register signal handlers */
mte_register_signal(SIGBUS, mte_default_handler,
test_cases[i].atag_check == ATAG_CHECK_ON);
mte_register_signal(SIGSEGV, mte_default_handler,
test_cases[i].atag_check == ATAG_CHECK_ON);
if (test_cases[i].enable_tco)
mte_enable_pstate_tco();
else
mte_disable_pstate_tco();
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,
test_cases[i].atag_check,
test_cases[i].tag_op),
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,
test_cases[i].atag_check,
test_cases[i].tag_op),
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,
test_cases[i].atag_check),
format_test_name(&test_cases[i]));
break;
default:
exit(KSFT_FAIL);
}
}
mte_restore_setup();
ksft_print_cnts();
return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;
}
Reference in New Issue View Git Blame Copy Permalink