1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright 2018, Breno Leitao, Gustavo Romero, IBM Corp.
4  *
5  * This test raises a SIGUSR1 signal, and toggle the MSR[TS]
6  * fields at the signal handler. With MSR[TS] being set, the kernel will
7  * force a recheckpoint, which may cause a segfault when returning to
8  * user space. Since the test needs to re-run, the segfault needs to be
9  * caught and handled.
10  *
11  * In order to continue the test even after a segfault, the context is
12  * saved prior to the signal being raised, and it is restored when there is
13  * a segmentation fault. This happens for COUNT_MAX times.
14  *
15  * This test never fails (as returning EXIT_FAILURE). It either succeeds,
16  * or crash the kernel (on a buggy kernel).
17  */
18 
19 #define _GNU_SOURCE
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <signal.h>
23 #include <string.h>
24 #include <ucontext.h>
25 #include <unistd.h>
26 #include <sys/mman.h>
27 
28 #include "tm.h"
29 #include "utils.h"
30 #include "reg.h"
31 
32 #define COUNT_MAX       5000		/* Number of interactions */
33 
34 /*
35  * This test only runs on 64 bits system. Unsetting MSR_TS_S to avoid
36  * compilation issue on 32 bits system. There is no side effect, since the
37  * whole test will be skipped if it is not running on 64 bits system.
38  */
39 #ifndef __powerpc64__
40 #undef  MSR_TS_S
41 #define MSR_TS_S	0
42 #endif
43 
44 /* Setting contexts because the test will crash and we want to recover */
45 ucontext_t init_context;
46 
47 /* count is changed in the signal handler, so it must be volatile */
48 static volatile int count;
49 
usr_signal_handler(int signo,siginfo_t * si,void * uc)50 void usr_signal_handler(int signo, siginfo_t *si, void *uc)
51 {
52 	ucontext_t *ucp = uc;
53 	int ret;
54 
55 	/*
56 	 * Allocating memory in a signal handler, and never freeing it on
57 	 * purpose, forcing the heap increase, so, the memory leak is what
58 	 * we want here.
59 	 */
60 	ucp->uc_link = mmap(NULL, sizeof(ucontext_t),
61 			    PROT_READ | PROT_WRITE,
62 			    MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
63 	if (ucp->uc_link == (void *)-1) {
64 		perror("Mmap failed");
65 		exit(-1);
66 	}
67 
68 	/* Forcing the page to be allocated in a page fault */
69 	ret = madvise(ucp->uc_link, sizeof(ucontext_t), MADV_DONTNEED);
70 	if (ret) {
71 		perror("madvise failed");
72 		exit(-1);
73 	}
74 
75 	memcpy(&ucp->uc_link->uc_mcontext, &ucp->uc_mcontext,
76 		sizeof(ucp->uc_mcontext));
77 
78 	/* Forcing to enable MSR[TM] */
79 	UCONTEXT_MSR(ucp) |= MSR_TS_S;
80 
81 	/*
82 	 * A fork inside a signal handler seems to be more efficient than a
83 	 * fork() prior to the signal being raised.
84 	 */
85 	if (fork() == 0) {
86 		/*
87 		 * Both child and parent will return, but, child returns
88 		 * with count set so it will exit in the next segfault.
89 		 * Parent will continue to loop.
90 		 */
91 		count = COUNT_MAX;
92 	}
93 
94 	/*
95 	 * If the change above does not hit the bug, it will cause a
96 	 * segmentation fault, since the ck structures are NULL.
97 	 */
98 }
99 
seg_signal_handler(int signo,siginfo_t * si,void * uc)100 void seg_signal_handler(int signo, siginfo_t *si, void *uc)
101 {
102 	count++;
103 
104 	/* Reexecute the test */
105 	setcontext(&init_context);
106 }
107 
tm_trap_test(void)108 void tm_trap_test(void)
109 {
110 	struct sigaction usr_sa, seg_sa;
111 	stack_t ss;
112 
113 	usr_sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
114 	usr_sa.sa_sigaction = usr_signal_handler;
115 
116 	seg_sa.sa_flags = SA_SIGINFO;
117 	seg_sa.sa_sigaction = seg_signal_handler;
118 
119 	/*
120 	 * Set initial context. Will get back here from
121 	 * seg_signal_handler()
122 	 */
123 	getcontext(&init_context);
124 
125 	while (count < COUNT_MAX) {
126 		/* Allocated an alternative signal stack area */
127 		ss.ss_sp = mmap(NULL, SIGSTKSZ, PROT_READ | PROT_WRITE,
128 				MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
129 		ss.ss_size = SIGSTKSZ;
130 		ss.ss_flags = 0;
131 
132 		if (ss.ss_sp == (void *)-1) {
133 			perror("mmap error\n");
134 			exit(-1);
135 		}
136 
137 		/* Force the allocation through a page fault */
138 		if (madvise(ss.ss_sp, SIGSTKSZ, MADV_DONTNEED)) {
139 			perror("madvise\n");
140 			exit(-1);
141 		}
142 
143 		/*
144 		 * Setting an alternative stack to generate a page fault when
145 		 * the signal is raised.
146 		 */
147 		if (sigaltstack(&ss, NULL)) {
148 			perror("sigaltstack\n");
149 			exit(-1);
150 		}
151 
152 		/* The signal handler will enable MSR_TS */
153 		sigaction(SIGUSR1, &usr_sa, NULL);
154 		/* If it does not crash, it might segfault, avoid it to retest */
155 		sigaction(SIGSEGV, &seg_sa, NULL);
156 
157 		raise(SIGUSR1);
158 		count++;
159 	}
160 }
161 
tm_signal_context_force_tm(void)162 int tm_signal_context_force_tm(void)
163 {
164 	SKIP_IF(!have_htm());
165 	/*
166 	 * Skipping if not running on 64 bits system, since I think it is
167 	 * not possible to set mcontext's [MSR] with TS, due to it being 32
168 	 * bits.
169 	 */
170 	SKIP_IF(!is_ppc64le());
171 
172 	tm_trap_test();
173 
174 	return EXIT_SUCCESS;
175 }
176 
main(int argc,char ** argv)177 int main(int argc, char **argv)
178 {
179 	test_harness(tm_signal_context_force_tm, "tm_signal_context_force_tm");
180 }
181