/* EXPORTED */
void VG_(sigframe_create)( ThreadId tid,
Addr sp_top_of_frame,
const vki_siginfo_t *siginfo,
const struct vki_ucontext *siguc,
void *handler,
UInt flags,
const vki_sigset_t *mask,
void *restorer )
{
struct vg_sig_private* priv;
Addr sp;
ThreadState* tst;
Int sigNo = siginfo->si_signo;
Addr faultaddr;
struct rt_sigframe* frame;
/* Stack must be 16-byte aligned */
vg_assert(VG_IS_16_ALIGNED(sizeof(struct vg_sig_private)));
vg_assert(VG_IS_16_ALIGNED(sizeof(struct rt_sigframe)));
sp_top_of_frame &= ~0xf;
sp = sp_top_of_frame - sizeof(struct rt_sigframe);
tst = VG_(get_ThreadState)(tid);
if (!extend(tst, sp, sp_top_of_frame - sp))
return;
vg_assert(VG_IS_16_ALIGNED(sp));
frame = (struct rt_sigframe *) sp;
/* clear it (conservatively) */
VG_(memset)(frame, 0, sizeof(*frame));
/////////
frame->pinfo = &frame->info;
frame->puc = &frame->uc;
frame->uc.uc_flags = 0;
frame->uc.uc_link = 0;
/////////
/* Set up the stack chain pointer */
VG_TRACK( pre_mem_write, Vg_CoreSignal, tid, "signal handler frame",
sp, sizeof(UWord) );
*(Addr *)sp = tst->arch.vex.guest_GPR1;
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
sp, sizeof(UWord) );
faultaddr = (Addr)siginfo->_sifields._sigfault._addr;
if (sigNo == VKI_SIGILL && siginfo->si_code > 0)
faultaddr = tst->arch.vex.guest_CIA;
VG_(memcpy)(&frame->info, siginfo, sizeof(*siginfo));
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
(Addr)&frame->info, sizeof(frame->info) );
frame->uc.uc_flags = 0;
frame->uc.uc_link = 0;
frame->uc.uc_stack = tst->altstack;
frame->uc.uc_sigmask = tst->sig_mask;
VG_TRACK( post_mem_write, Vg_CoreSignal, tid,
(Addr)(&frame->uc), sizeof(frame->uc) );
# define DO(gpr) frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+gpr] \
= tst->arch.vex.guest_GPR##gpr
DO(0); DO(1); DO(2); DO(3); DO(4); DO(5); DO(6); DO(7);
DO(8); DO(9); DO(10); DO(11); DO(12); DO(13); DO(14); DO(15);
DO(16); DO(17); DO(18); DO(19); DO(20); DO(21); DO(22); DO(23);
DO(24); DO(25); DO(26); DO(27); DO(28); DO(29); DO(30); DO(31);
# undef DO
frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP] = tst->arch.vex.guest_CIA;
frame->uc.uc_mcontext.gp_regs[VKI_PT_MSR] = 0xf032; /* pretty arbitrary */
frame->uc.uc_mcontext.gp_regs[VKI_PT_ORIG_R3] = tst->arch.vex.guest_GPR3;
frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR] = tst->arch.vex.guest_CTR;
frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK] = tst->arch.vex.guest_LR;
frame->uc.uc_mcontext.gp_regs[VKI_PT_XER] = LibVEX_GuestPPC64_get_XER(
&tst->arch.vex);
frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR] = LibVEX_GuestPPC64_get_CR(
&tst->arch.vex);
//mc->mc_gregs[VKI_PT_MQ] = 0;
//mc->mc_gregs[VKI_PT_TRAP] = 0;
//mc->mc_gregs[VKI_PT_DAR] = fault_addr;
//mc->mc_gregs[VKI_PT_DSISR] = 0;
//mc->mc_gregs[VKI_PT_RESULT] = 0;
/* XXX should do FP and vector regs */
/* set up signal return trampoline */
/* NB. 5 Sept 07. mc->mc_pad[0..1] used to contain a the code to
which the signal handler returns, and it just did sys_sigreturn
or sys_rt_sigreturn. But this doesn't work if the stack is
non-executable, and it isn't consistent with the x86-linux and
amd64-linux scheme for removing the stack frame. So instead be
consistent and use a stub in m_trampoline. Then it doesn't
matter whether or not the (guest) stack is executable. This
fixes #149519 and #145837. */
frame->tramp[0] = 0; /* invalid */
frame->tramp[1] = 0; /* invalid */
VG_TRACK(post_mem_write, Vg_CoreSignal, tst->tid,
(Addr)&frame->tramp, sizeof(frame->tramp));
/* invalidate any translation of this area */
VG_(discard_translations)( (Addr64)&frame->tramp[0],
sizeof(frame->tramp), "stack_mcontext" );
/* set the signal handler to return to the trampoline */
SET_SIGNAL_LR(tst, (Addr)&VG_(ppc64_linux_SUBST_FOR_rt_sigreturn));
/* Stack pointer for the handler .. (note, back chain set
earlier) */
SET_SIGNAL_GPR(tid, 1, sp);
/* Args for the handler .. */
SET_SIGNAL_GPR(tid, 3, sigNo);
SET_SIGNAL_GPR(tid, 4, (Addr) &frame->info);
SET_SIGNAL_GPR(tid, 5, (Addr) &frame->uc);
/* the kernel sets this, though it doesn't seem to be in the ABI */
SET_SIGNAL_GPR(tid, 6, (Addr) &frame->info);
/* Handler is in fact a standard ppc64-linux function descriptor,
so extract the function entry point and also the toc ptr to use. */
SET_SIGNAL_GPR(tid, 2, (Addr) ((ULong*)handler)[1]);
tst->arch.vex.guest_CIA = (Addr) ((ULong*)handler)[0];
priv = &frame->priv;
priv->magicPI = 0x31415927;
priv->sigNo_private = sigNo;
priv->vex_shadow1 = tst->arch.vex_shadow1;
priv->vex_shadow2 = tst->arch.vex_shadow2;
if (0)
VG_(printf)("pushed signal frame; %%R1 now = %#lx, "
"next %%CIA = %#llx, status=%d\n",
sp, tst->arch.vex.guest_CIA, tst->status);
}
static Int ptrace_setregs(Int pid, VexGuestArchState* vex)
{
#if defined(VGP_x86_linux)
struct vki_user_regs_struct regs;
VG_(memset)(®s, 0, sizeof(regs));
regs.cs = vex->guest_CS;
regs.ss = vex->guest_SS;
regs.ds = vex->guest_DS;
regs.es = vex->guest_ES;
regs.fs = vex->guest_FS;
regs.gs = vex->guest_GS;
regs.eax = vex->guest_EAX;
regs.ebx = vex->guest_EBX;
regs.ecx = vex->guest_ECX;
regs.edx = vex->guest_EDX;
regs.esi = vex->guest_ESI;
regs.edi = vex->guest_EDI;
regs.ebp = vex->guest_EBP;
regs.esp = vex->guest_ESP;
regs.eflags = LibVEX_GuestX86_get_eflags(vex);
regs.eip = vex->guest_EIP;
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, ®s);
#elif defined(VGP_amd64_linux)
struct vki_user_regs_struct regs;
VG_(memset)(®s, 0, sizeof(regs));
regs.rax = vex->guest_RAX;
regs.rbx = vex->guest_RBX;
regs.rcx = vex->guest_RCX;
regs.rdx = vex->guest_RDX;
regs.rsi = vex->guest_RSI;
regs.rdi = vex->guest_RDI;
regs.rbp = vex->guest_RBP;
regs.rsp = vex->guest_RSP;
regs.r8 = vex->guest_R8;
regs.r9 = vex->guest_R9;
regs.r10 = vex->guest_R10;
regs.r11 = vex->guest_R11;
regs.r12 = vex->guest_R12;
regs.r13 = vex->guest_R13;
regs.r14 = vex->guest_R14;
regs.r15 = vex->guest_R15;
regs.eflags = LibVEX_GuestAMD64_get_rflags(vex);
regs.rip = vex->guest_RIP;
/* Set %{c,d,e,f,s,g}s and %{fs,gs}_base (whatever those are) to
values which don't fail the kernel's sanity checks. I have no
idea what these should really be set to. Anyway, mostly it
seems that zero is an allowable value, except for %cs and %ss
which have to have their lowest 2 bits be 11. See putreg() in
linux-2.6.23/arch/x86_64/kernel/ptrace.c for the apparently
relevant sanity checks. This fixes #145622. */
regs.cs = 3;
regs.ds = 0;
regs.es = 0;
regs.fs = 0;
regs.ss = 3;
regs.gs = 0;
regs.fs_base = 0;
regs.gs_base = 0;
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, ®s);
#elif defined(VGP_ppc32_linux)
Int rc = 0;
/* apparently the casting to void* is the Right Thing To Do */
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R0 * 4), (void*)vex->guest_GPR0);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R1 * 4), (void*)vex->guest_GPR1);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R2 * 4), (void*)vex->guest_GPR2);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R3 * 4), (void*)vex->guest_GPR3);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R4 * 4), (void*)vex->guest_GPR4);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R5 * 4), (void*)vex->guest_GPR5);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R6 * 4), (void*)vex->guest_GPR6);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R7 * 4), (void*)vex->guest_GPR7);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R8 * 4), (void*)vex->guest_GPR8);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R9 * 4), (void*)vex->guest_GPR9);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R10 * 4), (void*)vex->guest_GPR10);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R11 * 4), (void*)vex->guest_GPR11);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R12 * 4), (void*)vex->guest_GPR12);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R13 * 4), (void*)vex->guest_GPR13);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R14 * 4), (void*)vex->guest_GPR14);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R15 * 4), (void*)vex->guest_GPR15);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R16 * 4), (void*)vex->guest_GPR16);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R17 * 4), (void*)vex->guest_GPR17);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R18 * 4), (void*)vex->guest_GPR18);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R19 * 4), (void*)vex->guest_GPR19);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R20 * 4), (void*)vex->guest_GPR20);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R21 * 4), (void*)vex->guest_GPR21);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R22 * 4), (void*)vex->guest_GPR22);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R23 * 4), (void*)vex->guest_GPR23);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R24 * 4), (void*)vex->guest_GPR24);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R25 * 4), (void*)vex->guest_GPR25);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R26 * 4), (void*)vex->guest_GPR26);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R27 * 4), (void*)vex->guest_GPR27);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R28 * 4), (void*)vex->guest_GPR28);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R29 * 4), (void*)vex->guest_GPR29);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R30 * 4), (void*)vex->guest_GPR30);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R31 * 4), (void*)vex->guest_GPR31);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_NIP * 4), (void*)vex->guest_CIA);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CCR * 4),
(void*)LibVEX_GuestPPC32_get_CR(vex));
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_LNK * 4), (void*)vex->guest_LR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CTR * 4), (void*)vex->guest_CTR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_XER * 4),
(void*)LibVEX_GuestPPC32_get_XER(vex));
return rc;
#elif defined(VGP_ppc64_linux)
Int rc = 0;
/* FRJ: copied nearly verbatim from the ppc32 case. I compared the
vki-ppc64-linux.h with its ppc32 counterpart and saw no
appreciable differences, other than the registers being 8 bytes
instead of 4. No idea why we don't set all of the entries
declared in vki_pt_regs, but ppc32 doesn't so there must be a
reason.
Finally, note that CR and XER are 32 bits even for ppc64 (see
libvex_guest_ppc64.h), but the vki_pt_regs struct still gives
them 64 bits.
*/
/* apparently the casting to void* is the Right Thing To Do */
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R0 * 8), (void*)vex->guest_GPR0);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R1 * 8), (void*)vex->guest_GPR1);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R2 * 8), (void*)vex->guest_GPR2);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R3 * 8), (void*)vex->guest_GPR3);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R4 * 8), (void*)vex->guest_GPR4);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R5 * 8), (void*)vex->guest_GPR5);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R6 * 8), (void*)vex->guest_GPR6);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R7 * 8), (void*)vex->guest_GPR7);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R8 * 8), (void*)vex->guest_GPR8);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R9 * 8), (void*)vex->guest_GPR9);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R10 * 8), (void*)vex->guest_GPR10);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R11 * 8), (void*)vex->guest_GPR11);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R12 * 8), (void*)vex->guest_GPR12);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R13 * 8), (void*)vex->guest_GPR13);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R14 * 8), (void*)vex->guest_GPR14);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R15 * 8), (void*)vex->guest_GPR15);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R16 * 8), (void*)vex->guest_GPR16);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R17 * 8), (void*)vex->guest_GPR17);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R18 * 8), (void*)vex->guest_GPR18);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R19 * 8), (void*)vex->guest_GPR19);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R20 * 8), (void*)vex->guest_GPR20);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R21 * 8), (void*)vex->guest_GPR21);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R22 * 8), (void*)vex->guest_GPR22);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R23 * 8), (void*)vex->guest_GPR23);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R24 * 8), (void*)vex->guest_GPR24);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R25 * 8), (void*)vex->guest_GPR25);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R26 * 8), (void*)vex->guest_GPR26);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R27 * 8), (void*)vex->guest_GPR27);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R28 * 8), (void*)vex->guest_GPR28);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R29 * 8), (void*)vex->guest_GPR29);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R30 * 8), (void*)vex->guest_GPR30);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R31 * 8), (void*)vex->guest_GPR31);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_NIP * 8), (void*)vex->guest_CIA);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CCR * 8),
(void*)(long)LibVEX_GuestPPC64_get_CR(vex));
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_LNK * 8), (void*)vex->guest_LR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CTR * 8), (void*)vex->guest_CTR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_XER * 8),
(void*)(long)LibVEX_GuestPPC64_get_XER(vex));
return rc;
#elif defined(VGP_arm_linux)
struct vki_user_regs_struct uregs;
VG_(memset)(&uregs, 0, sizeof(uregs));
uregs.ARM_r0 = vex->guest_R0;
uregs.ARM_r1 = vex->guest_R1;
uregs.ARM_r2 = vex->guest_R2;
uregs.ARM_r3 = vex->guest_R3;
uregs.ARM_r4 = vex->guest_R4;
uregs.ARM_r5 = vex->guest_R5;
uregs.ARM_r6 = vex->guest_R6;
uregs.ARM_r7 = vex->guest_R7;
uregs.ARM_r8 = vex->guest_R8;
uregs.ARM_r9 = vex->guest_R9;
uregs.ARM_r10 = vex->guest_R10;
uregs.ARM_fp = vex->guest_R11;
uregs.ARM_ip = vex->guest_R12;
uregs.ARM_sp = vex->guest_R13;
uregs.ARM_lr = vex->guest_R14;
uregs.ARM_pc = vex->guest_R15T;
uregs.ARM_cpsr = LibVEX_GuestARM_get_cpsr(vex);
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, &uregs);
#elif defined(VGP_ppc32_aix5)
I_die_here;
#elif defined(VGP_ppc64_aix5)
I_die_here;
#elif defined(VGP_x86_darwin)
I_die_here;
#elif defined(VGP_amd64_darwin)
I_die_here;
#else
# error Unknown arch
#endif
}
static Int ptrace_setregs(Int pid, VexGuestArchState* vex)
{
#if defined(VGP_x86_linux)
struct vki_user_regs_struct regs;
VG_(memset)(®s, 0, sizeof(regs));
regs.cs = vex->guest_CS;
regs.ss = vex->guest_SS;
regs.ds = vex->guest_DS;
regs.es = vex->guest_ES;
regs.fs = vex->guest_FS;
regs.gs = vex->guest_GS;
regs.eax = vex->guest_EAX;
regs.ebx = vex->guest_EBX;
regs.ecx = vex->guest_ECX;
regs.edx = vex->guest_EDX;
regs.esi = vex->guest_ESI;
regs.edi = vex->guest_EDI;
regs.ebp = vex->guest_EBP;
regs.esp = vex->guest_ESP;
regs.eflags = LibVEX_GuestX86_get_eflags(vex);
regs.eip = vex->guest_EIP;
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, ®s);
#elif defined(VGP_amd64_linux)
struct vki_user_regs_struct regs;
VG_(memset)(®s, 0, sizeof(regs));
regs.rax = vex->guest_RAX;
regs.rbx = vex->guest_RBX;
regs.rcx = vex->guest_RCX;
regs.rdx = vex->guest_RDX;
regs.rsi = vex->guest_RSI;
regs.rdi = vex->guest_RDI;
regs.rbp = vex->guest_RBP;
regs.rsp = vex->guest_RSP;
regs.r8 = vex->guest_R8;
regs.r9 = vex->guest_R9;
regs.r10 = vex->guest_R10;
regs.r11 = vex->guest_R11;
regs.r12 = vex->guest_R12;
regs.r13 = vex->guest_R13;
regs.r14 = vex->guest_R14;
regs.r15 = vex->guest_R15;
regs.eflags = LibVEX_GuestAMD64_get_rflags(vex);
regs.rip = vex->guest_RIP;
/* Set %{c,d,e,f,s,g}s and %{fs,gs}_base (whatever those are) to
values which don't fail the kernel's sanity checks. I have no
idea what these should really be set to. Anyway, mostly it
seems that zero is an allowable value, except for %cs and %ss
which have to have their lowest 2 bits be 11. See putreg() in
linux-2.6.23/arch/x86_64/kernel/ptrace.c for the apparently
relevant sanity checks. This fixes #145622. */
regs.cs = 3;
regs.ds = 0;
regs.es = 0;
regs.fs = 0;
regs.ss = 3;
regs.gs = 0;
regs.fs_base = 0;
regs.gs_base = 0;
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, ®s);
#elif defined(VGP_ppc32_linux)
Int rc = 0;
/* apparently the casting to void* is the Right Thing To Do */
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R0 * 4), (void*)vex->guest_GPR0);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R1 * 4), (void*)vex->guest_GPR1);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R2 * 4), (void*)vex->guest_GPR2);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R3 * 4), (void*)vex->guest_GPR3);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R4 * 4), (void*)vex->guest_GPR4);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R5 * 4), (void*)vex->guest_GPR5);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R6 * 4), (void*)vex->guest_GPR6);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R7 * 4), (void*)vex->guest_GPR7);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R8 * 4), (void*)vex->guest_GPR8);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R9 * 4), (void*)vex->guest_GPR9);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R10 * 4), (void*)vex->guest_GPR10);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R11 * 4), (void*)vex->guest_GPR11);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R12 * 4), (void*)vex->guest_GPR12);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R13 * 4), (void*)vex->guest_GPR13);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R14 * 4), (void*)vex->guest_GPR14);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R15 * 4), (void*)vex->guest_GPR15);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R16 * 4), (void*)vex->guest_GPR16);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R17 * 4), (void*)vex->guest_GPR17);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R18 * 4), (void*)vex->guest_GPR18);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R19 * 4), (void*)vex->guest_GPR19);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R20 * 4), (void*)vex->guest_GPR20);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R21 * 4), (void*)vex->guest_GPR21);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R22 * 4), (void*)vex->guest_GPR22);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R23 * 4), (void*)vex->guest_GPR23);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R24 * 4), (void*)vex->guest_GPR24);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R25 * 4), (void*)vex->guest_GPR25);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R26 * 4), (void*)vex->guest_GPR26);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R27 * 4), (void*)vex->guest_GPR27);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R28 * 4), (void*)vex->guest_GPR28);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R29 * 4), (void*)vex->guest_GPR29);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R30 * 4), (void*)vex->guest_GPR30);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R31 * 4), (void*)vex->guest_GPR31);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_NIP * 4), (void*)vex->guest_CIA);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CCR * 4),
(void*)LibVEX_GuestPPC32_get_CR(vex));
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_LNK * 4), (void*)vex->guest_LR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CTR * 4), (void*)vex->guest_CTR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_XER * 4),
(void*)LibVEX_GuestPPC32_get_XER(vex));
return rc;
#elif defined(VGP_ppc64_linux)
Int rc = 0;
/* FRJ: copied nearly verbatim from the ppc32 case. I compared the
vki-ppc64-linux.h with its ppc32 counterpart and saw no
appreciable differences, other than the registers being 8 bytes
instead of 4. No idea why we don't set all of the entries
declared in vki_pt_regs, but ppc32 doesn't so there must be a
reason.
Finally, note that CR and XER are 32 bits even for ppc64 (see
libvex_guest_ppc64.h), but the vki_pt_regs struct still gives
them 64 bits.
*/
/* apparently the casting to void* is the Right Thing To Do */
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R0 * 8), (void*)vex->guest_GPR0);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R1 * 8), (void*)vex->guest_GPR1);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R2 * 8), (void*)vex->guest_GPR2);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R3 * 8), (void*)vex->guest_GPR3);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R4 * 8), (void*)vex->guest_GPR4);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R5 * 8), (void*)vex->guest_GPR5);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R6 * 8), (void*)vex->guest_GPR6);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R7 * 8), (void*)vex->guest_GPR7);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R8 * 8), (void*)vex->guest_GPR8);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R9 * 8), (void*)vex->guest_GPR9);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R10 * 8), (void*)vex->guest_GPR10);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R11 * 8), (void*)vex->guest_GPR11);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R12 * 8), (void*)vex->guest_GPR12);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R13 * 8), (void*)vex->guest_GPR13);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R14 * 8), (void*)vex->guest_GPR14);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R15 * 8), (void*)vex->guest_GPR15);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R16 * 8), (void*)vex->guest_GPR16);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R17 * 8), (void*)vex->guest_GPR17);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R18 * 8), (void*)vex->guest_GPR18);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R19 * 8), (void*)vex->guest_GPR19);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R20 * 8), (void*)vex->guest_GPR20);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R21 * 8), (void*)vex->guest_GPR21);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R22 * 8), (void*)vex->guest_GPR22);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R23 * 8), (void*)vex->guest_GPR23);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R24 * 8), (void*)vex->guest_GPR24);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R25 * 8), (void*)vex->guest_GPR25);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R26 * 8), (void*)vex->guest_GPR26);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R27 * 8), (void*)vex->guest_GPR27);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R28 * 8), (void*)vex->guest_GPR28);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R29 * 8), (void*)vex->guest_GPR29);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R30 * 8), (void*)vex->guest_GPR30);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_R31 * 8), (void*)vex->guest_GPR31);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_NIP * 8), (void*)vex->guest_CIA);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CCR * 8),
(void*)(long)LibVEX_GuestPPC64_get_CR(vex));
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_LNK * 8), (void*)vex->guest_LR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_CTR * 8), (void*)vex->guest_CTR);
rc |= VG_(ptrace)(VKI_PTRACE_POKEUSR, pid, (void*)(VKI_PT_XER * 8),
(void*)(long)LibVEX_GuestPPC64_get_XER(vex));
return rc;
#elif defined(VGP_arm_linux)
struct vki_user_regs_struct uregs;
VG_(memset)(&uregs, 0, sizeof(uregs));
uregs.ARM_r0 = vex->guest_R0;
uregs.ARM_r1 = vex->guest_R1;
uregs.ARM_r2 = vex->guest_R2;
uregs.ARM_r3 = vex->guest_R3;
uregs.ARM_r4 = vex->guest_R4;
uregs.ARM_r5 = vex->guest_R5;
uregs.ARM_r6 = vex->guest_R6;
uregs.ARM_r7 = vex->guest_R7;
uregs.ARM_r8 = vex->guest_R8;
uregs.ARM_r9 = vex->guest_R9;
uregs.ARM_r10 = vex->guest_R10;
uregs.ARM_fp = vex->guest_R11;
uregs.ARM_ip = vex->guest_R12;
uregs.ARM_sp = vex->guest_R13;
uregs.ARM_lr = vex->guest_R14;
// Remove the T bit from the bottom of R15T. It will get shipped
// over in CPSR.T instead, since LibVEX_GuestARM_get_cpsr copies
// it from R15T[0].
uregs.ARM_pc = vex->guest_R15T & 0xFFFFFFFE;
uregs.ARM_cpsr = LibVEX_GuestARM_get_cpsr(vex);
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, &uregs);
#elif defined(VGP_arm64_linux)
I_die_here;
//ATC
struct vki_user_pt_regs uregs;
VG_(memset)(&uregs, 0, sizeof(uregs));
uregs.regs[0] = vex->guest_X0;
uregs.regs[1] = vex->guest_X1;
uregs.regs[2] = vex->guest_X2;
uregs.regs[3] = vex->guest_X3;
uregs.regs[4] = vex->guest_X4;
uregs.regs[5] = vex->guest_X5;
uregs.regs[6] = vex->guest_X6;
uregs.regs[7] = vex->guest_X7;
uregs.regs[8] = vex->guest_X8;
uregs.regs[9] = vex->guest_X9;
uregs.regs[10] = vex->guest_X10;
uregs.regs[11] = vex->guest_X11;
uregs.regs[12] = vex->guest_X12;
uregs.regs[13] = vex->guest_X13;
uregs.regs[14] = vex->guest_X14;
uregs.regs[15] = vex->guest_X15;
uregs.regs[16] = vex->guest_X16;
uregs.regs[17] = vex->guest_X17;
uregs.regs[18] = vex->guest_X18;
uregs.regs[19] = vex->guest_X19;
uregs.regs[20] = vex->guest_X20;
uregs.regs[21] = vex->guest_X21;
uregs.regs[22] = vex->guest_X22;
uregs.regs[23] = vex->guest_X23;
uregs.regs[24] = vex->guest_X24;
uregs.regs[25] = vex->guest_X25;
uregs.regs[26] = vex->guest_X26;
uregs.regs[27] = vex->guest_X27;
uregs.regs[28] = vex->guest_X28;
uregs.regs[29] = vex->guest_X29;
uregs.regs[30] = vex->guest_X30;
uregs.sp = vex->guest_XSP;
uregs.pc = vex->guest_PC;
uregs.pstate = LibVEX_GuestARM64_get_nzcv(vex); /* is this correct? */
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, &uregs);
#elif defined(VGP_x86_darwin)
I_die_here;
#elif defined(VGP_amd64_darwin)
I_die_here;
#elif defined(VGP_s390x_linux)
struct vki_user_regs_struct regs;
vki_ptrace_area pa;
/* We don't set the psw mask and start at offset 8 */
pa.vki_len = (unsigned long) ®s.per_info - (unsigned long) ®s.psw.addr;
pa.vki_process_addr = (unsigned long) ®s.psw.addr;
pa.vki_kernel_addr = 8;
VG_(memset)(®s, 0, sizeof(regs));
regs.psw.addr = vex->guest_IA;
/* We don't set the mask */
regs.gprs[0] = vex->guest_r0;
regs.gprs[1] = vex->guest_r1;
regs.gprs[2] = vex->guest_r2;
regs.gprs[3] = vex->guest_r3;
regs.gprs[4] = vex->guest_r4;
regs.gprs[5] = vex->guest_r5;
regs.gprs[6] = vex->guest_r6;
regs.gprs[7] = vex->guest_r7;
regs.gprs[8] = vex->guest_r8;
regs.gprs[9] = vex->guest_r9;
regs.gprs[10] = vex->guest_r10;
regs.gprs[11] = vex->guest_r11;
regs.gprs[12] = vex->guest_r12;
regs.gprs[13] = vex->guest_r13;
regs.gprs[14] = vex->guest_r14;
regs.gprs[15] = vex->guest_r15;
regs.acrs[0] = vex->guest_a0;
regs.acrs[1] = vex->guest_a1;
regs.acrs[2] = vex->guest_a2;
regs.acrs[3] = vex->guest_a3;
regs.acrs[4] = vex->guest_a4;
regs.acrs[5] = vex->guest_a5;
regs.acrs[6] = vex->guest_a6;
regs.acrs[7] = vex->guest_a7;
regs.acrs[8] = vex->guest_a8;
regs.acrs[9] = vex->guest_a9;
regs.acrs[10] = vex->guest_a10;
regs.acrs[11] = vex->guest_a11;
regs.acrs[12] = vex->guest_a12;
regs.acrs[13] = vex->guest_a13;
regs.acrs[14] = vex->guest_a14;
regs.acrs[15] = vex->guest_a15;
/* only used for system call restart and friends, just use r2 */
regs.orig_gpr2 = vex->guest_r2;
regs.fp_regs.fprs[0].ui = vex->guest_f0;
regs.fp_regs.fprs[1].ui = vex->guest_f1;
regs.fp_regs.fprs[2].ui = vex->guest_f2;
regs.fp_regs.fprs[3].ui = vex->guest_f3;
regs.fp_regs.fprs[4].ui = vex->guest_f4;
regs.fp_regs.fprs[5].ui = vex->guest_f5;
regs.fp_regs.fprs[6].ui = vex->guest_f6;
regs.fp_regs.fprs[7].ui = vex->guest_f7;
regs.fp_regs.fprs[8].ui = vex->guest_f8;
regs.fp_regs.fprs[9].ui = vex->guest_f9;
regs.fp_regs.fprs[10].ui = vex->guest_f10;
regs.fp_regs.fprs[11].ui = vex->guest_f11;
regs.fp_regs.fprs[12].ui = vex->guest_f12;
regs.fp_regs.fprs[13].ui = vex->guest_f13;
regs.fp_regs.fprs[14].ui = vex->guest_f14;
regs.fp_regs.fprs[15].ui = vex->guest_f15;
regs.fp_regs.fpc = vex->guest_fpc;
return VG_(ptrace)(VKI_PTRACE_POKEUSR_AREA, pid, &pa, NULL);
#elif defined(VGP_mips32_linux) || defined(VGP_mips64_linux)
struct vki_user_regs_struct regs;
VG_(memset)(®s, 0, sizeof(regs));
regs.MIPS_r0 = vex->guest_r0;
regs.MIPS_r1 = vex->guest_r1;
regs.MIPS_r2 = vex->guest_r2;
regs.MIPS_r3 = vex->guest_r3;
regs.MIPS_r4 = vex->guest_r4;
regs.MIPS_r5 = vex->guest_r5;
regs.MIPS_r6 = vex->guest_r6;
regs.MIPS_r7 = vex->guest_r7;
regs.MIPS_r8 = vex->guest_r8;
regs.MIPS_r9 = vex->guest_r9;
regs.MIPS_r10 = vex->guest_r10;
regs.MIPS_r11 = vex->guest_r11;
regs.MIPS_r12 = vex->guest_r12;
regs.MIPS_r13 = vex->guest_r13;
regs.MIPS_r14 = vex->guest_r14;
regs.MIPS_r15 = vex->guest_r15;
regs.MIPS_r16 = vex->guest_r16;
regs.MIPS_r17 = vex->guest_r17;
regs.MIPS_r18 = vex->guest_r18;
regs.MIPS_r19 = vex->guest_r19;
regs.MIPS_r20 = vex->guest_r20;
regs.MIPS_r21 = vex->guest_r21;
regs.MIPS_r22 = vex->guest_r22;
regs.MIPS_r23 = vex->guest_r23;
regs.MIPS_r24 = vex->guest_r24;
regs.MIPS_r25 = vex->guest_r25;
regs.MIPS_r26 = vex->guest_r26;
regs.MIPS_r27 = vex->guest_r27;
regs.MIPS_r28 = vex->guest_r28;
regs.MIPS_r29 = vex->guest_r29;
regs.MIPS_r30 = vex->guest_r30;
regs.MIPS_r31 = vex->guest_r31;
return VG_(ptrace)(VKI_PTRACE_SETREGS, pid, NULL, ®s);
#else
# error Unknown arch
#endif
}
/*
When a client clones, we need to keep track of the new thread. This means:
1. allocate a ThreadId+ThreadState+stack for the thread
2. initialize the thread's new VCPU state
3. create the thread using the same args as the client requested,
but using the scheduler entrypoint for IP, and a separate stack
for SP.
*/
static SysRes do_clone ( ThreadId ptid,
UInt flags, Addr sp,
Int *parent_tidptr,
Int *child_tidptr,
Addr child_tls)
{
const Bool debug = False;
ThreadId ctid = VG_(alloc_ThreadState)();
ThreadState* ptst = VG_(get_ThreadState)(ptid);
ThreadState* ctst = VG_(get_ThreadState)(ctid);
ULong word64;
UWord* stack;
SysRes res;
vki_sigset_t blockall, savedmask;
VG_(sigfillset)(&blockall);
vg_assert(VG_(is_running_thread)(ptid));
vg_assert(VG_(is_valid_tid)(ctid));
stack = (UWord*)ML_(allocstack)(ctid);
if (stack == NULL) {
res = VG_(mk_SysRes_Error)( VKI_ENOMEM );
goto out;
}
//? /* make a stack frame */
//? stack -= 16;
//? *(UWord *)stack = 0;
/* Copy register state
Both parent and child return to the same place, and the code
following the clone syscall works out which is which, so we
don't need to worry about it.
The parent gets the child's new tid returned from clone, but the
child gets 0.
If the clone call specifies a NULL SP for the new thread, then
it actually gets a copy of the parent's SP.
The child's TLS register (r2) gets set to the tlsaddr argument
if the CLONE_SETTLS flag is set.
*/
setup_child( &ctst->arch, &ptst->arch );
/* Make sys_clone appear to have returned Success(0) in the
child. */
{ UInt old_cr = LibVEX_GuestPPC64_get_CR( &ctst->arch.vex );
/* %r3 = 0 */
ctst->arch.vex.guest_GPR3 = 0;
/* %cr0.so = 0 */
LibVEX_GuestPPC64_put_CR( old_cr & ~(1<<28), &ctst->arch.vex );
}
if (sp != 0)
ctst->arch.vex.guest_GPR1 = sp;
ctst->os_state.parent = ptid;
/* inherit signal mask */
ctst->sig_mask = ptst->sig_mask;
ctst->tmp_sig_mask = ptst->sig_mask;
/* Start the child with its threadgroup being the same as the
parent's. This is so that any exit_group calls that happen
after the child is created but before it sets its
os_state.threadgroup field for real (in thread_wrapper in
syswrap-linux.c), really kill the new thread. a.k.a this avoids
a race condition in which the thread is unkillable (via
exit_group) because its threadgroup is not set. The race window
is probably only a few hundred or a few thousand cycles long.
See #226116. */
ctst->os_state.threadgroup = ptst->os_state.threadgroup;
ML_(guess_and_register_stack) (sp, ctst);
/* Assume the clone will succeed, and tell any tool that wants to
know that this thread has come into existence. If the clone
fails, we'll send out a ll_exit notification for it at the out:
label below, to clean up. */
vg_assert(VG_(owns_BigLock_LL)(ptid));
VG_TRACK ( pre_thread_ll_create, ptid, ctid );
if (flags & VKI_CLONE_SETTLS) {
if (debug)
VG_(printf)("clone child has SETTLS: tls at %#lx\n", child_tls);
ctst->arch.vex.guest_GPR13 = child_tls;
}
flags &= ~VKI_CLONE_SETTLS;
/* start the thread with everything blocked */
VG_(sigprocmask)(VKI_SIG_SETMASK, &blockall, &savedmask);
/* Create the new thread */
word64 = do_syscall_clone_ppc64_linux(
ML_(start_thread_NORETURN),
stack, flags, &VG_(threads)[ctid],
child_tidptr, parent_tidptr, NULL
);
/* Low half word64 is syscall return value. Hi half is
the entire CR, from which we need to extract CR0.SO. */
/* VG_(printf)("word64 = 0x%llx\n", word64); */
res = VG_(mk_SysRes_ppc64_linux)(
/*val*/(UInt)(word64 & 0xFFFFFFFFULL),
/*errflag*/ (UInt)((word64 >> (32+28)) & 1)
);
VG_(sigprocmask)(VKI_SIG_SETMASK, &savedmask, NULL);
out:
if (sr_isError(res)) {
/* clone failed */
VG_(cleanup_thread)(&ctst->arch);
ctst->status = VgTs_Empty;
/* oops. Better tell the tool the thread exited in a hurry :-) */
VG_TRACK( pre_thread_ll_exit, ctid );
}
return res;
}
