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