Revision 60e99246 linux-user/signal.c
b/linux-user/signal.c | ||
---|---|---|
2052 | 2052 |
} target_mcontext_t; |
2053 | 2053 |
|
2054 | 2054 |
struct target_ucontext { |
2055 |
struct target_ucontext *uc_link; |
|
2056 |
abi_ulong uc_flags; |
|
2057 |
target_sigset_t uc_sigmask; |
|
2058 |
target_mcontext_t uc_mcontext; |
|
2055 |
struct target_ucontext *tuc_link;
|
|
2056 |
abi_ulong tuc_flags;
|
|
2057 |
target_sigset_t tuc_sigmask;
|
|
2058 |
target_mcontext_t tuc_mcontext;
|
|
2059 | 2059 |
}; |
2060 | 2060 |
|
2061 | 2061 |
/* A V9 register window */ |
... | ... | |
2081 | 2081 |
ucp_addr = env->regwptr[UREG_I0]; |
2082 | 2082 |
if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) |
2083 | 2083 |
goto do_sigsegv; |
2084 |
grp = &ucp->uc_mcontext.mc_gregs; |
|
2084 |
grp = &ucp->tuc_mcontext.mc_gregs;
|
|
2085 | 2085 |
err = __get_user(pc, &((*grp)[MC_PC])); |
2086 | 2086 |
err |= __get_user(npc, &((*grp)[MC_NPC])); |
2087 | 2087 |
if (err || ((pc | npc) & 3)) |
... | ... | |
2091 | 2091 |
sigset_t set; |
2092 | 2092 |
|
2093 | 2093 |
if (TARGET_NSIG_WORDS == 1) { |
2094 |
if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0])) |
|
2094 |
if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
|
|
2095 | 2095 |
goto do_sigsegv; |
2096 | 2096 |
} else { |
2097 | 2097 |
abi_ulong *src, *dst; |
2098 |
src = ucp->uc_sigmask.sig; |
|
2098 |
src = ucp->tuc_sigmask.sig;
|
|
2099 | 2099 |
dst = target_set.sig; |
2100 | 2100 |
for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); |
2101 | 2101 |
i++, dst++, src++) |
... | ... | |
2129 | 2129 |
err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6])); |
2130 | 2130 |
err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7])); |
2131 | 2131 |
|
2132 |
err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); |
|
2133 |
err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); |
|
2132 |
err |= __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
|
|
2133 |
err |= __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
|
|
2134 | 2134 |
|
2135 | 2135 |
w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6]; |
2136 | 2136 |
if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), |
... | ... | |
2139 | 2139 |
if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), |
2140 | 2140 |
abi_ulong) != 0) |
2141 | 2141 |
goto do_sigsegv; |
2142 |
err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); |
|
2143 |
err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); |
|
2142 |
err |= __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
|
|
2143 |
err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
|
|
2144 | 2144 |
{ |
2145 | 2145 |
uint32_t *src, *dst; |
2146 |
src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; |
|
2146 |
src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
|
|
2147 | 2147 |
dst = env->fpr; |
2148 | 2148 |
/* XXX: check that the CPU storage is the same as user context */ |
2149 | 2149 |
for (i = 0; i < 64; i++, dst++, src++) |
2150 | 2150 |
err |= __get_user(*dst, src); |
2151 | 2151 |
} |
2152 | 2152 |
err |= __get_user(env->fsr, |
2153 |
&(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); |
|
2153 |
&(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
|
|
2154 | 2154 |
err |= __get_user(env->gsr, |
2155 |
&(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); |
|
2155 |
&(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
|
|
2156 | 2156 |
if (err) |
2157 | 2157 |
goto do_sigsegv; |
2158 | 2158 |
unlock_user_struct(ucp, ucp_addr, 0); |
... | ... | |
2178 | 2178 |
if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) |
2179 | 2179 |
goto do_sigsegv; |
2180 | 2180 |
|
2181 |
mcp = &ucp->uc_mcontext; |
|
2181 |
mcp = &ucp->tuc_mcontext;
|
|
2182 | 2182 |
grp = &mcp->mc_gregs; |
2183 | 2183 |
|
2184 | 2184 |
/* Skip over the trap instruction, first. */ |
... | ... | |
2191 | 2191 |
host_to_target_sigset_internal(&target_set, &set); |
2192 | 2192 |
if (TARGET_NSIG_WORDS == 1) { |
2193 | 2193 |
err |= __put_user(target_set.sig[0], |
2194 |
(abi_ulong *)&ucp->uc_sigmask); |
|
2194 |
(abi_ulong *)&ucp->tuc_sigmask);
|
|
2195 | 2195 |
} else { |
2196 | 2196 |
abi_ulong *src, *dst; |
2197 | 2197 |
src = target_set.sig; |
2198 |
dst = ucp->uc_sigmask.sig; |
|
2198 |
dst = ucp->tuc_sigmask.sig;
|
|
2199 | 2199 |
for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong); |
2200 | 2200 |
i++, dst++, src++) |
2201 | 2201 |
err |= __put_user(*src, dst); |
... | ... | |
2238 | 2238 |
{ |
2239 | 2239 |
uint32_t *src, *dst; |
2240 | 2240 |
src = env->fpr; |
2241 |
dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs; |
|
2241 |
dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
|
|
2242 | 2242 |
/* XXX: check that the CPU storage is the same as user context */ |
2243 | 2243 |
for (i = 0; i < 64; i++, dst++, src++) |
2244 | 2244 |
err |= __put_user(*src, dst); |
... | ... | |
2346 | 2346 |
}; |
2347 | 2347 |
|
2348 | 2348 |
struct target_ucontext { |
2349 |
target_ulong uc_flags; |
|
2350 |
target_ulong uc_link; |
|
2351 |
target_stack_t uc_stack; |
|
2349 |
target_ulong tuc_flags;
|
|
2350 |
target_ulong tuc_link;
|
|
2351 |
target_stack_t tuc_stack;
|
|
2352 | 2352 |
target_ulong pad0; |
2353 |
struct target_sigcontext uc_mcontext; |
|
2354 |
target_sigset_t uc_sigmask; |
|
2353 |
struct target_sigcontext tuc_mcontext;
|
|
2354 |
target_sigset_t tuc_sigmask;
|
|
2355 | 2355 |
}; |
2356 | 2356 |
|
2357 | 2357 |
struct target_rt_sigframe { |
... | ... | |
2663 | 2663 |
|
2664 | 2664 |
copy_siginfo_to_user(&frame->rs_info, info); |
2665 | 2665 |
|
2666 |
__put_user(0, &frame->rs_uc.uc_flags); |
|
2667 |
__put_user(0, &frame->rs_uc.uc_link); |
|
2668 |
__put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.uc_stack.ss_sp); |
|
2669 |
__put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.uc_stack.ss_size); |
|
2666 |
__put_user(0, &frame->rs_uc.tuc_flags);
|
|
2667 |
__put_user(0, &frame->rs_uc.tuc_link);
|
|
2668 |
__put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
|
|
2669 |
__put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
|
|
2670 | 2670 |
__put_user(sas_ss_flags(get_sp_from_cpustate(env)), |
2671 |
&frame->rs_uc.uc_stack.ss_flags); |
|
2671 |
&frame->rs_uc.tuc_stack.ss_flags);
|
|
2672 | 2672 |
|
2673 |
setup_sigcontext(env, &frame->rs_uc.uc_mcontext); |
|
2673 |
setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
|
|
2674 | 2674 |
|
2675 | 2675 |
for(i = 0; i < TARGET_NSIG_WORDS; i++) { |
2676 |
__put_user(set->sig[i], &frame->rs_uc.uc_sigmask.sig[i]); |
|
2676 |
__put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
|
|
2677 | 2677 |
} |
2678 | 2678 |
|
2679 | 2679 |
/* |
... | ... | |
2720 | 2720 |
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) |
2721 | 2721 |
goto badframe; |
2722 | 2722 |
|
2723 |
target_to_host_sigset(&blocked, &frame->rs_uc.uc_sigmask); |
|
2723 |
target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
|
|
2724 | 2724 |
sigprocmask(SIG_SETMASK, &blocked, NULL); |
2725 | 2725 |
|
2726 |
if (restore_sigcontext(env, &frame->rs_uc.uc_mcontext)) |
|
2726 |
if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
|
|
2727 | 2727 |
goto badframe; |
2728 | 2728 |
|
2729 | 2729 |
if (do_sigaltstack(frame_addr + |
2730 |
offsetof(struct target_rt_sigframe, rs_uc.uc_stack), |
|
2730 |
offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
|
|
2731 | 2731 |
0, get_sp_from_cpustate(env)) == -EFAULT) |
2732 | 2732 |
goto badframe; |
2733 | 2733 |
|
... | ... | |
2779 | 2779 |
|
2780 | 2780 |
|
2781 | 2781 |
struct target_ucontext { |
2782 |
target_ulong uc_flags; |
|
2783 |
struct target_ucontext *uc_link; |
|
2784 |
target_stack_t uc_stack; |
|
2785 |
struct target_sigcontext uc_mcontext; |
|
2786 |
target_sigset_t uc_sigmask; /* mask last for extensibility */ |
|
2782 |
target_ulong tuc_flags;
|
|
2783 |
struct target_ucontext *tuc_link;
|
|
2784 |
target_stack_t tuc_stack;
|
|
2785 |
struct target_sigcontext tuc_mcontext;
|
|
2786 |
target_sigset_t tuc_sigmask; /* mask last for extensibility */
|
|
2787 | 2787 |
}; |
2788 | 2788 |
|
2789 | 2789 |
struct target_rt_sigframe |
... | ... | |
2940 | 2940 |
err |= copy_siginfo_to_user(&frame->info, info); |
2941 | 2941 |
|
2942 | 2942 |
/* Create the ucontext. */ |
2943 |
err |= __put_user(0, &frame->uc.uc_flags); |
|
2944 |
err |= __put_user(0, (unsigned long *)&frame->uc.uc_link); |
|
2943 |
err |= __put_user(0, &frame->uc.tuc_flags);
|
|
2944 |
err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link);
|
|
2945 | 2945 |
err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp, |
2946 |
&frame->uc.uc_stack.ss_sp); |
|
2946 |
&frame->uc.tuc_stack.ss_sp);
|
|
2947 | 2947 |
err |= __put_user(sas_ss_flags(regs->gregs[15]), |
2948 |
&frame->uc.uc_stack.ss_flags); |
|
2948 |
&frame->uc.tuc_stack.ss_flags);
|
|
2949 | 2949 |
err |= __put_user(target_sigaltstack_used.ss_size, |
2950 |
&frame->uc.uc_stack.ss_size); |
|
2951 |
err |= setup_sigcontext(&frame->uc.uc_mcontext, |
|
2950 |
&frame->uc.tuc_stack.ss_size);
|
|
2951 |
err |= setup_sigcontext(&frame->uc.tuc_mcontext,
|
|
2952 | 2952 |
regs, set->sig[0]); |
2953 | 2953 |
for(i = 0; i < TARGET_NSIG_WORDS; i++) { |
2954 |
err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); |
|
2954 |
err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
|
|
2955 | 2955 |
} |
2956 | 2956 |
|
2957 | 2957 |
/* Set up to return from userspace. If provided, use a stub |
... | ... | |
3038 | 3038 |
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) |
3039 | 3039 |
goto badframe; |
3040 | 3040 |
|
3041 |
target_to_host_sigset(&blocked, &frame->uc.uc_sigmask); |
|
3041 |
target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
|
|
3042 | 3042 |
sigprocmask(SIG_SETMASK, &blocked, NULL); |
3043 | 3043 |
|
3044 |
if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0)) |
|
3044 |
if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
|
|
3045 | 3045 |
goto badframe; |
3046 | 3046 |
|
3047 | 3047 |
if (do_sigaltstack(frame_addr + |
3048 |
offsetof(struct target_rt_sigframe, uc.uc_stack), |
|
3048 |
offsetof(struct target_rt_sigframe, uc.tuc_stack),
|
|
3049 | 3049 |
0, get_sp_from_cpustate(regs)) == -EFAULT) |
3050 | 3050 |
goto badframe; |
3051 | 3051 |
|
... | ... | |
3555 | 3555 |
}; |
3556 | 3556 |
|
3557 | 3557 |
struct target_ucontext { |
3558 |
target_ulong uc_flags; |
|
3559 |
target_ulong uc_link; /* struct ucontext __user * */ |
|
3560 |
struct target_sigaltstack uc_stack; |
|
3558 |
target_ulong tuc_flags;
|
|
3559 |
target_ulong tuc_link; /* struct ucontext __user * */
|
|
3560 |
struct target_sigaltstack tuc_stack;
|
|
3561 | 3561 |
#if !defined(TARGET_PPC64) |
3562 |
int32_t uc_pad[7]; |
|
3563 |
target_ulong uc_regs; /* struct mcontext __user * |
|
3562 |
int32_t tuc_pad[7];
|
|
3563 |
target_ulong tuc_regs; /* struct mcontext __user *
|
|
3564 | 3564 |
points to uc_mcontext field */ |
3565 | 3565 |
#endif |
3566 |
target_sigset_t uc_sigmask; |
|
3566 |
target_sigset_t tuc_sigmask;
|
|
3567 | 3567 |
#if defined(TARGET_PPC64) |
3568 | 3568 |
target_sigset_t unused[15]; /* Allow for uc_sigmask growth */ |
3569 |
struct target_sigcontext uc_mcontext; |
|
3569 |
struct target_sigcontext tuc_mcontext;
|
|
3570 | 3570 |
#else |
3571 |
int32_t uc_maskext[30]; |
|
3572 |
int32_t uc_pad2[3]; |
|
3573 |
struct target_mcontext uc_mcontext; |
|
3571 |
int32_t tuc_maskext[30];
|
|
3572 |
int32_t tuc_pad2[3];
|
|
3573 |
struct target_mcontext tuc_mcontext;
|
|
3574 | 3574 |
#endif |
3575 | 3575 |
}; |
3576 | 3576 |
|
... | ... | |
3883 | 3883 |
|
3884 | 3884 |
err |= copy_siginfo_to_user(&rt_sf->info, info); |
3885 | 3885 |
|
3886 |
err |= __put_user(0, &rt_sf->uc.uc_flags); |
|
3887 |
err |= __put_user(0, &rt_sf->uc.uc_link); |
|
3886 |
err |= __put_user(0, &rt_sf->uc.tuc_flags);
|
|
3887 |
err |= __put_user(0, &rt_sf->uc.tuc_link);
|
|
3888 | 3888 |
err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp, |
3889 |
&rt_sf->uc.uc_stack.ss_sp); |
|
3889 |
&rt_sf->uc.tuc_stack.ss_sp);
|
|
3890 | 3890 |
err |= __put_user(sas_ss_flags(env->gpr[1]), |
3891 |
&rt_sf->uc.uc_stack.ss_flags); |
|
3891 |
&rt_sf->uc.tuc_stack.ss_flags);
|
|
3892 | 3892 |
err |= __put_user(target_sigaltstack_used.ss_size, |
3893 |
&rt_sf->uc.uc_stack.ss_size); |
|
3894 |
err |= __put_user(h2g (&rt_sf->uc.uc_mcontext), |
|
3895 |
&rt_sf->uc.uc_regs); |
|
3893 |
&rt_sf->uc.tuc_stack.ss_size);
|
|
3894 |
err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext),
|
|
3895 |
&rt_sf->uc.tuc_regs);
|
|
3896 | 3896 |
for(i = 0; i < TARGET_NSIG_WORDS; i++) { |
3897 |
err |= __put_user(set->sig[i], &rt_sf->uc.uc_sigmask.sig[i]); |
|
3897 |
err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
|
|
3898 | 3898 |
} |
3899 | 3899 |
|
3900 |
frame = &rt_sf->uc.uc_mcontext; |
|
3900 |
frame = &rt_sf->uc.tuc_mcontext;
|
|
3901 | 3901 |
err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn); |
3902 | 3902 |
|
3903 | 3903 |
/* The kernel checks for the presence of a VDSO here. We don't |
... | ... | |
3985 | 3985 |
sigset_t blocked; |
3986 | 3986 |
target_sigset_t set; |
3987 | 3987 |
|
3988 |
if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, uc_sigmask), |
|
3988 |
if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
|
|
3989 | 3989 |
sizeof (set))) |
3990 | 3990 |
return 1; |
3991 | 3991 |
|
... | ... | |
3993 | 3993 |
fprintf (stderr, "do_setcontext: not implemented\n"); |
3994 | 3994 |
return 0; |
3995 | 3995 |
#else |
3996 |
if (__get_user(mcp_addr, &ucp->uc_regs)) |
|
3996 |
if (__get_user(mcp_addr, &ucp->tuc_regs))
|
|
3997 | 3997 |
return 1; |
3998 | 3998 |
|
3999 | 3999 |
if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1)) |
... | ... | |
4026 | 4026 |
goto sigsegv; |
4027 | 4027 |
|
4028 | 4028 |
do_sigaltstack(rt_sf_addr |
4029 |
+ offsetof(struct target_rt_sigframe, uc.uc_stack), |
|
4029 |
+ offsetof(struct target_rt_sigframe, uc.tuc_stack),
|
|
4030 | 4030 |
0, env->gpr[1]); |
4031 | 4031 |
|
4032 | 4032 |
unlock_user_struct(rt_sf, rt_sf_addr, 1); |
... | ... | |
4082 | 4082 |
#define TARGET_MCONTEXT_VERSION 2 |
4083 | 4083 |
|
4084 | 4084 |
struct target_ucontext { |
4085 |
abi_ulong uc_flags; |
|
4086 |
abi_ulong uc_link; |
|
4087 |
target_stack_t uc_stack; |
|
4088 |
struct target_mcontext uc_mcontext; |
|
4089 |
abi_long uc_filler[80]; |
|
4090 |
target_sigset_t uc_sigmask; |
|
4085 |
abi_ulong tuc_flags;
|
|
4086 |
abi_ulong tuc_link;
|
|
4087 |
target_stack_t tuc_stack;
|
|
4088 |
struct target_mcontext tuc_mcontext;
|
|
4089 |
abi_long tuc_filler[80];
|
|
4090 |
target_sigset_t tuc_sigmask;
|
|
4091 | 4091 |
}; |
4092 | 4092 |
|
4093 | 4093 |
struct target_rt_sigframe |
... | ... | |
4212 | 4212 |
static inline int target_rt_setup_ucontext(struct target_ucontext *uc, |
4213 | 4213 |
CPUState *env) |
4214 | 4214 |
{ |
4215 |
target_greg_t *gregs = uc->uc_mcontext.gregs; |
|
4215 |
target_greg_t *gregs = uc->tuc_mcontext.gregs;
|
|
4216 | 4216 |
int err; |
4217 | 4217 |
|
4218 |
err = __put_user(TARGET_MCONTEXT_VERSION, &uc->uc_mcontext.version); |
|
4218 |
err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
|
|
4219 | 4219 |
err |= __put_user(env->dregs[0], &gregs[0]); |
4220 | 4220 |
err |= __put_user(env->dregs[1], &gregs[1]); |
4221 | 4221 |
err |= __put_user(env->dregs[2], &gregs[2]); |
... | ... | |
4244 | 4244 |
{ |
4245 | 4245 |
int temp; |
4246 | 4246 |
int err; |
4247 |
target_greg_t *gregs = uc->uc_mcontext.gregs; |
|
4247 |
target_greg_t *gregs = uc->tuc_mcontext.gregs;
|
|
4248 | 4248 |
|
4249 |
err = __get_user(temp, &uc->uc_mcontext.version); |
|
4249 |
err = __get_user(temp, &uc->tuc_mcontext.version);
|
|
4250 | 4250 |
if (temp != TARGET_MCONTEXT_VERSION) |
4251 | 4251 |
goto badframe; |
4252 | 4252 |
|
... | ... | |
4306 | 4306 |
|
4307 | 4307 |
/* Create the ucontext */ |
4308 | 4308 |
|
4309 |
err |= __put_user(0, &frame->uc.uc_flags); |
|
4310 |
err |= __put_user(0, &frame->uc.uc_link); |
|
4309 |
err |= __put_user(0, &frame->uc.tuc_flags);
|
|
4310 |
err |= __put_user(0, &frame->uc.tuc_link);
|
|
4311 | 4311 |
err |= __put_user(target_sigaltstack_used.ss_sp, |
4312 |
&frame->uc.uc_stack.ss_sp); |
|
4312 |
&frame->uc.tuc_stack.ss_sp);
|
|
4313 | 4313 |
err |= __put_user(sas_ss_flags(env->aregs[7]), |
4314 |
&frame->uc.uc_stack.ss_flags); |
|
4314 |
&frame->uc.tuc_stack.ss_flags);
|
|
4315 | 4315 |
err |= __put_user(target_sigaltstack_used.ss_size, |
4316 |
&frame->uc.uc_stack.ss_size); |
|
4316 |
&frame->uc.tuc_stack.ss_size);
|
|
4317 | 4317 |
err |= target_rt_setup_ucontext(&frame->uc, env); |
4318 | 4318 |
|
4319 | 4319 |
if (err) |
4320 | 4320 |
goto give_sigsegv; |
4321 | 4321 |
|
4322 | 4322 |
for(i = 0; i < TARGET_NSIG_WORDS; i++) { |
4323 |
if (__put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i])) |
|
4323 |
if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
|
|
4324 | 4324 |
goto give_sigsegv; |
4325 | 4325 |
} |
4326 | 4326 |
|
... | ... | |
4409 | 4409 |
goto badframe; |
4410 | 4410 |
|
4411 | 4411 |
if (do_sigaltstack(frame_addr + |
4412 |
offsetof(struct target_rt_sigframe, uc.uc_stack), |
|
4412 |
offsetof(struct target_rt_sigframe, uc.tuc_stack),
|
|
4413 | 4413 |
0, get_sp_from_cpustate(env)) == -EFAULT) |
4414 | 4414 |
goto badframe; |
4415 | 4415 |
|
... | ... | |
4447 | 4447 |
}; |
4448 | 4448 |
|
4449 | 4449 |
struct target_ucontext { |
4450 |
abi_ulong uc_flags; |
|
4451 |
abi_ulong uc_link; |
|
4452 |
abi_ulong uc_osf_sigmask; |
|
4453 |
target_stack_t uc_stack; |
|
4454 |
struct target_sigcontext uc_mcontext; |
|
4455 |
target_sigset_t uc_sigmask; |
|
4450 |
abi_ulong tuc_flags;
|
|
4451 |
abi_ulong tuc_link;
|
|
4452 |
abi_ulong tuc_osf_sigmask;
|
|
4453 |
target_stack_t tuc_stack;
|
|
4454 |
struct target_sigcontext tuc_mcontext;
|
|
4455 |
target_sigset_t tuc_sigmask;
|
|
4456 | 4456 |
}; |
4457 | 4457 |
|
4458 | 4458 |
struct target_sigframe { |
... | ... | |
4588 | 4588 |
|
4589 | 4589 |
err |= copy_siginfo_to_user(&frame->info, info); |
4590 | 4590 |
|
4591 |
err |= __put_user(0, &frame->uc.uc_flags); |
|
4592 |
err |= __put_user(0, &frame->uc.uc_link); |
|
4593 |
err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask); |
|
4591 |
err |= __put_user(0, &frame->uc.tuc_flags);
|
|
4592 |
err |= __put_user(0, &frame->uc.tuc_link);
|
|
4593 |
err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
|
|
4594 | 4594 |
err |= __put_user(target_sigaltstack_used.ss_sp, |
4595 |
&frame->uc.uc_stack.ss_sp); |
|
4595 |
&frame->uc.tuc_stack.ss_sp);
|
|
4596 | 4596 |
err |= __put_user(sas_ss_flags(env->ir[IR_SP]), |
4597 |
&frame->uc.uc_stack.ss_flags); |
|
4597 |
&frame->uc.tuc_stack.ss_flags);
|
|
4598 | 4598 |
err |= __put_user(target_sigaltstack_used.ss_size, |
4599 |
&frame->uc.uc_stack.ss_size); |
|
4600 |
err |= setup_sigcontext(&frame->uc.uc_mcontext, env, frame_addr, set); |
|
4599 |
&frame->uc.tuc_stack.ss_size);
|
|
4600 |
err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
|
|
4601 | 4601 |
for (i = 0; i < TARGET_NSIG_WORDS; ++i) { |
4602 |
err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]); |
|
4602 |
err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
|
|
4603 | 4603 |
} |
4604 | 4604 |
|
4605 | 4605 |
if (ka->sa_restorer) { |
... | ... | |
4668 | 4668 |
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) { |
4669 | 4669 |
goto badframe; |
4670 | 4670 |
} |
4671 |
target_to_host_sigset(&set, &frame->uc.uc_sigmask); |
|
4671 |
target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
|
|
4672 | 4672 |
sigprocmask(SIG_SETMASK, &set, NULL); |
4673 | 4673 |
|
4674 |
if (restore_sigcontext(env, &frame->uc.uc_mcontext)) { |
|
4674 |
if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
|
|
4675 | 4675 |
goto badframe; |
4676 | 4676 |
} |
4677 | 4677 |
if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe, |
4678 |
uc.uc_stack), |
|
4678 |
uc.tuc_stack),
|
|
4679 | 4679 |
0, env->ir[IR_SP]) == -EFAULT) { |
4680 | 4680 |
goto badframe; |
4681 | 4681 |
} |
Also available in: Unified diff