zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-17 08:04:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
ffaaef1cbc1bb287c8ab4500d104472c901fba3b
ftmemsim-valgrind/coregrind/m_syswrap/syswrap-ppc64-aix5.c
Nicholas Nethercote b05a2a18d7 This commit merges the BUILD_TWEAKS branch onto the trunk. It has the 
following improvements:

- Arch/OS/platform-specific files are now included/excluded via the
  preprocessor, rather than via the build system.  This is more consistent
  (we use the pre-processor for small arch/OS/platform-specific chunks
  within files) and makes the build system much simpler, as the sources for
  all programs are the same on all platforms.

- Vast amounts of cut+paste Makefile.am code has been factored out.  If a
  new platform is implemented, you need to add 11 extra Makefile.am lines.
  Previously it was over 100 lines.

- Vex has been autotoolised.  Dependency checking now works in Vex (no more
  incomplete builds).  Parallel builds now also work.  --with-vex no longer
  works;  it's little use and a pain to support.  VEX/Makefile is still in
  the Vex repository and gets overwritten at configure-time;  it should
  probably be renamed Makefile-gcc to avoid possible problems, such as
  accidentally committing a generated Makefile.  There's a bunch of hacky
  copying to deal with the fact that autotools don't handle same-named files
  in different directories.  Julian plans to rename the files to avoid this
  problem.

- Various small Makefile.am things have been made more standard automake
  style, eg. the use of pkginclude/pkglib prefixes instead of rolling our
  own.

- The existing five top-level Makefile.am include files have been
  consolidated into three.

- Most Makefile.am files now are structured more clearly, with comment
  headers separating sections, declarations relating to the same things next
  to each other, better spacing and layout, etc.

- Removed the unused exp-ptrcheck/tests/x86 directory.

- Renamed some XML files.

- Factored out some duplicated dSYM handling code.

- Split auxprogs/ into auxprogs/ and mpi/, which allowed the resulting
  Makefile.am files to be much more standard.

- Cleaned up m_coredump by merging a bunch of files that had been
  overzealously separated.

The net result is 630 fewer lines of Makefile.am code, or 897 if you exclude
the added Makefile.vex.am, or 997 once the hacky file copying for Vex is
removed.  And the build system is much simpler.


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@10364
2009-06-24 00:37:09 +00:00

798 lines
30 KiB
C
Raw Blame History

/*--------------------------------------------------------------------*/
/*--- Platform-specific syscalls stuff. syswrap-ppc64-aix5.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2006-2009 OpenWorks LLP
info@open-works.co.uk
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
Neither the names of the U.S. Department of Energy nor the
University of California nor the names of its contributors may be
used to endorse or promote products derived from this software
without prior written permission.
*/
#if defined(VGP_ppc64_aix5)
#include "pub_core_basics.h"
#include "pub_core_vki.h"
#include "pub_core_vkiscnums.h"
#include "pub_core_threadstate.h"
#include "pub_core_debuglog.h"
#include "pub_core_libcassert.h"
#include "pub_core_libcprint.h"
#include "pub_core_libcproc.h"
#include "pub_core_options.h"
#include "pub_core_scheduler.h"
#include "pub_core_sigframe.h" // For VG_(sigframe_destroy)()
#include "pub_core_signals.h"
#include "pub_core_syscall.h"
#include "pub_core_syswrap.h"
#include "pub_core_tooliface.h"
#include "priv_types_n_macros.h"
#include "priv_syswrap-aix5.h" /* for decls of aix5-common wrappers */
#include "priv_syswrap-main.h"
/* --------- HACKS --------- */
/* XXXXXXXXXXXX these HACKS are copies of stuff in syswrap-linux.c;
check for duplication. */
/* HACK: is in syswrap-generic.c, but that doesn't get build on AIX. */
/* Dump out a summary, and a more detailed list, of open file descriptors. */
void VG_(show_open_fds) ( void )
{
I_die_here;
}
static Bool i_am_the_only_thread ( void )
{
Int c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
return c == 1;
}
void VG_(reap_threads)(ThreadId self)
{
while (!i_am_the_only_thread()) {
/* Let other thread(s) run */
VG_(vg_yield)();
VG_(poll_signals)(self);
}
vg_assert(i_am_the_only_thread());
}
void VG_(init_preopened_fds) ( void )
{
I_die_here;
}
// Run a thread from beginning to end and return the thread's
// scheduler-return-code.
static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
{
VgSchedReturnCode ret;
ThreadId tid = (ThreadId)tidW;
ThreadState* tst = VG_(get_ThreadState)(tid);
VG_(debugLog)(1, "syswrap-aix64",
"thread_wrapper(tid=%lld): entry\n",
(ULong)tidW);
vg_assert(tst->status == VgTs_Init);
/* make sure we get the CPU lock before doing anything significant */
VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
if (0)
VG_(printf)("thread tid %d started: stack = %p\n",
tid, &tid);
VG_TRACK( pre_thread_first_insn, tid );
tst->os_state.lwpid = VG_(gettid)();
tst->os_state.threadgroup = VG_(getpid)();
/* Thread created with all signals blocked; scheduler will set the
appropriate mask */
ret = VG_(scheduler)(tid);
vg_assert(VG_(is_exiting)(tid));
vg_assert(tst->status == VgTs_Runnable);
vg_assert(VG_(is_running_thread)(tid));
VG_(debugLog)(1, "syswrap-aix64",
"thread_wrapper(tid=%lld): exit\n",
(ULong)tidW);
/* Return to caller, still holding the lock. */
return ret;
}
/* Run a thread all the way to the end, then do appropriate exit actions
(this is the last-one-out-turn-off-the-lights bit). */
static void run_a_thread_NORETURN ( Word tidW )
{
ThreadId tid = (ThreadId)tidW;
VgSchedReturnCode src;
Int c;
VG_(debugLog)(1, "syswrap-aix64",
"run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
(ULong)tidW);
/* Run the thread all the way through. */
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-aix64",
"run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
(ULong)tidW);
c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
vg_assert(src == VgSrc_ExitThread
|| src == VgSrc_ExitProcess
|| src == VgSrc_FatalSig);
if (c == 1 || src == VgSrc_ExitProcess) {
VG_(debugLog)(1, "syswrap-aix64",
"run_a_thread_NORETURN(tid=%lld): "
"exit process (%d threads remaining)\n",
(ULong)tidW, c);
/* We are the last one standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
Use the continuation pointer set at startup in m_main. */
( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);
} else {
ThreadState *tst;
VG_(debugLog)(1, "syswrap-aix64",
"run_a_thread_NORETURN(tid=%lld): "
"not last one standing\n",
(ULong)tidW);
/* OK, thread is dead, but others still exist. Just exit. */
vg_assert(c >= 2);
tst = VG_(get_ThreadState)(tid);
/* This releases the run lock */
VG_(exit_thread)(tid);
vg_assert(tst->status == VgTs_Zombie);
/* We have to use this sequence to terminate the thread to
prevent a subtle race. If VG_(exit_thread)() had left the
ThreadState as Empty, then it could have been reallocated,
reusing the stack while we're doing these last cleanups.
Instead, VG_(exit_thread) leaves it as Zombie to prevent
reallocation. We need to make sure we don't touch the stack
between marking it Empty and exiting. Hence the
assembler. */
{ ULong block[4];
vg_assert(sizeof(tst->status == 8));
vg_assert(__NR_AIX5_thread_terminate
!= __NR_AIX5_UNKNOWN);
block[0] = (ULong)VgTs_Empty;
block[1] = (ULong) & (tst->status);
block[2] = (ULong) tst->os_state.exitcode;
block[3] = __NR_AIX5_thread_terminate;
asm volatile (
"mr 29,%0\n\t" /* r29 = &block[0] */
"ld 20, 0(29)\n\t" /* r20 = VgTs_Empty */
"ld 21, 8(29)\n\t" /* r21 = & (tst->status) */
"ld 22, 16(29)\n\t" /* r22 = tst->os_state.exitcode */
"ld 23, 24(29)\n\t" /* r23 = __NR_exit */
/* after this point we can't safely use the stack. */
"std 20, 0(21)\n\t" /* tst->status = VgTs_Empty */
"mr 2,23\n\t" /* r2 = __NR_exit */
"mr 3,22\n\t" /* set r3 = tst->os_state.exitcode */
/* set up for syscall */
"crorc 6,6,6\n\t"
".long 0x48000005\n\t" /* "bl here+4" */
"mflr 29\n\t"
"addi 29,29,16\n\t"
"mtlr 29\n\t"
"sc\n\t" /* exit(tst->os_state.exitcode) */
:
: "b" (&block[0])
: "lr", "memory", "r2", "r3", "r20", "r21", "r22", "r23", "r29"
);
}
VG_(core_panic)("Thread exit failed?\n");
}
/*NOTREACHED*/
vg_assert(0);
}
static Word start_thread_NORETURN ( void* arg )
{
ThreadState* tst = (ThreadState*)arg;
ThreadId tid = tst->tid;
run_a_thread_NORETURN ( (Word)tid );
/*NOTREACHED*/
vg_assert(0);
}
/* Call f(arg1), but first switch stacks, using 'stack' as the new
stack. f itself needs to never return. */
__attribute__((noreturn))
static
void call_on_new_stack_0_1_NORETURN ( Addr stack,
void (*f_NORETURN)(Word),
Word arg1 )
{
UWord* fdescr = (UWord*)f_NORETURN;
volatile UWord block[5];
block[0] = fdescr[0]; /* nia */
block[1] = stack; /* r1 */
block[2] = fdescr[1]; /* r2 */
block[3] = arg1; /* r3 */
block[4] = fdescr[2]; /* r11 */
__asm__ __volatile__(
"mr 4,%0\n\t" /* r4 = block */
"ld 1, 8(4)\n\t"
"ld 2, 16(4)\n\t"
"ld 3, 24(4)\n\t"
"ld 11,32(4)\n\t"
"ld 4, 0(4)\n\t"
"mtctr 4\n\t"
"bctr\n"
: /*out*/ : /*in*/ "b"(&block[0])
);
/*NOTREACHED*/
__asm__ __volatile__("trap");
while (1) {} /* convince gcc that this really doesn't return */
}
/* Allocate a stack for the main thread, and run it all the way to the
end. Although we already have a working VgStack
(VG_(interim_stack)) it's better to allocate a new one, so that
overflow detection works uniformly for all threads.
*/
void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
{
Addr sp;
VG_(debugLog)(1, "syswrap-aix64",
"entering VG_(main_thread_wrapper_NORETURN)\n");
sp = ML_(allocstack)(tid);
/* If we can't even allocate the first thread's stack, we're hosed.
Give up. */
vg_assert2(sp != 0, "Cannot allocate main thread's stack.");
/* shouldn't be any other threads around yet */
vg_assert( VG_(count_living_threads)() == 1 );
/* make a stack frame */
sp -= 16;
sp &= ~0xF;
*(UWord *)sp = 0;
call_on_new_stack_0_1_NORETURN(
(Addr)sp, /* stack */
run_a_thread_NORETURN, /* fn to call */
(Word)tid /* arg to give it */
);
/*NOTREACHED*/
vg_assert(0);
}
/* --------- end HACKS --------- */
/* ---------------------------------------------------------------------
More thread stuff
------------------------------------------------------------------ */
void VG_(cleanup_thread) ( ThreadArchState* arch )
{
}
/* ---------------------------------------------------------------------
PRE/POST wrappers for ppc64/AIX5-specific syscalls
------------------------------------------------------------------ */
/* --- !!! --- EXTERNAL HEADERS start --- !!! --- */
#include <sys/thread.h>
/* --- !!! --- EXTERNAL HEADERS end --- !!! --- */
/* Add prototypes for the wrappers declared here, so that gcc doesn't
harass us for not having prototypes. Really this is a kludge --
the right thing to do is to make these wrappers 'static' since they
aren't visible outside this file, but that requires even more macro
magic. */
#define PRE(name) DEFN_PRE_TEMPLATE(ppc64_aix5, name)
#define POST(name) DEFN_POST_TEMPLATE(ppc64_aix5, name)
DECL_TEMPLATE(ppc64_aix5, sys__clock_gettime);
DECL_TEMPLATE(ppc64_aix5, sys__fp_fpscrx64_);
DECL_TEMPLATE(ppc64_aix5, sys_kload);
DECL_TEMPLATE(ppc64_aix5, sys_kunload64);
DECL_TEMPLATE(ppc64_aix5, sys_thread_setstate);
DECL_TEMPLATE(ppc64_aix5, sys_FAKE_SIGRETURN);
PRE(sys__clock_gettime)
{
/* Seems like ARG2 points at a destination buffer? */
/* _clock_gettime (UNDOCUMENTED) ( 0, 0xA, 0x2FF21808 ) */
PRINT("_clock_gettime (UNDOCUMENTED) ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3 );
PRE_REG_READ3(int, "_clock_gettime", int, arg1, int, arg2, void*, arg3);
PRE_MEM_WRITE( "_clock_gettime(dst)", ARG2, sizeof(struct timespec) );
}
POST(sys__clock_gettime)
{
vg_assert(SUCCESS);
POST_MEM_WRITE( ARG2, sizeof(struct timespec) );
}
PRE(sys__fp_fpscrx64_)
{
PRINT("_fp_fpscrx64_ (BOGUS HANDLER)");
}
PRE(sys_kload)
{
PRINT("kload (UNDOCUMENTED)( %#lx(%s), %ld, %ld )",
ARG1,(Char*)ARG1, ARG2, ARG3 );
PRE_REG_READ3(void*, "kload", char*, name, long, arg2, char*, arg3);
}
POST(sys_kload)
{
vg_assert(SUCCESS);
if (0) VG_(printf)("kload result = %#lx\n", RES);
if (RES)
POST_MEM_WRITE( RES, 64 );
ML_(aix5_rescan_procmap_after_load_or_unload)();
}
PRE(sys_kunload64)
{
PRINT("kunload64 (UNDOCUMENTED)( %#lx, %ld, %ld, %#lx )",
ARG1, ARG2, ARG3, ARG4 );
PRE_REG_READ4(long, "kunload64",
void*, arg1, long, arg2, long, arg3, void*, arg4);
}
POST(sys_kunload64)
{
vg_assert(SUCCESS);
ML_(aix5_rescan_procmap_after_load_or_unload)();
}
PRE(sys_thread_setstate)
{
UWord dst_lwpid = (UWord)ARG1;
struct tstate* ats_new = (struct tstate*)ARG2;
struct tstate* ats_old = (struct tstate*)ARG3;
ThreadId dst_tid = VG_INVALID_THREADID;
ThreadState* dst_ts = NULL;
Int i;
/* Arrgh. We MUST retain the lock during this syscall. Reason is
that this is sometimes used for asynchronous thread cancellation
(nuking other threads). If we don't have the lock during the
syscall, then it's possible that the thread we're nuking might
get the lock before it gets killed off, and so we can never
re-acquire the lock after this syscall, and the system
deadlocks. */
/* 10 July 06: above comment is a misdiagnosis. It appears that
for thread cancellation (that is, with ->flags == TSTATE_INTR)
the target thread is has its PC changed by the the kernel to
something else, possibly to pthread_exit(), so that it can run
its cancellation handlers and exit. Currently is unknown how
the kernel knows what to set the target thread's PC to. I did
establish that all the other data passed in the struct is not
relevant: when ->flags == TSTATE_INTR, all the other words can
be set to 0x0 or 0xFFFFFFFF and the syscall still works. So the
address is not passed like that. Also I looked at args to
thread_setmystate_fast, which is used when a thread sets its
cancellation state, but none of those are code addresses.
Also, it's ok for the kernel to simply change the target
thread's PC to something else for async thread cancellation, but
for deferred cancellation something else is needed, and I can't
see how that would work either.
Anyway, net result is, target thread ends up not running on the
simulator (not dead), which is why it's necessary to hold onto
the lock at this point. */
/* 30 July 06: added kludge to intercept attempts to cancel another
thread and instead just force that thread to run
pthread_exit(PTHREAD_CANCELED). This allows V to keep
control. */
PRINT("thread_setstate (BOGUS HANDLER) "
"( %ld, %p,%p )", dst_lwpid, ats_new, ats_old);
if (1 && VG_(clo_trace_syscalls) && ats_new)
ML_(aix5debugstuff_show_tstate)((Addr)ats_new,
"thread_setstate (NEW)");
/* Intercept and handle ourselves any attempts to cancel
another thread (including this one). */
if (ats_new && (!ats_old) && ats_new->flags == TSTATE_INTR) {
dst_ts = NULL;
if (VG_(clo_trace_syscalls))
VG_(printf)("(INTR for lwpid %ld)", dst_lwpid);
dst_tid = VG_INVALID_THREADID;
for (i = 0; i < VG_N_THREADS; i++) {
dst_ts = VG_(get_ThreadState)(i);
if ((dst_ts->status == VgTs_Runnable
|| dst_ts->status == VgTs_Yielding
|| dst_ts->status == VgTs_WaitSys)
&& dst_ts->os_state.lwpid == dst_lwpid) {
dst_tid = i;
break;
}
}
if (VG_(clo_trace_syscalls)) {
if (dst_tid == VG_INVALID_THREADID)
VG_(printf)("(== unknown tid)");
else
VG_(printf)("(== tid %d)", (Int)dst_tid);
}
if (dst_tid != VG_INVALID_THREADID) {
/* A cancel has been requested for ctid. If the target
thread has cancellation enabled, honour it right now. If
not, mark the thread as having a cancellation request, so
that if it later enables cancellation then the
cancellation will take effect. */
vg_assert(dst_ts);
if (dst_ts->os_state.cancel_progress == Canc_NoRequest) {
if (dst_ts->os_state.cancel_disabled) {
if (VG_(clo_trace_syscalls))
VG_(printf)("(target has cancel disabled"
"; request lodged)");
dst_ts->os_state.cancel_progress = Canc_Requested;
} else {
if (VG_(clo_trace_syscalls))
VG_(printf)("(forcing target into pthread_exit)");
dst_ts->os_state.cancel_progress = Canc_Actioned;
Bool ok = ML_(aix5_force_thread_into_pthread_exit)(dst_tid);
if (!ok) {
/* now at serious risk of deadlock/livelock. Give up
rather than continue. */
ML_(aix5_set_threadstate_for_emergency_exit)
(tid, "pthread_cancel(case2-64): "
"cannot find pthread_exit; aborting");
SET_STATUS_Success(0);
return;
}
}
}
SET_STATUS_Success(0);
return;
}
}
/* Well, it's not a cancellation request. Maybe it is the
initialisation of a previously created thread? */
if (ats_new && !ats_old) {
dst_tid = VG_INVALID_THREADID;
for (i = 0; i < VG_N_THREADS; i++) {
dst_ts = VG_(get_ThreadState)(i);
if (dst_ts->status == VgTs_Init
&& dst_ts->os_state.lwpid == dst_lwpid) {
dst_tid = i;
break;
}
}
if (dst_tid != VG_INVALID_THREADID) {
/* Found the associated child */
if (VG_(clo_trace_syscalls))
VG_(printf)("(initialised child tid %d)", (Int)dst_tid);
dst_ts = VG_(get_ThreadState)(dst_tid);
UWord* stack = (UWord*)ML_(allocstack)(dst_tid);
/* XXX TODO: check allocstack failure */
/* copy the specified child register state into the guest
slot (we need that context to run on the simulated CPU,
not the real one) and put pointers to our own
run-the-simulator function into what we'll hand off to the
kernel instead. */
/* The guest thread is to start running whatever context
this syscall showed up with. */
dst_ts->arch.vex.guest_GPR0 = ats_new->mst.gpr[0];
dst_ts->arch.vex.guest_GPR1 = ats_new->mst.gpr[1]; /* sp */
dst_ts->arch.vex.guest_GPR2 = ats_new->mst.gpr[2]; /* toc */
dst_ts->arch.vex.guest_GPR3 = ats_new->mst.gpr[3]; /* initarg */
dst_ts->arch.vex.guest_GPR4 = ats_new->mst.gpr[4];
dst_ts->arch.vex.guest_GPR5 = ats_new->mst.gpr[5];
dst_ts->arch.vex.guest_GPR6 = ats_new->mst.gpr[6];
dst_ts->arch.vex.guest_GPR7 = ats_new->mst.gpr[7];
dst_ts->arch.vex.guest_GPR8 = ats_new->mst.gpr[8];
dst_ts->arch.vex.guest_GPR9 = ats_new->mst.gpr[9];
dst_ts->arch.vex.guest_GPR10 = ats_new->mst.gpr[10];
dst_ts->arch.vex.guest_GPR11 = ats_new->mst.gpr[11]; /* ?? */
dst_ts->arch.vex.guest_GPR12 = ats_new->mst.gpr[12];
dst_ts->arch.vex.guest_GPR13 = ats_new->mst.gpr[13];
dst_ts->arch.vex.guest_GPR14 = ats_new->mst.gpr[14];
dst_ts->arch.vex.guest_GPR15 = ats_new->mst.gpr[15];
dst_ts->arch.vex.guest_GPR16 = ats_new->mst.gpr[16];
dst_ts->arch.vex.guest_GPR17 = ats_new->mst.gpr[17];
dst_ts->arch.vex.guest_GPR18 = ats_new->mst.gpr[18];
dst_ts->arch.vex.guest_GPR19 = ats_new->mst.gpr[19];
dst_ts->arch.vex.guest_GPR20 = ats_new->mst.gpr[20];
dst_ts->arch.vex.guest_GPR21 = ats_new->mst.gpr[21];
dst_ts->arch.vex.guest_GPR22 = ats_new->mst.gpr[22];
dst_ts->arch.vex.guest_GPR23 = ats_new->mst.gpr[23];
dst_ts->arch.vex.guest_GPR24 = ats_new->mst.gpr[24];
dst_ts->arch.vex.guest_GPR25 = ats_new->mst.gpr[25];
dst_ts->arch.vex.guest_GPR26 = ats_new->mst.gpr[26];
dst_ts->arch.vex.guest_GPR27 = ats_new->mst.gpr[27];
dst_ts->arch.vex.guest_GPR28 = ats_new->mst.gpr[28];
dst_ts->arch.vex.guest_GPR29 = ats_new->mst.gpr[29];
dst_ts->arch.vex.guest_GPR30 = ats_new->mst.gpr[30];
dst_ts->arch.vex.guest_GPR31 = ats_new->mst.gpr[31];
dst_ts->arch.vex.guest_CIA = ats_new->mst.iar; /* pc */
dst_ts->arch.vex.guest_LR = ats_new->mst.lr;
dst_ts->arch.vex.guest_CTR = ats_new->mst.ctr;
LibVEX_GuestPPC64_put_CR( ats_new->mst.cr, &dst_ts->arch.vex );
LibVEX_GuestPPC64_put_XER( ats_new->mst.xer, &dst_ts->arch.vex );
/* Record what seems like the highest legitimate stack
address for this thread, so that the stack unwinder works
properly. It seems reasonable to use the R1 value
supplied here. */
dst_ts->client_stack_highest_word = dst_ts->arch.vex.guest_GPR1;
/* The host thread is to start running
start_thread_NORETURN */
UWord* wrapper_fdescr = (UWord*) & start_thread_NORETURN;
ats_new->mst.gpr[1] = (UWord)stack;
ats_new->mst.gpr[2] = wrapper_fdescr[1];
ats_new->mst.iar = wrapper_fdescr[0];
ats_new->mst.gpr[3] = (UWord)dst_ts;
/* Set initial cancellation status for the thread. */
dst_ts->os_state.cancel_async = False;
dst_ts->os_state.cancel_disabled = False;
dst_ts->os_state.cancel_progress = Canc_NoRequest;
}
}
}
POST(sys_thread_setstate)
{
if (ARG3)
POST_MEM_WRITE( ARG3, sizeof(struct tstate) );
if (0 && VG_(clo_trace_syscalls) && ARG3)
ML_(aix5debugstuff_show_tstate)(ARG3, "thread_setstate (OLD)");
}
PRE(sys_FAKE_SIGRETURN)
{
/* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
an explanation of what follows. */
/* This handles the fake signal-return system call created by
sigframe-ppc64-aix5.c. */
PRINT("FAKE_SIGRETURN ( )");
vg_assert(VG_(is_valid_tid)(tid));
vg_assert(tid >= 1 && tid < VG_N_THREADS);
vg_assert(VG_(is_running_thread)(tid));
/* Remove the signal frame from this thread's (guest) stack,
in the process restoring the pre-signal guest state. */
VG_(sigframe_destroy)(tid, True);
/* Tell the driver not to update the guest state with the "result",
and set a bogus result to keep it happy. */
*flags |= SfNoWriteResult;
SET_STATUS_Success(0);
/* Check to see if any signals arose as a result of this. */
*flags |= SfPollAfter;
}
/* ---------------------------------------------------------------------
The ppc64/AIX5 syscall table
------------------------------------------------------------------ */
typedef
struct {
UInt* pSysNo;
SyscallTableEntry wrappers;
}
AIX5SCTabEntry;
#undef PLAXY
#undef PLAX_
#define PLAXY(sysno, name) \
{ & sysno, \
{ & WRAPPER_PRE_NAME(ppc64_aix5, name), \
& WRAPPER_POST_NAME(ppc64_aix5, name) }}
#define PLAX_(sysno, name) \
{ & sysno, \
{ & WRAPPER_PRE_NAME(ppc64_aix5, name), \
NULL }}
static /* but not const */
AIX5SCTabEntry aix5_ppc64_syscall_table[]
= {
AIXXY(__NR_AIX5___libc_sbrk, sys___libc_sbrk),
AIXX_(__NR_AIX5___msleep, sys___msleep),
PLAXY(__NR_AIX5__clock_gettime, sys__clock_gettime),
AIXX_(__NR_AIX5__exit, sys__exit),
PLAX_(__NR_AIX5__fp_fpscrx64_, sys__fp_fpscrx64_),
AIXX_(__NR_AIX5__getpid, sys__getpid),
AIXXY(__NR_AIX5__nsleep, sys__nsleep),
AIXX_(__NR_AIX5__pause, sys__pause),
AIXXY(__NR_AIX5__poll, sys__poll),
AIXX_(__NR_AIX5__select, sys__select),
AIXX_(__NR_AIX5__sem_wait, sys__sem_wait),
AIXXY(__NR_AIX5__sigaction, sys__sigaction),
AIXX_(__NR_AIX5__thread_self, sys__thread_self),
AIXX_(__NR_AIX5_access, sys_access),
AIXX_(__NR_AIX5_accessx, sys_accessx),
AIXXY(__NR_AIX5_appgetrlimit, sys_appgetrlimit),
AIXXY(__NR_AIX5_appgetrusage, sys_appgetrusage),
AIXX_(__NR_AIX5_appsetrlimit, sys_appsetrlimit),
AIXX_(__NR_AIX5_appulimit, sys_appulimit),
AIXX_(__NR_AIX5_bind, sys_bind),
AIXX_(__NR_AIX5_chdir, sys_chdir),
AIXX_(__NR_AIX5_chmod, sys_chmod),
AIXX_(__NR_AIX5_chown, sys_chown),
AIXX_(__NR_AIX5_close, sys_close),
AIXX_(__NR_AIX5_connext, sys_connext),
AIXX_(__NR_AIX5_execve, sys_execve),
AIXXY(__NR_AIX5_finfo, sys_finfo),
AIXXY(__NR_AIX5_fstatfs, sys_fstatfs),
AIXXY(__NR_AIX5_fstatx, sys_fstatx),
AIXXY(__NR_AIX5_getdirent, sys_getdirent),
AIXXY(__NR_AIX5_getdirent64, sys_getdirent64),
AIXXY(__NR_AIX5_getdomainname, sys_getdomainname),
AIXX_(__NR_AIX5_getgidx, sys_getgidx),
AIXXY(__NR_AIX5_gethostname, sys_gethostname),
AIXXY(__NR_AIX5_getpriv, sys_getpriv),
AIXXY(__NR_AIX5_getprocs, sys_getprocs),
AIXXY(__NR_AIX5_getprocs64, sys_getprocs), /* XXX: correct? */
AIXX_(__NR_AIX5_getrpid, sys_getrpid),
AIXXY(__NR_AIX5_getsockopt, sys_getsockopt),
AIXX_(__NR_AIX5_gettimerid, sys_gettimerid),
AIXX_(__NR_AIX5_getuidx, sys_getuidx),
AIXXY(__NR_AIX5_incinterval, sys_incinterval),
AIXXY(__NR_AIX5_kfcntl, sys_kfcntl),
AIXX_(__NR_AIX5_kfork, sys_kfork),
AIXX_(__NR_AIX5_kill, sys_kill),
AIXXY(__NR_AIX5_kioctl, sys_kioctl),
PLAXY(__NR_AIX5_kload, sys_kload),
AIXX_(__NR_AIX5_klseek, sys_klseek),
AIXXY(__NR_AIX5_kread, sys_kread),
AIXXY(__NR_AIX5_kreadv, sys_kreadv),
AIXX_(__NR_AIX5_kthread_ctl, sys_kthread_ctl),
AIXX_(__NR_AIX5_ktruncate, sys_ktruncate),
PLAXY(__NR_AIX5_kunload64, sys_kunload64),
AIXXY(__NR_AIX5_kwaitpid, sys_kwaitpid),
AIXX_(__NR_AIX5_kwrite, sys_kwrite),
AIXX_(__NR_AIX5_kwritev, sys_kwritev),
AIXX_(__NR_AIX5_lseek, sys_lseek),
AIXX_(__NR_AIX5_mkdir, sys_mkdir),
AIXXY(__NR_AIX5_mmap, sys_mmap),
AIXXY(__NR_AIX5_mntctl, sys_mntctl),
AIXXY(__NR_AIX5_mprotect, sys_mprotect),
AIXXY(__NR_AIX5_munmap, sys_munmap),
AIXXY(__NR_AIX5_ngetpeername, sys_ngetpeername),
AIXXY(__NR_AIX5_ngetsockname, sys_ngetsockname),
AIXXY(__NR_AIX5_nrecvfrom, sys_nrecvfrom),
AIXX_(__NR_AIX5_nrecvmsg, sys_nrecvmsg),
AIXX_(__NR_AIX5_open, sys_open),
AIXXY(__NR_AIX5_pipe, sys_pipe),
AIXX_(__NR_AIX5_privcheck, sys_privcheck),
AIXX_(__NR_AIX5_rename, sys_rename),
AIXXY(__NR_AIX5_sbrk, sys_sbrk),
AIXXY(__NR_AIX5_sem_init, sys_sem_init),
AIXXY(__NR_AIX5_sem_post, sys_sem_post),
AIXX_(__NR_AIX5_send, sys_send),
AIXX_(__NR_AIX5_setgid, sys_setgid),
AIXX_(__NR_AIX5_setsockopt, sys_setsockopt),
AIXX_(__NR_AIX5_setuid, sys_setuid),
AIXXY(__NR_AIX5_shmat, sys_shmat),
AIXXY(__NR_AIX5_shmctl, sys_shmctl),
AIXXY(__NR_AIX5_shmdt, sys_shmdt),
AIXX_(__NR_AIX5_shmget, sys_shmget),
AIXX_(__NR_AIX5_shutdown, sys_shutdown),
AIXX_(__NR_AIX5_sigcleanup, sys_sigcleanup),
AIXXY(__NR_AIX5_sigprocmask, sys_sigprocmask),
AIXXY(__NR_AIX5_sys_parm, sys_sys_parm),
AIXXY(__NR_AIX5_sysconfig, sys_sysconfig),
AIXX_(__NR_AIX5_socket, sys_socket),
AIXXY(__NR_AIX5_statx, sys_statx),
AIXXY(__NR_AIX5_thread_create, sys_thread_create),
AIXX_(__NR_AIX5_thread_init, sys_thread_init),
AIXX_(__NR_AIX5_thread_kill, sys_thread_kill),
AIXXY(__NR_AIX5_thread_setmystate, sys_thread_setmystate),
AIXX_(__NR_AIX5_thread_setmystate_fast, sys_thread_setmystate_fast),
PLAXY(__NR_AIX5_thread_setstate, sys_thread_setstate),
AIXX_(__NR_AIX5_thread_terminate_unlock, sys_thread_terminate_unlock),
AIXX_(__NR_AIX5_thread_tsleep, sys_thread_tsleep),
AIXX_(__NR_AIX5_thread_twakeup, sys_thread_twakeup),
AIXX_(__NR_AIX5_thread_unlock, sys_thread_unlock),
AIXX_(__NR_AIX5_thread_waitlock_, sys_thread_waitlock_),
AIXXY(__NR_AIX5_times, sys_times),
AIXXY(__NR_AIX5_uname, sys_uname),
AIXX_(__NR_AIX5_unlink, sys_unlink),
AIXX_(__NR_AIX5_utimes, sys_utimes),
AIXXY(__NR_AIX5_vmgetinfo, sys_vmgetinfo),
AIXX_(__NR_AIX5_yield, sys_yield),
PLAX_(__NR_AIX5_FAKE_SIGRETURN, sys_FAKE_SIGRETURN)
};
SyscallTableEntry* ML_(get_ppc64_aix5_syscall_entry) ( UInt sysno )
{
Int i;
AIX5SCTabEntry tmp;
const Int tab_size = sizeof(aix5_ppc64_syscall_table)
/ sizeof(aix5_ppc64_syscall_table[0]);
for (i = 0; i < tab_size; i++)
if (sysno == *(aix5_ppc64_syscall_table[i].pSysNo))
break;
vg_assert(i >= 0 && i <= tab_size);
if (i == tab_size)
return NULL; /* can't find a wrapper */
/* Move found one a bit closer to the front, so as to
make future searches cheaper. */
if (i > 0) {
tmp = aix5_ppc64_syscall_table[i-1];
aix5_ppc64_syscall_table[i-1] = aix5_ppc64_syscall_table[i];
aix5_ppc64_syscall_table[i] = tmp;
i--;
}
vg_assert(i >= 0 && i < tab_size);
return &aix5_ppc64_syscall_table[i].wrappers;
}
#endif // defined(VGP_ppc64_aix5)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink