1
2
3
4#define _GNU_SOURCE
5
6#include <errno.h>
7#include <fcntl.h>
8#include <signal.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12#include <ucontext.h>
13#include <sys/mman.h>
14#include <sys/stat.h>
15#include <sys/types.h>
16
17#include "kselftest.h"
18#include "mte_common_util.h"
19#include "mte_def.h"
20
21#define RUNS (MT_TAG_COUNT)
22#define UNDERFLOW MT_GRANULE_SIZE
23#define OVERFLOW MT_GRANULE_SIZE
24#define TAG_CHECK_ON 0
25#define TAG_CHECK_OFF 1
26
27static size_t page_size;
28static int sizes[] = {
29 1, 537, 989, 1269, MT_GRANULE_SIZE - 1, MT_GRANULE_SIZE,
30 0, 0, 0
31};
32
33static int check_mte_memory(char *ptr, int size, int mode, int tag_check)
34{
35 mte_initialize_current_context(mode, (uintptr_t)ptr, size);
36 memset(ptr, '1', size);
37 mte_wait_after_trig();
38 if (cur_mte_cxt.fault_valid == true)
39 return KSFT_FAIL;
40
41 mte_initialize_current_context(mode, (uintptr_t)ptr, -UNDERFLOW);
42 memset(ptr - UNDERFLOW, '2', UNDERFLOW);
43 mte_wait_after_trig();
44 if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)
45 return KSFT_FAIL;
46 if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)
47 return KSFT_FAIL;
48
49 mte_initialize_current_context(mode, (uintptr_t)ptr, size + OVERFLOW);
50 memset(ptr + size, '3', OVERFLOW);
51 mte_wait_after_trig();
52 if (cur_mte_cxt.fault_valid == false && tag_check == TAG_CHECK_ON)
53 return KSFT_FAIL;
54 if (cur_mte_cxt.fault_valid == true && tag_check == TAG_CHECK_OFF)
55 return KSFT_FAIL;
56
57 return KSFT_PASS;
58}
59
60static int check_anonymous_memory_mapping(int mem_type, int mode, int mapping, int tag_check)
61{
62 char *ptr, *map_ptr;
63 int run, result, map_size;
64 int item = sizeof(sizes)/sizeof(int);
65
66 item = sizeof(sizes)/sizeof(int);
67 mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);
68 for (run = 0; run < item; run++) {
69 map_size = sizes[run] + OVERFLOW + UNDERFLOW;
70 map_ptr = (char *)mte_allocate_memory(map_size, mem_type, mapping, false);
71 if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS)
72 return KSFT_FAIL;
73
74 ptr = map_ptr + UNDERFLOW;
75 mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);
76
77 ptr = mte_insert_tags((void *)ptr, sizes[run]);
78 if (!ptr || cur_mte_cxt.fault_valid == true) {
79 ksft_print_msg("FAIL: Insert tags on anonymous mmap memory\n");
80 munmap((void *)map_ptr, map_size);
81 return KSFT_FAIL;
82 }
83 result = check_mte_memory(ptr, sizes[run], mode, tag_check);
84 mte_clear_tags((void *)ptr, sizes[run]);
85 mte_free_memory((void *)map_ptr, map_size, mem_type, false);
86 if (result == KSFT_FAIL)
87 return KSFT_FAIL;
88 }
89 return KSFT_PASS;
90}
91
92static int check_file_memory_mapping(int mem_type, int mode, int mapping, int tag_check)
93{
94 char *ptr, *map_ptr;
95 int run, fd, map_size;
96 int total = sizeof(sizes)/sizeof(int);
97 int result = KSFT_PASS;
98
99 mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);
100 for (run = 0; run < total; run++) {
101 fd = create_temp_file();
102 if (fd == -1)
103 return KSFT_FAIL;
104
105 map_size = sizes[run] + UNDERFLOW + OVERFLOW;
106 map_ptr = (char *)mte_allocate_file_memory(map_size, mem_type, mapping, false, fd);
107 if (check_allocated_memory(map_ptr, map_size, mem_type, false) != KSFT_PASS) {
108 close(fd);
109 return KSFT_FAIL;
110 }
111 ptr = map_ptr + UNDERFLOW;
112 mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);
113
114 ptr = mte_insert_tags((void *)ptr, sizes[run]);
115 if (!ptr || cur_mte_cxt.fault_valid == true) {
116 ksft_print_msg("FAIL: Insert tags on file based memory\n");
117 munmap((void *)map_ptr, map_size);
118 close(fd);
119 return KSFT_FAIL;
120 }
121 result = check_mte_memory(ptr, sizes[run], mode, tag_check);
122 mte_clear_tags((void *)ptr, sizes[run]);
123 munmap((void *)map_ptr, map_size);
124 close(fd);
125 if (result == KSFT_FAIL)
126 break;
127 }
128 return result;
129}
130
131static int check_clear_prot_mte_flag(int mem_type, int mode, int mapping)
132{
133 char *ptr, *map_ptr;
134 int run, prot_flag, result, fd, map_size;
135 int total = sizeof(sizes)/sizeof(int);
136
137 prot_flag = PROT_READ | PROT_WRITE;
138 mte_switch_mode(mode, MTE_ALLOW_NON_ZERO_TAG);
139 for (run = 0; run < total; run++) {
140 map_size = sizes[run] + OVERFLOW + UNDERFLOW;
141 ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping,
142 UNDERFLOW, OVERFLOW);
143 if (check_allocated_memory_range(ptr, sizes[run], mem_type,
144 UNDERFLOW, OVERFLOW) != KSFT_PASS)
145 return KSFT_FAIL;
146 map_ptr = ptr - UNDERFLOW;
147
148 if (mprotect(map_ptr, map_size, prot_flag)) {
149 mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,
150 UNDERFLOW, OVERFLOW);
151 ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");
152 return KSFT_FAIL;
153 }
154 result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON);
155 mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);
156 if (result != KSFT_PASS)
157 return KSFT_FAIL;
158
159 fd = create_temp_file();
160 if (fd == -1)
161 return KSFT_FAIL;
162 ptr = (char *)mte_allocate_file_memory_tag_range(sizes[run], mem_type, mapping,
163 UNDERFLOW, OVERFLOW, fd);
164 if (check_allocated_memory_range(ptr, sizes[run], mem_type,
165 UNDERFLOW, OVERFLOW) != KSFT_PASS) {
166 close(fd);
167 return KSFT_FAIL;
168 }
169 map_ptr = ptr - UNDERFLOW;
170
171 if (mprotect(map_ptr, map_size, prot_flag)) {
172 ksft_print_msg("FAIL: mprotect not ignoring clear PROT_MTE property\n");
173 mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,
174 UNDERFLOW, OVERFLOW);
175 close(fd);
176 return KSFT_FAIL;
177 }
178 result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON);
179 mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);
180 close(fd);
181 if (result != KSFT_PASS)
182 return KSFT_FAIL;
183 }
184 return KSFT_PASS;
185}
186
187int main(int argc, char *argv[])
188{
189 int err;
190 int item = sizeof(sizes)/sizeof(int);
191
192 err = mte_default_setup();
193 if (err)
194 return err;
195 page_size = getpagesize();
196 if (!page_size) {
197 ksft_print_msg("ERR: Unable to get page size\n");
198 return KSFT_FAIL;
199 }
200 sizes[item - 3] = page_size - 1;
201 sizes[item - 2] = page_size;
202 sizes[item - 1] = page_size + 1;
203
204
205 mte_register_signal(SIGBUS, mte_default_handler);
206 mte_register_signal(SIGSEGV, mte_default_handler);
207
208
209 ksft_set_plan(22);
210
211 mte_enable_pstate_tco();
212
213 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
214 "Check anonymous memory with private mapping, sync error mode, mmap memory and tag check off\n");
215 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
216 "Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check off\n");
217
218 mte_disable_pstate_tco();
219 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
220 "Check anonymous memory with private mapping, no error mode, mmap memory and tag check off\n");
221 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_NONE_ERR, MAP_PRIVATE, TAG_CHECK_OFF),
222 "Check file memory with private mapping, no error mode, mmap/mprotect memory and tag check off\n");
223
224 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
225 "Check anonymous memory with private mapping, sync error mode, mmap memory and tag check on\n");
226 evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
227 "Check anonymous memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");
228 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
229 "Check anonymous memory with shared mapping, sync error mode, mmap memory and tag check on\n");
230 evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
231 "Check anonymous memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");
232 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
233 "Check anonymous memory with private mapping, async error mode, mmap memory and tag check on\n");
234 evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
235 "Check anonymous memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");
236 evaluate_test(check_anonymous_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
237 "Check anonymous memory with shared mapping, async error mode, mmap memory and tag check on\n");
238 evaluate_test(check_anonymous_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
239 "Check anonymous memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");
240
241 evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
242 "Check file memory with private mapping, sync error mode, mmap memory and tag check on\n");
243 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
244 "Check file memory with private mapping, sync error mode, mmap/mprotect memory and tag check on\n");
245 evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
246 "Check file memory with shared mapping, sync error mode, mmap memory and tag check on\n");
247 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_SYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
248 "Check file memory with shared mapping, sync error mode, mmap/mprotect memory and tag check on\n");
249 evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
250 "Check file memory with private mapping, async error mode, mmap memory and tag check on\n");
251 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_PRIVATE, TAG_CHECK_ON),
252 "Check file memory with private mapping, async error mode, mmap/mprotect memory and tag check on\n");
253 evaluate_test(check_file_memory_mapping(USE_MMAP, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
254 "Check file memory with shared mapping, async error mode, mmap memory and tag check on\n");
255 evaluate_test(check_file_memory_mapping(USE_MPROTECT, MTE_ASYNC_ERR, MAP_SHARED, TAG_CHECK_ON),
256 "Check file memory with shared mapping, async error mode, mmap/mprotect memory and tag check on\n");
257
258 evaluate_test(check_clear_prot_mte_flag(USE_MMAP, MTE_SYNC_ERR, MAP_PRIVATE),
259 "Check clear PROT_MTE flags with private mapping, sync error mode and mmap memory\n");
260 evaluate_test(check_clear_prot_mte_flag(USE_MPROTECT, MTE_SYNC_ERR, MAP_PRIVATE),
261 "Check clear PROT_MTE flags with private mapping and sync error mode and mmap/mprotect memory\n");
262
263 mte_restore_setup();
264 ksft_print_cnts();
265 return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;
266}
267
