1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019 ARM Limited */
3 
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <signal.h>
7 #include <string.h>
8 #include <unistd.h>
9 #include <assert.h>
10 #include <sys/auxv.h>
11 #include <linux/auxvec.h>
12 #include <ucontext.h>
13 
14 #include <asm/unistd.h>
15 
16 #include <kselftest.h>
17 
18 #include "test_signals.h"
19 #include "test_signals_utils.h"
20 #include "testcases/testcases.h"
21 
22 
23 extern struct tdescr *current;
24 
25 static int sig_copyctx = SIGTRAP;
26 
27 static char const *const feats_names[FMAX_END] = {
28 	" SSBS ",
29 	" SVE ",
30 	" SME ",
31 	" FA64 ",
32 	" SME2 ",
33 };
34 
35 #define MAX_FEATS_SZ	128
36 static char feats_string[MAX_FEATS_SZ];
37 
38 static inline char *feats_to_string(unsigned long feats)
39 {
40 	size_t flen = MAX_FEATS_SZ - 1;
41 
42 	feats_string[0] = '\0';
43 
44 	for (int i = 0; i < FMAX_END; i++) {
45 		if (feats & (1UL << i)) {
46 			size_t tlen = strlen(feats_names[i]);
47 
48 			assert(flen > tlen);
49 			flen -= tlen;
50 			strncat(feats_string, feats_names[i], flen);
51 		}
52 	}
53 
54 	return feats_string;
55 }
56 
57 static void unblock_signal(int signum)
58 {
59 	sigset_t sset;
60 
61 	sigemptyset(&sset);
62 	sigaddset(&sset, signum);
63 	sigprocmask(SIG_UNBLOCK, &sset, NULL);
64 }
65 
66 static void default_result(struct tdescr *td, bool force_exit)
67 {
68 	if (td->result == KSFT_SKIP) {
69 		fprintf(stderr, "==>> completed. SKIP.\n");
70 	} else if (td->pass) {
71 		fprintf(stderr, "==>> completed. PASS(1)\n");
72 		td->result = KSFT_PASS;
73 	} else {
74 		fprintf(stdout, "==>> completed. FAIL(0)\n");
75 		td->result = KSFT_FAIL;
76 	}
77 
78 	if (force_exit)
79 		exit(td->result);
80 }
81 
82 /*
83  * The following handle_signal_* helpers are used by main default_handler
84  * and are meant to return true when signal is handled successfully:
85  * when false is returned instead, it means that the signal was somehow
86  * unexpected in that context and it was NOT handled; default_handler will
87  * take care of such unexpected situations.
88  */
89 
90 static bool handle_signal_unsupported(struct tdescr *td,
91 				      siginfo_t *si, void *uc)
92 {
93 	if (feats_ok(td))
94 		return false;
95 
96 	/* Mangling PC to avoid loops on original SIGILL */
97 	((ucontext_t *)uc)->uc_mcontext.pc += 4;
98 
99 	if (!td->initialized) {
100 		fprintf(stderr,
101 			"Got SIG_UNSUPP @test_init. Ignore.\n");
102 	} else {
103 		fprintf(stderr,
104 			"-- RX SIG_UNSUPP on unsupported feat...OK\n");
105 		td->pass = 1;
106 		default_result(current, 1);
107 	}
108 
109 	return true;
110 }
111 
112 static bool handle_signal_trigger(struct tdescr *td,
113 				  siginfo_t *si, void *uc)
114 {
115 	td->triggered = 1;
116 	/* ->run was asserted NON-NULL in test_setup() already */
117 	td->run(td, si, uc);
118 
119 	return true;
120 }
121 
122 static bool handle_signal_ok(struct tdescr *td,
123 			     siginfo_t *si, void *uc)
124 {
125 	/*
126 	 * it's a bug in the test code when this assert fail:
127 	 * if sig_trig was defined, it must have been used before getting here.
128 	 */
129 	assert(!td->sig_trig || td->triggered);
130 	fprintf(stderr,
131 		"SIG_OK -- SP:0x%llX  si_addr@:%p  si_code:%d  token@:%p  offset:%ld\n",
132 		((ucontext_t *)uc)->uc_mcontext.sp,
133 		si->si_addr, si->si_code, td->token, td->token - si->si_addr);
134 	/*
135 	 * fake_sigreturn tests, which have sanity_enabled=1, set, at the very
136 	 * last time, the token field to the SP address used to place the fake
137 	 * sigframe: so token==0 means we never made it to the end,
138 	 * segfaulting well-before, and the test is possibly broken.
139 	 */
140 	if (!td->sanity_disabled && !td->token) {
141 		fprintf(stdout,
142 			"current->token ZEROED...test is probably broken!\n");
143 		abort();
144 	}
145 	/*
146 	 * Trying to narrow down the SEGV to the ones generated by Kernel itself
147 	 * via arm64_notify_segfault(). This is a best-effort check anyway, and
148 	 * the si_code check may need to change if this aspect of the kernel
149 	 * ABI changes.
150 	 */
151 	if (td->sig_ok == SIGSEGV && si->si_code != SEGV_ACCERR) {
152 		fprintf(stdout,
153 			"si_code != SEGV_ACCERR...test is probably broken!\n");
154 		abort();
155 	}
156 	td->pass = 1;
157 	/*
158 	 * Some tests can lead to SEGV loops: in such a case we want to
159 	 * terminate immediately exiting straight away; some others are not
160 	 * supposed to outlive the signal handler code, due to the content of
161 	 * the fake sigframe which caused the signal itself.
162 	 */
163 	default_result(current, 1);
164 
165 	return true;
166 }
167 
168 static bool handle_signal_copyctx(struct tdescr *td,
169 				  siginfo_t *si, void *uc_in)
170 {
171 	ucontext_t *uc = uc_in;
172 	struct _aarch64_ctx *head;
173 	struct extra_context *extra, *copied_extra;
174 	size_t offset = 0;
175 	size_t to_copy;
176 
177 	ASSERT_GOOD_CONTEXT(uc);
178 
179 	/* Mangling PC to avoid loops on original BRK instr */
180 	uc->uc_mcontext.pc += 4;
181 
182 	/*
183 	 * Check for an preserve any extra data too with fixups.
184 	 */
185 	head = (struct _aarch64_ctx *)uc->uc_mcontext.__reserved;
186 	head = get_header(head, EXTRA_MAGIC, td->live_sz, &offset);
187 	if (head) {
188 		extra = (struct extra_context *)head;
189 
190 		/*
191 		 * The extra buffer must be immediately after the
192 		 * extra_context and a 16 byte terminator. Include it
193 		 * in the copy, this was previously validated in
194 		 * ASSERT_GOOD_CONTEXT().
195 		 */
196 		to_copy = __builtin_offsetof(ucontext_t,
197 					     uc_mcontext.__reserved);
198 		to_copy += offset + sizeof(struct extra_context) + 16;
199 		to_copy += extra->size;
200 		copied_extra = (struct extra_context *)&(td->live_uc->uc_mcontext.__reserved[offset]);
201 	} else {
202 		copied_extra = NULL;
203 		to_copy = sizeof(ucontext_t);
204 	}
205 
206 	if (to_copy > td->live_sz) {
207 		fprintf(stderr,
208 			"Not enough space to grab context, %lu/%lu bytes\n",
209 			td->live_sz, to_copy);
210 		return false;
211 	}
212 
213 	memcpy(td->live_uc, uc, to_copy);
214 
215 	/*
216 	 * If there was any EXTRA_CONTEXT fix up the size to be the
217 	 * struct extra_context and the following terminator record,
218 	 * this means that the rest of the code does not need to have
219 	 * special handling for the record and we don't need to fix up
220 	 * datap for the new location.
221 	 */
222 	if (copied_extra)
223 		copied_extra->head.size = sizeof(*copied_extra) + 16;
224 
225 	td->live_uc_valid = 1;
226 	fprintf(stderr,
227 		"%lu byte GOOD CONTEXT grabbed from sig_copyctx handler\n",
228 		to_copy);
229 
230 	return true;
231 }
232 
233 static void default_handler(int signum, siginfo_t *si, void *uc)
234 {
235 	if (current->sig_unsupp && signum == current->sig_unsupp &&
236 	    handle_signal_unsupported(current, si, uc)) {
237 		fprintf(stderr, "Handled SIG_UNSUPP\n");
238 	} else if (current->sig_trig && signum == current->sig_trig &&
239 		   handle_signal_trigger(current, si, uc)) {
240 		fprintf(stderr, "Handled SIG_TRIG\n");
241 	} else if (current->sig_ok && signum == current->sig_ok &&
242 		   handle_signal_ok(current, si, uc)) {
243 		fprintf(stderr, "Handled SIG_OK\n");
244 	} else if (signum == sig_copyctx && current->live_uc &&
245 		   handle_signal_copyctx(current, si, uc)) {
246 		fprintf(stderr, "Handled SIG_COPYCTX\n");
247 	} else {
248 		if (signum == SIGALRM && current->timeout) {
249 			fprintf(stderr, "-- Timeout !\n");
250 		} else {
251 			fprintf(stderr,
252 				"-- RX UNEXPECTED SIGNAL: %d code %d address %p\n",
253 				signum, si->si_code, si->si_addr);
254 		}
255 		default_result(current, 1);
256 	}
257 }
258 
259 static int default_setup(struct tdescr *td)
260 {
261 	struct sigaction sa;
262 
263 	sa.sa_sigaction = default_handler;
264 	sa.sa_flags = SA_SIGINFO | SA_RESTART;
265 	sa.sa_flags |= td->sa_flags;
266 	sigemptyset(&sa.sa_mask);
267 	/* uncatchable signals naturally skipped ... */
268 	for (int sig = 1; sig < 32; sig++)
269 		sigaction(sig, &sa, NULL);
270 	/*
271 	 * RT Signals default disposition is Term but they cannot be
272 	 * generated by the Kernel in response to our tests; so just catch
273 	 * them all and report them as UNEXPECTED signals.
274 	 */
275 	for (int sig = SIGRTMIN; sig <= SIGRTMAX; sig++)
276 		sigaction(sig, &sa, NULL);
277 
278 	/* just in case...unblock explicitly all we need */
279 	if (td->sig_trig)
280 		unblock_signal(td->sig_trig);
281 	if (td->sig_ok)
282 		unblock_signal(td->sig_ok);
283 	if (td->sig_unsupp)
284 		unblock_signal(td->sig_unsupp);
285 
286 	if (td->timeout) {
287 		unblock_signal(SIGALRM);
288 		alarm(td->timeout);
289 	}
290 	fprintf(stderr, "Registered handlers for all signals.\n");
291 
292 	return 1;
293 }
294 
295 static inline int default_trigger(struct tdescr *td)
296 {
297 	return !raise(td->sig_trig);
298 }
299 
300 int test_init(struct tdescr *td)
301 {
302 	if (td->sig_trig == sig_copyctx) {
303 		fprintf(stdout,
304 			"Signal %d is RESERVED, cannot be used as a trigger. Aborting\n",
305 			sig_copyctx);
306 		return 0;
307 	}
308 	/* just in case */
309 	unblock_signal(sig_copyctx);
310 
311 	td->minsigstksz = getauxval(AT_MINSIGSTKSZ);
312 	if (!td->minsigstksz)
313 		td->minsigstksz = MINSIGSTKSZ;
314 	fprintf(stderr, "Detected MINSTKSIGSZ:%d\n", td->minsigstksz);
315 
316 	if (td->feats_required || td->feats_incompatible) {
317 		td->feats_supported = 0;
318 		/*
319 		 * Checking for CPU required features using both the
320 		 * auxval and the arm64 MRS Emulation to read sysregs.
321 		 */
322 		if (getauxval(AT_HWCAP) & HWCAP_SSBS)
323 			td->feats_supported |= FEAT_SSBS;
324 		if (getauxval(AT_HWCAP) & HWCAP_SVE)
325 			td->feats_supported |= FEAT_SVE;
326 		if (getauxval(AT_HWCAP2) & HWCAP2_SME)
327 			td->feats_supported |= FEAT_SME;
328 		if (getauxval(AT_HWCAP2) & HWCAP2_SME_FA64)
329 			td->feats_supported |= FEAT_SME_FA64;
330 		if (getauxval(AT_HWCAP2) & HWCAP2_SME2)
331 			td->feats_supported |= FEAT_SME2;
332 		if (feats_ok(td)) {
333 			if (td->feats_required & td->feats_supported)
334 				fprintf(stderr,
335 					"Required Features: [%s] supported\n",
336 					feats_to_string(td->feats_required &
337 							td->feats_supported));
338 			if (!(td->feats_incompatible & td->feats_supported))
339 				fprintf(stderr,
340 					"Incompatible Features: [%s] absent\n",
341 					feats_to_string(td->feats_incompatible));
342 		} else {
343 			if ((td->feats_required & td->feats_supported) !=
344 			    td->feats_supported)
345 				fprintf(stderr,
346 					"Required Features: [%s] NOT supported\n",
347 					feats_to_string(td->feats_required &
348 							~td->feats_supported));
349 			if (td->feats_incompatible & td->feats_supported)
350 				fprintf(stderr,
351 					"Incompatible Features: [%s] supported\n",
352 					feats_to_string(td->feats_incompatible &
353 							~td->feats_supported));
354 
355 
356 			td->result = KSFT_SKIP;
357 			return 0;
358 		}
359 	}
360 
361 	/* Perform test specific additional initialization */
362 	if (td->init && !td->init(td)) {
363 		fprintf(stderr, "FAILED Testcase initialization.\n");
364 		return 0;
365 	}
366 	td->initialized = 1;
367 	fprintf(stderr, "Testcase initialized.\n");
368 
369 	return 1;
370 }
371 
372 int test_setup(struct tdescr *td)
373 {
374 	/* assert core invariants symptom of a rotten testcase */
375 	assert(current);
376 	assert(td);
377 	assert(td->name);
378 	assert(td->run);
379 
380 	/* Default result is FAIL if test setup fails */
381 	td->result = KSFT_FAIL;
382 	if (td->setup)
383 		return td->setup(td);
384 	else
385 		return default_setup(td);
386 }
387 
388 int test_run(struct tdescr *td)
389 {
390 	if (td->trigger)
391 		return td->trigger(td);
392 	else if (td->sig_trig)
393 		return default_trigger(td);
394 	else
395 		return td->run(td, NULL, NULL);
396 }
397 
398 void test_result(struct tdescr *td)
399 {
400 	if (td->initialized && td->result != KSFT_SKIP && td->check_result)
401 		td->check_result(td);
402 	default_result(td, 0);
403 }
404 
405 void test_cleanup(struct tdescr *td)
406 {
407 	if (td->cleanup)
408 		td->cleanup(td);
409 }
410