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