]>
Commit | Line | Data |
---|---|---|
84778508 BS |
1 | /* |
2 | * Emulation of BSD signals | |
3 | * | |
4 | * Copyright (c) 2003 - 2008 Fabrice Bellard | |
1366ef81 | 5 | * Copyright (c) 2013 Stacey Son |
84778508 BS |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
8167ee88 | 18 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
84778508 | 19 | */ |
84778508 | 20 | |
5abfac27 | 21 | #include "qemu/osdep.h" |
cd617484 | 22 | #include "qemu/log.h" |
84778508 | 23 | #include "qemu.h" |
d96bf49b | 24 | #include "gdbstub/user.h" |
0ef59989 | 25 | #include "signal-common.h" |
6ddc1abe | 26 | #include "trace.h" |
fc9f9bdd | 27 | #include "hw/core/tcg-cpu-ops.h" |
85fc1b5d | 28 | #include "host-signal.h" |
84778508 | 29 | |
149076ad WL |
30 | static struct target_sigaction sigact_table[TARGET_NSIG]; |
31 | static void host_signal_handler(int host_sig, siginfo_t *info, void *puc); | |
c93cbac1 WL |
32 | static void target_to_host_sigset_internal(sigset_t *d, |
33 | const target_sigset_t *s); | |
34 | ||
46f4f76d WL |
35 | static inline int on_sig_stack(TaskState *ts, unsigned long sp) |
36 | { | |
37 | return sp - ts->sigaltstack_used.ss_sp < ts->sigaltstack_used.ss_size; | |
38 | } | |
39 | ||
40 | static inline int sas_ss_flags(TaskState *ts, unsigned long sp) | |
41 | { | |
42 | return ts->sigaltstack_used.ss_size == 0 ? SS_DISABLE : | |
43 | on_sig_stack(ts, sp) ? SS_ONSTACK : 0; | |
44 | } | |
149076ad | 45 | |
1366ef81 WL |
46 | /* |
47 | * The BSD ABIs use the same singal numbers across all the CPU architectures, so | |
48 | * (unlike Linux) these functions are just the identity mapping. This might not | |
49 | * be true for XyzBSD running on AbcBSD, which doesn't currently work. | |
50 | */ | |
51 | int host_to_target_signal(int sig) | |
52 | { | |
53 | return sig; | |
54 | } | |
55 | ||
56 | int target_to_host_signal(int sig) | |
57 | { | |
58 | return sig; | |
59 | } | |
60 | ||
c93cbac1 WL |
61 | static inline void target_sigemptyset(target_sigset_t *set) |
62 | { | |
63 | memset(set, 0, sizeof(*set)); | |
64 | } | |
65 | ||
66 | static inline void target_sigaddset(target_sigset_t *set, int signum) | |
67 | { | |
68 | signum--; | |
69 | uint32_t mask = (uint32_t)1 << (signum % TARGET_NSIG_BPW); | |
70 | set->__bits[signum / TARGET_NSIG_BPW] |= mask; | |
71 | } | |
72 | ||
73 | static inline int target_sigismember(const target_sigset_t *set, int signum) | |
74 | { | |
75 | signum--; | |
76 | abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW); | |
77 | return (set->__bits[signum / TARGET_NSIG_BPW] & mask) != 0; | |
78 | } | |
79 | ||
aae57ac3 WL |
80 | /* Adjust the signal context to rewind out of safe-syscall if we're in it */ |
81 | static inline void rewind_if_in_safe_syscall(void *puc) | |
82 | { | |
83 | ucontext_t *uc = (ucontext_t *)puc; | |
84 | uintptr_t pcreg = host_signal_pc(uc); | |
85 | ||
86 | if (pcreg > (uintptr_t)safe_syscall_start | |
87 | && pcreg < (uintptr_t)safe_syscall_end) { | |
88 | host_signal_set_pc(uc, (uintptr_t)safe_syscall_start); | |
89 | } | |
90 | } | |
91 | ||
c93cbac1 WL |
92 | /* |
93 | * Note: The following take advantage of the BSD signal property that all | |
94 | * signals are available on all architectures. | |
95 | */ | |
96 | static void host_to_target_sigset_internal(target_sigset_t *d, | |
97 | const sigset_t *s) | |
98 | { | |
99 | int i; | |
100 | ||
101 | target_sigemptyset(d); | |
102 | for (i = 1; i <= NSIG; i++) { | |
103 | if (sigismember(s, i)) { | |
104 | target_sigaddset(d, host_to_target_signal(i)); | |
105 | } | |
106 | } | |
107 | } | |
108 | ||
109 | void host_to_target_sigset(target_sigset_t *d, const sigset_t *s) | |
110 | { | |
111 | target_sigset_t d1; | |
112 | int i; | |
113 | ||
114 | host_to_target_sigset_internal(&d1, s); | |
115 | for (i = 0; i < _SIG_WORDS; i++) { | |
116 | d->__bits[i] = tswap32(d1.__bits[i]); | |
117 | } | |
118 | } | |
119 | ||
120 | static void target_to_host_sigset_internal(sigset_t *d, | |
121 | const target_sigset_t *s) | |
122 | { | |
123 | int i; | |
124 | ||
125 | sigemptyset(d); | |
126 | for (i = 1; i <= TARGET_NSIG; i++) { | |
127 | if (target_sigismember(s, i)) { | |
128 | sigaddset(d, target_to_host_signal(i)); | |
129 | } | |
130 | } | |
131 | } | |
132 | ||
133 | void target_to_host_sigset(sigset_t *d, const target_sigset_t *s) | |
134 | { | |
135 | target_sigset_t s1; | |
136 | int i; | |
137 | ||
138 | for (i = 0; i < TARGET_NSIG_WORDS; i++) { | |
139 | s1.__bits[i] = tswap32(s->__bits[i]); | |
140 | } | |
141 | target_to_host_sigset_internal(d, &s1); | |
142 | } | |
143 | ||
c34f2aaf WL |
144 | static bool has_trapno(int tsig) |
145 | { | |
146 | return tsig == TARGET_SIGILL || | |
147 | tsig == TARGET_SIGFPE || | |
148 | tsig == TARGET_SIGSEGV || | |
149 | tsig == TARGET_SIGBUS || | |
150 | tsig == TARGET_SIGTRAP; | |
151 | } | |
152 | ||
c34f2aaf WL |
153 | /* Siginfo conversion. */ |
154 | ||
155 | /* | |
156 | * Populate tinfo w/o swapping based on guessing which fields are valid. | |
157 | */ | |
158 | static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo, | |
159 | const siginfo_t *info) | |
160 | { | |
161 | int sig = host_to_target_signal(info->si_signo); | |
162 | int si_code = info->si_code; | |
163 | int si_type; | |
164 | ||
165 | /* | |
166 | * Make sure we that the variable portion of the target siginfo is zeroed | |
167 | * out so we don't leak anything into that. | |
168 | */ | |
169 | memset(&tinfo->_reason, 0, sizeof(tinfo->_reason)); | |
170 | ||
171 | /* | |
172 | * This is awkward, because we have to use a combination of the si_code and | |
173 | * si_signo to figure out which of the union's members are valid.o We | |
174 | * therefore make our best guess. | |
175 | * | |
176 | * Once we have made our guess, we record it in the top 16 bits of | |
177 | * the si_code, so that tswap_siginfo() later can use it. | |
178 | * tswap_siginfo() will strip these top bits out before writing | |
179 | * si_code to the guest (sign-extending the lower bits). | |
180 | */ | |
181 | tinfo->si_signo = sig; | |
182 | tinfo->si_errno = info->si_errno; | |
183 | tinfo->si_code = info->si_code; | |
184 | tinfo->si_pid = info->si_pid; | |
185 | tinfo->si_uid = info->si_uid; | |
186 | tinfo->si_status = info->si_status; | |
187 | tinfo->si_addr = (abi_ulong)(unsigned long)info->si_addr; | |
188 | /* | |
189 | * si_value is opaque to kernel. On all FreeBSD platforms, | |
190 | * sizeof(sival_ptr) >= sizeof(sival_int) so the following | |
191 | * always will copy the larger element. | |
192 | */ | |
193 | tinfo->si_value.sival_ptr = | |
194 | (abi_ulong)(unsigned long)info->si_value.sival_ptr; | |
195 | ||
196 | switch (si_code) { | |
197 | /* | |
198 | * All the SI_xxx codes that are defined here are global to | |
199 | * all the signals (they have values that none of the other, | |
200 | * more specific signal info will set). | |
201 | */ | |
202 | case SI_USER: | |
203 | case SI_LWP: | |
204 | case SI_KERNEL: | |
205 | case SI_QUEUE: | |
206 | case SI_ASYNCIO: | |
207 | /* | |
208 | * Only the fixed parts are valid (though FreeBSD doesn't always | |
209 | * set all the fields to non-zero values. | |
210 | */ | |
211 | si_type = QEMU_SI_NOINFO; | |
212 | break; | |
213 | case SI_TIMER: | |
214 | tinfo->_reason._timer._timerid = info->_reason._timer._timerid; | |
215 | tinfo->_reason._timer._overrun = info->_reason._timer._overrun; | |
216 | si_type = QEMU_SI_TIMER; | |
217 | break; | |
218 | case SI_MESGQ: | |
219 | tinfo->_reason._mesgq._mqd = info->_reason._mesgq._mqd; | |
220 | si_type = QEMU_SI_MESGQ; | |
221 | break; | |
222 | default: | |
223 | /* | |
224 | * We have to go based on the signal number now to figure out | |
225 | * what's valid. | |
226 | */ | |
eb9d35f6 | 227 | si_type = QEMU_SI_NOINFO; |
c34f2aaf WL |
228 | if (has_trapno(sig)) { |
229 | tinfo->_reason._fault._trapno = info->_reason._fault._trapno; | |
230 | si_type = QEMU_SI_FAULT; | |
231 | } | |
232 | #ifdef TARGET_SIGPOLL | |
233 | /* | |
234 | * FreeBSD never had SIGPOLL, but emulates it for Linux so there's | |
235 | * a chance it may popup in the future. | |
236 | */ | |
237 | if (sig == TARGET_SIGPOLL) { | |
238 | tinfo->_reason._poll._band = info->_reason._poll._band; | |
239 | si_type = QEMU_SI_POLL; | |
240 | } | |
241 | #endif | |
242 | /* | |
243 | * Unsure that this can actually be generated, and our support for | |
244 | * capsicum is somewhere between weak and non-existant, but if we get | |
245 | * one, then we know what to save. | |
246 | */ | |
eb9d35f6 | 247 | #ifdef QEMU_SI_CAPSICUM |
c34f2aaf WL |
248 | if (sig == TARGET_SIGTRAP) { |
249 | tinfo->_reason._capsicum._syscall = | |
250 | info->_reason._capsicum._syscall; | |
251 | si_type = QEMU_SI_CAPSICUM; | |
252 | } | |
eb9d35f6 | 253 | #endif |
c34f2aaf WL |
254 | break; |
255 | } | |
256 | tinfo->si_code = deposit32(si_code, 24, 8, si_type); | |
257 | } | |
258 | ||
08eb66d5 WL |
259 | static void tswap_siginfo(target_siginfo_t *tinfo, const target_siginfo_t *info) |
260 | { | |
261 | int si_type = extract32(info->si_code, 24, 8); | |
262 | int si_code = sextract32(info->si_code, 0, 24); | |
263 | ||
264 | __put_user(info->si_signo, &tinfo->si_signo); | |
265 | __put_user(info->si_errno, &tinfo->si_errno); | |
266 | __put_user(si_code, &tinfo->si_code); /* Zero out si_type, it's internal */ | |
267 | __put_user(info->si_pid, &tinfo->si_pid); | |
268 | __put_user(info->si_uid, &tinfo->si_uid); | |
269 | __put_user(info->si_status, &tinfo->si_status); | |
270 | __put_user(info->si_addr, &tinfo->si_addr); | |
271 | /* | |
272 | * Unswapped, because we passed it through mostly untouched. si_value is | |
273 | * opaque to the kernel, so we didn't bother with potentially wasting cycles | |
274 | * to swap it into host byte order. | |
275 | */ | |
276 | tinfo->si_value.sival_ptr = info->si_value.sival_ptr; | |
277 | ||
278 | /* | |
279 | * We can use our internal marker of which fields in the structure | |
280 | * are valid, rather than duplicating the guesswork of | |
281 | * host_to_target_siginfo_noswap() here. | |
282 | */ | |
283 | switch (si_type) { | |
284 | case QEMU_SI_NOINFO: /* No additional info */ | |
285 | break; | |
286 | case QEMU_SI_FAULT: | |
287 | __put_user(info->_reason._fault._trapno, | |
288 | &tinfo->_reason._fault._trapno); | |
289 | break; | |
290 | case QEMU_SI_TIMER: | |
291 | __put_user(info->_reason._timer._timerid, | |
292 | &tinfo->_reason._timer._timerid); | |
293 | __put_user(info->_reason._timer._overrun, | |
294 | &tinfo->_reason._timer._overrun); | |
295 | break; | |
296 | case QEMU_SI_MESGQ: | |
297 | __put_user(info->_reason._mesgq._mqd, &tinfo->_reason._mesgq._mqd); | |
298 | break; | |
299 | case QEMU_SI_POLL: | |
300 | /* Note: Not generated on FreeBSD */ | |
301 | __put_user(info->_reason._poll._band, &tinfo->_reason._poll._band); | |
302 | break; | |
eb9d35f6 | 303 | #ifdef QEMU_SI_CAPSICUM |
08eb66d5 WL |
304 | case QEMU_SI_CAPSICUM: |
305 | __put_user(info->_reason._capsicum._syscall, | |
306 | &tinfo->_reason._capsicum._syscall); | |
307 | break; | |
eb9d35f6 | 308 | #endif |
08eb66d5 WL |
309 | default: |
310 | g_assert_not_reached(); | |
311 | } | |
312 | } | |
313 | ||
394cf694 WL |
314 | int block_signals(void) |
315 | { | |
316 | TaskState *ts = (TaskState *)thread_cpu->opaque; | |
317 | sigset_t set; | |
318 | ||
319 | /* | |
320 | * It's OK to block everything including SIGSEGV, because we won't run any | |
321 | * further guest code before unblocking signals in | |
322 | * process_pending_signals(). We depend on the FreeBSD behaivor here where | |
323 | * this will only affect this thread's signal mask. We don't use | |
324 | * pthread_sigmask which might seem more correct because that routine also | |
325 | * does odd things with SIGCANCEL to implement pthread_cancel(). | |
326 | */ | |
327 | sigfillset(&set); | |
328 | sigprocmask(SIG_SETMASK, &set, 0); | |
329 | ||
330 | return qatomic_xchg(&ts->signal_pending, 1); | |
331 | } | |
332 | ||
37714547 WL |
333 | /* Returns 1 if given signal should dump core if not handled. */ |
334 | static int core_dump_signal(int sig) | |
335 | { | |
336 | switch (sig) { | |
337 | case TARGET_SIGABRT: | |
338 | case TARGET_SIGFPE: | |
339 | case TARGET_SIGILL: | |
340 | case TARGET_SIGQUIT: | |
341 | case TARGET_SIGSEGV: | |
342 | case TARGET_SIGTRAP: | |
343 | case TARGET_SIGBUS: | |
344 | return 1; | |
345 | default: | |
346 | return 0; | |
347 | } | |
348 | } | |
349 | ||
350 | /* Abort execution with signal. */ | |
8905770b MAL |
351 | static G_NORETURN |
352 | void dump_core_and_abort(int target_sig) | |
37714547 WL |
353 | { |
354 | CPUArchState *env = thread_cpu->env_ptr; | |
355 | CPUState *cpu = env_cpu(env); | |
356 | TaskState *ts = cpu->opaque; | |
357 | int core_dumped = 0; | |
358 | int host_sig; | |
359 | struct sigaction act; | |
360 | ||
361 | host_sig = target_to_host_signal(target_sig); | |
362 | gdb_signalled(env, target_sig); | |
363 | ||
364 | /* Dump core if supported by target binary format */ | |
365 | if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) { | |
366 | stop_all_tasks(); | |
367 | core_dumped = | |
368 | ((*ts->bprm->core_dump)(target_sig, env) == 0); | |
369 | } | |
370 | if (core_dumped) { | |
371 | struct rlimit nodump; | |
372 | ||
373 | /* | |
374 | * We already dumped the core of target process, we don't want | |
375 | * a coredump of qemu itself. | |
376 | */ | |
377 | getrlimit(RLIMIT_CORE, &nodump); | |
378 | nodump.rlim_cur = 0; | |
379 | setrlimit(RLIMIT_CORE, &nodump); | |
380 | (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) " | |
381 | "- %s\n", target_sig, strsignal(host_sig), "core dumped"); | |
382 | } | |
383 | ||
384 | /* | |
385 | * The proper exit code for dying from an uncaught signal is | |
386 | * -<signal>. The kernel doesn't allow exit() or _exit() to pass | |
387 | * a negative value. To get the proper exit code we need to | |
388 | * actually die from an uncaught signal. Here the default signal | |
389 | * handler is installed, we send ourself a signal and we wait for | |
390 | * it to arrive. | |
391 | */ | |
392 | memset(&act, 0, sizeof(act)); | |
393 | sigfillset(&act.sa_mask); | |
394 | act.sa_handler = SIG_DFL; | |
395 | sigaction(host_sig, &act, NULL); | |
396 | ||
397 | kill(getpid(), host_sig); | |
398 | ||
399 | /* | |
400 | * Make sure the signal isn't masked (just reuse the mask inside | |
401 | * of act). | |
402 | */ | |
403 | sigdelset(&act.sa_mask, host_sig); | |
404 | sigsuspend(&act.sa_mask); | |
405 | ||
406 | /* unreachable */ | |
407 | abort(); | |
408 | } | |
409 | ||
5abfac27 WL |
410 | /* |
411 | * Queue a signal so that it will be send to the virtual CPU as soon as | |
412 | * possible. | |
413 | */ | |
e32a6301 WL |
414 | void queue_signal(CPUArchState *env, int sig, int si_type, |
415 | target_siginfo_t *info) | |
5abfac27 | 416 | { |
38be620c WL |
417 | CPUState *cpu = env_cpu(env); |
418 | TaskState *ts = cpu->opaque; | |
419 | ||
420 | trace_user_queue_signal(env, sig); | |
421 | ||
422 | info->si_code = deposit32(info->si_code, 24, 8, si_type); | |
423 | ||
424 | ts->sync_signal.info = *info; | |
425 | ts->sync_signal.pending = sig; | |
426 | /* Signal that a new signal is pending. */ | |
427 | qatomic_set(&ts->signal_pending, 1); | |
428 | return; | |
5abfac27 WL |
429 | } |
430 | ||
149076ad WL |
431 | static int fatal_signal(int sig) |
432 | { | |
433 | ||
434 | switch (sig) { | |
435 | case TARGET_SIGCHLD: | |
436 | case TARGET_SIGURG: | |
437 | case TARGET_SIGWINCH: | |
438 | case TARGET_SIGINFO: | |
439 | /* Ignored by default. */ | |
440 | return 0; | |
441 | case TARGET_SIGCONT: | |
442 | case TARGET_SIGSTOP: | |
443 | case TARGET_SIGTSTP: | |
444 | case TARGET_SIGTTIN: | |
445 | case TARGET_SIGTTOU: | |
446 | /* Job control signals. */ | |
447 | return 0; | |
448 | default: | |
449 | return 1; | |
450 | } | |
451 | } | |
452 | ||
0ef59989 WL |
453 | /* |
454 | * Force a synchronously taken QEMU_SI_FAULT signal. For QEMU the | |
455 | * 'force' part is handled in process_pending_signals(). | |
456 | */ | |
457 | void force_sig_fault(int sig, int code, abi_ulong addr) | |
458 | { | |
459 | CPUState *cpu = thread_cpu; | |
460 | CPUArchState *env = cpu->env_ptr; | |
461 | target_siginfo_t info = {}; | |
462 | ||
463 | info.si_signo = sig; | |
464 | info.si_errno = 0; | |
465 | info.si_code = code; | |
466 | info.si_addr = addr; | |
e32a6301 | 467 | queue_signal(env, sig, QEMU_SI_FAULT, &info); |
0ef59989 WL |
468 | } |
469 | ||
149076ad WL |
470 | static void host_signal_handler(int host_sig, siginfo_t *info, void *puc) |
471 | { | |
e625c7ef WL |
472 | CPUArchState *env = thread_cpu->env_ptr; |
473 | CPUState *cpu = env_cpu(env); | |
474 | TaskState *ts = cpu->opaque; | |
475 | target_siginfo_t tinfo; | |
476 | ucontext_t *uc = puc; | |
477 | struct emulated_sigtable *k; | |
478 | int guest_sig; | |
479 | uintptr_t pc = 0; | |
480 | bool sync_sig = false; | |
481 | ||
482 | /* | |
483 | * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special | |
484 | * handling wrt signal blocking and unwinding. | |
485 | */ | |
486 | if ((host_sig == SIGSEGV || host_sig == SIGBUS) && info->si_code > 0) { | |
487 | MMUAccessType access_type; | |
488 | uintptr_t host_addr; | |
489 | abi_ptr guest_addr; | |
490 | bool is_write; | |
491 | ||
492 | host_addr = (uintptr_t)info->si_addr; | |
493 | ||
494 | /* | |
495 | * Convert forcefully to guest address space: addresses outside | |
496 | * reserved_va are still valid to report via SEGV_MAPERR. | |
497 | */ | |
498 | guest_addr = h2g_nocheck(host_addr); | |
499 | ||
500 | pc = host_signal_pc(uc); | |
501 | is_write = host_signal_write(info, uc); | |
502 | access_type = adjust_signal_pc(&pc, is_write); | |
503 | ||
504 | if (host_sig == SIGSEGV) { | |
505 | bool maperr = true; | |
506 | ||
507 | if (info->si_code == SEGV_ACCERR && h2g_valid(host_addr)) { | |
508 | /* If this was a write to a TB protected page, restart. */ | |
509 | if (is_write && | |
510 | handle_sigsegv_accerr_write(cpu, &uc->uc_sigmask, | |
511 | pc, guest_addr)) { | |
512 | return; | |
513 | } | |
514 | ||
515 | /* | |
516 | * With reserved_va, the whole address space is PROT_NONE, | |
517 | * which means that we may get ACCERR when we want MAPERR. | |
518 | */ | |
519 | if (page_get_flags(guest_addr) & PAGE_VALID) { | |
520 | maperr = false; | |
521 | } else { | |
522 | info->si_code = SEGV_MAPERR; | |
523 | } | |
524 | } | |
525 | ||
526 | sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL); | |
527 | cpu_loop_exit_sigsegv(cpu, guest_addr, access_type, maperr, pc); | |
528 | } else { | |
529 | sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL); | |
530 | if (info->si_code == BUS_ADRALN) { | |
531 | cpu_loop_exit_sigbus(cpu, guest_addr, access_type, pc); | |
532 | } | |
533 | } | |
534 | ||
535 | sync_sig = true; | |
536 | } | |
537 | ||
538 | /* Get the target signal number. */ | |
539 | guest_sig = host_to_target_signal(host_sig); | |
540 | if (guest_sig < 1 || guest_sig > TARGET_NSIG) { | |
541 | return; | |
542 | } | |
543 | trace_user_host_signal(cpu, host_sig, guest_sig); | |
544 | ||
545 | host_to_target_siginfo_noswap(&tinfo, info); | |
546 | ||
547 | k = &ts->sigtab[guest_sig - 1]; | |
548 | k->info = tinfo; | |
549 | k->pending = guest_sig; | |
550 | ts->signal_pending = 1; | |
551 | ||
552 | /* | |
553 | * For synchronous signals, unwind the cpu state to the faulting | |
554 | * insn and then exit back to the main loop so that the signal | |
555 | * is delivered immediately. | |
556 | */ | |
557 | if (sync_sig) { | |
558 | cpu->exception_index = EXCP_INTERRUPT; | |
559 | cpu_loop_exit_restore(cpu, pc); | |
560 | } | |
561 | ||
562 | rewind_if_in_safe_syscall(puc); | |
563 | ||
564 | /* | |
565 | * Block host signals until target signal handler entered. We | |
566 | * can't block SIGSEGV or SIGBUS while we're executing guest | |
567 | * code in case the guest code provokes one in the window between | |
568 | * now and it getting out to the main loop. Signals will be | |
569 | * unblocked again in process_pending_signals(). | |
570 | */ | |
571 | sigfillset(&uc->uc_sigmask); | |
572 | sigdelset(&uc->uc_sigmask, SIGSEGV); | |
573 | sigdelset(&uc->uc_sigmask, SIGBUS); | |
574 | ||
575 | /* Interrupt the virtual CPU as soon as possible. */ | |
576 | cpu_exit(thread_cpu); | |
149076ad WL |
577 | } |
578 | ||
43ed4267 WL |
579 | /* do_sigaltstack() returns target values and errnos. */ |
580 | /* compare to kern/kern_sig.c sys_sigaltstack() and kern_sigaltstack() */ | |
581 | abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp) | |
582 | { | |
583 | TaskState *ts = (TaskState *)thread_cpu->opaque; | |
584 | int ret; | |
585 | target_stack_t oss; | |
586 | ||
587 | if (uoss_addr) { | |
588 | /* Save current signal stack params */ | |
589 | oss.ss_sp = tswapl(ts->sigaltstack_used.ss_sp); | |
590 | oss.ss_size = tswapl(ts->sigaltstack_used.ss_size); | |
591 | oss.ss_flags = tswapl(sas_ss_flags(ts, sp)); | |
592 | } | |
593 | ||
594 | if (uss_addr) { | |
595 | target_stack_t *uss; | |
596 | target_stack_t ss; | |
597 | size_t minstacksize = TARGET_MINSIGSTKSZ; | |
598 | ||
599 | ret = -TARGET_EFAULT; | |
600 | if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) { | |
601 | goto out; | |
602 | } | |
603 | __get_user(ss.ss_sp, &uss->ss_sp); | |
604 | __get_user(ss.ss_size, &uss->ss_size); | |
605 | __get_user(ss.ss_flags, &uss->ss_flags); | |
606 | unlock_user_struct(uss, uss_addr, 0); | |
607 | ||
608 | ret = -TARGET_EPERM; | |
609 | if (on_sig_stack(ts, sp)) { | |
610 | goto out; | |
611 | } | |
612 | ||
613 | ret = -TARGET_EINVAL; | |
614 | if (ss.ss_flags != TARGET_SS_DISABLE | |
615 | && ss.ss_flags != TARGET_SS_ONSTACK | |
616 | && ss.ss_flags != 0) { | |
617 | goto out; | |
618 | } | |
619 | ||
620 | if (ss.ss_flags == TARGET_SS_DISABLE) { | |
621 | ss.ss_size = 0; | |
622 | ss.ss_sp = 0; | |
623 | } else { | |
624 | ret = -TARGET_ENOMEM; | |
625 | if (ss.ss_size < minstacksize) { | |
626 | goto out; | |
627 | } | |
628 | } | |
629 | ||
630 | ts->sigaltstack_used.ss_sp = ss.ss_sp; | |
631 | ts->sigaltstack_used.ss_size = ss.ss_size; | |
632 | } | |
633 | ||
634 | if (uoss_addr) { | |
635 | ret = -TARGET_EFAULT; | |
636 | if (copy_to_user(uoss_addr, &oss, sizeof(oss))) { | |
637 | goto out; | |
638 | } | |
639 | } | |
640 | ||
641 | ret = 0; | |
642 | out: | |
643 | return ret; | |
644 | } | |
645 | ||
394cf694 WL |
646 | /* do_sigaction() return host values and errnos */ |
647 | int do_sigaction(int sig, const struct target_sigaction *act, | |
648 | struct target_sigaction *oact) | |
649 | { | |
650 | struct target_sigaction *k; | |
651 | struct sigaction act1; | |
652 | int host_sig; | |
653 | int ret = 0; | |
654 | ||
655 | if (sig < 1 || sig > TARGET_NSIG) { | |
656 | return -TARGET_EINVAL; | |
657 | } | |
658 | ||
659 | if ((sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) && | |
660 | act != NULL && act->_sa_handler != TARGET_SIG_DFL) { | |
661 | return -TARGET_EINVAL; | |
662 | } | |
663 | ||
664 | if (block_signals()) { | |
665 | return -TARGET_ERESTART; | |
666 | } | |
667 | ||
668 | k = &sigact_table[sig - 1]; | |
669 | if (oact) { | |
670 | oact->_sa_handler = tswapal(k->_sa_handler); | |
671 | oact->sa_flags = tswap32(k->sa_flags); | |
672 | oact->sa_mask = k->sa_mask; | |
673 | } | |
674 | if (act) { | |
675 | k->_sa_handler = tswapal(act->_sa_handler); | |
676 | k->sa_flags = tswap32(act->sa_flags); | |
677 | k->sa_mask = act->sa_mask; | |
678 | ||
679 | /* Update the host signal state. */ | |
680 | host_sig = target_to_host_signal(sig); | |
681 | if (host_sig != SIGSEGV && host_sig != SIGBUS) { | |
682 | memset(&act1, 0, sizeof(struct sigaction)); | |
683 | sigfillset(&act1.sa_mask); | |
684 | act1.sa_flags = SA_SIGINFO; | |
685 | if (k->sa_flags & TARGET_SA_RESTART) { | |
686 | act1.sa_flags |= SA_RESTART; | |
687 | } | |
688 | /* | |
689 | * Note: It is important to update the host kernel signal mask to | |
690 | * avoid getting unexpected interrupted system calls. | |
691 | */ | |
692 | if (k->_sa_handler == TARGET_SIG_IGN) { | |
693 | act1.sa_sigaction = (void *)SIG_IGN; | |
694 | } else if (k->_sa_handler == TARGET_SIG_DFL) { | |
695 | if (fatal_signal(sig)) { | |
696 | act1.sa_sigaction = host_signal_handler; | |
697 | } else { | |
698 | act1.sa_sigaction = (void *)SIG_DFL; | |
699 | } | |
700 | } else { | |
701 | act1.sa_sigaction = host_signal_handler; | |
702 | } | |
703 | ret = sigaction(host_sig, &act1, NULL); | |
704 | } | |
705 | } | |
706 | return ret; | |
707 | } | |
708 | ||
46f4f76d WL |
709 | static inline abi_ulong get_sigframe(struct target_sigaction *ka, |
710 | CPUArchState *env, size_t frame_size) | |
711 | { | |
712 | TaskState *ts = (TaskState *)thread_cpu->opaque; | |
713 | abi_ulong sp; | |
714 | ||
715 | /* Use default user stack */ | |
716 | sp = get_sp_from_cpustate(env); | |
717 | ||
718 | if ((ka->sa_flags & TARGET_SA_ONSTACK) && sas_ss_flags(ts, sp) == 0) { | |
719 | sp = ts->sigaltstack_used.ss_sp + ts->sigaltstack_used.ss_size; | |
720 | } | |
721 | ||
722 | /* TODO: make this a target_arch function / define */ | |
723 | #if defined(TARGET_ARM) | |
724 | return (sp - frame_size) & ~7; | |
725 | #elif defined(TARGET_AARCH64) | |
726 | return (sp - frame_size) & ~15; | |
727 | #else | |
728 | return sp - frame_size; | |
729 | #endif | |
730 | } | |
731 | ||
732 | /* compare to $M/$M/exec_machdep.c sendsig and sys/kern/kern_sig.c sigexit */ | |
733 | ||
734 | static void setup_frame(int sig, int code, struct target_sigaction *ka, | |
735 | target_sigset_t *set, target_siginfo_t *tinfo, CPUArchState *env) | |
736 | { | |
737 | struct target_sigframe *frame; | |
738 | abi_ulong frame_addr; | |
739 | int i; | |
740 | ||
741 | frame_addr = get_sigframe(ka, env, sizeof(*frame)); | |
742 | trace_user_setup_frame(env, frame_addr); | |
743 | if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { | |
744 | unlock_user_struct(frame, frame_addr, 1); | |
745 | dump_core_and_abort(TARGET_SIGILL); | |
746 | return; | |
747 | } | |
748 | ||
749 | memset(frame, 0, sizeof(*frame)); | |
750 | setup_sigframe_arch(env, frame_addr, frame, 0); | |
751 | ||
752 | for (i = 0; i < TARGET_NSIG_WORDS; i++) { | |
753 | __put_user(set->__bits[i], &frame->sf_uc.uc_sigmask.__bits[i]); | |
754 | } | |
755 | ||
756 | if (tinfo) { | |
757 | frame->sf_si.si_signo = tinfo->si_signo; | |
758 | frame->sf_si.si_errno = tinfo->si_errno; | |
759 | frame->sf_si.si_code = tinfo->si_code; | |
760 | frame->sf_si.si_pid = tinfo->si_pid; | |
761 | frame->sf_si.si_uid = tinfo->si_uid; | |
762 | frame->sf_si.si_status = tinfo->si_status; | |
763 | frame->sf_si.si_addr = tinfo->si_addr; | |
764 | /* see host_to_target_siginfo_noswap() for more details */ | |
765 | frame->sf_si.si_value.sival_ptr = tinfo->si_value.sival_ptr; | |
766 | /* | |
767 | * At this point, whatever is in the _reason union is complete | |
768 | * and in target order, so just copy the whole thing over, even | |
769 | * if it's too large for this specific signal. | |
770 | * host_to_target_siginfo_noswap() and tswap_siginfo() have ensured | |
771 | * that's so. | |
772 | */ | |
773 | memcpy(&frame->sf_si._reason, &tinfo->_reason, | |
774 | sizeof(tinfo->_reason)); | |
775 | } | |
776 | ||
777 | set_sigtramp_args(env, sig, frame, frame_addr, ka); | |
778 | ||
779 | unlock_user_struct(frame, frame_addr, 1); | |
780 | } | |
781 | ||
c885ae0e WL |
782 | static int reset_signal_mask(target_ucontext_t *ucontext) |
783 | { | |
784 | int i; | |
785 | sigset_t blocked; | |
786 | target_sigset_t target_set; | |
787 | TaskState *ts = (TaskState *)thread_cpu->opaque; | |
788 | ||
789 | for (i = 0; i < TARGET_NSIG_WORDS; i++) { | |
790 | if (__get_user(target_set.__bits[i], | |
791 | &ucontext->uc_sigmask.__bits[i])) { | |
792 | return -TARGET_EFAULT; | |
793 | } | |
794 | } | |
795 | target_to_host_sigset_internal(&blocked, &target_set); | |
796 | ts->signal_mask = blocked; | |
797 | ||
798 | return 0; | |
799 | } | |
800 | ||
801 | /* See sys/$M/$M/exec_machdep.c sigreturn() */ | |
802 | long do_sigreturn(CPUArchState *env, abi_ulong addr) | |
803 | { | |
804 | long ret; | |
805 | abi_ulong target_ucontext; | |
806 | target_ucontext_t *ucontext = NULL; | |
807 | ||
808 | /* Get the target ucontext address from the stack frame */ | |
809 | ret = get_ucontext_sigreturn(env, addr, &target_ucontext); | |
810 | if (is_error(ret)) { | |
811 | return ret; | |
812 | } | |
813 | trace_user_do_sigreturn(env, addr); | |
814 | if (!lock_user_struct(VERIFY_READ, ucontext, target_ucontext, 0)) { | |
815 | goto badframe; | |
816 | } | |
817 | ||
818 | /* Set the register state back to before the signal. */ | |
819 | if (set_mcontext(env, &ucontext->uc_mcontext, 1)) { | |
820 | goto badframe; | |
821 | } | |
822 | ||
823 | /* And reset the signal mask. */ | |
824 | if (reset_signal_mask(ucontext)) { | |
825 | goto badframe; | |
826 | } | |
827 | ||
828 | unlock_user_struct(ucontext, target_ucontext, 0); | |
829 | return -TARGET_EJUSTRETURN; | |
830 | ||
831 | badframe: | |
832 | if (ucontext != NULL) { | |
833 | unlock_user_struct(ucontext, target_ucontext, 0); | |
834 | } | |
835 | return -TARGET_EFAULT; | |
836 | } | |
837 | ||
84778508 BS |
838 | void signal_init(void) |
839 | { | |
149076ad WL |
840 | TaskState *ts = (TaskState *)thread_cpu->opaque; |
841 | struct sigaction act; | |
842 | struct sigaction oact; | |
843 | int i; | |
844 | int host_sig; | |
845 | ||
846 | /* Set the signal mask from the host mask. */ | |
847 | sigprocmask(0, 0, &ts->signal_mask); | |
848 | ||
849 | sigfillset(&act.sa_mask); | |
850 | act.sa_sigaction = host_signal_handler; | |
851 | act.sa_flags = SA_SIGINFO; | |
852 | ||
853 | for (i = 1; i <= TARGET_NSIG; i++) { | |
854 | #ifdef CONFIG_GPROF | |
855 | if (i == TARGET_SIGPROF) { | |
856 | continue; | |
857 | } | |
858 | #endif | |
859 | host_sig = target_to_host_signal(i); | |
860 | sigaction(host_sig, NULL, &oact); | |
861 | if (oact.sa_sigaction == (void *)SIG_IGN) { | |
862 | sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN; | |
863 | } else if (oact.sa_sigaction == (void *)SIG_DFL) { | |
864 | sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL; | |
865 | } | |
866 | /* | |
867 | * If there's already a handler installed then something has | |
868 | * gone horribly wrong, so don't even try to handle that case. | |
869 | * Install some handlers for our own use. We need at least | |
870 | * SIGSEGV and SIGBUS, to detect exceptions. We can not just | |
871 | * trap all signals because it affects syscall interrupt | |
872 | * behavior. But do trap all default-fatal signals. | |
873 | */ | |
874 | if (fatal_signal(i)) { | |
875 | sigaction(host_sig, &act, NULL); | |
876 | } | |
877 | } | |
84778508 BS |
878 | } |
879 | ||
6c6d4b56 WL |
880 | static void handle_pending_signal(CPUArchState *env, int sig, |
881 | struct emulated_sigtable *k) | |
882 | { | |
883 | CPUState *cpu = env_cpu(env); | |
884 | TaskState *ts = cpu->opaque; | |
885 | struct target_sigaction *sa; | |
886 | int code; | |
887 | sigset_t set; | |
888 | abi_ulong handler; | |
889 | target_siginfo_t tinfo; | |
890 | target_sigset_t target_old_set; | |
891 | ||
892 | trace_user_handle_signal(env, sig); | |
893 | ||
894 | k->pending = 0; | |
895 | ||
896 | sig = gdb_handlesig(cpu, sig); | |
897 | if (!sig) { | |
898 | sa = NULL; | |
899 | handler = TARGET_SIG_IGN; | |
900 | } else { | |
901 | sa = &sigact_table[sig - 1]; | |
902 | handler = sa->_sa_handler; | |
903 | } | |
904 | ||
905 | if (do_strace) { | |
906 | print_taken_signal(sig, &k->info); | |
907 | } | |
908 | ||
909 | if (handler == TARGET_SIG_DFL) { | |
910 | /* | |
911 | * default handler : ignore some signal. The other are job | |
912 | * control or fatal. | |
913 | */ | |
914 | if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || | |
915 | sig == TARGET_SIGTTOU) { | |
916 | kill(getpid(), SIGSTOP); | |
917 | } else if (sig != TARGET_SIGCHLD && sig != TARGET_SIGURG && | |
918 | sig != TARGET_SIGINFO && sig != TARGET_SIGWINCH && | |
919 | sig != TARGET_SIGCONT) { | |
920 | dump_core_and_abort(sig); | |
921 | } | |
922 | } else if (handler == TARGET_SIG_IGN) { | |
923 | /* ignore sig */ | |
924 | } else if (handler == TARGET_SIG_ERR) { | |
925 | dump_core_and_abort(sig); | |
926 | } else { | |
927 | /* compute the blocked signals during the handler execution */ | |
928 | sigset_t *blocked_set; | |
929 | ||
930 | target_to_host_sigset(&set, &sa->sa_mask); | |
931 | /* | |
932 | * SA_NODEFER indicates that the current signal should not be | |
933 | * blocked during the handler. | |
934 | */ | |
935 | if (!(sa->sa_flags & TARGET_SA_NODEFER)) { | |
936 | sigaddset(&set, target_to_host_signal(sig)); | |
937 | } | |
938 | ||
939 | /* | |
940 | * Save the previous blocked signal state to restore it at the | |
941 | * end of the signal execution (see do_sigreturn). | |
942 | */ | |
943 | host_to_target_sigset_internal(&target_old_set, &ts->signal_mask); | |
944 | ||
945 | blocked_set = ts->in_sigsuspend ? | |
946 | &ts->sigsuspend_mask : &ts->signal_mask; | |
947 | sigorset(&ts->signal_mask, blocked_set, &set); | |
948 | ts->in_sigsuspend = false; | |
949 | sigprocmask(SIG_SETMASK, &ts->signal_mask, NULL); | |
950 | ||
951 | /* XXX VM86 on x86 ??? */ | |
952 | ||
953 | code = k->info.si_code; /* From host, so no si_type */ | |
954 | /* prepare the stack frame of the virtual CPU */ | |
955 | if (sa->sa_flags & TARGET_SA_SIGINFO) { | |
956 | tswap_siginfo(&tinfo, &k->info); | |
957 | setup_frame(sig, code, sa, &target_old_set, &tinfo, env); | |
958 | } else { | |
959 | setup_frame(sig, code, sa, &target_old_set, NULL, env); | |
960 | } | |
961 | if (sa->sa_flags & TARGET_SA_RESETHAND) { | |
962 | sa->_sa_handler = TARGET_SIG_DFL; | |
963 | } | |
964 | } | |
965 | } | |
966 | ||
d7acd317 | 967 | void process_pending_signals(CPUArchState *env) |
84778508 | 968 | { |
d7acd317 WL |
969 | CPUState *cpu = env_cpu(env); |
970 | int sig; | |
971 | sigset_t *blocked_set, set; | |
972 | struct emulated_sigtable *k; | |
973 | TaskState *ts = cpu->opaque; | |
974 | ||
975 | while (qatomic_read(&ts->signal_pending)) { | |
976 | sigfillset(&set); | |
977 | sigprocmask(SIG_SETMASK, &set, 0); | |
978 | ||
979 | restart_scan: | |
980 | sig = ts->sync_signal.pending; | |
981 | if (sig) { | |
982 | /* | |
983 | * Synchronous signals are forced by the emulated CPU in some way. | |
984 | * If they are set to ignore, restore the default handler (see | |
985 | * sys/kern_sig.c trapsignal() and execsigs() for this behavior) | |
986 | * though maybe this is done only when forcing exit for non SIGCHLD. | |
987 | */ | |
988 | if (sigismember(&ts->signal_mask, target_to_host_signal(sig)) || | |
989 | sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) { | |
990 | sigdelset(&ts->signal_mask, target_to_host_signal(sig)); | |
991 | sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL; | |
992 | } | |
993 | handle_pending_signal(env, sig, &ts->sync_signal); | |
994 | } | |
995 | ||
996 | k = ts->sigtab; | |
997 | for (sig = 1; sig <= TARGET_NSIG; sig++, k++) { | |
998 | blocked_set = ts->in_sigsuspend ? | |
999 | &ts->sigsuspend_mask : &ts->signal_mask; | |
1000 | if (k->pending && | |
1001 | !sigismember(blocked_set, target_to_host_signal(sig))) { | |
1002 | handle_pending_signal(env, sig, k); | |
1003 | /* | |
1004 | * Restart scan from the beginning, as handle_pending_signal | |
1005 | * might have resulted in a new synchronous signal (eg SIGSEGV). | |
1006 | */ | |
1007 | goto restart_scan; | |
1008 | } | |
1009 | } | |
1010 | ||
1011 | /* | |
1012 | * Unblock signals and check one more time. Unblocking signals may cause | |
1013 | * us to take another host signal, which will set signal_pending again. | |
1014 | */ | |
1015 | qatomic_set(&ts->signal_pending, 0); | |
1016 | ts->in_sigsuspend = false; | |
1017 | set = ts->signal_mask; | |
1018 | sigdelset(&set, SIGSEGV); | |
1019 | sigdelset(&set, SIGBUS); | |
1020 | sigprocmask(SIG_SETMASK, &set, 0); | |
1021 | } | |
1022 | ts->in_sigsuspend = false; | |
84778508 | 1023 | } |
835b04ed WL |
1024 | |
1025 | void cpu_loop_exit_sigsegv(CPUState *cpu, target_ulong addr, | |
1026 | MMUAccessType access_type, bool maperr, uintptr_t ra) | |
1027 | { | |
fc9f9bdd WL |
1028 | const struct TCGCPUOps *tcg_ops = CPU_GET_CLASS(cpu)->tcg_ops; |
1029 | ||
1030 | if (tcg_ops->record_sigsegv) { | |
1031 | tcg_ops->record_sigsegv(cpu, addr, access_type, maperr, ra); | |
1032 | } | |
1033 | ||
1034 | force_sig_fault(TARGET_SIGSEGV, | |
1035 | maperr ? TARGET_SEGV_MAPERR : TARGET_SEGV_ACCERR, | |
1036 | addr); | |
1037 | cpu->exception_index = EXCP_INTERRUPT; | |
1038 | cpu_loop_exit_restore(cpu, ra); | |
835b04ed WL |
1039 | } |
1040 | ||
1041 | void cpu_loop_exit_sigbus(CPUState *cpu, target_ulong addr, | |
1042 | MMUAccessType access_type, uintptr_t ra) | |
1043 | { | |
cfdee273 WL |
1044 | const struct TCGCPUOps *tcg_ops = CPU_GET_CLASS(cpu)->tcg_ops; |
1045 | ||
1046 | if (tcg_ops->record_sigbus) { | |
1047 | tcg_ops->record_sigbus(cpu, addr, access_type, ra); | |
1048 | } | |
1049 | ||
1050 | force_sig_fault(TARGET_SIGBUS, TARGET_BUS_ADRALN, addr); | |
1051 | cpu->exception_index = EXCP_INTERRUPT; | |
1052 | cpu_loop_exit_restore(cpu, ra); | |
835b04ed | 1053 | } |