1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2020 ARM Limited 3 4 #define _GNU_SOURCE 5 6 #include <errno.h> 7 #include <signal.h> 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <string.h> 11 #include <ucontext.h> 12 #include <sys/wait.h> 13 14 #include "kselftest.h" 15 #include "mte_common_util.h" 16 #include "mte_def.h" 17 18 #define BUFFER_SIZE (5 * MT_GRANULE_SIZE) 19 #define RUNS (MT_TAG_COUNT) 20 #define UNDERFLOW MT_GRANULE_SIZE 21 #define OVERFLOW MT_GRANULE_SIZE 22 23 static size_t page_size; 24 static int sizes[] = { 25 1, 537, 989, 1269, MT_GRANULE_SIZE - 1, MT_GRANULE_SIZE, 26 /* page size - 1*/ 0, /* page_size */ 0, /* page size + 1 */ 0 27 }; 28 29 static int check_child_tag_inheritance(char *ptr, int size, int mode) 30 { 31 int i, parent_tag, child_tag, fault, child_status; 32 pid_t child; 33 34 parent_tag = MT_FETCH_TAG((uintptr_t)ptr); 35 fault = 0; 36 37 child = fork(); 38 if (child == -1) { 39 ksft_print_msg("FAIL: child process creation\n"); 40 return KSFT_FAIL; 41 } else if (child == 0) { 42 mte_initialize_current_context(mode, (uintptr_t)ptr, size); 43 /* Do copy on write */ 44 memset(ptr, '1', size); 45 mte_wait_after_trig(); 46 if (cur_mte_cxt.fault_valid == true) { 47 fault = 1; 48 goto check_child_tag_inheritance_err; 49 } 50 for (i = 0 ; i < size ; i += MT_GRANULE_SIZE) { 51 child_tag = MT_FETCH_TAG((uintptr_t)(mte_get_tag_address(ptr + i))); 52 if (parent_tag != child_tag) { 53 ksft_print_msg("FAIL: child mte tag mismatch\n"); 54 fault = 1; 55 goto check_child_tag_inheritance_err; 56 } 57 } 58 mte_initialize_current_context(mode, (uintptr_t)ptr, -UNDERFLOW); 59 memset(ptr - UNDERFLOW, '2', UNDERFLOW); 60 mte_wait_after_trig(); 61 if (cur_mte_cxt.fault_valid == false) { 62 fault = 1; 63 goto check_child_tag_inheritance_err; 64 } 65 mte_initialize_current_context(mode, (uintptr_t)ptr, size + OVERFLOW); 66 memset(ptr + size, '3', OVERFLOW); 67 mte_wait_after_trig(); 68 if (cur_mte_cxt.fault_valid == false) { 69 fault = 1; 70 goto check_child_tag_inheritance_err; 71 } 72 check_child_tag_inheritance_err: 73 _exit(fault); 74 } 75 /* Wait for child process to terminate */ 76 wait(&child_status); 77 if (WIFEXITED(child_status)) 78 fault = WEXITSTATUS(child_status); 79 else 80 fault = 1; 81 return (fault) ? KSFT_FAIL : KSFT_PASS; 82 } 83 84 static int check_child_memory_mapping(int mem_type, int mode, int mapping) 85 { 86 char *ptr; 87 int run, result; 88 int item = sizeof(sizes)/sizeof(int); 89 90 item = sizeof(sizes)/sizeof(int); 91 mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG); 92 for (run = 0; run < item; run++) { 93 ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping, 94 UNDERFLOW, OVERFLOW); 95 if (check_allocated_memory_range(ptr, sizes[run], mem_type, 96 UNDERFLOW, OVERFLOW) != KSFT_PASS) 97 return KSFT_FAIL; 98 result = check_child_tag_inheritance(ptr, sizes[run], mode); 99 mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW); 100 if (result == KSFT_FAIL) 101 return result; 102 } 103 return KSFT_PASS; 104 } 105 106 static int check_child_file_mapping(int mem_type, int mode, int mapping) 107 { 108 char *ptr, *map_ptr; 109 int run, fd, map_size, result = KSFT_PASS; 110 int total = sizeof(sizes)/sizeof(int); 111 112 mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG); 113 for (run = 0; run < total; run++) { 114 fd = create_temp_file(); 115 if (fd == -1) 116 return KSFT_FAIL; 117 118 map_size = sizes[run] + OVERFLOW + UNDERFLOW; 119 map_ptr = (char *)mte_allocate_file_memory(map_size, mem_type, mapping, false, fd); 120 if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS) { 121 close(fd); 122 return KSFT_FAIL; 123 } 124 ptr = map_ptr + UNDERFLOW; 125 mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]); 126 /* Only mte enabled memory will allow tag insertion */ 127 ptr = mte_insert_tags((void *)ptr, sizes[run]); 128 if (!ptr || cur_mte_cxt.fault_valid == true) { 129 ksft_print_msg("FAIL: Insert tags on file based memory\n"); 130 munmap((void *)map_ptr, map_size); 131 close(fd); 132 return KSFT_FAIL; 133 } 134 result = check_child_tag_inheritance(ptr, sizes[run], mode); 135 mte_clear_tags((void *)ptr, sizes[run]); 136 munmap((void *)map_ptr, map_size); 137 close(fd); 138 if (result != KSFT_PASS) 139 return KSFT_FAIL; 140 } 141 return KSFT_PASS; 142 } 143 144 int main(int argc, char *argv[]) 145 { 146 int err; 147 int item = sizeof(sizes)/sizeof(int); 148 149 page_size = getpagesize(); 150 if (!page_size) { 151 ksft_print_msg("ERR: Unable to get page size\n"); 152 return KSFT_FAIL; 153 } 154 sizes[item - 3] = page_size - 1; 155 sizes[item - 2] = page_size; 156 sizes[item - 1] = page_size + 1; 157 158 err = mte_default_setup(); 159 if (err) 160 return err; 161 162 /* Register SIGSEGV handler */ 163 mte_register_signal(SIGSEGV, mte_default_handler); 164 mte_register_signal(SIGBUS, mte_default_handler); 165 166 /* Set test plan */ 167 ksft_set_plan(12); 168 169 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE), 170 "Check child anonymous memory with private mapping, precise mode and mmap memory\n"); 171 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED), 172 "Check child anonymous memory with shared mapping, precise mode and mmap memory\n"); 173 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE), 174 "Check child anonymous memory with private mapping, imprecise mode and mmap memory\n"); 175 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED), 176 "Check child anonymous memory with shared mapping, imprecise mode and mmap memory\n"); 177 evaluate_test(check_child_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE), 178 "Check child anonymous memory with private mapping, precise mode and mmap/mprotect memory\n"); 179 evaluate_test(check_child_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED), 180 "Check child anonymous memory with shared mapping, precise mode and mmap/mprotect memory\n"); 181 182 evaluate_test(check_child_file_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE), 183 "Check child file memory with private mapping, precise mode and mmap memory\n"); 184 evaluate_test(check_child_file_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED), 185 "Check child file memory with shared mapping, precise mode and mmap memory\n"); 186 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE), 187 "Check child file memory with private mapping, imprecise mode and mmap memory\n"); 188 evaluate_test(check_child_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED), 189 "Check child file memory with shared mapping, imprecise mode and mmap memory\n"); 190 evaluate_test(check_child_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE), 191 "Check child file memory with private mapping, precise mode and mmap/mprotect memory\n"); 192 evaluate_test(check_child_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED), 193 "Check child file memory with shared mapping, precise mode and mmap/mprotect memory\n"); 194 195 mte_restore_setup(); 196 ksft_print_cnts(); 197 return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL; 198 } 199