tmp105: Correct handling of temperature limit checks
[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
353 = host_to_target_waitstatus(info->si_status);
354 tinfo->_sifields._sigchld._utime = info->si_utime;
355 tinfo->_sifields._sigchld._stime = info->si_stime;
356 si_type = QEMU_SI_CHLD;
357 break;
358 case TARGET_SIGIO:
359 tinfo->_sifields._sigpoll._band = info->si_band;
360 tinfo->_sifields._sigpoll._fd = info->si_fd;
361 si_type = QEMU_SI_POLL;
362 break;
363 default:
364 /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
365 tinfo->_sifields._rt._pid = info->si_pid;
366 tinfo->_sifields._rt._uid = info->si_uid;
367 /* XXX: potential problem if 64 bit */
368 tinfo->_sifields._rt._sigval.sival_ptr
369 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
370 si_type = QEMU_SI_RT;
371 break;
372 }
373 break;
374 }
375
376 tinfo->si_code = deposit32(si_code, 16, 16, si_type);
377 }
378
379 void tswap_siginfo(target_siginfo_t *tinfo,
380 const target_siginfo_t *info)
381 {
382 int si_type = extract32(info->si_code, 16, 16);
383 int si_code = sextract32(info->si_code, 0, 16);
384
385 __put_user(info->si_signo, &tinfo->si_signo);
386 __put_user(info->si_errno, &tinfo->si_errno);
387 __put_user(si_code, &tinfo->si_code);
388
389 /* We can use our internal marker of which fields in the structure
390 * are valid, rather than duplicating the guesswork of
391 * host_to_target_siginfo_noswap() here.
392 */
393 switch (si_type) {
394 case QEMU_SI_KILL:
395 __put_user(info->_sifields._kill._pid, &tinfo->_sifields._kill._pid);
396 __put_user(info->_sifields._kill._uid, &tinfo->_sifields._kill._uid);
397 break;
398 case QEMU_SI_TIMER:
399 __put_user(info->_sifields._timer._timer1,
400 &tinfo->_sifields._timer._timer1);
401 __put_user(info->_sifields._timer._timer2,
402 &tinfo->_sifields._timer._timer2);
403 break;
404 case QEMU_SI_POLL:
405 __put_user(info->_sifields._sigpoll._band,
406 &tinfo->_sifields._sigpoll._band);
407 __put_user(info->_sifields._sigpoll._fd,
408 &tinfo->_sifields._sigpoll._fd);
409 break;
410 case QEMU_SI_FAULT:
411 __put_user(info->_sifields._sigfault._addr,
412 &tinfo->_sifields._sigfault._addr);
413 break;
414 case QEMU_SI_CHLD:
415 __put_user(info->_sifields._sigchld._pid,
416 &tinfo->_sifields._sigchld._pid);
417 __put_user(info->_sifields._sigchld._uid,
418 &tinfo->_sifields._sigchld._uid);
419 __put_user(info->_sifields._sigchld._status,
420 &tinfo->_sifields._sigchld._status);
421 __put_user(info->_sifields._sigchld._utime,
422 &tinfo->_sifields._sigchld._utime);
423 __put_user(info->_sifields._sigchld._stime,
424 &tinfo->_sifields._sigchld._stime);
425 break;
426 case QEMU_SI_RT:
427 __put_user(info->_sifields._rt._pid, &tinfo->_sifields._rt._pid);
428 __put_user(info->_sifields._rt._uid, &tinfo->_sifields._rt._uid);
429 __put_user(info->_sifields._rt._sigval.sival_ptr,
430 &tinfo->_sifields._rt._sigval.sival_ptr);
431 break;
432 default:
433 g_assert_not_reached();
434 }
435 }
436
437 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
438 {
439 target_siginfo_t tgt_tmp;
440 host_to_target_siginfo_noswap(&tgt_tmp, info);
441 tswap_siginfo(tinfo, &tgt_tmp);
442 }
443
444 /* XXX: we support only POSIX RT signals are used. */
445 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
446 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
447 {
448 /* This conversion is used only for the rt_sigqueueinfo syscall,
449 * and so we know that the _rt fields are the valid ones.
450 */
451 abi_ulong sival_ptr;
452
453 __get_user(info->si_signo, &tinfo->si_signo);
454 __get_user(info->si_errno, &tinfo->si_errno);
455 __get_user(info->si_code, &tinfo->si_code);
456 __get_user(info->si_pid, &tinfo->_sifields._rt._pid);
457 __get_user(info->si_uid, &tinfo->_sifields._rt._uid);
458 __get_user(sival_ptr, &tinfo->_sifields._rt._sigval.sival_ptr);
459 info->si_value.sival_ptr = (void *)(long)sival_ptr;
460 }
461
462 static int fatal_signal (int sig)
463 {
464 switch (sig) {
465 case TARGET_SIGCHLD:
466 case TARGET_SIGURG:
467 case TARGET_SIGWINCH:
468 /* Ignored by default. */
469 return 0;
470 case TARGET_SIGCONT:
471 case TARGET_SIGSTOP:
472 case TARGET_SIGTSTP:
473 case TARGET_SIGTTIN:
474 case TARGET_SIGTTOU:
475 /* Job control signals. */
476 return 0;
477 default:
478 return 1;
479 }
480 }
481
482 /* returns 1 if given signal should dump core if not handled */
483 static int core_dump_signal(int sig)
484 {
485 switch (sig) {
486 case TARGET_SIGABRT:
487 case TARGET_SIGFPE:
488 case TARGET_SIGILL:
489 case TARGET_SIGQUIT:
490 case TARGET_SIGSEGV:
491 case TARGET_SIGTRAP:
492 case TARGET_SIGBUS:
493 return (1);
494 default:
495 return (0);
496 }
497 }
498
499 static void signal_table_init(void)
500 {
501 int host_sig, target_sig, count;
502
503 /*
504 * Signals are supported starting from TARGET_SIGRTMIN and going up
505 * until we run out of host realtime signals.
506 * glibc at least uses only the lower 2 rt signals and probably
507 * nobody's using the upper ones.
508 * it's why SIGRTMIN (34) is generally greater than __SIGRTMIN (32)
509 * To fix this properly we need to do manual signal delivery multiplexed
510 * over a single host signal.
511 * Attempts for configure "missing" signals via sigaction will be
512 * silently ignored.
513 */
514 for (host_sig = SIGRTMIN; host_sig <= SIGRTMAX; host_sig++) {
515 target_sig = host_sig - SIGRTMIN + TARGET_SIGRTMIN;
516 if (target_sig <= TARGET_NSIG) {
517 host_to_target_signal_table[host_sig] = target_sig;
518 }
519 }
520
521 /* generate signal conversion tables */
522 for (target_sig = 1; target_sig <= TARGET_NSIG; target_sig++) {
523 target_to_host_signal_table[target_sig] = _NSIG; /* poison */
524 }
525 for (host_sig = 1; host_sig < _NSIG; host_sig++) {
526 if (host_to_target_signal_table[host_sig] == 0) {
527 host_to_target_signal_table[host_sig] = host_sig;
528 }
529 target_sig = host_to_target_signal_table[host_sig];
530 if (target_sig <= TARGET_NSIG) {
531 target_to_host_signal_table[target_sig] = host_sig;
532 }
533 }
534
535 if (trace_event_get_state_backends(TRACE_SIGNAL_TABLE_INIT)) {
536 for (target_sig = 1, count = 0; target_sig <= TARGET_NSIG; target_sig++) {
537 if (target_to_host_signal_table[target_sig] == _NSIG) {
538 count++;
539 }
540 }
541 trace_signal_table_init(count);
542 }
543 }
544
545 void signal_init(void)
546 {
547 TaskState *ts = (TaskState *)thread_cpu->opaque;
548 struct sigaction act;
549 struct sigaction oact;
550 int i;
551 int host_sig;
552
553 /* initialize signal conversion tables */
554 signal_table_init();
555
556 /* Set the signal mask from the host mask. */
557 sigprocmask(0, 0, &ts->signal_mask);
558
559 sigfillset(&act.sa_mask);
560 act.sa_flags = SA_SIGINFO;
561 act.sa_sigaction = host_signal_handler;
562 for(i = 1; i <= TARGET_NSIG; i++) {
563 #ifdef CONFIG_GPROF
564 if (i == TARGET_SIGPROF) {
565 continue;
566 }
567 #endif
568 host_sig = target_to_host_signal(i);
569 sigaction(host_sig, NULL, &oact);
570 if (oact.sa_sigaction == (void *)SIG_IGN) {
571 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
572 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
573 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
574 }
575 /* If there's already a handler installed then something has
576 gone horribly wrong, so don't even try to handle that case. */
577 /* Install some handlers for our own use. We need at least
578 SIGSEGV and SIGBUS, to detect exceptions. We can not just
579 trap all signals because it affects syscall interrupt
580 behavior. But do trap all default-fatal signals. */
581 if (fatal_signal (i))
582 sigaction(host_sig, &act, NULL);
583 }
584 }
585
586 /* Force a synchronously taken signal. The kernel force_sig() function
587 * also forces the signal to "not blocked, not ignored", but for QEMU
588 * that work is done in process_pending_signals().
589 */
590 void force_sig(int sig)
591 {
592 CPUState *cpu = thread_cpu;
593 CPUArchState *env = cpu->env_ptr;
594 target_siginfo_t info;
595
596 info.si_signo = sig;
597 info.si_errno = 0;
598 info.si_code = TARGET_SI_KERNEL;
599 info._sifields._kill._pid = 0;
600 info._sifields._kill._uid = 0;
601 queue_signal(env, info.si_signo, QEMU_SI_KILL, &info);
602 }
603
604 /* Force a SIGSEGV if we couldn't write to memory trying to set
605 * up the signal frame. oldsig is the signal we were trying to handle
606 * at the point of failure.
607 */
608 #if !defined(TARGET_RISCV)
609 void force_sigsegv(int oldsig)
610 {
611 if (oldsig == SIGSEGV) {
612 /* Make sure we don't try to deliver the signal again; this will
613 * end up with handle_pending_signal() calling dump_core_and_abort().
614 */
615 sigact_table[oldsig - 1]._sa_handler = TARGET_SIG_DFL;
616 }
617 force_sig(TARGET_SIGSEGV);
618 }
619
620 #endif
621
622 /* abort execution with signal */
623 static void QEMU_NORETURN dump_core_and_abort(int target_sig)
624 {
625 CPUState *cpu = thread_cpu;
626 CPUArchState *env = cpu->env_ptr;
627 TaskState *ts = (TaskState *)cpu->opaque;
628 int host_sig, core_dumped = 0;
629 struct sigaction act;
630
631 host_sig = target_to_host_signal(target_sig);
632 trace_user_force_sig(env, target_sig, host_sig);
633 gdb_signalled(env, target_sig);
634
635 /* dump core if supported by target binary format */
636 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
637 stop_all_tasks();
638 core_dumped =
639 ((*ts->bprm->core_dump)(target_sig, env) == 0);
640 }
641 if (core_dumped) {
642 /* we already dumped the core of target process, we don't want
643 * a coredump of qemu itself */
644 struct rlimit nodump;
645 getrlimit(RLIMIT_CORE, &nodump);
646 nodump.rlim_cur=0;
647 setrlimit(RLIMIT_CORE, &nodump);
648 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
649 target_sig, strsignal(host_sig), "core dumped" );
650 }
651
652 /* The proper exit code for dying from an uncaught signal is
653 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
654 * a negative value. To get the proper exit code we need to
655 * actually die from an uncaught signal. Here the default signal
656 * handler is installed, we send ourself a signal and we wait for
657 * it to arrive. */
658 sigfillset(&act.sa_mask);
659 act.sa_handler = SIG_DFL;
660 act.sa_flags = 0;
661 sigaction(host_sig, &act, NULL);
662
663 /* For some reason raise(host_sig) doesn't send the signal when
664 * statically linked on x86-64. */
665 kill(getpid(), host_sig);
666
667 /* Make sure the signal isn't masked (just reuse the mask inside
668 of act) */
669 sigdelset(&act.sa_mask, host_sig);
670 sigsuspend(&act.sa_mask);
671
672 /* unreachable */
673 abort();
674 }
675
676 /* queue a signal so that it will be send to the virtual CPU as soon
677 as possible */
678 int queue_signal(CPUArchState *env, int sig, int si_type,
679 target_siginfo_t *info)
680 {
681 CPUState *cpu = env_cpu(env);
682 TaskState *ts = cpu->opaque;
683
684 trace_user_queue_signal(env, sig);
685
686 info->si_code = deposit32(info->si_code, 16, 16, si_type);
687
688 ts->sync_signal.info = *info;
689 ts->sync_signal.pending = sig;
690 /* signal that a new signal is pending */
691 qatomic_set(&ts->signal_pending, 1);
692 return 1; /* indicates that the signal was queued */
693 }
694
695 #ifndef HAVE_SAFE_SYSCALL
696 static inline void rewind_if_in_safe_syscall(void *puc)
697 {
698 /* Default version: never rewind */
699 }
700 #endif
701
702 static void host_signal_handler(int host_signum, siginfo_t *info,
703 void *puc)
704 {
705 CPUArchState *env = thread_cpu->env_ptr;
706 CPUState *cpu = env_cpu(env);
707 TaskState *ts = cpu->opaque;
708
709 int sig;
710 target_siginfo_t tinfo;
711 ucontext_t *uc = puc;
712 struct emulated_sigtable *k;
713
714 /* the CPU emulator uses some host signals to detect exceptions,
715 we forward to it some signals */
716 if ((host_signum == SIGSEGV || host_signum == SIGBUS)
717 && info->si_code > 0) {
718 if (cpu_signal_handler(host_signum, info, puc))
719 return;
720 }
721
722 /* get target signal number */
723 sig = host_to_target_signal(host_signum);
724 if (sig < 1 || sig > TARGET_NSIG)
725 return;
726 trace_user_host_signal(env, host_signum, sig);
727
728 rewind_if_in_safe_syscall(puc);
729
730 host_to_target_siginfo_noswap(&tinfo, info);
731 k = &ts->sigtab[sig - 1];
732 k->info = tinfo;
733 k->pending = sig;
734 ts->signal_pending = 1;
735
736 /* Block host signals until target signal handler entered. We
737 * can't block SIGSEGV or SIGBUS while we're executing guest
738 * code in case the guest code provokes one in the window between
739 * now and it getting out to the main loop. Signals will be
740 * unblocked again in process_pending_signals().
741 *
742 * WARNING: we cannot use sigfillset() here because the uc_sigmask
743 * field is a kernel sigset_t, which is much smaller than the
744 * libc sigset_t which sigfillset() operates on. Using sigfillset()
745 * would write 0xff bytes off the end of the structure and trash
746 * data on the struct.
747 * We can't use sizeof(uc->uc_sigmask) either, because the libc
748 * headers define the struct field with the wrong (too large) type.
749 */
750 memset(&uc->uc_sigmask, 0xff, SIGSET_T_SIZE);
751 sigdelset(&uc->uc_sigmask, SIGSEGV);
752 sigdelset(&uc->uc_sigmask, SIGBUS);
753
754 /* interrupt the virtual CPU as soon as possible */
755 cpu_exit(thread_cpu);
756 }
757
758 /* do_sigaltstack() returns target values and errnos. */
759 /* compare linux/kernel/signal.c:do_sigaltstack() */
760 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
761 {
762 int ret;
763 struct target_sigaltstack oss;
764 TaskState *ts = (TaskState *)thread_cpu->opaque;
765
766 /* XXX: test errors */
767 if(uoss_addr)
768 {
769 __put_user(ts->sigaltstack_used.ss_sp, &oss.ss_sp);
770 __put_user(ts->sigaltstack_used.ss_size, &oss.ss_size);
771 __put_user(sas_ss_flags(sp), &oss.ss_flags);
772 }
773
774 if(uss_addr)
775 {
776 struct target_sigaltstack *uss;
777 struct target_sigaltstack ss;
778 size_t minstacksize = TARGET_MINSIGSTKSZ;
779
780 #if defined(TARGET_PPC64)
781 /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */
782 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
783 if (get_ppc64_abi(image) > 1) {
784 minstacksize = 4096;
785 }
786 #endif
787
788 ret = -TARGET_EFAULT;
789 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) {
790 goto out;
791 }
792 __get_user(ss.ss_sp, &uss->ss_sp);
793 __get_user(ss.ss_size, &uss->ss_size);
794 __get_user(ss.ss_flags, &uss->ss_flags);
795 unlock_user_struct(uss, uss_addr, 0);
796
797 ret = -TARGET_EPERM;
798 if (on_sig_stack(sp))
799 goto out;
800
801 ret = -TARGET_EINVAL;
802 if (ss.ss_flags != TARGET_SS_DISABLE
803 && ss.ss_flags != TARGET_SS_ONSTACK
804 && ss.ss_flags != 0)
805 goto out;
806
807 if (ss.ss_flags == TARGET_SS_DISABLE) {
808 ss.ss_size = 0;
809 ss.ss_sp = 0;
810 } else {
811 ret = -TARGET_ENOMEM;
812 if (ss.ss_size < minstacksize) {
813 goto out;
814 }
815 }
816
817 ts->sigaltstack_used.ss_sp = ss.ss_sp;
818 ts->sigaltstack_used.ss_size = ss.ss_size;
819 }
820
821 if (uoss_addr) {
822 ret = -TARGET_EFAULT;
823 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
824 goto out;
825 }
826
827 ret = 0;
828 out:
829 return ret;
830 }
831
832 /* do_sigaction() return target values and host errnos */
833 int do_sigaction(int sig, const struct target_sigaction *act,
834 struct target_sigaction *oact)
835 {
836 struct target_sigaction *k;
837 struct sigaction act1;
838 int host_sig;
839 int ret = 0;
840
841 trace_signal_do_sigaction_guest(sig, TARGET_NSIG);
842
843 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) {
844 return -TARGET_EINVAL;
845 }
846
847 if (block_signals()) {
848 return -TARGET_ERESTARTSYS;
849 }
850
851 k = &sigact_table[sig - 1];
852 if (oact) {
853 __put_user(k->_sa_handler, &oact->_sa_handler);
854 __put_user(k->sa_flags, &oact->sa_flags);
855 #ifdef TARGET_ARCH_HAS_SA_RESTORER
856 __put_user(k->sa_restorer, &oact->sa_restorer);
857 #endif
858 /* Not swapped. */
859 oact->sa_mask = k->sa_mask;
860 }
861 if (act) {
862 /* FIXME: This is not threadsafe. */
863 __get_user(k->_sa_handler, &act->_sa_handler);
864 __get_user(k->sa_flags, &act->sa_flags);
865 #ifdef TARGET_ARCH_HAS_SA_RESTORER
866 __get_user(k->sa_restorer, &act->sa_restorer);
867 #endif
868 /* To be swapped in target_to_host_sigset. */
869 k->sa_mask = act->sa_mask;
870
871 /* we update the host linux signal state */
872 host_sig = target_to_host_signal(sig);
873 trace_signal_do_sigaction_host(host_sig, TARGET_NSIG);
874 if (host_sig > SIGRTMAX) {
875 /* we don't have enough host signals to map all target signals */
876 qemu_log_mask(LOG_UNIMP, "Unsupported target signal #%d, ignored\n",
877 sig);
878 /*
879 * we don't return an error here because some programs try to
880 * register an handler for all possible rt signals even if they
881 * don't need it.
882 * An error here can abort them whereas there can be no problem
883 * to not have the signal available later.
884 * This is the case for golang,
885 * See https://github.com/golang/go/issues/33746
886 * So we silently ignore the error.
887 */
888 return 0;
889 }
890 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
891 sigfillset(&act1.sa_mask);
892 act1.sa_flags = SA_SIGINFO;
893 if (k->sa_flags & TARGET_SA_RESTART)
894 act1.sa_flags |= SA_RESTART;
895 /* NOTE: it is important to update the host kernel signal
896 ignore state to avoid getting unexpected interrupted
897 syscalls */
898 if (k->_sa_handler == TARGET_SIG_IGN) {
899 act1.sa_sigaction = (void *)SIG_IGN;
900 } else if (k->_sa_handler == TARGET_SIG_DFL) {
901 if (fatal_signal (sig))
902 act1.sa_sigaction = host_signal_handler;
903 else
904 act1.sa_sigaction = (void *)SIG_DFL;
905 } else {
906 act1.sa_sigaction = host_signal_handler;
907 }
908 ret = sigaction(host_sig, &act1, NULL);
909 }
910 }
911 return ret;
912 }
913
914 static void handle_pending_signal(CPUArchState *cpu_env, int sig,
915 struct emulated_sigtable *k)
916 {
917 CPUState *cpu = env_cpu(cpu_env);
918 abi_ulong handler;
919 sigset_t set;
920 target_sigset_t target_old_set;
921 struct target_sigaction *sa;
922 TaskState *ts = cpu->opaque;
923
924 trace_user_handle_signal(cpu_env, sig);
925 /* dequeue signal */
926 k->pending = 0;
927
928 sig = gdb_handlesig(cpu, sig);
929 if (!sig) {
930 sa = NULL;
931 handler = TARGET_SIG_IGN;
932 } else {
933 sa = &sigact_table[sig - 1];
934 handler = sa->_sa_handler;
935 }
936
937 if (unlikely(qemu_loglevel_mask(LOG_STRACE))) {
938 print_taken_signal(sig, &k->info);
939 }
940
941 if (handler == TARGET_SIG_DFL) {
942 /* default handler : ignore some signal. The other are job control or fatal */
943 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
944 kill(getpid(),SIGSTOP);
945 } else if (sig != TARGET_SIGCHLD &&
946 sig != TARGET_SIGURG &&
947 sig != TARGET_SIGWINCH &&
948 sig != TARGET_SIGCONT) {
949 dump_core_and_abort(sig);
950 }
951 } else if (handler == TARGET_SIG_IGN) {
952 /* ignore sig */
953 } else if (handler == TARGET_SIG_ERR) {
954 dump_core_and_abort(sig);
955 } else {
956 /* compute the blocked signals during the handler execution */
957 sigset_t *blocked_set;
958
959 target_to_host_sigset(&set, &sa->sa_mask);
960 /* SA_NODEFER indicates that the current signal should not be
961 blocked during the handler */
962 if (!(sa->sa_flags & TARGET_SA_NODEFER))
963 sigaddset(&set, target_to_host_signal(sig));
964
965 /* save the previous blocked signal state to restore it at the
966 end of the signal execution (see do_sigreturn) */
967 host_to_target_sigset_internal(&target_old_set, &ts->signal_mask);
968
969 /* block signals in the handler */
970 blocked_set = ts->in_sigsuspend ?
971 &ts->sigsuspend_mask : &ts->signal_mask;
972 sigorset(&ts->signal_mask, blocked_set, &set);
973 ts->in_sigsuspend = 0;
974
975 /* if the CPU is in VM86 mode, we restore the 32 bit values */
976 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
977 {
978 CPUX86State *env = cpu_env;
979 if (env->eflags & VM_MASK)
980 save_v86_state(env);
981 }
982 #endif
983 /* prepare the stack frame of the virtual CPU */
984 #if defined(TARGET_ARCH_HAS_SETUP_FRAME)
985 if (sa->sa_flags & TARGET_SA_SIGINFO) {
986 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
987 } else {
988 setup_frame(sig, sa, &target_old_set, cpu_env);
989 }
990 #else
991 /* These targets do not have traditional signals. */
992 setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
993 #endif
994 if (sa->sa_flags & TARGET_SA_RESETHAND) {
995 sa->_sa_handler = TARGET_SIG_DFL;
996 }
997 }
998 }
999
1000 void process_pending_signals(CPUArchState *cpu_env)
1001 {
1002 CPUState *cpu = env_cpu(cpu_env);
1003 int sig;
1004 TaskState *ts = cpu->opaque;
1005 sigset_t set;
1006 sigset_t *blocked_set;
1007
1008 while (qatomic_read(&ts->signal_pending)) {
1009 /* FIXME: This is not threadsafe. */
1010 sigfillset(&set);
1011 sigprocmask(SIG_SETMASK, &set, 0);
1012
1013 restart_scan:
1014 sig = ts->sync_signal.pending;
1015 if (sig) {
1016 /* Synchronous signals are forced,
1017 * see force_sig_info() and callers in Linux
1018 * Note that not all of our queue_signal() calls in QEMU correspond
1019 * to force_sig_info() calls in Linux (some are send_sig_info()).
1020 * However it seems like a kernel bug to me to allow the process
1021 * to block a synchronous signal since it could then just end up
1022 * looping round and round indefinitely.
1023 */
1024 if (sigismember(&ts->signal_mask, target_to_host_signal_table[sig])
1025 || sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) {
1026 sigdelset(&ts->signal_mask, target_to_host_signal_table[sig]);
1027 sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL;
1028 }
1029
1030 handle_pending_signal(cpu_env, sig, &ts->sync_signal);
1031 }
1032
1033 for (sig = 1; sig <= TARGET_NSIG; sig++) {
1034 blocked_set = ts->in_sigsuspend ?
1035 &ts->sigsuspend_mask : &ts->signal_mask;
1036
1037 if (ts->sigtab[sig - 1].pending &&
1038 (!sigismember(blocked_set,
1039 target_to_host_signal_table[sig]))) {
1040 handle_pending_signal(cpu_env, sig, &ts->sigtab[sig - 1]);
1041 /* Restart scan from the beginning, as handle_pending_signal
1042 * might have resulted in a new synchronous signal (eg SIGSEGV).
1043 */
1044 goto restart_scan;
1045 }
1046 }
1047
1048 /* if no signal is pending, unblock signals and recheck (the act
1049 * of unblocking might cause us to take another host signal which
1050 * will set signal_pending again).
1051 */
1052 qatomic_set(&ts->signal_pending, 0);
1053 ts->in_sigsuspend = 0;
1054 set = ts->signal_mask;
1055 sigdelset(&set, SIGSEGV);
1056 sigdelset(&set, SIGBUS);
1057 sigprocmask(SIG_SETMASK, &set, 0);
1058 }
1059 ts->in_sigsuspend = 0;
1060 }