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 |
}
|