2 * Emulation of Linux signals
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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/>.
19 #include "qemu/osdep.h"
21 #include "user-internals.h"
22 #include "signal-common.h"
23 #include "linux-user/trace.h"
25 /* from the Linux kernel - /arch/x86/include/uapi/asm/sigcontext.h */
28 uint16_t significand
[4];
32 struct target_fpxreg
{
33 uint16_t significand
[4];
38 struct target_xmmreg
{
42 struct target_fpstate_32
{
43 /* Regular FPU environment */
51 struct target_fpreg st
[8];
53 uint16_t magic
; /* 0xffff = regular FPU data only */
55 /* FXSR FPU environment */
56 uint32_t _fxsr_env
[6]; /* FXSR FPU env is ignored */
59 struct target_fpxreg fxsr_st
[8]; /* FXSR FPU reg data is ignored */
60 struct target_xmmreg xmm
[8];
64 struct target_fpstate_64
{
74 uint32_t st_space
[32];
75 uint32_t xmm_space
[64];
76 uint32_t reserved
[24];
80 # define target_fpstate target_fpstate_32
82 # define target_fpstate target_fpstate_64
85 struct target_sigcontext_32
{
103 uint32_t esp_at_signal
;
105 uint32_t fpstate
; /* pointer */
110 struct target_sigcontext_64
{
142 uint64_t fpstate
; /* pointer */
146 #ifndef TARGET_X86_64
147 # define target_sigcontext target_sigcontext_32
149 # define target_sigcontext target_sigcontext_64
152 /* see Linux/include/uapi/asm-generic/ucontext.h */
153 struct target_ucontext
{
156 target_stack_t tuc_stack
;
157 struct target_sigcontext tuc_mcontext
;
158 target_sigset_t tuc_sigmask
; /* mask last for extensibility */
161 #ifndef TARGET_X86_64
165 struct target_sigcontext sc
;
166 struct target_fpstate fpstate
;
167 abi_ulong extramask
[TARGET_NSIG_WORDS
-1];
176 struct target_siginfo info
;
177 struct target_ucontext uc
;
178 struct target_fpstate fpstate
;
186 struct target_ucontext uc
;
187 struct target_siginfo info
;
188 struct target_fpstate fpstate
;
194 * Set up a signal frame.
197 /* XXX: save x87 state */
198 static void setup_sigcontext(struct target_sigcontext
*sc
,
199 struct target_fpstate
*fpstate
, CPUX86State
*env
, abi_ulong mask
,
200 abi_ulong fpstate_addr
)
202 CPUState
*cs
= env_cpu(env
);
203 #ifndef TARGET_X86_64
206 /* already locked in setup_frame() */
207 __put_user(env
->segs
[R_GS
].selector
, (unsigned int *)&sc
->gs
);
208 __put_user(env
->segs
[R_FS
].selector
, (unsigned int *)&sc
->fs
);
209 __put_user(env
->segs
[R_ES
].selector
, (unsigned int *)&sc
->es
);
210 __put_user(env
->segs
[R_DS
].selector
, (unsigned int *)&sc
->ds
);
211 __put_user(env
->regs
[R_EDI
], &sc
->edi
);
212 __put_user(env
->regs
[R_ESI
], &sc
->esi
);
213 __put_user(env
->regs
[R_EBP
], &sc
->ebp
);
214 __put_user(env
->regs
[R_ESP
], &sc
->esp
);
215 __put_user(env
->regs
[R_EBX
], &sc
->ebx
);
216 __put_user(env
->regs
[R_EDX
], &sc
->edx
);
217 __put_user(env
->regs
[R_ECX
], &sc
->ecx
);
218 __put_user(env
->regs
[R_EAX
], &sc
->eax
);
219 __put_user(cs
->exception_index
, &sc
->trapno
);
220 __put_user(env
->error_code
, &sc
->err
);
221 __put_user(env
->eip
, &sc
->eip
);
222 __put_user(env
->segs
[R_CS
].selector
, (unsigned int *)&sc
->cs
);
223 __put_user(env
->eflags
, &sc
->eflags
);
224 __put_user(env
->regs
[R_ESP
], &sc
->esp_at_signal
);
225 __put_user(env
->segs
[R_SS
].selector
, (unsigned int *)&sc
->ss
);
227 cpu_x86_fsave(env
, fpstate_addr
, 1);
228 fpstate
->status
= fpstate
->sw
;
230 __put_user(magic
, &fpstate
->magic
);
231 __put_user(fpstate_addr
, &sc
->fpstate
);
233 /* non-iBCS2 extensions.. */
234 __put_user(mask
, &sc
->oldmask
);
235 __put_user(env
->cr
[2], &sc
->cr2
);
237 __put_user(env
->regs
[R_EDI
], &sc
->rdi
);
238 __put_user(env
->regs
[R_ESI
], &sc
->rsi
);
239 __put_user(env
->regs
[R_EBP
], &sc
->rbp
);
240 __put_user(env
->regs
[R_ESP
], &sc
->rsp
);
241 __put_user(env
->regs
[R_EBX
], &sc
->rbx
);
242 __put_user(env
->regs
[R_EDX
], &sc
->rdx
);
243 __put_user(env
->regs
[R_ECX
], &sc
->rcx
);
244 __put_user(env
->regs
[R_EAX
], &sc
->rax
);
246 __put_user(env
->regs
[8], &sc
->r8
);
247 __put_user(env
->regs
[9], &sc
->r9
);
248 __put_user(env
->regs
[10], &sc
->r10
);
249 __put_user(env
->regs
[11], &sc
->r11
);
250 __put_user(env
->regs
[12], &sc
->r12
);
251 __put_user(env
->regs
[13], &sc
->r13
);
252 __put_user(env
->regs
[14], &sc
->r14
);
253 __put_user(env
->regs
[15], &sc
->r15
);
255 __put_user(cs
->exception_index
, &sc
->trapno
);
256 __put_user(env
->error_code
, &sc
->err
);
257 __put_user(env
->eip
, &sc
->rip
);
259 __put_user(env
->eflags
, &sc
->eflags
);
260 __put_user(env
->segs
[R_CS
].selector
, &sc
->cs
);
261 __put_user((uint16_t)0, &sc
->gs
);
262 __put_user((uint16_t)0, &sc
->fs
);
263 __put_user(env
->segs
[R_SS
].selector
, &sc
->ss
);
265 __put_user(mask
, &sc
->oldmask
);
266 __put_user(env
->cr
[2], &sc
->cr2
);
268 /* fpstate_addr must be 16 byte aligned for fxsave */
269 assert(!(fpstate_addr
& 0xf));
271 cpu_x86_fxsave(env
, fpstate_addr
);
272 __put_user(fpstate_addr
, &sc
->fpstate
);
277 * Determine which stack to use..
280 static inline abi_ulong
281 get_sigframe(struct target_sigaction
*ka
, CPUX86State
*env
, size_t frame_size
)
285 /* Default to using normal stack */
286 esp
= get_sp_from_cpustate(env
);
288 esp
-= 128; /* this is the redzone */
291 /* This is the X/Open sanctioned signal stack switching. */
292 if (ka
->sa_flags
& TARGET_SA_ONSTACK
) {
293 esp
= target_sigsp(esp
, ka
);
295 #ifndef TARGET_X86_64
296 /* This is the legacy signal stack switching. */
297 if ((env
->segs
[R_SS
].selector
& 0xffff) != __USER_DS
&&
298 !(ka
->sa_flags
& TARGET_SA_RESTORER
) &&
300 esp
= (unsigned long) ka
->sa_restorer
;
305 #ifndef TARGET_X86_64
306 return (esp
- frame_size
) & -8ul;
308 return ((esp
- frame_size
) & (~15ul)) - 8;
312 #ifndef TARGET_X86_64
313 static void install_sigtramp(void *tramp
)
315 /* This is popl %eax ; movl $syscall,%eax ; int $0x80 */
316 __put_user(0xb858, (uint16_t *)(tramp
+ 0));
317 __put_user(TARGET_NR_sigreturn
, (int32_t *)(tramp
+ 2));
318 __put_user(0x80cd, (uint16_t *)(tramp
+ 6));
321 static void install_rt_sigtramp(void *tramp
)
323 /* This is movl $syscall,%eax ; int $0x80 */
324 __put_user(0xb8, (uint8_t *)(tramp
+ 0));
325 __put_user(TARGET_NR_rt_sigreturn
, (int32_t *)(tramp
+ 1));
326 __put_user(0x80cd, (uint16_t *)(tramp
+ 5));
329 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
330 void setup_frame(int sig
, struct target_sigaction
*ka
,
331 target_sigset_t
*set
, CPUX86State
*env
)
333 abi_ulong frame_addr
;
334 struct sigframe
*frame
;
337 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
338 trace_user_setup_frame(env
, frame_addr
);
340 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
343 __put_user(sig
, &frame
->sig
);
345 setup_sigcontext(&frame
->sc
, &frame
->fpstate
, env
, set
->sig
[0],
346 frame_addr
+ offsetof(struct sigframe
, fpstate
));
348 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
349 __put_user(set
->sig
[i
], &frame
->extramask
[i
- 1]);
352 /* Set up to return from userspace. If provided, use a stub
353 already in userspace. */
354 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
355 __put_user(ka
->sa_restorer
, &frame
->pretcode
);
357 /* This is no longer used, but is retained for ABI compatibility. */
358 install_sigtramp(frame
->retcode
);
359 __put_user(default_sigreturn
, &frame
->pretcode
);
362 /* Set up registers for signal handler */
363 env
->regs
[R_ESP
] = frame_addr
;
364 env
->eip
= ka
->_sa_handler
;
366 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
367 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
368 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
369 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
370 env
->eflags
&= ~TF_MASK
;
372 unlock_user_struct(frame
, frame_addr
, 1);
381 /* compare linux/arch/x86/kernel/signal.c:setup_rt_frame() */
382 void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
383 target_siginfo_t
*info
,
384 target_sigset_t
*set
, CPUX86State
*env
)
386 abi_ulong frame_addr
;
387 #ifndef TARGET_X86_64
390 struct rt_sigframe
*frame
;
393 frame_addr
= get_sigframe(ka
, env
, sizeof(*frame
));
394 trace_user_setup_rt_frame(env
, frame_addr
);
396 if (!lock_user_struct(VERIFY_WRITE
, frame
, frame_addr
, 0))
399 /* These fields are only in rt_sigframe on 32 bit */
400 #ifndef TARGET_X86_64
401 __put_user(sig
, &frame
->sig
);
402 addr
= frame_addr
+ offsetof(struct rt_sigframe
, info
);
403 __put_user(addr
, &frame
->pinfo
);
404 addr
= frame_addr
+ offsetof(struct rt_sigframe
, uc
);
405 __put_user(addr
, &frame
->puc
);
407 if (ka
->sa_flags
& TARGET_SA_SIGINFO
) {
408 tswap_siginfo(&frame
->info
, info
);
411 /* Create the ucontext. */
412 __put_user(0, &frame
->uc
.tuc_flags
);
413 __put_user(0, &frame
->uc
.tuc_link
);
414 target_save_altstack(&frame
->uc
.tuc_stack
, env
);
415 setup_sigcontext(&frame
->uc
.tuc_mcontext
, &frame
->fpstate
, env
,
416 set
->sig
[0], frame_addr
+ offsetof(struct rt_sigframe
, fpstate
));
418 for(i
= 0; i
< TARGET_NSIG_WORDS
; i
++) {
419 __put_user(set
->sig
[i
], &frame
->uc
.tuc_sigmask
.sig
[i
]);
422 /* Set up to return from userspace. If provided, use a stub
423 already in userspace. */
424 if (ka
->sa_flags
& TARGET_SA_RESTORER
) {
425 __put_user(ka
->sa_restorer
, &frame
->pretcode
);
428 /* For x86_64, SA_RESTORER is required ABI. */
431 /* This is no longer used, but is retained for ABI compatibility. */
432 install_rt_sigtramp(frame
->retcode
);
433 __put_user(default_rt_sigreturn
, &frame
->pretcode
);
437 /* Set up registers for signal handler */
438 env
->regs
[R_ESP
] = frame_addr
;
439 env
->eip
= ka
->_sa_handler
;
441 #ifndef TARGET_X86_64
442 env
->regs
[R_EAX
] = sig
;
443 env
->regs
[R_EDX
] = frame_addr
+ offsetof(struct rt_sigframe
, info
);
444 env
->regs
[R_ECX
] = frame_addr
+ offsetof(struct rt_sigframe
, uc
);
446 env
->regs
[R_EAX
] = 0;
447 env
->regs
[R_EDI
] = sig
;
448 env
->regs
[R_ESI
] = frame_addr
+ offsetof(struct rt_sigframe
, info
);
449 env
->regs
[R_EDX
] = frame_addr
+ offsetof(struct rt_sigframe
, uc
);
452 cpu_x86_load_seg(env
, R_DS
, __USER_DS
);
453 cpu_x86_load_seg(env
, R_ES
, __USER_DS
);
454 cpu_x86_load_seg(env
, R_CS
, __USER_CS
);
455 cpu_x86_load_seg(env
, R_SS
, __USER_DS
);
456 env
->eflags
&= ~TF_MASK
;
458 unlock_user_struct(frame
, frame_addr
, 1);
467 restore_sigcontext(CPUX86State
*env
, struct target_sigcontext
*sc
)
469 unsigned int err
= 0;
470 abi_ulong fpstate_addr
;
471 unsigned int tmpflags
;
473 #ifndef TARGET_X86_64
474 cpu_x86_load_seg(env
, R_GS
, tswap16(sc
->gs
));
475 cpu_x86_load_seg(env
, R_FS
, tswap16(sc
->fs
));
476 cpu_x86_load_seg(env
, R_ES
, tswap16(sc
->es
));
477 cpu_x86_load_seg(env
, R_DS
, tswap16(sc
->ds
));
479 env
->regs
[R_EDI
] = tswapl(sc
->edi
);
480 env
->regs
[R_ESI
] = tswapl(sc
->esi
);
481 env
->regs
[R_EBP
] = tswapl(sc
->ebp
);
482 env
->regs
[R_ESP
] = tswapl(sc
->esp
);
483 env
->regs
[R_EBX
] = tswapl(sc
->ebx
);
484 env
->regs
[R_EDX
] = tswapl(sc
->edx
);
485 env
->regs
[R_ECX
] = tswapl(sc
->ecx
);
486 env
->regs
[R_EAX
] = tswapl(sc
->eax
);
488 env
->eip
= tswapl(sc
->eip
);
490 env
->regs
[8] = tswapl(sc
->r8
);
491 env
->regs
[9] = tswapl(sc
->r9
);
492 env
->regs
[10] = tswapl(sc
->r10
);
493 env
->regs
[11] = tswapl(sc
->r11
);
494 env
->regs
[12] = tswapl(sc
->r12
);
495 env
->regs
[13] = tswapl(sc
->r13
);
496 env
->regs
[14] = tswapl(sc
->r14
);
497 env
->regs
[15] = tswapl(sc
->r15
);
499 env
->regs
[R_EDI
] = tswapl(sc
->rdi
);
500 env
->regs
[R_ESI
] = tswapl(sc
->rsi
);
501 env
->regs
[R_EBP
] = tswapl(sc
->rbp
);
502 env
->regs
[R_EBX
] = tswapl(sc
->rbx
);
503 env
->regs
[R_EDX
] = tswapl(sc
->rdx
);
504 env
->regs
[R_EAX
] = tswapl(sc
->rax
);
505 env
->regs
[R_ECX
] = tswapl(sc
->rcx
);
506 env
->regs
[R_ESP
] = tswapl(sc
->rsp
);
508 env
->eip
= tswapl(sc
->rip
);
511 cpu_x86_load_seg(env
, R_CS
, lduw_p(&sc
->cs
) | 3);
512 cpu_x86_load_seg(env
, R_SS
, lduw_p(&sc
->ss
) | 3);
514 tmpflags
= tswapl(sc
->eflags
);
515 env
->eflags
= (env
->eflags
& ~0x40DD5) | (tmpflags
& 0x40DD5);
516 // regs->orig_eax = -1; /* disable syscall checks */
518 fpstate_addr
= tswapl(sc
->fpstate
);
519 if (fpstate_addr
!= 0) {
520 if (!access_ok(env_cpu(env
), VERIFY_READ
, fpstate_addr
,
521 sizeof(struct target_fpstate
))) {
524 #ifndef TARGET_X86_64
525 cpu_x86_frstor(env
, fpstate_addr
, 1);
527 cpu_x86_fxrstor(env
, fpstate_addr
);
536 /* Note: there is no sigreturn on x86_64, there is only rt_sigreturn */
537 #ifndef TARGET_X86_64
538 long do_sigreturn(CPUX86State
*env
)
540 struct sigframe
*frame
;
541 abi_ulong frame_addr
= env
->regs
[R_ESP
] - 8;
542 target_sigset_t target_set
;
546 trace_user_do_sigreturn(env
, frame_addr
);
547 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
549 /* set blocked signals */
550 __get_user(target_set
.sig
[0], &frame
->sc
.oldmask
);
551 for(i
= 1; i
< TARGET_NSIG_WORDS
; i
++) {
552 __get_user(target_set
.sig
[i
], &frame
->extramask
[i
- 1]);
555 target_to_host_sigset_internal(&set
, &target_set
);
558 /* restore registers */
559 if (restore_sigcontext(env
, &frame
->sc
))
561 unlock_user_struct(frame
, frame_addr
, 0);
562 return -QEMU_ESIGRETURN
;
565 unlock_user_struct(frame
, frame_addr
, 0);
566 force_sig(TARGET_SIGSEGV
);
567 return -QEMU_ESIGRETURN
;
571 long do_rt_sigreturn(CPUX86State
*env
)
573 abi_ulong frame_addr
;
574 struct rt_sigframe
*frame
;
577 frame_addr
= env
->regs
[R_ESP
] - sizeof(abi_ulong
);
578 trace_user_do_rt_sigreturn(env
, frame_addr
);
579 if (!lock_user_struct(VERIFY_READ
, frame
, frame_addr
, 1))
581 target_to_host_sigset(&set
, &frame
->uc
.tuc_sigmask
);
584 if (restore_sigcontext(env
, &frame
->uc
.tuc_mcontext
)) {
588 target_restore_altstack(&frame
->uc
.tuc_stack
, env
);
590 unlock_user_struct(frame
, frame_addr
, 0);
591 return -QEMU_ESIGRETURN
;
594 unlock_user_struct(frame
, frame_addr
, 0);
595 force_sig(TARGET_SIGSEGV
);
596 return -QEMU_ESIGRETURN
;
599 #ifndef TARGET_X86_64
600 void setup_sigtramp(abi_ulong sigtramp_page
)
602 uint16_t *tramp
= lock_user(VERIFY_WRITE
, sigtramp_page
, 2 * 8, 0);
603 assert(tramp
!= NULL
);
605 default_sigreturn
= sigtramp_page
;
606 install_sigtramp(tramp
);
608 default_rt_sigreturn
= sigtramp_page
+ 8;
609 install_rt_sigtramp(tramp
+ 8);
611 unlock_user(tramp
, sigtramp_page
, 2 * 8);