/* Just before starting the client, we may need to make final
adjustments to its initial image. Also we need to set up the VEX
guest state for thread 1 (the root thread) and copy in essential
starting values. This is handed the IIFinaliseImageInfo created by
VG_(ii_create_image).
*/
void VG_(ii_finalise_image)( IIFinaliseImageInfo iifii )
{
UInt adler32_act;
SysRes sres;
/* On AIX we get a block of 37 words telling us the initial state
for (GPR0 .. GPR31, PC, CR, LR, CTR, XER), and we start with all
the other registers zeroed. */
ThreadArchState* arch = &VG_(threads)[1].arch;
# if defined(VGP_ppc32_aix5)
vg_assert(0 == sizeof(VexGuestPPC32State) % 8);
/* Zero out the initial state, and set up the simulated FPU in a
sane way. */
LibVEX_GuestPPC32_initialise(&arch->vex);
/* Zero out the shadow area. */
VG_(memset)(&arch->vex_shadow, 0, sizeof(VexGuestPPC32State));
# else /* defined(VGP_ppc64_aix5) */
vg_assert(0 == sizeof(VexGuestPPC64State) % 8);
/* Zero out the initial state, and set up the simulated FPU in a
sane way. */
LibVEX_GuestPPC64_initialise(&arch->vex);
/* Zero out the shadow area. */
VG_(memset)(&arch->vex_shadow, 0, sizeof(VexGuestPPC64State));
# endif
/* iifii.intregs37 contains the integer register state as it needs
to be at client startup. These values are supplied by the
launcher. The 37 regs are:initial values from launcher for:
GPR0 .. GPR31, PC, CR, LR, CTR, XER. */
/* Put essential stuff into the new state. */
arch->vex.guest_GPR0 = (UWord)iifii.intregs37[0];
arch->vex.guest_GPR1 = (UWord)iifii.intregs37[1];
arch->vex.guest_GPR2 = (UWord)iifii.intregs37[2];
arch->vex.guest_GPR3 = (UWord)iifii.intregs37[3];
arch->vex.guest_GPR4 = (UWord)iifii.intregs37[4];
arch->vex.guest_GPR5 = (UWord)iifii.intregs37[5];
arch->vex.guest_GPR6 = (UWord)iifii.intregs37[6];
arch->vex.guest_GPR7 = (UWord)iifii.intregs37[7];
arch->vex.guest_GPR8 = (UWord)iifii.intregs37[8];
arch->vex.guest_GPR9 = (UWord)iifii.intregs37[9];
arch->vex.guest_GPR10 = (UWord)iifii.intregs37[10];
arch->vex.guest_GPR11 = (UWord)iifii.intregs37[11];
arch->vex.guest_GPR12 = (UWord)iifii.intregs37[12];
arch->vex.guest_GPR13 = (UWord)iifii.intregs37[13];
arch->vex.guest_GPR14 = (UWord)iifii.intregs37[14];
arch->vex.guest_GPR15 = (UWord)iifii.intregs37[15];
arch->vex.guest_GPR16 = (UWord)iifii.intregs37[16];
arch->vex.guest_GPR17 = (UWord)iifii.intregs37[17];
arch->vex.guest_GPR18 = (UWord)iifii.intregs37[18];
arch->vex.guest_GPR19 = (UWord)iifii.intregs37[19];
arch->vex.guest_GPR20 = (UWord)iifii.intregs37[20];
arch->vex.guest_GPR21 = (UWord)iifii.intregs37[21];
arch->vex.guest_GPR22 = (UWord)iifii.intregs37[22];
arch->vex.guest_GPR23 = (UWord)iifii.intregs37[23];
arch->vex.guest_GPR24 = (UWord)iifii.intregs37[24];
arch->vex.guest_GPR25 = (UWord)iifii.intregs37[25];
arch->vex.guest_GPR26 = (UWord)iifii.intregs37[26];
arch->vex.guest_GPR27 = (UWord)iifii.intregs37[27];
arch->vex.guest_GPR28 = (UWord)iifii.intregs37[28];
arch->vex.guest_GPR29 = (UWord)iifii.intregs37[29];
arch->vex.guest_GPR30 = (UWord)iifii.intregs37[30];
arch->vex.guest_GPR31 = (UWord)iifii.intregs37[31];
arch->vex.guest_CIA = (UWord)iifii.intregs37[32+0];
arch->vex.guest_LR = (UWord)iifii.intregs37[32+2];
arch->vex.guest_CTR = (UWord)iifii.intregs37[32+3];
# if defined(VGP_ppc32_aix5)
LibVEX_GuestPPC32_put_CR( (UWord)iifii.intregs37[32+1], &arch->vex );
LibVEX_GuestPPC32_put_XER( (UWord)iifii.intregs37[32+4], &arch->vex );
/* Set the cache line size (KLUDGE) */
VG_(machine_ppc32_set_clszB)( 128 );
# else /* defined(VGP_ppc64_aix5) */
LibVEX_GuestPPC64_put_CR( (UWord)iifii.intregs37[32+1], &arch->vex );
LibVEX_GuestPPC64_put_XER( (UWord)iifii.intregs37[32+4], &arch->vex );
/* Set the cache line size (KLUDGE) */
VG_(machine_ppc64_set_clszB)( 128 );
# endif
/* Fix up the client's command line. Its argc/v/envp is in r3/4/5
(32-bit AIX) or r14/15/16 (64-bit AIX). but that is for the
Valgrind invokation as a whole. Hence we need to decrement argc
and advance argv to step over the args for Valgrind, and the
name of the Valgrind tool exe bogusly inserted by the launcher
(hence the "+1"). */
# if defined(VGP_ppc32_aix5)
{ UWord n_vargs = VG_(sizeXA)( VG_(args_for_valgrind) );
vg_assert(arch->vex.guest_GPR3 >= 1 + n_vargs);
arch->vex.guest_GPR3 -= (1 + n_vargs);
arch->vex.guest_GPR4 += sizeof(UWord) * (1 + n_vargs);
}
# else /* defined(VGP_ppc64_aix5) */
{ UWord n_vargs = VG_(sizeXA)( VG_(args_for_valgrind) );
vg_assert(arch->vex.guest_GPR14 >= 1 + n_vargs);
arch->vex.guest_GPR14 -= (1 + n_vargs);
arch->vex.guest_GPR15 += sizeof(UWord) * (1 + n_vargs);
}
# endif
/* At this point the guest register state is correct for client
startup. However, that's not where we want to start; in fact we
want to start at VG_(ppc{32,64}_aix5_do_preloads_then_start_client),
passing it iifii.preloadpage in r3. This will load the core/tool
preload .so's, then restore r2-r10 from what's stashed in the
preloadpage, and then start the client really. Hence: */
/* Save r2-r10 and the client start point in preloadpage */
iifii.preloadpage->r2 = (ULong)arch->vex.guest_GPR2;
iifii.preloadpage->r3 = (ULong)arch->vex.guest_GPR3;
iifii.preloadpage->r4 = (ULong)arch->vex.guest_GPR4;
iifii.preloadpage->r5 = (ULong)arch->vex.guest_GPR5;
iifii.preloadpage->r6 = (ULong)arch->vex.guest_GPR6;
iifii.preloadpage->r7 = (ULong)arch->vex.guest_GPR7;
iifii.preloadpage->r8 = (ULong)arch->vex.guest_GPR8;
iifii.preloadpage->r9 = (ULong)arch->vex.guest_GPR9;
iifii.preloadpage->r10 = (ULong)arch->vex.guest_GPR10;
iifii.preloadpage->client_start = (ULong)arch->vex.guest_CIA;
# if defined(VGP_ppc32_aix5)
/* Set up to start at VG_(ppc32_aix5_do_preloads_then_start_client) */
arch->vex.guest_CIA = (UWord)&VG_(ppc32_aix5_do_preloads_then_start_client);
# else /* defined(VGP_ppc64_aix5) */
/* Set up to start at VG_(ppc64_aix5_do_preloads_then_start_client) */
arch->vex.guest_CIA = (UWord)&VG_(ppc64_aix5_do_preloads_then_start_client);
# endif
arch->vex.guest_GPR3 = (UWord)iifii.preloadpage;
/* The rest of the preloadpage fields will already have been filled
in by VG_(setup_client_initial_image). So we're done. */
/* Finally, decompress the page compressed by the launcher. We
can't do this any earlier, because the page is (effectively)
decompressed in place, which trashes iifii.intregs37. So we have
to wait till this point, at which we're done with iifii.intregs37
(to be precise, with what it points at). */
VG_(debugLog)(1, "initimg", "decompressing page at %p\n",
(void*)iifii.compressed_page);
vg_assert(VG_IS_PAGE_ALIGNED(iifii.compressed_page));
Huffman_Uncompress( (void*)iifii.compressed_page, unz_page,
VKI_PAGE_SIZE, VKI_PAGE_SIZE );
adler32_act = compute_adler32(unz_page, VKI_PAGE_SIZE);
VG_(debugLog)(1, "initimg",
"decompress done, adler32s: act 0x%x, exp 0x%x\n",
adler32_act, iifii.adler32_exp );
VG_(memcpy)((void*)iifii.compressed_page, unz_page, VKI_PAGE_SIZE);
VG_(debugLog)(1, "initimg", "copy back done\n");
/* Tell the tool that we just wrote to the registers. */
VG_TRACK( post_reg_write, Vg_CoreStartup, /*tid*/1, /*offset*/0,
sizeof(VexGuestArchState));
/* Determine the brk limit. */
VG_(debugLog)(1, "initimg", "establishing current brk ..\n");
vg_assert(__NR_AIX5_sbrk != __NR_AIX5_UNKNOWN);
sres = VG_(do_syscall1)(__NR_AIX5_sbrk, 0);
vg_assert(sres.err == 0); /* assert no error */
VG_(brk_base) = VG_(brk_limit) = sres.res;
VG_(debugLog)(1, "initimg", ".. brk = %p\n", (void*)VG_(brk_base));
}
/* EXPORTED */
void VG_(sigframe_destroy)( ThreadId tid, Bool isRT )
{
ThreadState *tst;
struct vg_sig_private *priv;
Addr sp;
UInt frame_size;
struct rt_sigframe *frame;
Int sigNo;
Bool has_siginfo = isRT;
vg_assert(VG_(is_valid_tid)(tid));
tst = VG_(get_ThreadState)(tid);
/* Check that the stack frame looks valid */
sp = tst->arch.vex.guest_GPR1;
vg_assert(VG_IS_16_ALIGNED(sp));
/* JRS 17 Nov 05: This code used to check that *sp -- which should
have been set by the stwu at the start of the handler -- points
to just above the frame (ie, the previous frame). However, that
isn't valid when delivering signals on alt stacks. So I removed
it. The frame is still sanity-checked using the priv->magicPI
field. */
frame = (struct rt_sigframe *)sp;
frame_size = sizeof(*frame);
priv = &frame->priv;
vg_assert(priv->magicPI == 0x31415927);
tst->sig_mask = frame->uc.uc_sigmask;
tst->tmp_sig_mask = tst->sig_mask;
sigNo = priv->sigNo_private;
# define DO(gpr) tst->arch.vex.guest_GPR##gpr \
= frame->uc.uc_mcontext.gp_regs[VKI_PT_R0+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
tst->arch.vex.guest_CIA = frame->uc.uc_mcontext.gp_regs[VKI_PT_NIP];
LibVEX_GuestPPC64_put_CR( frame->uc.uc_mcontext.gp_regs[VKI_PT_CCR],
&tst->arch.vex );
tst->arch.vex.guest_LR = frame->uc.uc_mcontext.gp_regs[VKI_PT_LNK];
tst->arch.vex.guest_CTR = frame->uc.uc_mcontext.gp_regs[VKI_PT_CTR];
LibVEX_GuestPPC64_put_XER( frame->uc.uc_mcontext.gp_regs[VKI_PT_XER],
&tst->arch.vex );
tst->arch.vex_shadow1 = priv->vex_shadow1;
tst->arch.vex_shadow2 = priv->vex_shadow2;
VG_TRACK(die_mem_stack_signal, sp, frame_size);
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
"vg_pop_signal_frame (thread %d): isRT=%d valid magic; EIP=%#llx",
tid, has_siginfo, tst->arch.vex.guest_CIA);
/* tell the tools */
VG_TRACK( post_deliver_signal, tid, sigNo );
}
/*
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;
}