Update version for v7.1.0-rc3 release
[qemu.git] / linux-user / signal.c
1 /*
2 * Emulation of Linux signals
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "qemu/osdep.h"
20 #include "qemu/bitops.h"
21 #include "exec/gdbstub.h"
22 #include "hw/core/tcg-cpu-ops.h"
23
24 #include <sys/ucontext.h>
25 #include <sys/resource.h>
26
27 #include "qemu.h"
28 #include "user-internals.h"
29 #include "strace.h"
30 #include "loader.h"
31 #include "trace.h"
32 #include "signal-common.h"
33 #include "host-signal.h"
34 #include "user/safe-syscall.h"
35
36 static struct target_sigaction sigact_table[TARGET_NSIG];
37
38 static void host_signal_handler(int host_signum, siginfo_t *info,
39 void *puc);
40
41 /* Fallback addresses into sigtramp page. */
42 abi_ulong default_sigreturn;
43 abi_ulong default_rt_sigreturn;
44
45 /*
46 * System includes define _NSIG as SIGRTMAX + 1,
47 * but qemu (like the kernel) defines TARGET_NSIG as TARGET_SIGRTMAX
48 * and the first signal is SIGHUP defined as 1
49 * Signal number 0 is reserved for use as kill(pid, 0), to test whether
50 * a process exists without sending it a signal.
51 */
52 #ifdef __SIGRTMAX
53 QEMU_BUILD_BUG_ON(__SIGRTMAX + 1 != _NSIG);
54 #endif
55 static uint8_t host_to_target_signal_table[_NSIG] = {
56 [SIGHUP] = TARGET_SIGHUP,
57 [SIGINT] = TARGET_SIGINT,
58 [SIGQUIT] = TARGET_SIGQUIT,
59 [SIGILL] = TARGET_SIGILL,
60 [SIGTRAP] = TARGET_SIGTRAP,
61 [SIGABRT] = TARGET_SIGABRT,
62 /* [SIGIOT] = TARGET_SIGIOT,*/
63 [SIGBUS] = TARGET_SIGBUS,
64 [SIGFPE] = TARGET_SIGFPE,
65 [SIGKILL] = TARGET_SIGKILL,
66 [SIGUSR1] = TARGET_SIGUSR1,
67 [SIGSEGV] = TARGET_SIGSEGV,
68 [SIGUSR2] = TARGET_SIGUSR2,
69 [SIGPIPE] = TARGET_SIGPIPE,
70 [SIGALRM] = TARGET_SIGALRM,
71 [SIGTERM] = TARGET_SIGTERM,
72 #ifdef SIGSTKFLT
73 [SIGSTKFLT] = TARGET_SIGSTKFLT,
74 #endif
75 [SIGCHLD] = TARGET_SIGCHLD,
76 [SIGCONT] = TARGET_SIGCONT,
77 [SIGSTOP] = TARGET_SIGSTOP,
78 [SIGTSTP] = TARGET_SIGTSTP,
79 [SIGTTIN] = TARGET_SIGTTIN,
80 [SIGTTOU] = TARGET_SIGTTOU,
81 [SIGURG] = TARGET_SIGURG,
82 [SIGXCPU] = TARGET_SIGXCPU,
83 [SIGXFSZ] = TARGET_SIGXFSZ,
84 [SIGVTALRM] = TARGET_SIGVTALRM,
85 [SIGPROF] = TARGET_SIGPROF,
86 [SIGWINCH] = TARGET_SIGWINCH,
87 [SIGIO] = TARGET_SIGIO,
88 [SIGPWR] = TARGET_SIGPWR,
89 [SIGSYS] = TARGET_SIGSYS,
90 /* next signals stay the same */
91 };
92
93 static uint8_t target_to_host_signal_table[TARGET_NSIG + 1];
94
95 /* valid sig is between 1 and _NSIG - 1 */
96 int host_to_target_signal(int sig)
97 {
98 if (sig < 1 || sig >= _NSIG) {
99 return sig;
100 }
101 return host_to_target_signal_table[sig];
102 }
103
104 /* valid sig is between 1 and TARGET_NSIG */
105 int target_to_host_signal(int sig)
106 {
107 if (sig < 1 || sig > TARGET_NSIG) {
108 return sig;
109 }
110 return target_to_host_signal_table[sig];
111 }
112
113 static inline void target_sigaddset(target_sigset_t *set, int signum)
114 {
115 signum--;
116 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
117 set->sig[signum / TARGET_NSIG_BPW] |= mask;
118 }
119
120 static inline int target_sigismember(const target_sigset_t *set, int signum)
121 {
122 signum--;
123 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
124 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
125 }
126
127 void host_to_target_sigset_internal(target_sigset_t *d,
128 const sigset_t *s)
129 {
130 int host_sig, target_sig;
131 target_sigemptyset(d);
132 for (host_sig = 1; host_sig < _NSIG; host_sig++) {
133 target_sig = host_to_target_signal(host_sig);
134 if (target_sig < 1 || target_sig > TARGET_NSIG) {
135 continue;
136 }
137 if (sigismember(s, host_sig)) {
138 target_sigaddset(d, target_sig);
139 }
140 }
141 }
142
143 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
144 {
145 target_sigset_t d1;
146 int i;
147
148 host_to_target_sigset_internal(&d1, s);
149 for(i = 0;i < TARGET_NSIG_WORDS; i++)
150 d->sig[i] = tswapal(d1.sig[i]);
151 }
152
153 void target_to_host_sigset_internal(sigset_t *d,
154 const target_sigset_t *s)
155 {
156 int host_sig, target_sig;
157 sigemptyset(d);
158 for (target_sig = 1; target_sig <= TARGET_NSIG; target_sig++) {
159 host_sig = target_to_host_signal(target_sig);
160 if (host_sig < 1 || host_sig >= _NSIG) {
161 continue;
162 }
163 if (target_sigismember(s, target_sig)) {
164 sigaddset(d, host_sig);
165 }
166 }
167 }
168
169 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
170 {
171 target_sigset_t s1;
172 int i;
173
174 for(i = 0;i < TARGET_NSIG_WORDS; i++)
175 s1.sig[i] = tswapal(s->sig[i]);
176 target_to_host_sigset_internal(d, &s1);
177 }
178
179 void host_to_target_old_sigset(abi_ulong *old_sigset,
180 const sigset_t *sigset)
181 {
182 target_sigset_t d;
183 host_to_target_sigset(&d, sigset);
184 *old_sigset = d.sig[0];
185 }
186
187 void target_to_host_old_sigset(sigset_t *sigset,
188 const abi_ulong *old_sigset)
189 {
190 target_sigset_t d;
191 int i;
192
193 d.sig[0] = *old_sigset;
194 for(i = 1;i < TARGET_NSIG_WORDS; i++)
195 d.sig[i] = 0;
196 target_to_host_sigset(sigset, &d);
197 }
198
199 int block_signals(void)
200 {
201 TaskState *ts = (TaskState *)thread_cpu->opaque;
202 sigset_t set;
203
204 /* It's OK to block everything including SIGSEGV, because we won't
205 * run any further guest code before unblocking signals in
206 * process_pending_signals().
207 */
208 sigfillset(&set);
209 sigprocmask(SIG_SETMASK, &set, 0);
210
211 return qatomic_xchg(&ts->signal_pending, 1);
212 }
213
214 /* Wrapper for sigprocmask function
215 * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset
216 * are host signal set, not guest ones. Returns -QEMU_ERESTARTSYS if
217 * a signal was already pending and the syscall must be restarted, or
218 * 0 on success.
219 * If set is NULL, this is guaranteed not to fail.
220 */
221 int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
222 {
223 TaskState *ts = (TaskState *)thread_cpu->opaque;
224
225 if (oldset) {
226 *oldset = ts->signal_mask;
227 }
228
229 if (set) {
230 int i;
231
232 if (block_signals()) {
233 return -QEMU_ERESTARTSYS;
234 }
235
236 switch (how) {
237 case SIG_BLOCK:
238 sigorset(&ts->signal_mask, &ts->signal_mask, set);
239 break;
240 case SIG_UNBLOCK:
241 for (i = 1; i <= NSIG; ++i) {
242 if (sigismember(set, i)) {
243 sigdelset(&ts->signal_mask, i);
244 }
245 }
246 break;
247 case SIG_SETMASK:
248 ts->signal_mask = *set;
249 break;
250 default:
251 g_assert_not_reached();
252 }
253
254 /* Silently ignore attempts to change blocking status of KILL or STOP */
255 sigdelset(&ts->signal_mask, SIGKILL);
256 sigdelset(&ts->signal_mask, SIGSTOP);
257 }
258 return 0;
259 }
260
261 /* Just set the guest's signal mask to the specified value; the
262 * caller is assumed to have called block_signals() already.
263 */
264 void set_sigmask(const sigset_t *set)
265 {
266 TaskState *ts = (TaskState *)thread_cpu->opaque;
267
268 ts->signal_mask = *set;
269 }
270
271 /* sigaltstack management */
272
273 int on_sig_stack(unsigned long sp)
274 {
275 TaskState *ts = (TaskState *)thread_cpu->opaque;
276
277 return (sp - ts->sigaltstack_used.ss_sp
278 < ts->sigaltstack_used.ss_size);
279 }
280
281 int sas_ss_flags(unsigned long sp)
282 {
283 TaskState *ts = (TaskState *)thread_cpu->opaque;
284
285 return (ts->sigaltstack_used.ss_size == 0 ? SS_DISABLE
286 : on_sig_stack(sp) ? SS_ONSTACK : 0);
287 }
288
289 abi_ulong target_sigsp(abi_ulong sp, struct target_sigaction *ka)
290 {
291 /*
292 * This is the X/Open sanctioned signal stack switching.
293 */
294 TaskState *ts = (TaskState *)thread_cpu->opaque;
295
296 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
297 return ts->sigaltstack_used.ss_sp + ts->sigaltstack_used.ss_size;
298 }
299 return sp;
300 }
301
302 void target_save_altstack(target_stack_t *uss, CPUArchState *env)
303 {
304 TaskState *ts = (TaskState *)thread_cpu->opaque;
305
306 __put_user(ts->sigaltstack_used.ss_sp, &uss->ss_sp);
307 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &uss->ss_flags);
308 __put_user(ts->sigaltstack_used.ss_size, &uss->ss_size);
309 }
310
311 abi_long target_restore_altstack(target_stack_t *uss, CPUArchState *env)
312 {
313 TaskState *ts = (TaskState *)thread_cpu->opaque;
314 size_t minstacksize = TARGET_MINSIGSTKSZ;
315 target_stack_t ss;
316
317 #if defined(TARGET_PPC64)
318 /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */
319 struct image_info *image = ts->info;
320 if (get_ppc64_abi(image) > 1) {
321 minstacksize = 4096;
322 }
323 #endif
324
325 __get_user(ss.ss_sp, &uss->ss_sp);
326 __get_user(ss.ss_size, &uss->ss_size);
327 __get_user(ss.ss_flags, &uss->ss_flags);
328
329 if (on_sig_stack(get_sp_from_cpustate(env))) {
330 return -TARGET_EPERM;
331 }
332
333 switch (ss.ss_flags) {
334 default:
335 return -TARGET_EINVAL;
336
337 case TARGET_SS_DISABLE:
338 ss.ss_size = 0;
339 ss.ss_sp = 0;
340 break;
341
342 case TARGET_SS_ONSTACK:
343 case 0:
344 if (ss.ss_size < minstacksize) {
345 return -TARGET_ENOMEM;
346 }
347 break;
348 }
349
350 ts->sigaltstack_used.ss_sp = ss.ss_sp;
351 ts->sigaltstack_used.ss_size = ss.ss_size;
352 return 0;
353 }
354
355 /* siginfo conversion */
356
357 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
358 const siginfo_t *info)
359 {
360 int sig = host_to_target_signal(info->si_signo);
361 int si_code = info->si_code;
362 int si_type;
363 tinfo->si_signo = sig;
364 tinfo->si_errno = 0;
365 tinfo->si_code = info->si_code;
366
367 /* This memset serves two purposes:
368 * (1) ensure we don't leak random junk to the guest later
369 * (2) placate false positives from gcc about fields
370 * being used uninitialized if it chooses to inline both this
371 * function and tswap_siginfo() into host_to_target_siginfo().
372 */
373 memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
374
375 /* This is awkward, because we have to use a combination of
376 * the si_code and si_signo to figure out which of the union's
377 * members are valid. (Within the host kernel it is always possible
378 * to tell, but the kernel carefully avoids giving userspace the
379 * high 16 bits of si_code, so we don't have the information to
380 * do this the easy way...) We therefore make our best guess,
381 * bearing in mind that a guest can spoof most of the si_codes
382 * via rt_sigqueueinfo() if it likes.
383 *
384 * Once we have made our guess, we record it in the top 16 bits of
385 * the si_code, so that tswap_siginfo() later can use it.
386 * tswap_siginfo() will strip these top bits out before writing
387 * si_code to the guest (sign-extending the lower bits).
388 */
389
390 switch (si_code) {
391 case SI_USER:
392 case SI_TKILL:
393 case SI_KERNEL:
394 /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
395 * These are the only unspoofable si_code values.
396 */
397 tinfo->_sifields._kill._pid = info->si_pid;
398 tinfo->_sifields._kill._uid = info->si_uid;
399 si_type = QEMU_SI_KILL;
400 break;
401 default:
402 /* Everything else is spoofable. Make best guess based on signal */
403 switch (sig) {
404 case TARGET_SIGCHLD:
405 tinfo->_sifields._sigchld._pid = info->si_pid;
406 tinfo->_sifields._sigchld._uid = info->si_uid;
407 if (si_code == CLD_EXITED)
408 tinfo->_sifields._sigchld._status = info->si_status;
409 else
410 tinfo->_sifields._sigchld._status
411 = host_to_target_signal(info->si_status & 0x7f)
412 | (info->si_status & ~0x7f);
413 tinfo->_sifields._sigchld._utime = info->si_utime;
414 tinfo->_sifields._sigchld._stime = info->si_stime;
415 si_type = QEMU_SI_CHLD;
416 break;
417 case TARGET_SIGIO:
418 tinfo->_sifields._sigpoll._band = info->si_band;
419 tinfo->_sifields._sigpoll._fd = info->si_fd;
420 si_type = QEMU_SI_POLL;
421 break;
422 default:
423 /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
424 tinfo->_sifields._rt._pid = info->si_pid;
425 tinfo->_sifields._rt._uid = info->si_uid;
426 /* XXX: potential problem if 64 bit */
427 tinfo->_sifields._rt._sigval.sival_ptr
428 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
429 si_type = QEMU_SI_RT;
430 break;
431 }
432 break;
433 }
434
435 tinfo->si_code = deposit32(si_code, 16, 16, si_type);
436 }
437
438 void tswap_siginfo(target_siginfo_t *tinfo,
439 const target_siginfo_t *info)
440 {
441 int si_type = extract32(info->si_code, 16, 16);
442 int si_code = sextract32(info->si_code, 0, 16);
443
444 __put_user(info->si_signo, &tinfo->si_signo);
445 __put_user(info->si_errno, &tinfo->si_errno);
446 __put_user(si_code, &tinfo->si_code);
447
448 /* We can use our internal marker of which fields in the structure
449 * are valid, rather than duplicating the guesswork of
450 * host_to_target_siginfo_noswap() here.
451 */
452 switch (si_type) {
453 case QEMU_SI_KILL:
454 __put_user(info->_sifields._kill._pid, &tinfo->_sifields._kill._pid);
455 __put_user(info->_sifields._kill._uid, &tinfo->_sifields._kill._uid);
456 break;
457 case QEMU_SI_TIMER:
458 __put_user(info->_sifields._timer._timer1,
459 &tinfo->_sifields._timer._timer1);
460 __put_user(info->_sifields._timer._timer2,
461 &tinfo->_sifields._timer._timer2);
462 break;
463 case QEMU_SI_POLL:
464 __put_user(info->_sifields._sigpoll._band,
465 &tinfo->_sifields._sigpoll._band);
466 __put_user(info->_sifields._sigpoll._fd,
467 &tinfo->_sifields._sigpoll._fd);
468 break;
469 case QEMU_SI_FAULT:
470 __put_user(info->_sifields._sigfault._addr,
471 &tinfo->_sifields._sigfault._addr);
472 break;
473 case QEMU_SI_CHLD:
474 __put_user(info->_sifields._sigchld._pid,
475 &tinfo->_sifields._sigchld._pid);
476 __put_user(info->_sifields._sigchld._uid,
477 &tinfo->_sifields._sigchld._uid);
478 __put_user(info->_sifields._sigchld._status,
479 &tinfo->_sifields._sigchld._status);
480 __put_user(info->_sifields._sigchld._utime,
481 &tinfo->_sifields._sigchld._utime);
482 __put_user(info->_sifields._sigchld._stime,
483 &tinfo->_sifields._sigchld._stime);
484 break;
485 case QEMU_SI_RT:
486 __put_user(info->_sifields._rt._pid, &tinfo->_sifields._rt._pid);
487 __put_user(info->_sifields._rt._uid, &tinfo->_sifields._rt._uid);
488 __put_user(info->_sifields._rt._sigval.sival_ptr,
489 &tinfo->_sifields._rt._sigval.sival_ptr);
490 break;
491 default:
492 g_assert_not_reached();
493 }
494 }
495
496 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
497 {
498 target_siginfo_t tgt_tmp;
499 host_to_target_siginfo_noswap(&tgt_tmp, info);
500 tswap_siginfo(tinfo, &tgt_tmp);
501 }
502
503 /* XXX: we support only POSIX RT signals are used. */
504 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
505 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
506 {
507 /* This conversion is used only for the rt_sigqueueinfo syscall,
508 * and so we know that the _rt fields are the valid ones.
509 */
510 abi_ulong sival_ptr;
511
512 __get_user(info->si_signo, &tinfo->si_signo);
513 __get_user(info->si_errno, &tinfo->si_errno);
514 __get_user(info->si_code, &tinfo->si_code);
515 __get_user(info->si_pid, &tinfo->_sifields._rt._pid);
516 __get_user(info->si_uid, &tinfo->_sifields._rt._uid);
517 __get_user(sival_ptr, &tinfo->_sifields._rt._sigval.sival_ptr);
518 info->si_value.sival_ptr = (void *)(long)sival_ptr;
519 }
520
521 static int fatal_signal (int sig)
522 {
523 switch (sig) {
524 case TARGET_SIGCHLD:
525 case TARGET_SIGURG:
526 case TARGET_SIGWINCH:
527 /* Ignored by default. */
528 return 0;
529 case TARGET_SIGCONT:
530 case TARGET_SIGSTOP:
531 case TARGET_SIGTSTP:
532 case TARGET_SIGTTIN:
533 case TARGET_SIGTTOU:
534 /* Job control signals. */
535 return 0;
536 default:
537 return 1;
538 }
539 }
540
541 /* returns 1 if given signal should dump core if not handled */
542 static int core_dump_signal(int sig)
543 {
544 switch (sig) {
545 case TARGET_SIGABRT:
546 case TARGET_SIGFPE:
547 case TARGET_SIGILL:
548 case TARGET_SIGQUIT:
549 case TARGET_SIGSEGV:
550 case TARGET_SIGTRAP:
551 case TARGET_SIGBUS:
552 return (1);
553 default:
554 return (0);
555 }
556 }
557
558 static void signal_table_init(void)
559 {
560 int host_sig, target_sig, count;
561
562 /*
563 * Signals are supported starting from TARGET_SIGRTMIN and going up
564 * until we run out of host realtime signals.
565 * glibc at least uses only the lower 2 rt signals and probably
566 * nobody's using the upper ones.
567 * it's why SIGRTMIN (34) is generally greater than __SIGRTMIN (32)
568 * To fix this properly we need to do manual signal delivery multiplexed
569 * over a single host signal.
570 * Attempts for configure "missing" signals via sigaction will be
571 * silently ignored.
572 */
573 for (host_sig = SIGRTMIN; host_sig <= SIGRTMAX; host_sig++) {
574 target_sig = host_sig - SIGRTMIN + TARGET_SIGRTMIN;
575 if (target_sig <= TARGET_NSIG) {
576 host_to_target_signal_table[host_sig] = target_sig;
577 }
578 }
579
580 /* generate signal conversion tables */
581 for (target_sig = 1; target_sig <= TARGET_NSIG; target_sig++) {
582 target_to_host_signal_table[target_sig] = _NSIG; /* poison */
583 }
584 for (host_sig = 1; host_sig < _NSIG; host_sig++) {
585 if (host_to_target_signal_table[host_sig] == 0) {
586 host_to_target_signal_table[host_sig] = host_sig;
587 }
588 target_sig = host_to_target_signal_table[host_sig];
589 if (target_sig <= TARGET_NSIG) {
590 target_to_host_signal_table[target_sig] = host_sig;
591 }
592 }
593
594 if (trace_event_get_state_backends(TRACE_SIGNAL_TABLE_INIT)) {
595 for (target_sig = 1, count = 0; target_sig <= TARGET_NSIG; target_sig++) {
596 if (target_to_host_signal_table[target_sig] == _NSIG) {
597 count++;
598 }
599 }
600 trace_signal_table_init(count);
601 }
602 }
603
604 void signal_init(void)
605 {
606 TaskState *ts = (TaskState *)thread_cpu->opaque;
607 struct sigaction act;
608 struct sigaction oact;
609 int i;
610 int host_sig;
611
612 /* initialize signal conversion tables */
613 signal_table_init();
614
615 /* Set the signal mask from the host mask. */
616 sigprocmask(0, 0, &ts->signal_mask);
617
618 sigfillset(&act.sa_mask);
619 act.sa_flags = SA_SIGINFO;
620 act.sa_sigaction = host_signal_handler;
621 for(i = 1; i <= TARGET_NSIG; i++) {
622 #ifdef CONFIG_GPROF
623 if (i == TARGET_SIGPROF) {
624 continue;
625 }
626 #endif
627 host_sig = target_to_host_signal(i);
628 sigaction(host_sig, NULL, &oact);
629 if (oact.sa_sigaction == (void *)SIG_IGN) {
630 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
631 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
632 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
633 }
634 /* If there's already a handler installed then something has
635 gone horribly wrong, so don't even try to handle that case. */
636 /* Install some handlers for our own use. We need at least
637 SIGSEGV and SIGBUS, to detect exceptions. We can not just
638 trap all signals because it affects syscall interrupt
639 behavior. But do trap all default-fatal signals. */
640 if (fatal_signal (i))
641 sigaction(host_sig, &act, NULL);
642 }
643 }
644
645 /* Force a synchronously taken signal. The kernel force_sig() function
646 * also forces the signal to "not blocked, not ignored", but for QEMU
647 * that work is done in process_pending_signals().
648 */
649 void force_sig(int sig)
650 {
651 CPUState *cpu = thread_cpu;
652 CPUArchState *env = cpu->env_ptr;
653 target_siginfo_t info = {};
654
655 info.si_signo = sig;
656 info.si_errno = 0;
657 info.si_code = TARGET_SI_KERNEL;
658 info._sifields._kill._pid = 0;
659 info._sifields._kill._uid = 0;
660 queue_signal(env, info.si_signo, QEMU_SI_KILL, &info);
661 }
662
663 /*
664 * Force a synchronously taken QEMU_SI_FAULT signal. For QEMU the
665 * 'force' part is handled in process_pending_signals().
666 */
667 void force_sig_fault(int sig, int code, abi_ulong addr)
668 {
669 CPUState *cpu = thread_cpu;
670 CPUArchState *env = cpu->env_ptr;
671 target_siginfo_t info = {};
672
673 info.si_signo = sig;
674 info.si_errno = 0;
675 info.si_code = code;
676 info._sifields._sigfault._addr = addr;
677 queue_signal(env, sig, QEMU_SI_FAULT, &info);
678 }
679
680 /* Force a SIGSEGV if we couldn't write to memory trying to set
681 * up the signal frame. oldsig is the signal we were trying to handle
682 * at the point of failure.
683 */
684 #if !defined(TARGET_RISCV)
685 void force_sigsegv(int oldsig)
686 {
687 if (oldsig == SIGSEGV) {
688 /* Make sure we don't try to deliver the signal again; this will
689 * end up with handle_pending_signal() calling dump_core_and_abort().
690 */
691 sigact_table[oldsig - 1]._sa_handler = TARGET_SIG_DFL;
692 }
693 force_sig(TARGET_SIGSEGV);
694 }
695 #endif
696
697 void cpu_loop_exit_sigsegv(CPUState *cpu, target_ulong addr,
698 MMUAccessType access_type, bool maperr, uintptr_t ra)
699 {
700 const struct TCGCPUOps *tcg_ops = CPU_GET_CLASS(cpu)->tcg_ops;
701
702 if (tcg_ops->record_sigsegv) {
703 tcg_ops->record_sigsegv(cpu, addr, access_type, maperr, ra);
704 }
705
706 force_sig_fault(TARGET_SIGSEGV,
707 maperr ? TARGET_SEGV_MAPERR : TARGET_SEGV_ACCERR,
708 addr);
709 cpu->exception_index = EXCP_INTERRUPT;
710 cpu_loop_exit_restore(cpu, ra);
711 }
712
713 void cpu_loop_exit_sigbus(CPUState *cpu, target_ulong addr,
714 MMUAccessType access_type, uintptr_t ra)
715 {
716 const struct TCGCPUOps *tcg_ops = CPU_GET_CLASS(cpu)->tcg_ops;
717
718 if (tcg_ops->record_sigbus) {
719 tcg_ops->record_sigbus(cpu, addr, access_type, ra);
720 }
721
722 force_sig_fault(TARGET_SIGBUS, TARGET_BUS_ADRALN, addr);
723 cpu->exception_index = EXCP_INTERRUPT;
724 cpu_loop_exit_restore(cpu, ra);
725 }
726
727 /* abort execution with signal */
728 static void QEMU_NORETURN dump_core_and_abort(int target_sig)
729 {
730 CPUState *cpu = thread_cpu;
731 CPUArchState *env = cpu->env_ptr;
732 TaskState *ts = (TaskState *)cpu->opaque;
733 int host_sig, core_dumped = 0;
734 struct sigaction act;
735
736 host_sig = target_to_host_signal(target_sig);
737 trace_user_force_sig(env, target_sig, host_sig);
738 gdb_signalled(env, target_sig);
739
740 /* dump core if supported by target binary format */
741 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
742 stop_all_tasks();
743 core_dumped =
744 ((*ts->bprm->core_dump)(target_sig, env) == 0);
745 }
746 if (core_dumped) {
747 /* we already dumped the core of target process, we don't want
748 * a coredump of qemu itself */
749 struct rlimit nodump;
750 getrlimit(RLIMIT_CORE, &nodump);
751 nodump.rlim_cur=0;
752 setrlimit(RLIMIT_CORE, &nodump);
753 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
754 target_sig, strsignal(host_sig), "core dumped" );
755 }
756
757 /* The proper exit code for dying from an uncaught signal is
758 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
759 * a negative value. To get the proper exit code we need to
760 * actually die from an uncaught signal. Here the default signal
761 * handler is installed, we send ourself a signal and we wait for
762 * it to arrive. */
763 sigfillset(&act.sa_mask);
764 act.sa_handler = SIG_DFL;
765 act.sa_flags = 0;
766 sigaction(host_sig, &act, NULL);
767
768 /* For some reason raise(host_sig) doesn't send the signal when
769 * statically linked on x86-64. */
770 kill(getpid(), host_sig);
771
772 /* Make sure the signal isn't masked (just reuse the mask inside
773 of act) */
774 sigdelset(&act.sa_mask, host_sig);
775 sigsuspend(&act.sa_mask);
776
777 /* unreachable */
778 abort();
779 }
780
781 /* queue a signal so that it will be send to the virtual CPU as soon
782 as possible */
783 int queue_signal(CPUArchState *env, int sig, int si_type,
784 target_siginfo_t *info)
785 {
786 CPUState *cpu = env_cpu(env);
787 TaskState *ts = cpu->opaque;
788
789 trace_user_queue_signal(env, sig);
790
791 info->si_code = deposit32(info->si_code, 16, 16, si_type);
792
793 ts->sync_signal.info = *info;
794 ts->sync_signal.pending = sig;
795 /* signal that a new signal is pending */
796 qatomic_set(&ts->signal_pending, 1);
797 return 1; /* indicates that the signal was queued */
798 }
799
800
801 /* Adjust the signal context to rewind out of safe-syscall if we're in it */
802 static inline void rewind_if_in_safe_syscall(void *puc)
803 {
804 ucontext_t *uc = (ucontext_t *)puc;
805 uintptr_t pcreg = host_signal_pc(uc);
806
807 if (pcreg > (uintptr_t)safe_syscall_start
808 && pcreg < (uintptr_t)safe_syscall_end) {
809 host_signal_set_pc(uc, (uintptr_t)safe_syscall_start);
810 }
811 }
812
813 static void host_signal_handler(int host_sig, siginfo_t *info, void *puc)
814 {
815 CPUArchState *env = thread_cpu->env_ptr;
816 CPUState *cpu = env_cpu(env);
817 TaskState *ts = cpu->opaque;
818 target_siginfo_t tinfo;
819 ucontext_t *uc = puc;
820 struct emulated_sigtable *k;
821 int guest_sig;
822 uintptr_t pc = 0;
823 bool sync_sig = false;
824
825 /*
826 * Non-spoofed SIGSEGV and SIGBUS are synchronous, and need special
827 * handling wrt signal blocking and unwinding.
828 */
829 if ((host_sig == SIGSEGV || host_sig == SIGBUS) && info->si_code > 0) {
830 MMUAccessType access_type;
831 uintptr_t host_addr;
832 abi_ptr guest_addr;
833 bool is_write;
834
835 host_addr = (uintptr_t)info->si_addr;
836
837 /*
838 * Convert forcefully to guest address space: addresses outside
839 * reserved_va are still valid to report via SEGV_MAPERR.
840 */
841 guest_addr = h2g_nocheck(host_addr);
842
843 pc = host_signal_pc(uc);
844 is_write = host_signal_write(info, uc);
845 access_type = adjust_signal_pc(&pc, is_write);
846
847 if (host_sig == SIGSEGV) {
848 bool maperr = true;
849
850 if (info->si_code == SEGV_ACCERR && h2g_valid(host_addr)) {
851 /* If this was a write to a TB protected page, restart. */
852 if (is_write &&
853 handle_sigsegv_accerr_write(cpu, &uc->uc_sigmask,
854 pc, guest_addr)) {
855 return;
856 }
857
858 /*
859 * With reserved_va, the whole address space is PROT_NONE,
860 * which means that we may get ACCERR when we want MAPERR.
861 */
862 if (page_get_flags(guest_addr) & PAGE_VALID) {
863 maperr = false;
864 } else {
865 info->si_code = SEGV_MAPERR;
866 }
867 }
868
869 sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
870 cpu_loop_exit_sigsegv(cpu, guest_addr, access_type, maperr, pc);
871 } else {
872 sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
873 if (info->si_code == BUS_ADRALN) {
874 cpu_loop_exit_sigbus(cpu, guest_addr, access_type, pc);
875 }
876 }
877
878 sync_sig = true;
879 }
880
881 /* get target signal number */
882 guest_sig = host_to_target_signal(host_sig);
883 if (guest_sig < 1 || guest_sig > TARGET_NSIG) {
884 return;
885 }
886 trace_user_host_signal(env, host_sig, guest_sig);
887
888 host_to_target_siginfo_noswap(&tinfo, info);
889 k = &ts->sigtab[guest_sig - 1];
890 k->info = tinfo;
891 k->pending = guest_sig;
892 ts->signal_pending = 1;
893
894 /*
895 * For synchronous signals, unwind the cpu state to the faulting
896 * insn and then exit back to the main loop so that the signal
897 * is delivered immediately.
898 */
899 if (sync_sig) {
900 cpu->exception_index = EXCP_INTERRUPT;
901 cpu_loop_exit_restore(cpu, pc);
902 }
903
904 rewind_if_in_safe_syscall(puc);
905
906 /*
907 * Block host signals until target signal handler entered. We
908 * can't block SIGSEGV or SIGBUS while we're executing guest
909 * code in case the guest code provokes one in the window between
910 * now and it getting out to the main loop. Signals will be
911 * unblocked again in process_pending_signals().
912 *
913 * WARNING: we cannot use sigfillset() here because the uc_sigmask
914 * field is a kernel sigset_t, which is much smaller than the
915 * libc sigset_t which sigfillset() operates on. Using sigfillset()
916 * would write 0xff bytes off the end of the structure and trash
917 * data on the struct.
918 * We can't use sizeof(uc->uc_sigmask) either, because the libc
919 * headers define the struct field with the wrong (too large) type.
920 */
921 memset(&uc->uc_sigmask, 0xff, SIGSET_T_SIZE);
922 sigdelset(&uc->uc_sigmask, SIGSEGV);
923 sigdelset(&uc->uc_sigmask, SIGBUS);
924
925 /* interrupt the virtual CPU as soon as possible */
926 cpu_exit(thread_cpu);
927 }
928
929 /* do_sigaltstack() returns target values and errnos. */
930 /* compare linux/kernel/signal.c:do_sigaltstack() */
931 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr,
932 CPUArchState *env)
933 {
934 target_stack_t oss, *uoss = NULL;
935 abi_long ret = -TARGET_EFAULT;
936
937 if (uoss_addr) {
938 /* Verify writability now, but do not alter user memory yet. */
939 if (!lock_user_struct(VERIFY_WRITE, uoss, uoss_addr, 0)) {
940 goto out;
941 }
942 target_save_altstack(&oss, env);
943 }
944
945 if (uss_addr) {
946 target_stack_t *uss;
947
948 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) {
949 goto out;
950 }
951 ret = target_restore_altstack(uss, env);
952 if (ret) {
953 goto out;
954 }
955 }
956
957 if (uoss_addr) {
958 memcpy(uoss, &oss, sizeof(oss));
959 unlock_user_struct(uoss, uoss_addr, 1);
960 uoss = NULL;
961 }
962 ret = 0;
963
964 out:
965 if (uoss) {
966 unlock_user_struct(uoss, uoss_addr, 0);
967 }
968 return ret;
969 }
970
971 /* do_sigaction() return target values and host errnos */
972 int do_sigaction(int sig, const struct target_sigaction *act,
973 struct target_sigaction *oact, abi_ulong ka_restorer)
974 {
975 struct target_sigaction *k;
976 struct sigaction act1;
977 int host_sig;
978 int ret = 0;
979
980 trace_signal_do_sigaction_guest(sig, TARGET_NSIG);
981
982 if (sig < 1 || sig > TARGET_NSIG) {
983 return -TARGET_EINVAL;
984 }
985
986 if (act && (sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)) {
987 return -TARGET_EINVAL;
988 }
989
990 if (block_signals()) {
991 return -QEMU_ERESTARTSYS;
992 }
993
994 k = &sigact_table[sig - 1];
995 if (oact) {
996 __put_user(k->_sa_handler, &oact->_sa_handler);
997 __put_user(k->sa_flags, &oact->sa_flags);
998 #ifdef TARGET_ARCH_HAS_SA_RESTORER
999 __put_user(k->sa_restorer, &oact->sa_restorer);
1000 #endif
1001 /* Not swapped. */
1002 oact->sa_mask = k->sa_mask;
1003 }
1004 if (act) {
1005 /* FIXME: This is not threadsafe. */
1006 __get_user(k->_sa_handler, &act->_sa_handler);
1007 __get_user(k->sa_flags, &act->sa_flags);
1008 #ifdef TARGET_ARCH_HAS_SA_RESTORER
1009 __get_user(k->sa_restorer, &act->sa_restorer);
1010 #endif
1011 #ifdef TARGET_ARCH_HAS_KA_RESTORER
1012 k->ka_restorer = ka_restorer;
1013 #endif
1014 /* To be swapped in target_to_host_sigset. */
1015 k->sa_mask = act->sa_mask;
1016
1017 /* we update the host linux signal state */
1018 host_sig = target_to_host_signal(sig);
1019 trace_signal_do_sigaction_host(host_sig, TARGET_NSIG);
1020 if (host_sig > SIGRTMAX) {
1021 /* we don't have enough host signals to map all target signals */
1022 qemu_log_mask(LOG_UNIMP, "Unsupported target signal #%d, ignored\n",
1023 sig);
1024 /*
1025 * we don't return an error here because some programs try to
1026 * register an handler for all possible rt signals even if they
1027 * don't need it.
1028 * An error here can abort them whereas there can be no problem
1029 * to not have the signal available later.
1030 * This is the case for golang,
1031 * See https://github.com/golang/go/issues/33746
1032 * So we silently ignore the error.
1033 */
1034 return 0;
1035 }
1036 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
1037 sigfillset(&act1.sa_mask);
1038 act1.sa_flags = SA_SIGINFO;
1039 if (k->sa_flags & TARGET_SA_RESTART)
1040 act1.sa_flags |= SA_RESTART;
1041 /* NOTE: it is important to update the host kernel signal
1042 ignore state to avoid getting unexpected interrupted
1043 syscalls */
1044 if (k->_sa_handler == TARGET_SIG_IGN) {
1045 act1.sa_sigaction = (void *)SIG_IGN;
1046 } else if (k->_sa_handler == TARGET_SIG_DFL) {
1047 if (fatal_signal (sig))
1048 act1.sa_sigaction = host_signal_handler;
1049 else
1050 act1.sa_sigaction = (void *)SIG_DFL;
1051 } else {
1052 act1.sa_sigaction = host_signal_handler;
1053 }
1054 ret = sigaction(host_sig, &act1, NULL);
1055 }
1056 }
1057 return ret;
1058 }
1059
1060 static void handle_pending_signal(CPUArchState *cpu_env, int sig,
1061 struct emulated_sigtable *k)
1062 {
1063 CPUState *cpu = env_cpu(cpu_env);
1064 abi_ulong handler;
1065 sigset_t set;
1066 target_sigset_t target_old_set;
1067 struct target_sigaction *sa;
1068 TaskState *ts = cpu->opaque;
1069
1070 trace_user_handle_signal(cpu_env, sig);
1071 /* dequeue signal */
1072 k->pending = 0;
1073
1074 sig = gdb_handlesig(cpu, sig);
1075 if (!sig) {
1076 sa = NULL;
1077 handler = TARGET_SIG_IGN;
1078 } else {
1079 sa = &sigact_table[sig - 1];
1080 handler = sa->_sa_handler;
1081 }
1082
1083 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
1084 print_taken_signal(sig, &k->info);
1085 }
1086
1087 if (handler == TARGET_SIG_DFL) {
1088 /* default handler : ignore some signal. The other are job control or fatal */
1089 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
1090 kill(getpid(),SIGSTOP);
1091 } else if (sig != TARGET_SIGCHLD &&
1092 sig != TARGET_SIGURG &&
1093 sig != TARGET_SIGWINCH &&
1094 sig != TARGET_SIGCONT) {
1095 dump_core_and_abort(sig);
1096 }
1097 } else if (handler == TARGET_SIG_IGN) {
1098 /* ignore sig */
1099 } else if (handler == TARGET_SIG_ERR) {
1100 dump_core_and_abort(sig);
1101 } else {
1102 /* compute the blocked signals during the handler execution */
1103 sigset_t *blocked_set;
1104
1105 target_to_host_sigset(&set, &sa->sa_mask);
1106 /* SA_NODEFER indicates that the current signal should not be
1107 blocked during the handler */
1108 if (!(sa->sa_flags & TARGET_SA_NODEFER))
1109 sigaddset(&set, target_to_host_signal(sig));
1110
1111 /* save the previous blocked signal state to restore it at the
1112 end of the signal execution (see do_sigreturn) */
1113 host_to_target_sigset_internal(&target_old_set, &ts->signal_mask);
1114
1115 /* block signals in the handler */
1116 blocked_set = ts->in_sigsuspend ?
1117 &ts->sigsuspend_mask : &ts->signal_mask;
1118 sigorset(&ts->signal_mask, blocked_set, &set);
1119 ts->in_sigsuspend = 0;
1120
1121 /* if the CPU is in VM86 mode, we restore the 32 bit values */
1122 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
1123 {
1124 CPUX86State *env = cpu_env;
1125 if (env->eflags & VM_MASK)
1126 save_v86_state(env);
1127 }
1128 #endif
1129 /* prepare the stack frame of the virtual CPU */
1130 #if defined(TARGET_ARCH_HAS_SETUP_FRAME)
1131 if (sa->sa_flags & TARGET_SA_SIGINFO) {
1132 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
1133 } else {
1134 setup_frame(sig, sa, &target_old_set, cpu_env);
1135 }
1136 #else
1137 /* These targets do not have traditional signals. */
1138 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
1139 #endif
1140 if (sa->sa_flags & TARGET_SA_RESETHAND) {
1141 sa->_sa_handler = TARGET_SIG_DFL;
1142 }
1143 }
1144 }
1145
1146 void process_pending_signals(CPUArchState *cpu_env)
1147 {
1148 CPUState *cpu = env_cpu(cpu_env);
1149 int sig;
1150 TaskState *ts = cpu->opaque;
1151 sigset_t set;
1152 sigset_t *blocked_set;
1153
1154 while (qatomic_read(&ts->signal_pending)) {
1155 /* FIXME: This is not threadsafe. */
1156 sigfillset(&set);
1157 sigprocmask(SIG_SETMASK, &set, 0);
1158
1159 restart_scan:
1160 sig = ts->sync_signal.pending;
1161 if (sig) {
1162 /* Synchronous signals are forced,
1163 * see force_sig_info() and callers in Linux
1164 * Note that not all of our queue_signal() calls in QEMU correspond
1165 * to force_sig_info() calls in Linux (some are send_sig_info()).
1166 * However it seems like a kernel bug to me to allow the process
1167 * to block a synchronous signal since it could then just end up
1168 * looping round and round indefinitely.
1169 */
1170 if (sigismember(&ts->signal_mask, target_to_host_signal_table[sig])
1171 || sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) {
1172 sigdelset(&ts->signal_mask, target_to_host_signal_table[sig]);
1173 sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL;
1174 }
1175
1176 handle_pending_signal(cpu_env, sig, &ts->sync_signal);
1177 }
1178
1179 for (sig = 1; sig <= TARGET_NSIG; sig++) {
1180 blocked_set = ts->in_sigsuspend ?
1181 &ts->sigsuspend_mask : &ts->signal_mask;
1182
1183 if (ts->sigtab[sig - 1].pending &&
1184 (!sigismember(blocked_set,
1185 target_to_host_signal_table[sig]))) {
1186 handle_pending_signal(cpu_env, sig, &ts->sigtab[sig - 1]);
1187 /* Restart scan from the beginning, as handle_pending_signal
1188 * might have resulted in a new synchronous signal (eg SIGSEGV).
1189 */
1190 goto restart_scan;
1191 }
1192 }
1193
1194 /* if no signal is pending, unblock signals and recheck (the act
1195 * of unblocking might cause us to take another host signal which
1196 * will set signal_pending again).
1197 */
1198 qatomic_set(&ts->signal_pending, 0);
1199 ts->in_sigsuspend = 0;
1200 set = ts->signal_mask;
1201 sigdelset(&set, SIGSEGV);
1202 sigdelset(&set, SIGBUS);
1203 sigprocmask(SIG_SETMASK, &set, 0);
1204 }
1205 ts->in_sigsuspend = 0;
1206 }