@FLAG_W_WRITE_STRINGS@ \
@FLAG_W_EMPTY_BODY@ \
@FLAG_W_FORMAT@ \
+ @FLAG_W_FORMAT_SIGNEDNESS@ \
@FLAG_W_FORMAT_SECURITY@ \
@FLAG_W_IGNORED_QUALIFIERS@ \
@FLAG_W_MISSING_PARAMETER_TYPE@ \
AC_GCC_WARNING_SUBST([write-strings], [FLAG_W_WRITE_STRINGS])
AC_GCC_WARNING_SUBST([empty-body], [FLAG_W_EMPTY_BODY])
AC_GCC_WARNING_SUBST([format], [FLAG_W_FORMAT])
+# Disabled for now until all platforms are clean
+# AC_GCC_WARNING_SUBST([format-signedness], [FLAG_W_FORMAT_SIGNEDNESS])
AC_GCC_WARNING_SUBST([cast-qual], [FLAG_W_CAST_QUAL])
AC_GCC_WARNING_SUBST([old-style-declaration], [FLAG_W_OLD_STYLE_DECLARATION])
AC_GCC_WARNING_SUBST([ignored-qualifiers], [FLAG_W_IGNORED_QUALIFIERS])
#define ARG7 (arrghs->arg7)
#define ARG8 (arrghs->arg8)
+/* Provide signed versions of the argument values */
+#define SARG1 ((Word)ARG1)
+#define SARG2 ((Word)ARG2)
+#define SARG3 ((Word)ARG3)
+#define SARG4 ((Word)ARG4)
+#define SARG5 ((Word)ARG5)
+#define SARG6 ((Word)ARG6)
+#define SARG7 ((Word)ARG7)
+#define SARG8 ((Word)ARG8)
+
/* Reference to the syscall's current result status/value. General
paranoia all round. */
#define SUCCESS (status->what == SsComplete && !sr_isError(status->sres))
if (0) VG_(printf)(
"wqthread_hijack: self %#lx, kport %#lx, "
"stackaddr %#lx, workitem %#lx, reuse/flags %x, sp %#lx\n",
- self, kport, stackaddr, workitem, reuse, sp);
+ self, kport, stackaddr, workitem, (UInt)reuse, sp);
/* Start the thread with all signals blocked. VG_(scheduler) will
set the mask correctly when we finally get there. */
tst = VG_(get_ThreadState)(tid);
- if (0) VG_(printf)("wqthread_hijack reuse %s: tid %d, tst %p, "
+ if (0) VG_(printf)("wqthread_hijack reuse %s: tid %u, tst %p, "
"tst->os_state.pthread %#lx, self %#lx\n",
tst->os_state.pthread == self ? "SAME" : "DIFF",
- tid, tst, tst->os_state.pthread, self);
+ tid, (void *)tst, tst->os_state.pthread, self);
vex = &tst->arch.vex;
vg_assert(tst->os_state.pthread - magic_delta == self);
PRE(sys_arch_prctl)
{
ThreadState* tst;
- PRINT( "arch_prctl ( %ld, %lx )", ARG1, ARG2 );
+ PRINT( "arch_prctl ( %ld, %lx )", SARG1, ARG2 );
vg_assert(VG_(is_valid_tid)(tid));
vg_assert(tid >= 1 && tid < VG_N_THREADS);
// space, and we should therefore not check anything it points to.
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace",
long, request, long, pid, long, addr, long, data);
switch (ARG1) {
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "fadvise64",
int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
}
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %d, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, (Int)ARG5, ARG6 );
+ PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %ld )",
+ ARG1, ARG2, SARG3, SARG4, SARG5, SARG6 );
PRE_REG_READ6(long, "mmap",
unsigned long, start, unsigned long, length,
- unsigned long, prot, unsigned long, flags,
- unsigned long, fd, unsigned long, offset);
+ int, prot, int, flags, int, fd, vki_off_t, offset);
r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
SET_STATUS_from_SysRes(r);
if (rflags != ~VKI_UC_GUEST_RFLAGS_NEG(uc)) {
VG_(debugLog)(1, "syswrap-solaris",
"The rflags value was restored from an "
- "explicitly set value in thread %d.\n", tid);
+ "explicitly set value in thread %u.\n", tid);
ok_restore = True;
}
else {
/* Check ok, the full restoration is possible. */
VG_(debugLog)(1, "syswrap-solaris",
"The CC_* guest state values were fully "
- "restored in thread %d.\n", tid);
+ "restored in thread %u.\n", tid);
ok_restore = True;
tst->arch.vex.guest_CC_OP = VKI_UC_GUEST_CC_OP(uc);
VG_(debugLog)(1, "syswrap-solaris",
"Cannot fully restore the CC_* guest state "
"values, using approximate rflags in thread "
- "%d.\n", tid);
+ "%u.\n", tid);
}
}
note = LibVEX_GuestAMD64_fxrstor((HWord)fs, &tst->arch.vex);
if (note != EmNote_NONE)
VG_(message)(Vg_UserMsg,
- "Error restoring FP state in thread %d: %s.\n",
+ "Error restoring FP state in thread %u: %s.\n",
tid, LibVEX_EmNote_string(note));
}
}
// pagesize or 4K-size units in offset? For ppc32/64-linux, this is
// 4K-sized. Assert that the page size is 4K here for safety.
vg_assert(VKI_PAGE_SIZE == 4096);
- PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ PRINT("sys_mmap2 ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap2",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
// things, eventually, I think. --njn
PRE(sys_lstat64)
{
- PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(sys_stat64)
{
- PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(sys_fstatat64)
{
- PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3);
PRE_REG_READ3(long, "fstatat64",
int, dfd, char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
PRE(sys_fstat64)
{
- PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("sys_fstat64 ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
}
that takes a pointer to the signal mask so supports more signals.
*/
*flags |= SfMayBlock;
- PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 );
+ PRINT("sys_sigsuspend ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3 );
PRE_REG_READ3(int, "sigsuspend",
int, history0, int, history1,
vki_old_sigset_t, mask);
// space, and we should therefore not check anything it points to.
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace",
long, request, long, pid, long, addr, long, data);
switch (ARG1) {
// ARM64 FIXME is this correct?
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "fadvise64",
int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
}
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %d, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, (Int)ARG5, ARG6 );
+ PRINT("sys_mmap ( %#lx, %lu, %lu, %#lx, %lu, %lu )",
+ ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
ThreadState* tst = VG_(get_ThreadState)(tid);
VG_(debugLog)(1, "syswrap-darwin",
- "thread_wrapper(tid=%lld): entry\n",
- (ULong)tidW);
+ "thread_wrapper(tid=%u): entry\n",
+ tid);
vg_assert(tst->status == VgTs_Init);
VG_(acquire_BigLock)(tid, "thread_wrapper");
if (0)
- VG_(printf)("thread tid %d started: stack = %p\n",
- tid, &tid);
+ VG_(printf)("thread tid %u started: stack = %p\n",
+ tid, (void *)&tid);
/* Make sure error reporting is enabled in the new thread. */
tst->err_disablement_level = 0;
vg_assert(VG_(is_running_thread)(tid));
VG_(debugLog)(1, "syswrap-darwin",
- "thread_wrapper(tid=%lld): done\n",
- (ULong)tidW);
+ "thread_wrapper(tid=%u): done\n",
+ tid);
/* Return to caller, still holding the lock. */
return ret;
}
}
- VG_(debugLog)( 2, "syswrap-darwin", "stack for tid %d at %p; init_SP=%p\n",
+ VG_(debugLog)( 2, "syswrap-darwin", "stack for tid %u at %p; init_SP=%p\n",
tid,
(void*)tst->os_state.valgrind_stack_base,
(void*)tst->os_state.valgrind_stack_init_SP );
ThreadState* tst;
VG_(debugLog)(1, "syswrap-darwin",
- "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): pre-thread_wrapper\n",
+ tid);
tst = VG_(get_ThreadState)(tid);
vg_assert(tst);
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-darwin",
- "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): post-thread_wrapper\n",
+ tid);
c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
);
VG_(debugLog)(
1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"WARNING: exiting thread has err_disablement_level = %u\n",
- (ULong)tidW, tst->err_disablement_level
+ tid, tst->err_disablement_level
);
}
tst->err_disablement_level = 0;
if (c == 1) {
VG_(debugLog)(1, "syswrap-darwin",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"last one standing\n",
- (ULong)tidW);
+ tid);
/* We are the last one standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
mach_msg_header_t msg;
VG_(debugLog)(1, "syswrap-darwin",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"not last one standing\n",
- (ULong)tidW);
+ tid);
/* OK, thread is dead, but others still exist. Just exit. */
if (0 || VG_(clo_trace_syscalls)) {
VG_(debugLog)(0, "syswrap-darwin",
- "sync_mappings (%s) (\"%s\", \"%s\", 0x%llx)\n",
- show_CheckHowOften(check), when, where, (ULong)num);
+ "sync_mappings (%s) (\"%s\", \"%s\", 0x%lx)\n",
+ show_CheckHowOften(check), when, where, num);
}
// 16 is enough for most cases, but small enough that overflow happens
case VKI_DTRACEHIOC_REMOVE:
case VKI_BIOCFLUSH:
case VKI_BIOCPROMISC:
- PRINT("ioctl ( %ld, 0x%lx )",ARG1,ARG2);
+ PRINT("ioctl ( %lu, 0x%lx )", ARG1, ARG2);
PRE_REG_READ2(long, "ioctl",
unsigned int, fd, unsigned int, request);
return;
default:
- PRINT("ioctl ( %ld, 0x%lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("ioctl ( %lu, 0x%lx, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "ioctl",
unsigned int, fd, unsigned int, request, unsigned long, arg);
}
case VKI_F_GETFD:
case VKI_F_GETFL:
case VKI_F_GETOWN:
- PRINT("fcntl ( %ld, %ld )", ARG1,ARG2);
+ PRINT("fcntl ( %lu, %lu )", ARG1,ARG2);
PRE_REG_READ2(long, "fcntl", unsigned int, fd, unsigned int, cmd);
break;
case VKI_F_SETFD:
case VKI_F_SETFL:
case VKI_F_SETOWN:
- PRINT("fcntl[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("fcntl[ARG3=='arg'] ( %lu, %lu, %lu )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd, unsigned long, arg);
break;
case VKI_F_GETLK:
case VKI_F_SETLK:
case VKI_F_SETLKW:
- PRINT("fcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("fcntl[ARG3=='lock'] ( %lu, %lu, %#lx )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct flock64 *, lock);
break;
# if DARWIN_VERS >= DARWIN_10_10
case VKI_F_SETLKWTIMEOUT:
- PRINT("fcntl[ARG3=='locktimeout'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("fcntl[ARG3=='locktimeout'] ( %lu, %lu, %#lx )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct flocktimeout *, lock);
case VKI_F_FREEZE_FS:
case VKI_F_THAW_FS:
case VKI_F_GLOBAL_NOCACHE:
- PRINT("fcntl ( %ld, %s )", ARG1, name_for_fcntl(ARG1));
+ PRINT("fcntl ( %lu, %s, %lu )", ARG1, name_for_fcntl(ARG1), ARG2);
PRE_REG_READ2(long, "fcntl", unsigned int, fd, unsigned int, cmd);
break;
// struct fstore
case VKI_F_PREALLOCATE:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct fstore *, fstore);
// off_t
case VKI_F_SETSIZE:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
vki_off_t *, offset);
// struct radvisory
case VKI_F_RDADVISE:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_radvisory *, radvisory);
// struct fbootstraptransfer
case VKI_F_READBOOTSTRAP:
case VKI_F_WRITEBOOTSTRAP:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct fbootstraptransfer *, bootstrap);
// struct log2phys (out)
case VKI_F_LOG2PHYS:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct log2phys *, l2p);
// char[maxpathlen] (out)
case VKI_F_GETPATH:
- PRINT("fcntl ( %ld, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
char *, pathbuf);
// char[maxpathlen] (in)
case VKI_F_PATHPKG_CHECK:
- PRINT("fcntl ( %ld, %s, %#lx '%s')", ARG1, name_for_fcntl(ARG2), ARG3,
- (char *)ARG3);
+ PRINT("fcntl ( %lu, %s, %#lx '%s')", ARG1, name_for_fcntl(ARG2), ARG3,
+ (HChar *)ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
char *, pathbuf);
break;
case VKI_F_ADDSIGS: /* Add detached signatures (for code signing) */
- PRINT("fcntl ( %ld, %s )", ARG1, name_for_fcntl(ARG2));
+ PRINT("fcntl ( %lu, %s )", ARG1, name_for_fcntl(ARG2));
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
vki_fsignatures_t *, sigs);
break;
case VKI_F_ADDFILESIGS: /* Add signature from same file (used by dyld for shared libs) */
- PRINT("fcntl ( %ld, %s )", ARG1, name_for_fcntl(ARG2));
+ PRINT("fcntl ( %lu, %s, %#lx )", ARG1, name_for_fcntl(ARG2), ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
vki_fsignatures_t *, sigs);
break;
default:
- PRINT("fcntl ( %ld, %ld [??] )", ARG1, ARG2);
- log_decaying("UNKNOWN fcntl %ld!", ARG2);
+ PRINT("fcntl ( %lu, %lu [??] )", ARG1, ARG2);
+ log_decaying("UNKNOWN fcntl %lu!", ARG2);
break;
}
}
PRE(futimes)
{
- PRINT("futimes ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("futimes ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "futimes", int, fd, struct timeval *, tvp);
if (!ML_(fd_allowed)(ARG1, "futimes", tid, False)) {
SET_STATUS_Failure( VKI_EBADF );
PRE(semget)
{
- PRINT("semget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("semget ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semget", vki_key_t, key, int, nsems, int, semflg);
}
PRE(semop)
{
*flags |= SfMayBlock;
- PRINT("semop ( %ld, %#lx, %lu )",ARG1,ARG2,ARG3);
+ PRINT("semop ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "semop",
int, semid, struct sembuf *, sops, vki_size_t, nsoops);
ML_(generic_PRE_sys_semop)(tid, ARG1,ARG2,ARG3);
switch (ARG3) {
case VKI_IPC_STAT:
case VKI_IPC_SET:
- PRINT("semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct semid_ds *, arg);
break;
case VKI_GETALL:
case VKI_SETALL:
- PRINT("semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
case VKI_SETVAL:
- PRINT("semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, int, arg);
break;
default:
- PRINT("semctl ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("semctl ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semctl",
int, semid, int, semnum, int, cmd);
break;
{
if (ARG2 & VKI_O_CREAT) {
// 4-arg version
- PRINT("sem_open ( %#lx(%s), %ld, %ld, %ld )",
- ARG1,(char*)ARG1,ARG2,ARG3,ARG4);
+ PRINT("sem_open ( %#lx(%s), %ld, %lu, %lu )",
+ ARG1, (HChar*)ARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(vki_sem_t *, "sem_open",
const char *, name, int, oflag, vki_mode_t, mode,
unsigned int, value);
} else {
// 2-arg version
- PRINT("sem_open ( %#lx(%s), %ld )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sem_open ( %#lx(%s), %ld )", ARG1, (HChar*)ARG1, SARG2);
PRE_REG_READ2(vki_sem_t *, "sem_open",
const char *, name, int, oflag);
}
PRE(sem_unlink)
{
- PRINT("sem_unlink( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sem_unlink( %#lx(%s) )", ARG1, (HChar*)ARG1);
PRE_REG_READ1(int, "sem_unlink", const char *, name);
PRE_MEM_RASCIIZ( "sem_unlink(name)", ARG1 );
}
PRE(sem_init)
{
- PRINT("sem_init( %#lx, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sem_init( %#lx, %ld, %lu )", ARG1, SARG2, ARG3);
PRE_REG_READ3(int, "sem_init", vki_sem_t *, sem,
int, pshared, unsigned int, value);
PRE_MEM_WRITE("sem_init(sem)", ARG1, sizeof(vki_sem_t));
PRE(kevent)
{
PRINT("kevent( %ld, %#lx, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(int,"kevent", int,kq,
const struct vki_kevent *,changelist, int,nchanges,
struct vki_kevent *,eventlist, int,nevents,
PRE(kevent64)
{
PRINT("kevent64( %ld, %#lx, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG1, ARG2, SARG3, ARG4, SARG5, ARG6);
PRE_REG_READ6(int,"kevent64", int,kq,
const struct vki_kevent64 *,changelist, int,nchanges,
struct vki_kevent64 *,eventlist, int,nevents,
PRE(workq_ops)
{
- PRINT("workq_ops( %ld(%s), %#lx, %ld )", ARG1, workqop_name(ARG1), ARG2,
- ARG3);
+ PRINT("workq_ops( %ld(%s), %#lx, %ld )", SARG1, workqop_name(ARG1), ARG2,
+ SARG3);
PRE_REG_READ3(int,"workq_ops", int,"options", void *,"item",
int,"priority");
PRE(__mac_syscall)
{
PRINT("__mac_syscall( %#lx(%s), %ld, %#lx )",
- ARG1, (HChar*)ARG1, ARG2, ARG3);
+ ARG1, (HChar*)ARG1, SARG2, ARG3);
PRE_REG_READ3(int,"__mac_syscall", char *,"policy",
int,"call", void *,"arg");
ThreadId t;
ThreadState* tst;
- PRINT("darwin exit( %ld )", ARG1);
+ PRINT("darwin exit( %ld )", SARG1);
PRE_REG_READ1(void, "exit", int, status);
tst = VG_(get_ThreadState)(tid);
PRE(sigaction)
{
- PRINT("sigaction ( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sigaction ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigaction",
int, signum, vki_sigaction_toK_t *, act,
vki_sigaction_fromK_t *, oldact);
PRE(__pthread_kill)
{
- PRINT("__pthread_kill ( %ld, %ld )", ARG1, ARG2);
+ PRINT("__pthread_kill ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "__pthread_kill", vki_pthread_t*, thread, int, sig);
}
{
// arguments are identical to sigprocmask (how, sigset_t*, sigset_t*).
UWord arg1;
- PRINT("__pthread_sigmask ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("__pthread_sigmask ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "__pthread_sigmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oldset);
if (ARG2 != 0)
*flags |= SfMayBlock; /* might kill this thread??? */
/* I don't think so -- I think it just changes the cancellation
state. But taking no chances. */
- PRINT("__pthread_canceled ( %ld )", ARG1);
+ PRINT("__pthread_canceled ( %#lx )", ARG1);
PRE_REG_READ1(long, "__pthread_canceled", void*, arg1);
}
PRE(__disable_threadsignal)
{
vki_sigset_t set;
- PRINT("__disable_threadsignal(%ld, %ld, %ld)", ARG1, ARG2, ARG3);
+ PRINT("__disable_threadsignal(%ld, %ld, %ld)", SARG1, SARG2, SARG3);
/* I don't think this really looks at its arguments. So don't
bother to check them. */
PRE(__pthread_chdir)
{
- PRINT("__pthread_chdir ( %#lx(%s) )", ARG1, (char*)ARG1);
+ PRINT("__pthread_chdir ( %#lx(%s) )", ARG1, (HChar*)ARG1);
PRE_REG_READ1(long, "__pthread_chdir", const char *, path);
PRE_MEM_RASCIIZ( "__pthread_chdir(path)", ARG1 );
}
PRE(__pthread_fchdir)
{
- PRINT("__pthread_fchdir ( %ld )", ARG1);
+ PRINT("__pthread_fchdir ( %lu )", ARG1);
PRE_REG_READ1(long, "__pthread_fchdir", unsigned int, fd);
}
PRE(kdebug_trace)
{
PRINT("kdebug_trace(%ld, %ld, %ld, %ld, %ld, %ld)",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG1, SARG2, SARG3, SARG4, SARG5, SARG6);
/*
Don't check anything - some clients pass fewer arguments.
PRE_REG_READ6(long, "kdebug_trace",
PRE(seteuid)
{
- PRINT("seteuid(%ld)", ARG1);
+ PRINT("seteuid(%lu)", ARG1);
PRE_REG_READ1(long, "seteuid", vki_uid_t, "uid");
}
PRE(setegid)
{
- PRINT("setegid(%ld)", ARG1);
+ PRINT("setegid(%lu)", ARG1);
PRE_REG_READ1(long, "setegid", vki_uid_t, "uid");
}
PRE(settid)
{
- PRINT("settid(%ld, %ld)", ARG1, ARG2);
+ PRINT("settid(%lu, %lu)", ARG1, ARG2);
PRE_REG_READ2(long, "settid", vki_uid_t, "uid", vki_gid_t, "gid");
}
PRE(getxattr)
{
PRINT("getxattr(%#lx(%s), %#lx(%s), %#lx, %lu, %lu, %ld)",
- ARG1, (char *)ARG1, ARG2, (char *)ARG2, ARG3, ARG4, ARG5, ARG6);
+ ARG1, (HChar *)ARG1, ARG2, (HChar *)ARG2, ARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(vki_ssize_t, "getxattr",
const char *, path, char *, name, void *, value,
PRE(fgetxattr)
{
PRINT("fgetxattr(%ld, %#lx(%s), %#lx, %lu, %lu, %ld)",
- ARG1, ARG2, (char *)ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG1, ARG2, (HChar *)ARG2, ARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(vki_ssize_t, "fgetxattr",
int, fd, char *, name, void *, value,
PRE(setxattr)
{
PRINT("setxattr ( %#lx(%s), %#lx(%s), %#lx, %lu, %lu, %ld )",
- ARG1, (char *)ARG1, ARG2, (char*)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ ARG1, (HChar *)ARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, ARG5, SARG6 );
PRE_REG_READ6(int, "setxattr",
const char *,"path", char *,"name", void *,"value",
vki_size_t,"size", uint32_t,"position", int,"options" );
PRE(fsetxattr)
{
PRINT( "fsetxattr ( %ld, %#lx(%s), %#lx, %lu, %lu, %ld )",
- ARG1, ARG2, (char*)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, ARG5, SARG6 );
PRE_REG_READ6(int, "fsetxattr",
int,"fd", char *,"name", void *,"value",
vki_size_t,"size", uint32_t,"position", int,"options" );
PRE(removexattr)
{
PRINT( "removexattr ( %#lx(%s), %#lx(%s), %ld )",
- ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3 );
+ ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, SARG3 );
PRE_REG_READ3(int, "removexattr",
const char*, "path", char*, "attrname", int, "options");
PRE_MEM_RASCIIZ( "removexattr(path)", ARG1 );
PRE(fremovexattr)
{
PRINT( "fremovexattr ( %ld, %#lx(%s), %ld )",
- ARG1, ARG2, (HChar*)ARG2, ARG3 );
+ SARG1, ARG2, (HChar*)ARG2, SARG3 );
PRE_REG_READ3(int, "fremovexattr",
int, "fd", char*, "attrname", int, "options");
PRE_MEM_RASCIIZ( "removexattr(attrname)", ARG2 );
PRE(listxattr)
{
PRINT( "listxattr ( %#lx(%s), %#lx, %lu, %ld )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4 );
+ ARG1, (HChar *)ARG1, ARG2, ARG3, SARG4 );
PRE_REG_READ4 (long, "listxattr",
const char *,"path", char *,"namebuf",
vki_size_t,"size", int,"options" );
PRE(flistxattr)
{
PRINT( "flistxattr ( %ld, %#lx, %lu, %ld )",
- ARG1, ARG2, ARG3, ARG4 );
+ SARG1, ARG2, ARG3, SARG4 );
PRE_REG_READ4 (long, "flistxattr",
int, "fd", char *,"namebuf",
vki_size_t,"size", int,"options" );
PRE(shmat)
{
UWord arg2tmp;
- PRINT("shmat ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("shmat ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmat",
int, shmid, const void *, shmaddr, int, shmflg);
arg2tmp = ML_(generic_PRE_sys_shmat)(tid, ARG1,ARG2,ARG3);
PRE(shmctl)
{
- PRINT("shmctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("shmctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "shmctl",
int, shmid, int, cmd, struct vki_shmid_ds *, buf);
ML_(generic_PRE_sys_shmctl)(tid, ARG1,ARG2,ARG3);
PRE(shmget)
{
- PRINT("shmget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("shmget ( %ld, %lu, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmget", vki_key_t, key, vki_size_t, size, int, shmflg);
}
PRE(shm_open)
{
- PRINT("shm_open(%#lx(%s), %ld, %ld)", ARG1, (char *)ARG1, ARG2, ARG3);
+ PRINT("shm_open(%#lx(%s), %ld, %lu)", ARG1, (HChar *)ARG1, SARG2, ARG3);
PRE_REG_READ3(long, "shm_open",
const char *,"name", int,"flags", vki_mode_t,"mode");
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (char*)ARG1);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
}
}
PRE(shm_unlink)
{
*flags |= SfMayBlock;
- PRINT("shm_unlink ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("shm_unlink ( %#lx(%s) )", ARG1, (HChar*)ARG1);
PRE_REG_READ1(long, "shm_unlink", const char *, pathname);
PRE_MEM_RASCIIZ( "shm_unlink(pathname)", ARG1 );
}
PRE(stat_extended)
{
PRINT("stat_extended( %#lx(%s), %#lx, %#lx, %#lx )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "stat_extended", char *, file_name, struct stat *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_RASCIIZ( "stat_extended(file_name)", ARG1 );
PRE(lstat_extended)
{
PRINT("lstat_extended( %#lx(%s), %#lx, %#lx, %#lx )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "lstat_extended", char *, file_name, struct stat *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_RASCIIZ( "lstat_extended(file_name)", ARG1 );
PRE(fstat_extended)
{
PRINT("fstat_extended( %ld, %#lx, %#lx, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "fstat_extended", int, fd, struct stat *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_WRITE( "fstat_extended(buf)", ARG2, sizeof(struct vki_stat) );
PRE(stat64_extended)
{
PRINT("stat64_extended( %#lx(%s), %#lx, %#lx, %#lx )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "stat64_extended", char *, file_name, struct stat64 *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_RASCIIZ( "stat64_extended(file_name)", ARG1 );
PRE(lstat64_extended)
{
PRINT("lstat64_extended( %#lx(%s), %#lx, %#lx, %#lx )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "lstat64_extended", char *, file_name, struct stat64 *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_RASCIIZ( "lstat64_extended(file_name)", ARG1 );
PRE(fstat64_extended)
{
PRINT("fstat64_extended( %ld, %#lx, %#lx, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "fstat64_extended", int, fd, struct stat64 *, buf,
void *, fsacl, vki_size_t *, fsacl_size);
PRE_MEM_WRITE( "fstat64_extended(buf)", ARG2, sizeof(struct vki_stat64) );
{
/* DDD: Note: this is not really correct. Handling of
chmod_extended is broken in the same way. */
- PRINT("fchmod_extended ( %ld, %ld, %ld, %ld, %#lx )",
+ PRINT("fchmod_extended ( %lu, %lu, %lu, %lu, %#lx )",
ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "fchmod_extended",
unsigned int, fildes,
{
/* DDD: Note: this is not really correct. Handling of
{,f}chmod_extended is broken in the same way. */
- PRINT("open_extended ( %#lx(%s), 0x%lx, %ld, %ld, %ld, %#lx )",
+ PRINT("open_extended ( %#lx(%s), %ld, %lu, %lu, %lu, %#lx )",
ARG1, ARG1 ? (HChar*)ARG1 : "(null)",
- ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "open_extended",
char*, path,
int, flags,
PRE(access_extended)
{
PRINT("access_extended( %#lx(%s), %lu, %#lx, %lu )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
// XXX: the accessx_descriptor struct contains padding, so this can cause
// unnecessary undefined value errors. But you arguably shouldn't be
// passing undefined values to the kernel anyway...
PRE(chflags)
{
- PRINT("chflags ( %#lx(%s), %lu )", ARG1, (char *)ARG1, ARG2);
+ PRINT("chflags ( %#lx(%s), %lu )", ARG1, (HChar *)ARG1, ARG2);
PRE_REG_READ2(int, "chflags", const char *,path, unsigned int,flags);
PRE_MEM_RASCIIZ("chflags(path)", ARG1);
PRE(fchflags)
{
- PRINT("fchflags ( %ld, %lu )", ARG1, ARG2);
+ PRINT("fchflags ( %ld, %lu )", SARG1, ARG2);
PRE_REG_READ2(int, "fchflags", int,fd, unsigned int,flags);
// GrP fixme sanity-check flags value?
PRE(stat64)
{
- PRINT("stat64 ( %#lx(%s), %#lx )", ARG1, (char *)ARG1, ARG2);
+ PRINT("stat64 ( %#lx(%s), %#lx )", ARG1, (HChar *)ARG1, ARG2);
PRE_REG_READ2(long, "stat", const char *,path, struct stat64 *,buf);
PRE_MEM_RASCIIZ("stat64(path)", ARG1);
PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(lstat64)
{
- PRINT("lstat64 ( %#lx(%s), %#lx )", ARG1, (char *)ARG1, ARG2);
+ PRINT("lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar *)ARG1, ARG2);
PRE_REG_READ2(long, "stat", const char *,path, struct stat64 *,buf);
PRE_MEM_RASCIIZ("lstat64(path)", ARG1);
PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(fstat64)
{
- PRINT("fstat64 ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("fstat64 ( %lu, %#lx )", ARG1,ARG2);
PRE_REG_READ2(long, "fstat", unsigned int, fd, struct stat64 *, buf);
PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
}
PRE(getfsstat)
{
- PRINT("getfsstat(%#lx, %ld, %ld)", ARG1, ARG2, ARG3);
+ PRINT("getfsstat(%#lx, %ld, %ld)", ARG1, SARG2, SARG3);
PRE_REG_READ3(int, "getfsstat",
struct vki_statfs *, buf, int, bufsize, int, flags);
if (ARG1) {
PRE(getfsstat64)
{
- PRINT("getfsstat64(%#lx, %ld, %ld)", ARG1, ARG2, ARG3);
+ PRINT("getfsstat64(%#lx, %ld, %ld)", ARG1, SARG2, SARG3);
PRE_REG_READ3(int, "getfsstat64",
struct vki_statfs64 *, buf, int, bufsize, int, flags);
if (ARG1) {
// by 'data'.
*flags |= SfMayBlock;
PRINT("sys_mount( %#lx(%s), %#lx(%s), %#lx, %#lx )",
- ARG1,(char*)ARG1, ARG2,(char*)ARG2, ARG3, ARG4);
+ ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "mount",
const char *, type, const char *, dir,
int, flags, void *, data);
PRE(getattrlist)
{
PRINT("getattrlist(%#lx(%s), %#lx, %#lx, %lu, %lu)",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4, ARG5);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(int, "getattrlist",
const char *,path, struct vki_attrlist *,attrList,
void *,attrBuf, vki_size_t,attrBufSize, unsigned int,options);
PRE(setattrlist)
{
PRINT("setattrlist(%#lx(%s), %#lx, %#lx, %lu, %lu)",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4, ARG5);
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(int, "setattrlist",
const char *,path, struct vki_attrlist *,attrList,
void *,attrBuf, vki_size_t,attrBufSize, unsigned int,options);
PRE(getdirentriesattr)
{
- PRINT("getdirentriesattr(%ld, %#lx, %#lx, %ld, %#lx, %#lx, %#lx, %ld)",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8);
+ PRINT("getdirentriesattr(%ld, %#lx, %#lx, %lu, %#lx, %#lx, %#lx, %lu)",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8);
PRE_REG_READ8(int, "getdirentriesattr",
int,fd, struct vki_attrlist *,attrList,
void *,attrBuf, size_t,attrBufSize,
PRE(exchangedata)
{
PRINT("exchangedata(%#lx(%s), %#lx(%s), %lu)",
- ARG1, (char*)ARG1, ARG2, (char*)ARG2, ARG3);
+ ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3);
PRE_REG_READ3(int, "exchangedata",
char *, path1, char *, path2, unsigned long, options);
PRE_MEM_RASCIIZ( "exchangedata(path1)", ARG1 );
PRE(fsctl)
{
- PRINT("fsctl ( %#lx(%s), %ld, %#lx, %ld )",
- ARG1, (char *)ARG1, ARG2, ARG3, ARG4);
+ PRINT("fsctl ( %#lx(%s), %lu, %#lx, %lu )",
+ ARG1, (HChar *)ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4( long, "fsctl",
char *,"path", unsigned int,"request",
void *,"data", unsigned int,"options");
PRE(initgroups)
{
- PRINT("initgroups(%s, %#lx, %lu)", (char *)ARG1, ARG2, ARG3);
+ PRINT("initgroups(%s, %#lx, %lu)", (HChar *)ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "initgroups",
int, setlen, vki_gid_t *, gidset, vki_uid_t, gmuid);
PRE_MEM_READ("gidset", ARG2, ARG1 * sizeof(vki_gid_t));
PRE(socket)
{
- PRINT("socket ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("socket ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "socket", int, domain, int, type, int, protocol);
}
PRE(setsockopt)
{
PRINT("setsockopt ( %ld, %ld, %ld, %#lx, %ld )",
- ARG1,ARG2,ARG3,ARG4,ARG5);
+ SARG1, SARG2, SARG3, ARG4, SARG5);
PRE_REG_READ5(long, "setsockopt",
int, s, int, level, int, optname,
const void *, optval, vki_socklen_t, optlen);
Addr optval_p = ARG4;
Addr optlen_p = ARG5;
PRINT("getsockopt ( %ld, %ld, %ld, %#lx, %#lx )",
- ARG1,ARG2,ARG3,ARG4,ARG5);
+ SARG1, SARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, "getsockopt",
int, s, int, level, int, optname,
void *, optval, vki_socklen_t *, optlen);
PRE(connect)
{
*flags |= SfMayBlock;
- PRINT("connect ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("connect ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "connect",
int, sockfd, struct sockaddr *, serv_addr, int, addrlen);
ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3);
PRE(accept)
{
*flags |= SfMayBlock;
- PRINT("accept ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("accept ( %ld, %#lx, %#lx )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "accept",
- int, s, struct sockaddr *, addr, int, *addrlen);
+ int, s, struct sockaddr *, addr, int *, addrlen);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
PRE(mkfifo)
{
*flags |= SfMayBlock;
- PRINT("mkfifo ( %#lx(%s), %lld )",ARG1,(char *)ARG1,(ULong)ARG2);
+ PRINT("mkfifo ( %#lx(%s), %lx )", ARG1, (HChar *)ARG1, ARG2);
PRE_REG_READ2(long, "mkfifo", const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "mkfifo(path)", ARG1 );
}
{
*flags |= SfMayBlock;
PRINT("sendto ( %ld, %s, %ld, %lu, %#lx, %ld )",
- ARG1,(char *)ARG2,ARG3,ARG4,ARG5,ARG6);
+ SARG1, (HChar *)ARG2, SARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendto",
int, s, const void *, msg, int, len,
unsigned int, flags,
{
#if VG_WORDSIZE == 4
PRINT("sendfile(%ld, %ld, %llu, %#lx, %#lx, %ld)",
- ARG1, ARG2, LOHI64(ARG3, ARG4), ARG5, ARG6, ARG7);
+ SARG1, SARG2, LOHI64(ARG3, ARG4), ARG5, ARG6, SARG7);
PRE_REG_READ7(long, "sendfile",
int, fromfd, int, tofd,
PRE_MEM_WRITE("sendfile(nwritten)", ARG5, sizeof(vki_uint64_t));
if (ARG6) PRE_MEM_WRITE("sendfile(sf_header)", ARG6, sizeof(struct sf_hdtr));
#else
- PRINT("sendfile(%ld, %ld, %ld, %#lx, %#lx, %ld)",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ PRINT("sendfile(%ld, %ld, %lu, %#lx, %#lx, %ld)",
+ SARG1, SARG2, ARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendfile",
int, fromfd, int, tofd,
{
*flags |= SfMayBlock;
PRINT("recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )",
- ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ SARG1, ARG2, SARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "recvfrom",
int, s, void *, buf, int, len, unsigned int, flags,
struct sockaddr *, from, int *, fromlen);
PRE(sendmsg)
{
*flags |= SfMayBlock;
- PRINT("sendmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sendmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "sendmsg",
int, s, const struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr *)ARG2);
PRE(recvmsg)
{
*flags |= SfMayBlock;
- PRINT("recvmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("recvmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)ARG2);
}
PRE(shutdown)
{
*flags |= SfMayBlock;
- PRINT("shutdown ( %ld, %ld )",ARG1,ARG2);
+ PRINT("shutdown ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(int, "shutdown", int, s, int, how);
}
PRE(bind)
{
- PRINT("bind ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("bind ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "bind",
int, sockfd, struct sockaddr *, my_addr, int, addrlen);
ML_(generic_PRE_sys_bind)(tid, ARG1,ARG2,ARG3);
PRE(listen)
{
- PRINT("listen ( %ld, %ld )",ARG1,ARG2);
+ PRINT("listen ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "listen", int, s, int, backlog);
}
PRE(getsockname)
{
- PRINT("getsockname ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("getsockname ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getsockname",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getsockname)(tid, ARG1,ARG2,ARG3);
PRE(getpeername)
{
- PRINT("getpeername ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("getpeername ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getpeername",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getpeername)(tid, ARG1,ARG2,ARG3);
PRE(socketpair)
{
- PRINT("socketpair ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("socketpair ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "socketpair",
int, d, int, type, int, protocol, int *, sv);
ML_(generic_PRE_sys_socketpair)(tid, ARG1,ARG2,ARG3,ARG4);
PRE(getlogin)
{
- PRINT("getlogin ( %#lx, %ld )", ARG1, ARG2);
+ PRINT("getlogin ( %#lx, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "getlogin",
char *,"namebuf", unsigned int,"namelen");
PRE(ptrace)
{
- PRINT("ptrace ( %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("ptrace ( %ld, %ld, %#lx, %ld )", SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "ptrace",
int,"request", vki_pid_t,"pid",
vki_caddr_t,"addr", int,"data");
PRE(lseek)
{
- PRINT("lseek ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("lseek ( %lu, %ld, %ld )", ARG1, SARG2, SARG3);
PRE_REG_READ4(vki_off_t, "lseek",
unsigned int,fd, int,offset_hi, int,offset_lo,
unsigned int,whence);
PRE(pathconf)
{
- PRINT("pathconf(%#lx(%s), %ld)", ARG1,(char *)ARG1,ARG2);
+ PRINT("pathconf(%#lx(%s), %ld)", ARG1, (HChar *)ARG1, SARG2);
PRE_REG_READ2(long,"pathconf", const char *,"path", int,"name");
PRE_MEM_RASCIIZ("pathconf(path)", ARG1);
}
PRE(fpathconf)
{
- PRINT("fpathconf(%ld, %ld)", ARG1,ARG2);
+ PRINT("fpathconf(%ld, %ld)", SARG1, SARG2);
PRE_REG_READ2(long,"fpathconf", int,"fd", int,"name");
if (!ML_(fd_allowed)(ARG1, "fpathconf", tid, False))
PRE(getdirentries)
{
- PRINT("getdirentries(%ld, %#lx, %ld, %#lx)", ARG1, ARG2, ARG3, ARG4);
+ PRINT("getdirentries(%ld, %#lx, %ld, %#lx)", SARG1, ARG2, SARG3, ARG4);
PRE_REG_READ4(int, "getdirentries",
int, fd, char *, buf, int, nbytes, long *, basep);
PRE_MEM_WRITE("getdirentries(basep)", ARG4, sizeof(long));
PRE(getdirentries64)
{
- PRINT("getdirentries64(%ld, %#lx, %lu, %#lx)", ARG1, ARG2, ARG3, ARG4);
+ PRINT("getdirentries64(%ld, %#lx, %lu, %#lx)", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(vki_ssize_t, "getdirentries",
int,fd, char *,buf, vki_size_t,nbytes, vki_off_t *,basep);
/* JRS 18-Nov-2014: it appears that sometimes |basep| doesn't point
PRE(statfs64)
{
- PRINT("statfs64 ( %#lx(%s), %#lx )",ARG1,(char *)ARG1,ARG2);
+ PRINT("statfs64 ( %#lx(%s), %#lx )", ARG1, (HChar *)ARG1, ARG2);
PRE_REG_READ2(long, "statfs64", const char *, path, struct statfs64 *, buf);
PRE_MEM_RASCIIZ( "statfs64(path)", ARG1 );
PRE_MEM_WRITE( "statfs64(buf)", ARG2, sizeof(struct vki_statfs64) );
PRE(fstatfs64)
{
- PRINT("fstatfs64 ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("fstatfs64 ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstatfs64",
unsigned int, fd, struct statfs *, buf);
PRE_MEM_WRITE( "fstatfs64(buf)", ARG2, sizeof(struct vki_statfs64) );
PRE(csops)
{
- PRINT("csops ( %ld, %#lx, %#lx, %lu )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("csops ( %ld, %#lx, %#lx, %lu )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(int, "csops",
vki_pid_t, pid, uint32_t, ops,
void *, useraddr, vki_size_t, usersize);
PRE(auditon)
{
- PRINT("auditon ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("auditon ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(int,"auditon",
int,"cmd", void*,"data", unsigned int,"length");
PRE(getaudit_addr)
{
- PRINT("getaudit_addr(%#lx, %lu)", ARG1, ARG2);
+ PRINT("getaudit_addr(%#lx, %ld)", ARG1, SARG2);
PRE_REG_READ1(void*, "auditinfo_addr", int, "length");
PRE_MEM_WRITE("getaudit_addr(auditinfo_addr)", ARG1, ARG2);
}
if (0) VG_(am_do_sync_check)("(PRE_MMAP)",__FILE__,__LINE__);
#if VG_WORDSIZE == 4
- PRINT("mmap ( %#lx, %lu, %ld, %ld, %ld, %lld )",
- ARG1, ARG2, ARG3, ARG4, ARG5, LOHI64(ARG6, ARG7) );
+ PRINT("mmap ( %#lx, %lu, %ld, %ld, %ld, %llu )",
+ ARG1, ARG2, SARG3, SARG4, SARG5, LOHI64(ARG6, ARG7) );
PRE_REG_READ7(Addr, "mmap",
Addr,start, vki_size_t,length, int,prot, int,flags, int,fd,
unsigned long,offset_hi, unsigned long,offset_lo);
// (Off64T)LOHI64(ARG6, ARG7) );
#else
PRINT("mmap ( %#lx, %lu, %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
+ ARG1, ARG2, SARG3, SARG4, SARG5, SARG6 );
PRE_REG_READ6(long, "mmap",
Addr,start, vki_size_t,length, int,prot, int,flags, int,fd,
Off64T,offset);
UWord newp = ARG5;
UWord newlen = ARG6;
- PRINT( "__sysctl ( %#lx, %ld, %#lx, %#lx, %#lx, %ld )",
+ PRINT( "__sysctl ( %#lx, %lu, %#lx, %#lx, %#lx, %#lx )",
name, namelen, oldp, oldlenp, newp, newlen );
PRE_REG_READ6(int, "__sysctl", int*, name, unsigned int, namelen,
PRE(sigprocmask)
{
UWord arg1;
- PRINT("sigprocmask ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sigprocmask ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigprocmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oldset);
if (ARG2 != 0)
Reply *reply = (Reply *)ARG1;
if (!reply->RetCode) {
- PRINT("page size %llu", (ULong)reply->out_page_size);
+ PRINT("page size %llu", (ULong)reply->out_page_size);
} else {
PRINT("mig return %d", reply->RetCode);
}
Request *req = (Request *)ARG1;
- PRINT("vm_allocate (%s, at %#llx, size %lld, flags %#x)",
+ PRINT("vm_allocate (%s, at %#llx, size %llu, flags %#x)",
name_for_port(MACH_REMOTE),
(ULong)req->address, (ULong)req->size, req->flags);
Request *req = (Request *)ARG1;
- PRINT("vm_deallocate(%s, at %#llx, size %lld)",
+ PRINT("vm_deallocate(%s, at %#llx, size %llu)",
name_for_port(MACH_REMOTE),
(ULong)req->address, (ULong)req->size);
Request *req = (Request *)ARG1;
- PRINT("vm_protect(%s, at %#llx, size %lld, set_max %d, prot %d)",
+ PRINT("vm_protect(%s, at %#llx, size %llu, set_max %d, prot %d)",
name_for_port(MACH_REMOTE),
(ULong)req->address, (ULong)req->size,
req->set_maximum, req->new_protection);
Request *req = (Request *)ARG1;
- PRINT("vm_inherit(%s, at %#llx, size %lld, value %d)",
+ PRINT("vm_inherit(%s, at %#llx, size %llu, value %d)",
name_for_port(MACH_REMOTE),
(ULong)req->address, (ULong)req->size,
req->new_inheritance);
Request *req = (Request *)ARG1;
// GrP fixme check these
- PRINT("vm_map(in %s, at %#llx, size %lld, from %s ...)",
+ PRINT("vm_map(in %s, at %#llx, size %llu, from %s ...)",
name_for_port(MACH_REMOTE),
(ULong)req->address, (ULong)req->size,
name_for_port(req->object.name));
mach_port_name_t source_task = req->src_task.name;
if (source_task == mach_task_self()) {
PRINT("vm_remap(mach_task_self(), "
- "to %#llx size %lld, from mach_task_self() at %#llx, ...)",
+ "to %#llx size %llu, from mach_task_self() at %#llx, ...)",
(ULong)req->target_address,
(ULong)req->size, (ULong)req->src_address);
} else {
PRINT("vm_remap(mach_task_self(), "
- "to %#llx size %lld, from task %u at %#llx, ...)",
+ "to %#llx size %llu, from task %u at %#llx, ...)",
(ULong)req->target_address, (ULong)req->size,
source_task, (ULong)req->src_address);
}
PRINT("mach_vm_purgable_control(%s, 0x%llx, %d, %d)",
name_for_port(MACH_REMOTE),
- (unsigned long long)req->address, req->control, req->state);
+ (ULong)req->address, req->control, req->state);
// GrP fixme verify address?
Request *req = (Request *)ARG1;
- PRINT("mach_vm_allocate (%s, at 0x%llx, size %lld, flags 0x%x)",
+ PRINT("mach_vm_allocate (%s, at 0x%llx, size %llu, flags 0x%x)",
name_for_port(MACH_REMOTE),
req->address, req->size, req->flags);
Request *req = (Request *)ARG1;
- PRINT("mach_vm_deallocate(%s, at 0x%llx, size %lld)",
+ PRINT("mach_vm_deallocate(%s, at 0x%llx, size %llu)",
name_for_port(MACH_REMOTE),
req->address, req->size);
Request *req = (Request *)ARG1;
- PRINT("mach_vm_protect(%s, at 0x%llx, size %lld, set_max %d, prot %d)",
+ PRINT("mach_vm_protect(%s, at 0x%llx, size %llu, set_max %d, prot %d)",
name_for_port(MACH_REMOTE), req->address, req->size,
req->set_maximum, req->new_protection);
PRE(syscall_thread_switch)
{
PRINT("syscall_thread_switch(%s, %ld, %ld)",
- name_for_port(ARG1), ARG2, ARG3);
+ name_for_port(ARG1), SARG2, SARG3);
PRE_REG_READ3(long, "syscall_thread_switch",
mach_port_t,"thread", int,"option", natural_t,"timeout");
int timeout, int relative,
time_t tv_sec, time_t tv_nsec */
PRINT("__semwait_signal(wait %s, signal %s, %ld, %ld, %lds:%ldns)",
- name_for_port(ARG1), name_for_port(ARG2), ARG3, ARG4, ARG5, ARG6);
+ name_for_port(ARG1), name_for_port(ARG2), SARG3, SARG4, SARG5, SARG6);
PRE_REG_READ6(long, "__semwait_signal",
int,"cond_sem", int,"mutex_sem",
int,"timeout", int,"relative",
PRE(task_for_pid)
{
- PRINT("task_for_pid(%s, %ld, %#lx)", name_for_port(ARG1), ARG2, ARG3);
+ PRINT("task_for_pid(%s, %ld, %#lx)", name_for_port(ARG1), SARG2, ARG3);
PRE_REG_READ3(long, "task_for_pid",
mach_port_t,"target",
vki_pid_t, "pid", mach_port_t *,"task");
PRE(swtch_pri)
{
- PRINT("swtch_pri ( %ld )", ARG1);
+ PRINT("swtch_pri ( %ld )", SARG1);
PRE_REG_READ1(long, "swtch_pri", int,"pri");
*flags |= SfMayBlock;
{
// int necp_match_policy(uint8_t *parameters, size_t parameters_size,
// struct necp_aggregate_result *returned_result)
- PRINT("necp_match_policy(FIXME)(%lx,%ld, %lx)", ARG1, ARG2, ARG3);
+ PRINT("necp_match_policy(FIXME)(%lx,%lu, %lx)", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "necp_match_policy", uint8_t*, parameters,
size_t, parameters_size, struct necp_aggregate_result*,
returned_result);
UWord oldp = ARG3;
UWord oldlenp = ARG4;
UWord newp = ARG5;
- UWord newlen = ARG6;
+ UWord newlen = ARG6; // FIXME: or newlenp ??
- PRINT( "sysctlbyname ( %#lx,%ld, %#lx,%#lx, %#lx,%ld )",
+ PRINT( "sysctlbyname ( %#lx,%lu, %#lx,%#lx, %#lx,%lu )",
name, namelen, oldp, oldlenp, newp, newlen );
PRE_REG_READ6(int, "sysctlbyname", char*, name, size_t, namelen,
void*, oldp, vki_size_t *, oldlenp,
- void*, newp, vki_size_t *, newlenp);
+ void*, newp, vki_size_t *, newlenp); // <---<<
// reads name[0..namelen-1]
PRE_MEM_READ("sysctlbyname(name)", name, namelen);
// uint64_t options);
// Presumably the last arg is value-pair in the 32 bit case.
PRINT("getattrlistbulk(FIXME)(%ld, %lx, %lx,%lu, %lu)",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(int, "getattrlistbulk", int, dirfd, void*, list,
void*, attributeBuffer, size_t, bufferSize,
uint32_t, options_lo32);
{
Word saved = SYSNO;
- PRINT("readlinkat ( %ld, %#lx(%s), %#lx, %llu )", ARG1,ARG2,(char*)ARG2,ARG3,(ULong)ARG4);
+ PRINT("readlinkat ( %ld, %#lx(%s), %#lx, %ld )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "readlinkat",
int, dfd, const char *, path, char *, buf, int, bufsiz);
PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
PRINT("guarded_open_dprotected_np("
"path:%#lx(%s), guard:%#lx, guardflags:%#lx, flags:%#lx, "
"dpclass:%#lx, dpflags: %#lx) FIXME",
- ARG1, (char*)ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ ARG1, (HChar*)ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
}
PRE(guarded_write_np)
VG_(register_stack)(seg->start, tst->client_stack_highest_byte);
if (debug)
- VG_(printf)("tid %d: guessed client stack range [%#lx-%#lx]\n",
+ VG_(printf)("tid %u: guessed client stack range [%#lx-%#lx]\n",
tst->tid, seg->start, tst->client_stack_highest_byte);
} else {
VG_(message)(Vg_UserMsg,
- "!? New thread %d starts with SP(%#lx) unmapped\n",
+ "!? New thread %u starts with SP(%#lx) unmapped\n",
tst->tid, sp);
tst->client_stack_highest_byte = 0;
tst->client_stack_szB = 0;
Bool f_maymove = toBool(flags & VKI_MREMAP_MAYMOVE);
if (0)
- VG_(printf)("do_remap (old %#lx %ld) (new %#lx %ld) %s %s\n",
+ VG_(printf)("do_remap (old %#lx %lu) (new %#lx %lu) %s %s\n",
old_addr,old_len,new_addr,new_len,
flags & VKI_MREMAP_MAYMOVE ? "MAYMOVE" : "",
flags & VKI_MREMAP_FIXED ? "FIXED" : "");
if (! VG_(am_extend_into_adjacent_reservation_client)( aseg->start, delta,
&overflow)) {
if (overflow)
- VG_(umsg)("brk segment overflow in thread #%d: can't grow to %#lx\n",
+ VG_(umsg)("brk segment overflow in thread #%u: can't grow to %#lx\n",
tid, newbrkP);
else
- VG_(umsg)("Cannot map memory to grow brk segment in thread #%d "
+ VG_(umsg)("Cannot map memory to grow brk segment in thread #%u "
"to %#lx\n", tid, newbrkP);
goto bad;
}
{
ThreadState* tst;
/* simple; just make this thread exit */
- PRINT("exit( %ld )", ARG1);
+ PRINT("exit( %ld )", SARG1);
PRE_REG_READ1(void, "exit", int, status);
tst = VG_(get_ThreadState)(tid);
/* Set the thread's status to be exiting, then claim that the
PRE(sys_iopl)
{
- PRINT("sys_iopl ( %ld )", ARG1);
+ PRINT("sys_iopl ( %lu )", ARG1);
PRE_REG_READ1(long, "iopl", unsigned long, level);
}
PRE(sys_fsync)
{
*flags |= SfMayBlock;
- PRINT("sys_fsync ( %ld )", ARG1);
+ PRINT("sys_fsync ( %lu )", ARG1);
PRE_REG_READ1(long, "fsync", unsigned int, fd);
}
PRE(sys_fdatasync)
{
*flags |= SfMayBlock;
- PRINT("sys_fdatasync ( %ld )", ARG1);
+ PRINT("sys_fdatasync ( %lu )", ARG1);
PRE_REG_READ1(long, "fdatasync", unsigned int, fd);
}
PRE(sys_msync)
{
*flags |= SfMayBlock;
- PRINT("sys_msync ( %#lx, %llu, %ld )", ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_msync ( %#lx, %lu, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "msync",
unsigned long, start, vki_size_t, length, int, flags);
PRE_MEM_READ( "msync(start)", ARG1, ARG2 );
struct vki_pmsg_strbuf *ctrl;
struct vki_pmsg_strbuf *data;
*flags |= SfMayBlock;
- PRINT("sys_getpmsg ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_getpmsg ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
+ ARG4, ARG5);
PRE_REG_READ5(int, "getpmsg",
int, fd, struct strbuf *, ctrl, struct strbuf *, data,
int *, bandp, int *, flagsp);
struct vki_pmsg_strbuf *ctrl;
struct vki_pmsg_strbuf *data;
*flags |= SfMayBlock;
- PRINT("sys_putpmsg ( %ld, %#lx, %#lx, %ld, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_putpmsg ( %ld, %#lx, %#lx, %ld, %ld )", SARG1, ARG2, ARG3,
+ SARG4, SARG5);
PRE_REG_READ5(int, "putpmsg",
int, fd, struct strbuf *, ctrl, struct strbuf *, data,
int, band, int, flags);
PRE(sys_getitimer)
{
struct vki_itimerval *value = (struct vki_itimerval*)ARG2;
- PRINT("sys_getitimer ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_getitimer ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "getitimer", int, which, struct itimerval *, value);
PRE_timeval_WRITE( "getitimer(&value->it_interval)", &(value->it_interval));
PRE(sys_setitimer)
{
- PRINT("sys_setitimer ( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_setitimer ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setitimer",
int, which,
struct itimerval *, value, struct itimerval *, ovalue);
PRE(sys_madvise)
{
*flags |= SfMayBlock;
- PRINT("sys_madvise ( %#lx, %llu, %ld )", ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_madvise ( %#lx, %lu, %ld )", ARG1, ARG2, SARG3);
PRE_REG_READ3(long, "madvise",
unsigned long, start, vki_size_t, length, int, advice);
}
// Nb: this is different to the glibc version described in the man pages,
// which lacks the fifth 'new_address' argument.
if (ARG4 & VKI_MREMAP_FIXED) {
- PRINT("sys_mremap ( %#lx, %llu, %ld, 0x%lx, %#lx )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_mremap ( %#lx, %lu, %lu, %#lx, %#lx )",
+ ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(unsigned long, "mremap",
unsigned long, old_addr, unsigned long, old_size,
unsigned long, new_size, unsigned long, flags,
unsigned long, new_addr);
} else {
- PRINT("sys_mremap ( %#lx, %llu, %ld, 0x%lx )",
- ARG1, (ULong)ARG2, ARG3, ARG4);
+ PRINT("sys_mremap ( %#lx, %lu, %lu, 0x%lx )",
+ ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(unsigned long, "mremap",
unsigned long, old_addr, unsigned long, old_size,
unsigned long, new_size, unsigned long, flags);
PRE(sys_nice)
{
- PRINT("sys_nice ( %ld )", ARG1);
+ PRINT("sys_nice ( %ld )", SARG1);
PRE_REG_READ1(long, "nice", int, inc);
}
PRE(sys_mlock)
{
*flags |= SfMayBlock;
- PRINT("sys_mlock ( %#lx, %llu )", ARG1, (ULong)ARG2);
+ PRINT("sys_mlock ( %#lx, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "mlock", unsigned long, addr, vki_size_t, len);
}
PRE(sys_munlock)
{
*flags |= SfMayBlock;
- PRINT("sys_munlock ( %#lx, %llu )", ARG1, (ULong)ARG2);
+ PRINT("sys_munlock ( %#lx, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "munlock", unsigned long, addr, vki_size_t, len);
}
PRE(sys_setpriority)
{
- PRINT("sys_setpriority ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_setpriority ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "setpriority", int, which, int, who, int, prio);
}
PRE(sys_getpriority)
{
- PRINT("sys_getpriority ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_getpriority ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "getpriority", int, which, int, who);
}
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_pwrite64 ( %ld, %#lx, %llu, %lld )",
- ARG1, ARG2, (ULong)ARG3, MERGE64(ARG4,ARG5));
+ PRINT("sys_pwrite64 ( %lu, %#lx, %lu, %lld )",
+ ARG1, ARG2, ARG3, (Long)MERGE64(ARG4,ARG5));
PRE_REG_READ5(ssize_t, "pwrite64",
unsigned int, fd, const char *, buf, vki_size_t, count,
vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset));
#elif VG_WORDSIZE == 8
- PRINT("sys_pwrite64 ( %ld, %#lx, %llu, %lld )",
- ARG1, ARG2, (ULong)ARG3, (Long)ARG4);
+ PRINT("sys_pwrite64 ( %lu, %#lx, %lu, %ld )",
+ ARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(ssize_t, "pwrite64",
unsigned int, fd, const char *, buf, vki_size_t, count,
Word, offset);
PRE(sys_fstatfs)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fstatfs ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("sys_fstatfs ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstatfs",
unsigned int, fd, struct statfs *, buf);
PRE_MEM_WRITE( "fstatfs(buf)", ARG2, sizeof(struct vki_statfs) );
PRE(sys_fstatfs64)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fstatfs64 ( %ld, %llu, %#lx )",ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_fstatfs64 ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fstatfs64",
unsigned int, fd, vki_size_t, size, struct statfs64 *, buf);
PRE_MEM_WRITE( "fstatfs64(buf)", ARG3, ARG2 );
PRE(sys_getsid)
{
- PRINT("sys_getsid ( %ld )", ARG1);
+ PRINT("sys_getsid ( %ld )", SARG1);
PRE_REG_READ1(long, "getsid", vki_pid_t, pid);
}
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_pread64 ( %ld, %#lx, %llu, %lld )",
- ARG1, ARG2, (ULong)ARG3, MERGE64(ARG4,ARG5));
+ PRINT("sys_pread64 ( %lu, %#lx, %lu, %lld )",
+ ARG1, ARG2, ARG3, (Long)MERGE64(ARG4,ARG5));
PRE_REG_READ5(ssize_t, "pread64",
unsigned int, fd, char *, buf, vki_size_t, count,
vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset));
#elif VG_WORDSIZE == 8
- PRINT("sys_pread64 ( %ld, %#lx, %llu, %lld )",
- ARG1, ARG2, (ULong)ARG3, (Long)ARG4);
+ PRINT("sys_pread64 ( %lu, %#lx, %lu, %ld )",
+ ARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(ssize_t, "pread64",
unsigned int, fd, char *, buf, vki_size_t, count,
Word, offset);
PRE(sys_mknod)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_mknod ( %#lx(%s), 0x%lx, 0x%lx )", ARG1, (char*)ARG1, ARG2, ARG3 );
+ PRINT("sys_mknod ( %#lx(%s), %#lx, %#lx )", ARG1, (HChar*)ARG1, ARG2, ARG3 );
PRE_REG_READ3(long, "mknod",
const char *, pathname, int, mode, unsigned, dev);
PRE_MEM_RASCIIZ( "mknod(pathname)", ARG1 );
PRE(sys_flock)
{
*flags |= SfMayBlock;
- PRINT("sys_flock ( %ld, %ld )", ARG1, ARG2 );
+ PRINT("sys_flock ( %lu, %lu )", ARG1, ARG2 );
PRE_REG_READ2(long, "flock", unsigned int, fd, unsigned int, operation);
}
too much of a mess to continue, so we have to abort. */
hosed:
vg_assert(FAILURE);
- VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx) failed, errno %ld\n",
- ARG1, (char*)ARG1, ARG2, ARG3, ERR);
+ VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx) failed, errno %lu\n",
+ ARG1, (HChar*)ARG1, ARG2, ARG3, ERR);
VG_(message)(Vg_UserMsg, "EXEC FAILED: I can't recover from "
"execve() failing, so I'm dying.\n");
VG_(message)(Vg_UserMsg, "Add more stringent tests in PRE(sys_execve), "
PRE(sys_access)
{
- PRINT("sys_access ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_access ( %#lx(%s), %ld )", ARG1, (HChar*)ARG1, SARG2);
PRE_REG_READ2(long, "access", const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "access(pathname)", ARG1 );
}
PRE(sys_alarm)
{
- PRINT("sys_alarm ( %ld )", ARG1);
+ PRINT("sys_alarm ( %lu )", ARG1);
PRE_REG_READ1(unsigned long, "alarm", unsigned int, seconds);
}
PRE(sys_chmod)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_chmod ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_chmod ( %#lx(%s), %lu )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "chmod", const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "chmod(path)", ARG1 );
}
PRE(sys_close)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_close ( %ld )", ARG1);
+ PRINT("sys_close ( %lu )", ARG1);
PRE_REG_READ1(long, "close", unsigned int, fd);
/* Detect and negate attempts by the client to close Valgrind's log fd */
PRE(sys_dup)
{
- PRINT("sys_dup ( %ld )", ARG1);
+ PRINT("sys_dup ( %lu )", ARG1);
PRE_REG_READ1(long, "dup", unsigned int, oldfd);
}
PRE(sys_dup2)
{
- PRINT("sys_dup2 ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_dup2 ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "dup2", unsigned int, oldfd, unsigned int, newfd);
if (!ML_(fd_allowed)(ARG2, "dup2", tid, True))
SET_STATUS_Failure( VKI_EBADF );
PRE(sys_fchdir)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fchdir ( %ld )", ARG1);
+ PRINT("sys_fchdir ( %lu )", ARG1);
PRE_REG_READ1(long, "fchdir", unsigned int, fd);
}
PRE(sys_fchown)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fchown ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fchown ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fchown",
unsigned int, fd, vki_uid_t, owner, vki_gid_t, group);
}
PRE(sys_fchmod)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fchmod ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_fchmod ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "fchmod", unsigned int, fildes, vki_mode_t, mode);
}
PRE(sys_newfstat)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_newfstat ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_newfstat ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstat", unsigned int, fd, struct stat *, buf);
PRE_MEM_WRITE( "fstat(buf)", ARG2, sizeof(struct vki_stat) );
}
PRE(sys_ftruncate)
{
*flags |= SfMayBlock;
- PRINT("sys_ftruncate ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_ftruncate ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "ftruncate", unsigned int, fd, unsigned long, length);
}
PRE(sys_truncate)
{
*flags |= SfMayBlock;
- PRINT("sys_truncate ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_truncate ( %#lx(%s), %lu )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "truncate",
const char *, path, unsigned long, length);
PRE_MEM_RASCIIZ( "truncate(path)", ARG1 );
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_ftruncate64 ( %ld, %lld )", ARG1, MERGE64(ARG2,ARG3));
+ PRINT("sys_ftruncate64 ( %lu, %llu )", ARG1, MERGE64(ARG2,ARG3));
PRE_REG_READ3(long, "ftruncate64",
unsigned int, fd,
UWord, MERGE64_FIRST(length), UWord, MERGE64_SECOND(length));
#else
- PRINT("sys_ftruncate64 ( %ld, %lld )", ARG1, (Long)ARG2);
+ PRINT("sys_ftruncate64 ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "ftruncate64",
unsigned int,fd, UWord,length);
#endif
PRE(sys_getdents)
{
*flags |= SfMayBlock;
- PRINT("sys_getdents ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_getdents ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getdents",
unsigned int, fd, struct vki_dirent *, dirp,
unsigned int, count);
PRE(sys_getdents64)
{
*flags |= SfMayBlock;
- PRINT("sys_getdents64 ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_getdents64 ( %lu, %#lx, %lu )",ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getdents64",
unsigned int, fd, struct vki_dirent64 *, dirp,
unsigned int, count);
PRE(sys_getgroups)
{
- PRINT("sys_getgroups ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_getgroups ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "getgroups", int, size, vki_gid_t *, list);
if (ARG1 > 0)
PRE_MEM_WRITE( "getgroups(list)", ARG2, ARG1 * sizeof(vki_gid_t) );
PRE(sys_getpgid)
{
- PRINT("sys_getpgid ( %ld )", ARG1);
+ PRINT("sys_getpgid ( %ld )", SARG1);
PRE_REG_READ1(long, "getpgid", vki_pid_t, pid);
}
PRE(sys_old_getrlimit)
{
- PRINT("sys_old_getrlimit ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_old_getrlimit ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "old_getrlimit",
unsigned int, resource, struct rlimit *, rlim);
PRE_MEM_WRITE( "old_getrlimit(rlim)", ARG2, sizeof(struct vki_rlimit) );
PRE(sys_getrlimit)
{
- PRINT("sys_getrlimit ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_getrlimit ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "getrlimit",
unsigned int, resource, struct rlimit *, rlim);
PRE_MEM_WRITE( "getrlimit(rlim)", ARG2, sizeof(struct vki_rlimit) );
PRE(sys_getrusage)
{
- PRINT("sys_getrusage ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_getrusage ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "getrusage", int, who, struct rusage *, usage);
PRE_MEM_WRITE( "getrusage(usage)", ARG2, sizeof(struct vki_rusage) );
}
if (!VG_(is_exiting)(tid)) {
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
- "Thread %d being killed with SIGKILL\n",
+ "Thread %u being killed with SIGKILL\n",
tst->tid);
tst->exitreason = VgSrc_FatalSig;
PRE(sys_kill)
{
- PRINT("sys_kill ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_kill ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "kill", int, pid, int, signal);
if (!ML_(client_signal_OK)(ARG2)) {
SET_STATUS_Failure( VKI_EINVAL );
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "kill: sent signal %ld to pid %ld\n",
- ARG2, ARG1);
+ SARG2, SARG1);
/* This kill might have given us a pending signal. Ask for a check once
the syscall is done. */
PRE(sys_mkdir)
{
*flags |= SfMayBlock;
- PRINT("sys_mkdir ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_mkdir ( %#lx(%s), %ld )", ARG1, (HChar*)ARG1, SARG2);
PRE_REG_READ2(long, "mkdir", const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "mkdir(pathname)", ARG1 );
}
PRE(sys_mprotect)
{
- PRINT("sys_mprotect ( %#lx, %llu, %ld )", ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_mprotect ( %#lx, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "mprotect",
unsigned long, addr, vki_size_t, len, unsigned long, prot);
{
if (ARG2 & VKI_O_CREAT) {
// 3-arg version
- PRINT("sys_open ( %#lx(%s), %ld, %ld )",ARG1,(char*)ARG1,ARG2,ARG3);
+ PRINT("sys_open ( %#lx(%s), %ld, %ld )",ARG1, (HChar*)ARG1, SARG2, SARG3);
PRE_REG_READ3(long, "open",
const char *, filename, int, flags, int, mode);
} else {
// 2-arg version
- PRINT("sys_open ( %#lx(%s), %ld )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_open ( %#lx(%s), %ld )",ARG1, (HChar*)ARG1, SARG2);
PRE_REG_READ2(long, "open",
const char *, filename, int, flags);
}
PRE(sys_read)
{
*flags |= SfMayBlock;
- PRINT("sys_read ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_read ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "read",
unsigned int, fd, char *, buf, vki_size_t, count);
{
Bool ok;
*flags |= SfMayBlock;
- PRINT("sys_write ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_write ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "write",
unsigned int, fd, const char *, buf, vki_size_t, count);
/* check to see if it is allowed. If not, try for an exemption from
PRE(sys_creat)
{
*flags |= SfMayBlock;
- PRINT("sys_creat ( %#lx(%s), %ld )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_creat ( %#lx(%s), %ld )", ARG1, (HChar*)ARG1, SARG2);
PRE_REG_READ2(long, "creat", const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "creat(pathname)", ARG1 );
}
UInt i;
struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
*flags |= SfMayBlock;
- PRINT("sys_poll ( %#lx, %ld, %ld )\n", ARG1,ARG2,ARG3);
+ PRINT("sys_poll ( %#lx, %lu, %ld )\n", ARG1, ARG2, SARG3);
PRE_REG_READ3(long, "poll",
struct vki_pollfd *, ufds, unsigned int, nfds, long, timeout);
Int i;
struct vki_iovec * vec;
*flags |= SfMayBlock;
- PRINT("sys_readv ( %ld, %#lx, %llu )",ARG1,ARG2,(ULong)ARG3);
+ PRINT("sys_readv ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "readv",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count);
PRE(sys_select)
{
*flags |= SfMayBlock;
- PRINT("sys_select ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_select ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
+ ARG4, ARG5);
PRE_REG_READ5(long, "select",
int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
vki_fd_set *, exceptfds, struct vki_timeval *, timeout);
PRE(sys_setgid)
{
- PRINT("sys_setgid ( %ld )", ARG1);
+ PRINT("sys_setgid ( %lu )", ARG1);
PRE_REG_READ1(long, "setgid", vki_gid_t, gid);
}
PRE(sys_setpgid)
{
- PRINT("setpgid ( %ld, %ld )", ARG1, ARG2);
+ PRINT("setpgid ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "setpgid", vki_pid_t, pid, vki_pid_t, pgid);
}
PRE(sys_setregid)
{
- PRINT("sys_setregid ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_setregid ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "setregid", vki_gid_t, rgid, vki_gid_t, egid);
}
PRE(sys_setrlimit)
{
UWord arg1 = ARG1;
- PRINT("sys_setrlimit ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_setrlimit ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "setrlimit",
unsigned int, resource, struct rlimit *, rlim);
PRE_MEM_READ( "setrlimit(rlim)", ARG2, sizeof(struct vki_rlimit) );
PRE(sys_setuid)
{
- PRINT("sys_setuid ( %ld )", ARG1);
+ PRINT("sys_setuid ( %lu )", ARG1);
PRE_REG_READ1(long, "setuid", vki_uid_t, uid);
}
PRE(sys_umask)
{
- PRINT("sys_umask ( %ld )", ARG1);
+ PRINT("sys_umask ( %ld )", SARG1);
PRE_REG_READ1(long, "umask", int, mask);
}
PRE(sys_waitpid)
{
*flags |= SfMayBlock;
- PRINT("sys_waitpid ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_waitpid ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "waitpid",
vki_pid_t, pid, unsigned int *, status, int, options);
PRE(sys_wait4)
{
*flags |= SfMayBlock;
- PRINT("sys_wait4 ( %ld, %#lx, %ld, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_wait4 ( %ld, %#lx, %ld, %#lx )", SARG1, ARG2, SARG3, ARG4);
PRE_REG_READ4(long, "wait4",
vki_pid_t, pid, unsigned int *, status, int, options,
Int i;
struct vki_iovec * vec;
*flags |= SfMayBlock;
- PRINT("sys_writev ( %ld, %#lx, %llu )",ARG1,ARG2,(ULong)ARG3);
+ PRINT("sys_writev ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "writev",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count);
PRE(sys_sethostname)
{
- PRINT("sys_sethostname ( %#lx, %ld )", ARG1,ARG2);
+ PRINT("sys_sethostname ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "sethostname", char *, name, int, len);
PRE_MEM_READ( "sethostname(name)", ARG1, ARG2 );
}
ThreadState* tst = VG_(get_ThreadState)(tid);
VG_(debugLog)(1, "syswrap-linux",
- "thread_wrapper(tid=%lld): entry\n",
- (ULong)tidW);
+ "thread_wrapper(tid=%u): entry\n",
+ tid);
vg_assert(tst->status == VgTs_Init);
VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
if (0)
- VG_(printf)("thread tid %d started: stack = %p\n",
- tid, &tid);
+ VG_(printf)("thread tid %u started: stack = %p\n",
+ tid, (void *)&tid);
/* Make sure error reporting is enabled in the new thread. */
tst->err_disablement_level = 0;
vg_assert(VG_(is_running_thread)(tid));
VG_(debugLog)(1, "syswrap-linux",
- "thread_wrapper(tid=%lld): exit, schedreturncode %s\n",
- (ULong)tidW, VG_(name_of_VgSchedReturnCode)(ret));
+ "thread_wrapper(tid=%u): exit, schedreturncode %s\n",
+ tid, VG_(name_of_VgSchedReturnCode)(ret));
/* Return to caller, still holding the lock. */
return ret;
#endif
VG_(debugLog)(1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): pre-thread_wrapper\n",
+ tid);
tst = VG_(get_ThreadState)(tid);
vg_assert(tst);
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): post-thread_wrapper\n",
+ tid);
c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
);
VG_(debugLog)(
1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"WARNING: exiting thread has err_disablement_level = %u\n",
- (ULong)tidW, tst->err_disablement_level
+ tid, tst->err_disablement_level
);
}
tst->err_disablement_level = 0;
if (c == 1) {
VG_(debugLog)(1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"last one standing\n",
- (ULong)tidW);
+ tid);
/* We are the last one standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
} else {
VG_(debugLog)(1, "syswrap-linux",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"not last one standing\n",
- (ULong)tidW);
+ tid);
/* OK, thread is dead, but others still exist. Just exit. */
}
if (0)
- VG_(printf)( "stack for tid %d at %p; init_SP=%p\n",
+ VG_(printf)( "stack for tid %u at %p; init_SP=%p\n",
tid,
(void*)tst->os_state.valgrind_stack_base,
(void*)tst->os_state.valgrind_stack_init_SP );
VG_(do_atfork_parent)(tid);
if (VG_(clo_trace_syscalls))
- VG_(printf)(" clone(fork): process %d created child %ld\n",
+ VG_(printf)(" clone(fork): process %d created child %lu\n",
VG_(getpid)(), sr_Res(res));
/* restore signal mask */
PRE(sys_umount)
{
- PRINT("sys_umount( %#lx, %ld )", ARG1, ARG2);
+ PRINT("sys_umount( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "umount2", char *, path, int, flags);
PRE_MEM_RASCIIZ( "umount2(path)", ARG1);
}
PRE(sys_setfsuid16)
{
- PRINT("sys_setfsuid16 ( %ld )", ARG1);
+ PRINT("sys_setfsuid16 ( %lu )", ARG1);
PRE_REG_READ1(long, "setfsuid16", vki_old_uid_t, uid);
}
PRE(sys_setfsuid)
{
- PRINT("sys_setfsuid ( %ld )", ARG1);
+ PRINT("sys_setfsuid ( %lu )", ARG1);
PRE_REG_READ1(long, "setfsuid", vki_uid_t, uid);
}
PRE(sys_setfsgid16)
{
- PRINT("sys_setfsgid16 ( %ld )", ARG1);
+ PRINT("sys_setfsgid16 ( %lu )", ARG1);
PRE_REG_READ1(long, "setfsgid16", vki_old_gid_t, gid);
}
PRE(sys_setfsgid)
{
- PRINT("sys_setfsgid ( %ld )", ARG1);
+ PRINT("sys_setfsgid ( %lu )", ARG1);
PRE_REG_READ1(long, "setfsgid", vki_gid_t, gid);
}
PRE(sys_setresuid16)
{
- PRINT("sys_setresuid16 ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresuid16 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresuid16",
vki_old_uid_t, ruid, vki_old_uid_t, euid, vki_old_uid_t, suid);
}
PRE(sys_setresuid)
{
- PRINT("sys_setresuid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresuid ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresuid",
vki_uid_t, ruid, vki_uid_t, euid, vki_uid_t, suid);
}
PRE(sys_setresgid16)
{
- PRINT("sys_setresgid16 ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresgid16 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresgid16",
vki_old_gid_t, rgid,
vki_old_gid_t, egid, vki_old_gid_t, sgid);
PRE(sys_setresgid)
{
- PRINT("sys_setresgid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresgid ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresgid",
vki_gid_t, rgid, vki_gid_t, egid, vki_gid_t, sgid);
}
ThreadId t;
ThreadState* tst;
- PRINT("exit_group( %ld )", ARG1);
+ PRINT("exit_group( %ld )", SARG1);
PRE_REG_READ1(void, "exit_group", int, status);
tst = VG_(get_ThreadState)(tid);
PRE(sys_llseek)
{
- PRINT("sys_llseek ( %ld, 0x%lx, 0x%lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_llseek ( %lu, 0x%lx, 0x%lx, %#lx, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "llseek",
unsigned int, fd, unsigned long, offset_high,
unsigned long, offset_low, vki_loff_t *, result,
PRE(sys_clock_adjtime)
{
struct vki_timex *tx = (struct vki_timex *)ARG2;
- PRINT("sys_clock_adjtime ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_clock_adjtime ( %ld, %#lx )", SARG1,ARG2);
PRE_REG_READ2(long, "clock_adjtime", vki_clockid_t, id, struct timex *, buf);
PRE_MEM_READ( "clock_adjtime(timex->modes)", ARG2, sizeof(tx->modes));
PRE(sys_ioperm)
{
- PRINT("sys_ioperm ( %ld, %ld, %ld )", ARG1, ARG2, ARG3 );
+ PRINT("sys_ioperm ( %lu, %lu, %ld )", ARG1, ARG2, SARG3 );
PRE_REG_READ3(long, "ioperm",
unsigned long, from, unsigned long, num, int, turn_on);
}
PRE(sys_syslog)
{
*flags |= SfMayBlock;
- PRINT("sys_syslog (%ld, %#lx, %ld)", ARG1,ARG2,ARG3);
+ PRINT("sys_syslog (%ld, %#lx, %ld)", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "syslog", int, type, char *, bufp, int, len);
switch (ARG1) {
// The kernel uses magic numbers here, rather than named constants,
PRE(sys_prctl)
{
*flags |= SfMayBlock;
- PRINT( "sys_prctl ( %ld, %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4, ARG5 );
+ PRINT( "sys_prctl ( %ld, %ld, %ld, %ld, %ld )", SARG1, SARG2, SARG3, SARG4, SARG5 );
switch (ARG1) {
case VKI_PR_SET_PDEATHSIG:
PRE_REG_READ2(int, "prctl", int, option, int, signal);
PRE(sys_sendfile)
{
*flags |= SfMayBlock;
- PRINT("sys_sendfile ( %ld, %ld, %#lx, %lu )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_sendfile ( %ld, %ld, %#lx, %lu )", SARG1,SARG2,ARG3,ARG4);
PRE_REG_READ4(ssize_t, "sendfile",
int, out_fd, int, in_fd, vki_off_t *, offset,
vki_size_t, count);
PRE(sys_sendfile64)
{
*flags |= SfMayBlock;
- PRINT("sendfile64 ( %ld, %ld, %#lx, %lu )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sendfile64 ( %ld, %ld, %#lx, %lu )",SARG1,SARG2,ARG3,ARG4);
PRE_REG_READ4(ssize_t, "sendfile64",
int, out_fd, int, in_fd, vki_loff_t *, offset,
vki_size_t, count);
ARG5 - u32 *uaddr2 REQUEUE,CMP_REQUEUE
ARG6 - int val3 CMP_REQUEUE
*/
- PRINT("sys_futex ( %#lx, %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_futex ( %#lx, %ld, %ld, %#lx, %#lx )", ARG1,SARG2,SARG3,ARG4,ARG5);
switch(ARG2 & ~(VKI_FUTEX_PRIVATE_FLAG|VKI_FUTEX_CLOCK_REALTIME)) {
case VKI_FUTEX_CMP_REQUEUE:
case VKI_FUTEX_WAKE_OP:
PRE(sys_set_robust_list)
{
- PRINT("sys_set_robust_list ( %#lx, %ld )", ARG1,ARG2);
+ PRINT("sys_set_robust_list ( %#lx, %lu )", ARG1,ARG2);
PRE_REG_READ2(long, "set_robust_list",
struct vki_robust_list_head *, head, vki_size_t, len);
PRE(sys_get_robust_list)
{
- PRINT("sys_get_robust_list ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_get_robust_list ( %ld, %#lx, %#lx )", SARG1,ARG2,ARG3);
PRE_REG_READ3(long, "get_robust_list",
int, pid,
struct vki_robust_list_head **, head_ptr,
PRE(sys_pselect6)
{
*flags |= SfMayBlock;
- PRINT("sys_pselect6 ( %ld, %#lx, %#lx, %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_pselect6 ( %ld, %#lx, %#lx, %#lx, %#lx, %#lx )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "pselect6",
int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
vki_fd_set *, exceptfds, struct vki_timeval *, timeout,
UInt i;
struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
*flags |= SfMayBlock;
- PRINT("sys_ppoll ( %#lx, %ld, %#lx, %#lx, %llu )\n", ARG1,ARG2,ARG3,ARG4,(ULong)ARG5);
+ PRINT("sys_ppoll ( %#lx, %lu, %#lx, %#lx, %lu )\n", ARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "ppoll",
struct vki_pollfd *, ufds, unsigned int, nfds,
struct vki_timespec *, tsp, vki_sigset_t *, sigmask,
PRE(sys_epoll_create)
{
- PRINT("sys_epoll_create ( %ld )", ARG1);
+ PRINT("sys_epoll_create ( %ld )", SARG1);
PRE_REG_READ1(long, "epoll_create", int, size);
}
POST(sys_epoll_create)
PRE(sys_epoll_create1)
{
- PRINT("sys_epoll_create1 ( %ld )", ARG1);
+ PRINT("sys_epoll_create1 ( %ld )", SARG1);
PRE_REG_READ1(long, "epoll_create1", int, flags);
}
POST(sys_epoll_create1)
"EPOLL_CTL_MOD"
};
PRINT("sys_epoll_ctl ( %ld, %s, %ld, %#lx )",
- ARG1, ( ARG2<3 ? epoll_ctl_s[ARG2] : "?" ), ARG3, ARG4);
+ SARG1, ( ARG2<3 ? epoll_ctl_s[ARG2] : "?" ), SARG3, ARG4);
PRE_REG_READ4(long, "epoll_ctl",
int, epfd, int, op, int, fd, struct vki_epoll_event *, event);
if (ARG2 != VKI_EPOLL_CTL_DEL)
PRE(sys_epoll_wait)
{
*flags |= SfMayBlock;
- PRINT("sys_epoll_wait ( %ld, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_epoll_wait ( %ld, %#lx, %ld, %ld )", SARG1, ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "epoll_wait",
int, epfd, struct vki_epoll_event *, events,
int, maxevents, int, timeout);
PRE(sys_epoll_pwait)
{
*flags |= SfMayBlock;
- PRINT("sys_epoll_pwait ( %ld, %#lx, %ld, %ld, %#lx, %llu )", ARG1,ARG2,ARG3,ARG4,ARG5,(ULong)ARG6);
+ PRINT("sys_epoll_pwait ( %ld, %#lx, %ld, %ld, %#lx, %lu )",
+ SARG1, ARG2, SARG3, SARG4, ARG5, ARG6);
PRE_REG_READ6(long, "epoll_pwait",
int, epfd, struct vki_epoll_event *, events,
int, maxevents, int, timeout, vki_sigset_t *, sigmask,
PRE(sys_eventfd2)
{
- PRINT("sys_eventfd2 ( %lu, %ld )", ARG1,ARG2);
+ PRINT("sys_eventfd2 ( %lu, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "sys_eventfd2", unsigned int, count, int, flags);
}
POST(sys_eventfd2)
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
PRINT("sys_fallocate ( %ld, %ld, %lld, %lld )",
- ARG1, ARG2, MERGE64(ARG3,ARG4), MERGE64(ARG5,ARG6));
+ SARG1, SARG2, (Long)MERGE64(ARG3,ARG4), (Long)MERGE64(ARG5,ARG6));
PRE_REG_READ6(long, "fallocate",
int, fd, int, mode,
unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
unsigned, MERGE64_FIRST(len), unsigned, MERGE64_SECOND(len));
#elif VG_WORDSIZE == 8
- PRINT("sys_fallocate ( %ld, %ld, %lld, %lld )",
- ARG1, ARG2, (Long)ARG3, (Long)ARG4);
+ PRINT("sys_fallocate ( %ld, %ld, %ld, %ld )",
+ SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, "fallocate",
int, fd, int, mode, vki_loff_t, offset, vki_loff_t, len);
#else
PRE(sys_prlimit64)
{
- PRINT("sys_prlimit64 ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_prlimit64 ( %ld, %lu, %#lx, %#lx )", SARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(long, "prlimit64",
vki_pid_t, pid, unsigned int, resource,
const struct rlimit64 *, new_rlim,
PRE(sys_tkill)
{
- PRINT("sys_tgkill ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_tgkill ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "tkill", int, tid, int, sig);
if (!ML_(client_signal_OK)(ARG2)) {
SET_STATUS_Failure( VKI_EINVAL );
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "tkill: sending signal %ld to pid %ld\n",
- ARG2, ARG1);
+ SARG2, SARG1);
/* If we're sending SIGKILL, check to see if the target is one of
our threads and handle it specially. */
{
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "tkill: sent signal %ld to pid %ld\n",
- ARG2, ARG1);
+ SARG2, SARG1);
}
PRE(sys_tgkill)
{
- PRINT("sys_tgkill ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_tgkill ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "tgkill", int, tgid, int, tid, int, sig);
if (!ML_(client_signal_OK)(ARG3)) {
SET_STATUS_Failure( VKI_EINVAL );
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
"tgkill: sending signal %ld to pid %ld/%ld\n",
- ARG3, ARG1, ARG2);
+ SARG3, SARG1, SARG2);
/* If we're sending SIGKILL, check to see if the target is one of
our threads and handle it specially. */
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
"tgkill: sent signal %ld to pid %ld/%ld\n",
- ARG3, ARG1, ARG2);
+ SARG3, SARG1, SARG2);
}
/* ---------------------------------------------------------------------
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %lld, %lu, %ld )",
- ARG1, MERGE64(ARG2,ARG3), ARG4, ARG5);
+ PRINT("sys_fadvise64 ( %ld, %llu, %lu, %ld )",
+ SARG1, MERGE64(ARG2,ARG3), ARG4, SARG5);
PRE_REG_READ5(long, "fadvise64",
int, fd, vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset),
vki_size_t, len, int, advice);
PRE(sys_fadvise64_64)
{
- PRINT("sys_fadvise64_64 ( %ld, %lld, %lld, %ld )",
- ARG1, MERGE64(ARG2,ARG3), MERGE64(ARG4,ARG5), ARG6);
+ PRINT("sys_fadvise64_64 ( %ld, %llu, %llu, %ld )",
+ SARG1, MERGE64(ARG2,ARG3), MERGE64(ARG4,ARG5), SARG6);
PRE_REG_READ6(long, "fadvise64_64",
int, fd, vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset),
vki_u32, MERGE64_FIRST(len), vki_u32, MERGE64_SECOND(len), int, advice);
{
Int i, j;
- PRINT("sys_io_submit ( %llu, %ld, %#lx )", (ULong)ARG1,ARG2,ARG3);
+ PRINT("sys_io_submit ( %lu, %ld, %#lx )", ARG1, SARG2, ARG3);
PRE_REG_READ3(long, "io_submit",
vki_aio_context_t, ctx_id, long, nr,
struct iocb **, iocbpp);
PRE(sys_mbind)
{
- PRINT("sys_mbind ( %#lx, %lu, %ld, %#lx, %lu, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_mbind ( %#lx, %lu, %lu, %#lx, %lu, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE_REG_READ6(long, "mbind",
unsigned long, start, unsigned long, len,
unsigned long, policy, unsigned long *, nodemask,
PRE(sys_set_mempolicy)
{
- PRINT("sys_set_mempolicy ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_set_mempolicy ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "set_mempolicy",
int, policy, unsigned long *, nodemask,
unsigned long, maxnode);
PRE(sys_get_mempolicy)
{
- PRINT("sys_get_mempolicy ( %#lx, %#lx, %ld, %#lx, %lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_get_mempolicy ( %#lx, %#lx, %lu, %#lx, %lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "get_mempolicy",
int *, policy, unsigned long *, nodemask,
unsigned long, maxnode, unsigned long, addr,
{
#if VG_WORDSIZE == 4
PRINT( "sys_fanotify_mark ( %ld, %lu, %llu, %ld, %#lx(%s))",
- ARG1,ARG2,MERGE64(ARG3,ARG4),ARG5,ARG6,(char *)ARG6);
+ SARG1, ARG2, MERGE64(ARG3,ARG4), SARG5, ARG6, (HChar *)ARG6);
PRE_REG_READ6(long, "sys_fanotify_mark",
int, fanotify_fd, unsigned int, flags,
__vki_u32, mask0, __vki_u32, mask1,
if (ARG6)
PRE_MEM_RASCIIZ( "fanotify_mark(path)", ARG6);
#elif VG_WORDSIZE == 8
- PRINT( "sys_fanotify_mark ( %ld, %lu, %llu, %ld, %#lx(%s))",
- ARG1,ARG2,(ULong)ARG3,ARG4,ARG5,(char *)ARG5);
+ PRINT( "sys_fanotify_mark ( %ld, %lu, %lu, %ld, %#lx(%s))",
+ SARG1, ARG2, ARG3, SARG4, ARG5, (HChar *)ARG5);
PRE_REG_READ5(long, "sys_fanotify_mark",
int, fanotify_fd, unsigned int, flags,
__vki_u64, mask,
PRE(sys_inotify_init1)
{
- PRINT("sys_inotify_init ( %ld )", ARG1);
+ PRINT("sys_inotify_init ( %ld )", SARG1);
PRE_REG_READ1(long, "inotify_init", int, flag);
}
PRE(sys_inotify_add_watch)
{
- PRINT( "sys_inotify_add_watch ( %ld, %#lx, %lx )", ARG1,ARG2,ARG3);
+ PRINT( "sys_inotify_add_watch ( %ld, %#lx, %lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "inotify_add_watch", int, fd, char *, path, int, mask);
PRE_MEM_RASCIIZ( "inotify_add_watch(path)", ARG2 );
}
PRE(sys_inotify_rm_watch)
{
- PRINT( "sys_inotify_rm_watch ( %ld, %lx )", ARG1,ARG2);
+ PRINT( "sys_inotify_rm_watch ( %ld, %lx )", SARG1, ARG2);
PRE_REG_READ2(long, "inotify_rm_watch", int, fd, int, wd);
}
PRE(sys_mq_open)
{
- PRINT("sys_mq_open( %#lx(%s), %ld, %lld, %#lx )",
- ARG1,(char*)ARG1,ARG2,(ULong)ARG3,ARG4);
+ PRINT("sys_mq_open( %#lx(%s), %ld, %lu, %#lx )",
+ ARG1, (HChar*)ARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "mq_open",
const char *, name, int, oflag, vki_mode_t, mode,
struct mq_attr *, attr);
PRE(sys_mq_timedsend)
{
*flags |= SfMayBlock;
- PRINT("sys_mq_timedsend ( %ld, %#lx, %llu, %ld, %#lx )",
- ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
+ PRINT("sys_mq_timedsend ( %ld, %#lx, %lu, %lu, %#lx )",
+ SARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "mq_timedsend",
vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,
unsigned int, msg_prio, const struct timespec *, abs_timeout);
PRE(sys_mq_timedreceive)
{
*flags |= SfMayBlock;
- PRINT("sys_mq_timedreceive( %ld, %#lx, %llu, %#lx, %#lx )",
- ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
+ PRINT("sys_mq_timedreceive( %ld, %#lx, %lu, %#lx, %#lx )",
+ SARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "mq_timedreceive",
vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,
unsigned int *, msg_prio,
PRE(sys_mq_notify)
{
- PRINT("sys_mq_notify( %ld, %#lx )", ARG1,ARG2 );
+ PRINT("sys_mq_notify( %ld, %#lx )", SARG1, ARG2 );
PRE_REG_READ2(long, "mq_notify",
vki_mqd_t, mqdes, const struct sigevent *, notification);
if (!ML_(fd_allowed)(ARG1, "mq_notify", tid, False))
PRE(sys_mq_getsetattr)
{
- PRINT("sys_mq_getsetattr( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3 );
+ PRINT("sys_mq_getsetattr( %ld, %#lx, %#lx )", SARG1,ARG2,ARG3 );
PRE_REG_READ3(long, "mq_getsetattr",
vki_mqd_t, mqdes, const struct mq_attr *, mqstat,
struct mq_attr *, omqstat);
PRE(sys_clock_settime)
{
- PRINT("sys_clock_settime( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_clock_settime( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "clock_settime",
vki_clockid_t, clk_id, const struct timespec *, tp);
PRE_MEM_READ( "clock_settime(tp)", ARG2, sizeof(struct vki_timespec) );
PRE(sys_clock_gettime)
{
- PRINT("sys_clock_gettime( %ld, %#lx )" , ARG1,ARG2);
+ PRINT("sys_clock_gettime( %ld, %#lx )" , SARG1, ARG2);
PRE_REG_READ2(long, "clock_gettime",
vki_clockid_t, clk_id, struct timespec *, tp);
PRE_MEM_WRITE( "clock_gettime(tp)", ARG2, sizeof(struct vki_timespec) );
PRE(sys_clock_getres)
{
- PRINT("sys_clock_getres( %ld, %#lx )" , ARG1,ARG2);
+ PRINT("sys_clock_getres( %ld, %#lx )" , SARG1, ARG2);
// Nb: we can't use "RES" as the param name because that's a macro
// defined above!
PRE_REG_READ2(long, "clock_getres",
PRE(sys_clock_nanosleep)
{
*flags |= SfMayBlock|SfPostOnFail;
- PRINT("sys_clock_nanosleep( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_clock_nanosleep( %ld, %ld, %#lx, %#lx )",
+ SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int32_t, "clock_nanosleep",
vki_clockid_t, clkid, int, flags,
const struct timespec *, rqtp, struct timespec *, rmtp);
PRE(sys_timer_create)
{
- PRINT("sys_timer_create( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_timer_create( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "timer_create",
vki_clockid_t, clockid, struct sigevent *, evp,
vki_timer_t *, timerid);
PRE(sys_timer_settime)
{
- PRINT("sys_timer_settime( %lld, %ld, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_timer_settime( %ld, %ld, %#lx, %#lx )", SARG1,SARG2,ARG3,ARG4);
PRE_REG_READ4(long, "timer_settime",
vki_timer_t, timerid, int, flags,
const struct itimerspec *, value,
PRE(sys_timer_gettime)
{
- PRINT("sys_timer_gettime( %lld, %#lx )", (ULong)ARG1,ARG2);
+ PRINT("sys_timer_gettime( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "timer_gettime",
vki_timer_t, timerid, struct itimerspec *, value);
PRE_MEM_WRITE( "timer_gettime(value)", ARG2,
{
if (linux_kernel_2_6_22()) {
/* 2.6.22 kernel: timerfd system call. */
- PRINT("sys_timerfd ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_timerfd ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "sys_timerfd",
int, fd, int, clockid, const struct itimerspec *, tmr);
PRE_MEM_READ("timerfd(tmr)", ARG3,
SET_STATUS_Failure( VKI_EBADF );
} else {
/* 2.6.24 and later kernels: timerfd_create system call. */
- PRINT("sys_timerfd_create (%ld, %ld )", ARG1, ARG2);
+ PRINT("sys_timerfd_create (%ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "timerfd_create", int, clockid, int, flags);
}
}
PRE(sys_timerfd_gettime)
{
- PRINT("sys_timerfd_gettime ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_timerfd_gettime ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "timerfd_gettime",
int, ufd,
struct vki_itimerspec*, otmr);
PRE(sys_timerfd_settime)
{
- PRINT("sys_timerfd_settime ( %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_timerfd_settime ( %ld, %ld, %#lx, %#lx )",
+ SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "timerfd_settime",
int, ufd,
int, flags,
PRE(sys_setuid16)
{
- PRINT("sys_setuid16 ( %ld )", ARG1);
+ PRINT("sys_setuid16 ( %lu )", ARG1);
PRE_REG_READ1(long, "setuid16", vki_old_uid_t, uid);
}
PRE(sys_setgid16)
{
- PRINT("sys_setgid16 ( %ld )", ARG1);
+ PRINT("sys_setgid16 ( %lu )", ARG1);
PRE_REG_READ1(long, "setgid16", vki_old_gid_t, gid);
}
PRE(sys_setregid16)
{
- PRINT("sys_setregid16 ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_setregid16 ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "setregid16", vki_old_gid_t, rgid, vki_old_gid_t, egid);
}
PRE(sys_getgroups16)
{
- PRINT("sys_getgroups16 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_getgroups16 ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "getgroups16", int, size, vki_old_gid_t *, list);
if (ARG1 > 0)
PRE_MEM_WRITE( "getgroups16(list)", ARG2, ARG1 * sizeof(vki_old_gid_t) );
PRE(sys_fchown16)
{
- PRINT("sys_fchown16 ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fchown16 ( %lu, %lu, %lu )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "fchown16",
unsigned int, fd, vki_old_uid_t, owner, vki_old_gid_t, group);
}
PRE(sys_setxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_setxattr ( %#lx, %#lx, %#lx, %llu, %ld )",
- ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
+ PRINT("sys_setxattr ( %#lx, %#lx, %#lx, %lu, %ld )",
+ ARG1, ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "setxattr",
char *, path, char *, name,
void *, value, vki_size_t, size, int, flags);
PRE(sys_lsetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_lsetxattr ( %#lx, %#lx, %#lx, %llu, %ld )",
- ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
+ PRINT("sys_lsetxattr ( %#lx, %#lx, %#lx, %lu, %ld )",
+ ARG1, ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "lsetxattr",
char *, path, char *, name,
void *, value, vki_size_t, size, int, flags);
PRE(sys_fsetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fsetxattr ( %ld, %#lx, %#lx, %llu, %ld )",
- ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
+ PRINT("sys_fsetxattr ( %ld, %#lx, %#lx, %lu, %ld )",
+ SARG1, ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "fsetxattr",
int, fd, char *, name, void *, value,
vki_size_t, size, int, flags);
PRE(sys_fgetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fgetxattr ( %ld, %#lx, %#lx, %llu )", ARG1, ARG2, ARG3, (ULong)ARG4);
+ PRINT("sys_fgetxattr ( %ld, %#lx, %#lx, %lu )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(ssize_t, "fgetxattr",
int, fd, char *, name, void *, value, vki_size_t, size);
PRE_MEM_RASCIIZ( "fgetxattr(name)", ARG2 );
PRE(sys_flistxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_flistxattr ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_flistxattr ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "flistxattr",
int, fd, char *, list, vki_size_t, size);
PRE_MEM_WRITE( "flistxattr(list)", ARG2, ARG3 );
PRE(sys_fremovexattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fremovexattr ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_fremovexattr ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "fremovexattr", int, fd, char *, name);
PRE_MEM_RASCIIZ( "fremovexattr(name)", ARG2 );
}
PRE(sys_sched_setparam)
{
- PRINT("sched_setparam ( %ld, %#lx )", ARG1, ARG2 );
+ PRINT("sched_setparam ( %ld, %#lx )", SARG1, ARG2 );
PRE_REG_READ2(long, "sched_setparam",
vki_pid_t, pid, struct sched_param *, p);
PRE_MEM_READ( "sched_setparam(p)", ARG2, sizeof(struct vki_sched_param) );
PRE(sys_sched_getparam)
{
- PRINT("sched_getparam ( %ld, %#lx )", ARG1, ARG2 );
+ PRINT("sched_getparam ( %ld, %#lx )", SARG1, ARG2 );
PRE_REG_READ2(long, "sched_getparam",
vki_pid_t, pid, struct sched_param *, p);
PRE_MEM_WRITE( "sched_getparam(p)", ARG2, sizeof(struct vki_sched_param) );
PRE(sys_sched_getscheduler)
{
- PRINT("sys_sched_getscheduler ( %ld )", ARG1);
+ PRINT("sys_sched_getscheduler ( %ld )", SARG1);
PRE_REG_READ1(long, "sched_getscheduler", vki_pid_t, pid);
}
PRE(sys_sched_setscheduler)
{
- PRINT("sys_sched_setscheduler ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_sched_setscheduler ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "sched_setscheduler",
vki_pid_t, pid, int, policy, struct sched_param *, p);
if (ARG3 != 0)
PRE(sys_sched_get_priority_max)
{
- PRINT("sched_get_priority_max ( %ld )", ARG1);
+ PRINT("sched_get_priority_max ( %ld )", SARG1);
PRE_REG_READ1(long, "sched_get_priority_max", int, policy);
}
PRE(sys_sched_get_priority_min)
{
- PRINT("sched_get_priority_min ( %ld )", ARG1);
+ PRINT("sched_get_priority_min ( %ld )", SARG1);
PRE_REG_READ1(long, "sched_get_priority_min", int, policy);
}
PRE(sys_sched_rr_get_interval)
{
- PRINT("sys_sched_rr_get_interval ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_sched_rr_get_interval ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(int, "sched_rr_get_interval",
vki_pid_t, pid,
struct vki_timespec *, tp);
PRE(sys_sched_setaffinity)
{
- PRINT("sched_setaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sched_setaffinity ( %ld, %lu, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sched_setaffinity",
vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
PRE_MEM_READ( "sched_setaffinity(mask)", ARG3, ARG2);
PRE(sys_sched_getaffinity)
{
- PRINT("sched_getaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sched_getaffinity ( %ld, %lu, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sched_getaffinity",
vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
PRE_MEM_WRITE( "sched_getaffinity(mask)", ARG3, ARG2);
PRE(sys_unshare)
{
- PRINT("sys_unshare ( %ld )", ARG1);
- PRE_REG_READ1(int, "unshare", int, flags);
+ PRINT("sys_unshare ( %#lx )", ARG1);
+ PRE_REG_READ1(int, "unshare", unsigned long, flags);
}
/* ---------------------------------------------------------------------
PRE(sys_dup3)
{
- PRINT("sys_dup3 ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_dup3 ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "dup3", unsigned int, oldfd, unsigned int, newfd, int, flags);
if (!ML_(fd_allowed)(ARG2, "dup3", tid, True))
SET_STATUS_Failure( VKI_EBADF );
PRE(sys_waitid)
{
*flags |= SfMayBlock;
- PRINT("sys_waitid( %ld, %ld, %#lx, %ld, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_waitid( %ld, %ld, %#lx, %ld, %#lx )",
+ SARG1, SARG2, ARG3, SARG4, ARG5);
PRE_REG_READ5(int32_t, "sys_waitid",
int, which, vki_pid_t, pid, struct vki_siginfo *, infop,
int, options, struct vki_rusage *, ru);
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_sync_file_range ( %ld, %lld, %lld, %ld )",
- ARG1,MERGE64(ARG2,ARG3),MERGE64(ARG4,ARG5),ARG6);
+ PRINT("sys_sync_file_range ( %ld, %lld, %lld, %#lx )",
+ SARG1, (Long)MERGE64(ARG2,ARG3), (Long)MERGE64(ARG4,ARG5),ARG6);
PRE_REG_READ6(long, "sync_file_range",
int, fd,
unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
unsigned, MERGE64_FIRST(nbytes), unsigned, MERGE64_SECOND(nbytes),
unsigned int, flags);
#elif VG_WORDSIZE == 8
- PRINT("sys_sync_file_range ( %ld, %lld, %lld, %ld )",
- ARG1,(Long)ARG2,(Long)ARG3,ARG4);
+ PRINT("sys_sync_file_range ( %ld, %ld, %ld, %#lx )",
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "sync_file_range",
int, fd, vki_loff_t, offset, vki_loff_t, nbytes,
unsigned int, flags);
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_sync_file_range2 ( %ld, %ld, %lld, %lld )",
- ARG1,ARG2,MERGE64(ARG3,ARG4),MERGE64(ARG5,ARG6));
+ PRINT("sys_sync_file_range2 ( %ld, %lu, %lld, %lld )",
+ SARG1, ARG2, (Long)MERGE64(ARG3,ARG4), (Long)MERGE64(ARG5,ARG6));
PRE_REG_READ6(long, "sync_file_range2",
int, fd, unsigned int, flags,
unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
unsigned, MERGE64_FIRST(nbytes), unsigned, MERGE64_SECOND(nbytes));
#elif VG_WORDSIZE == 8
- PRINT("sys_sync_file_range2 ( %ld, %ld, %lld, %lld )",
- ARG1,ARG2,(Long)ARG3,(Long)ARG4);
+ PRINT("sys_sync_file_range2 ( %ld, %lu, %ld, %ld )",
+ SARG1, ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "sync_file_range2",
int, fd, unsigned int, flags,
vki_loff_t, offset, vki_loff_t, nbytes);
PRE(sys_perf_event_open)
{
struct vki_perf_event_attr *attr;
- PRINT("sys_perf_event_open ( %#lx, %ld, %ld, %ld, %ld )",
- ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_perf_event_open ( %#lx, %ld, %ld, %ld, %#lx )",
+ ARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, "perf_event_open",
struct vki_perf_event_attr *, attr,
vki_pid_t, pid, int, cpu, int, group_fd,
PRE(sys_move_pages)
{
- PRINT("sys_move_pages ( %ld, %ld, %#lx, %#lx, %#lx, %lx )",
- ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_move_pages ( %ld, %lu, %#lx, %#lx, %#lx, %#lx )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(int, "move_pages",
vki_pid_t, pid, unsigned long, nr_pages, const void **, pages,
const int *, nodes, int *, status, int, flags);
PRE(sys_getrandom)
{
- PRINT("sys_getrandom ( %#lx, %ld, %ld )" , ARG1,ARG2,ARG3);
+ PRINT("sys_getrandom ( %#lx, %lu, %lu )" , ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "getrandom",
char *, buf, vki_size_t, count, unsigned int, flags);
PRE_MEM_WRITE( "getrandom(cpu)", ARG1, ARG2 );
PRE(sys_memfd_create)
{
- PRINT("sys_memfd_create ( %#lx, %ld )" , ARG1,ARG2);
+ PRINT("sys_memfd_create ( %#lx, %lu )" , ARG1, ARG2);
PRE_REG_READ2(int, "memfd_create",
char *, uname, unsigned int, flags);
PRE_MEM_RASCIIZ( "memfd_create(uname)", ARG1 );
PRE(sys_syncfs)
{
*flags |= SfMayBlock;
- PRINT("sys_syncfs ( %ld )", ARG1);
+ PRINT("sys_syncfs ( %lu )", ARG1);
PRE_REG_READ1(long, "syncfs", unsigned int, fd);
}
PRE(sys_lseek)
{
- PRINT("sys_lseek ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_lseek ( %lu, %ld, %lu )", ARG1, SARG2, ARG3);
PRE_REG_READ3(vki_off_t, "lseek",
unsigned int, fd, vki_off_t, offset, unsigned int, whence);
}
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_readahead ( %ld, %lld, %ld )", ARG1, MERGE64(ARG2,ARG3), ARG4);
+ PRINT("sys_readahead ( %ld, %lld, %lu )",
+ SARG1, (Long)MERGE64(ARG2,ARG3), ARG4);
PRE_REG_READ4(vki_off_t, "readahead",
int, fd, unsigned, MERGE64_FIRST(offset),
unsigned, MERGE64_SECOND(offset), vki_size_t, count);
#elif VG_WORDSIZE == 8
- PRINT("sys_readahead ( %ld, %lld, %ld )", ARG1, (Long)ARG2, ARG3);
+ PRINT("sys_readahead ( %ld, %ld, %lu )", SARG1, SARG2, ARG3);
PRE_REG_READ3(vki_off_t, "readahead",
int, fd, vki_loff_t, offset, vki_size_t, count);
#else
vki_sigset_t bigger_set;
vki_sigset_t bigger_oldset;
- PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigprocmask",
int, how, vki_old_sigset_t *, set, vki_old_sigset_t *, oldset);
if (ARG2 != 0)
vki_sigaction_toK_t new, *newp;
vki_sigaction_fromK_t old, *oldp;
- PRINT("sys_sigaction ( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_sigaction ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(int, "sigaction",
int, signum, const struct old_sigaction *, act,
struct old_sigaction *, oldact);
PRE(sys_signalfd4)
{
- PRINT("sys_signalfd4 ( %d, %#lx, %llu, %ld )", (Int)ARG1,ARG2,(ULong)ARG3,ARG4);
+ PRINT("sys_signalfd4 ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "sys_signalfd4",
int, fd, vki_sigset_t *, sigmask, vki_size_t, sigsetsize, int, flags);
PRE_MEM_READ( "signalfd(sigmask)", ARG2, sizeof(vki_sigset_t) );
PRE(sys_rt_sigaction)
{
- PRINT("sys_rt_sigaction ( %ld, %#lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_rt_sigaction ( %ld, %#lx, %#lx, %lu )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigaction",
int, signum, const struct sigaction *, act,
struct sigaction *, oldact, vki_size_t, sigsetsize);
PRE(sys_rt_sigprocmask)
{
- PRINT("sys_rt_sigprocmask ( %ld, %#lx, %#lx, %llu )",ARG1,ARG2,ARG3,(ULong)ARG4);
+ PRINT("sys_rt_sigprocmask ( %ld, %#lx, %#lx, %lu )",
+ SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigprocmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oldset,
vki_size_t, sigsetsize);
PRE(sys_rt_sigtimedwait)
{
*flags |= SfMayBlock;
- PRINT("sys_rt_sigtimedwait ( %#lx, %#lx, %#lx, %lld )",
- ARG1,ARG2,ARG3,(ULong)ARG4);
+ PRINT("sys_rt_sigtimedwait ( %#lx, %#lx, %#lx, %lu )",
+ ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigtimedwait",
const vki_sigset_t *, set, vki_siginfo_t *, info,
const struct timespec *, timeout, vki_size_t, sigsetsize);
PRE(sys_rt_sigqueueinfo)
{
- PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#lx)", ARG1, ARG2, ARG3);
+ PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#lx)", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "rt_sigqueueinfo",
int, pid, int, sig, vki_siginfo_t *, uinfo);
if (ARG2 != 0)
PRE(sys_rt_tgsigqueueinfo)
{
- PRINT("sys_rt_tgsigqueueinfo(%ld, %ld, %ld, %#lx)", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_rt_tgsigqueueinfo(%ld, %ld, %ld, %#lx)",
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "rt_tgsigqueueinfo",
int, tgid, int, pid, int, sig, vki_siginfo_t *, uinfo);
if (ARG3 != 0)
return EINVAL if it isn't.
*/
*flags |= SfMayBlock;
- PRINT("sys_rt_sigsuspend ( %#lx, %ld )", ARG1,ARG2 );
+ PRINT("sys_rt_sigsuspend ( %#lx, %lu )", ARG1, ARG2 );
PRE_REG_READ2(int, "rt_sigsuspend", vki_sigset_t *, mask, vki_size_t, size)
if (ARG1 != (Addr)NULL) {
PRE_MEM_READ( "rt_sigsuspend(mask)", ARG1, sizeof(vki_sigset_t) );
PRE(sys_ipc)
{
- PRINT("sys_ipc ( %ld, %ld, %ld, %ld, %#lx, %ld )",
- ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_ipc ( %lu, %ld, %ld, %ld, %#lx, %ld )",
+ ARG1, SARG2, SARG3, SARG4, ARG5, SARG6);
switch (ARG1 /* call */) {
case VKI_SEMOP:
ML_(generic_PRE_sys_shmctl)( tid, ARG2, ARG3, ARG5 );
break;
default:
- VG_(message)(Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %ld\n", ARG1 );
+ VG_(message)(Vg_DebugMsg, "FATAL: unhandled syscall(ipc) %lu\n", ARG1 );
VG_(core_panic)("... bye!\n");
break; /*NOTREACHED*/
}
break;
default:
VG_(message)(Vg_DebugMsg,
- "FATAL: unhandled syscall(ipc) %ld\n",
+ "FATAL: unhandled syscall(ipc) %lu\n",
ARG1 );
VG_(core_panic)("... bye!\n");
break; /*NOTREACHED*/
PRE(sys_semget)
{
- PRINT("sys_semget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_semget ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semget", vki_key_t, key, int, nsems, int, semflg);
}
PRE(sys_semop)
{
*flags |= SfMayBlock;
- PRINT("sys_semop ( %ld, %#lx, %lu )",ARG1,ARG2,ARG3);
+ PRINT("sys_semop ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "semop",
int, semid, struct sembuf *, sops, unsigned, nsoops);
ML_(generic_PRE_sys_semop)(tid, ARG1,ARG2,ARG3);
switch (ARG3 & ~VKI_IPC_64) {
case VKI_IPC_INFO:
case VKI_SEM_INFO:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct seminfo *, arg);
break;
case VKI_IPC_STAT:
case VKI_SEM_STAT:
case VKI_IPC_SET:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct semid_ds *, arg);
break;
case VKI_GETALL:
case VKI_SETALL:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
default:
- PRINT("sys_semctl ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_semctl ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semctl",
int, semid, int, semnum, int, cmd);
break;
PRE(sys_semtimedop)
{
*flags |= SfMayBlock;
- PRINT("sys_semtimedop ( %ld, %#lx, %lu, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semtimedop ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "semtimedop",
int, semid, struct sembuf *, sops, unsigned, nsoops,
struct timespec *, timeout);
PRE(sys_msgget)
{
- PRINT("sys_msgget ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_msgget ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "msgget", vki_key_t, key, int, msgflg);
}
PRE(sys_msgsnd)
{
- PRINT("sys_msgsnd ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_msgsnd ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "msgsnd",
int, msqid, struct msgbuf *, msgp, vki_size_t, msgsz, int, msgflg);
ML_(linux_PRE_sys_msgsnd)(tid, ARG1,ARG2,ARG3,ARG4);
PRE(sys_msgrcv)
{
- PRINT("sys_msgrcv ( %ld, %#lx, %ld, %ld, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_msgrcv ( %ld, %#lx, %lu, %ld, %ld )",
+ SARG1, ARG2, ARG3, SARG4, SARG5);
PRE_REG_READ5(long, "msgrcv",
int, msqid, struct msgbuf *, msgp, vki_size_t, msgsz,
long, msgytp, int, msgflg);
PRE(sys_msgctl)
{
- PRINT("sys_msgctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_msgctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "msgctl",
int, msqid, int, cmd, struct msqid_ds *, buf);
ML_(linux_PRE_sys_msgctl)(tid, ARG1,ARG2,ARG3);
PRE(sys_shmget)
{
- PRINT("sys_shmget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_shmget ( %ld, %lu, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmget", vki_key_t, key, vki_size_t, size, int, shmflg);
if (ARG3 & VKI_SHM_HUGETLB) {
static Bool warning_given = False;
PRE(wrap_sys_shmat)
{
UWord arg2tmp;
- PRINT("wrap_sys_shmat ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("wrap_sys_shmat ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmat",
int, shmid, const void *, shmaddr, int, shmflg);
#if defined(VGP_arm_linux)
PRE(sys_shmctl)
{
- PRINT("sys_shmctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_shmctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "shmctl",
int, shmid, int, cmd, struct shmid_ds *, buf);
#ifdef VGP_amd64_linux
}
*flags |= SfMayBlock;
- PRINT("sys_socketcall ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("sys_socketcall ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "socketcall", int, call, unsigned long *, args);
switch (ARG1 /* request */) {
PRE(sys_socket)
{
- PRINT("sys_socket ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_socket ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "socket", int, domain, int, type, int, protocol);
}
POST(sys_socket)
PRE(sys_setsockopt)
{
- PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %lu )",
+ SARG1, SARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, "setsockopt",
int, s, int, level, int, optname,
- const void *, optval, int, optlen);
+ const void *, optval, unsigned, optlen); // socklen_t
ML_(linux_PRE_sys_setsockopt)(tid, ARG1,ARG2,ARG3,ARG4,ARG5);
}
PRE(sys_getsockopt)
{
- PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %ld )",
+ SARG1, SARG2, SARG3, ARG4, SARG5);
PRE_REG_READ5(long, "getsockopt",
int, s, int, level, int, optname,
void *, optval, int, *optlen);
PRE(sys_connect)
{
*flags |= SfMayBlock;
- PRINT("sys_connect ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_connect ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "connect",
int, sockfd, struct sockaddr *, serv_addr, int, addrlen);
ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3);
PRE(sys_accept)
{
*flags |= SfMayBlock;
- PRINT("sys_accept ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_accept ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "accept",
- int, s, struct sockaddr *, addr, int, *addrlen);
+ int, s, struct sockaddr *, addr, int *, addrlen);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept)
PRE(sys_accept4)
{
*flags |= SfMayBlock;
- PRINT("sys_accept4 ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_accept4 ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "accept4",
- int, s, struct sockaddr *, addr, int, *addrlen, int, flags);
+ int, s, struct sockaddr *, addr, int *, addrlen, int, flags);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept4)
PRE(sys_send)
{
*flags |= SfMayBlock;
- PRINT("sys_send ( %ld, %#lx, %ld, %lu )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_send ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "send",
- int, s, const void *, msg, int, len,
- unsigned int, flags);
+ int, s, const void *, msg, vki_size_t, len,
+ int, flags);
ML_(generic_PRE_sys_send)( tid, ARG1, ARG2, ARG3 );
}
PRE(sys_sendto)
{
*flags |= SfMayBlock;
- PRINT("sys_sendto ( %ld, %#lx, %ld, %lu, %#lx, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_sendto ( %ld, %#lx, %lu, %lu, %#lx, %ld )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendto",
- int, s, const void *, msg, int, len,
+ int, s, const void *, msg, vki_size_t, len,
unsigned int, flags,
const struct sockaddr *, to, int, tolen);
ML_(generic_PRE_sys_sendto)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
PRE (sys_recv)
{
*flags |= SfMayBlock;
- PRINT ("sys_recv ( %ld, %#lx, %ld, %lu )", ARG1, ARG2, ARG3, ARG4);
- PRE_REG_READ4 (long, "recv", int, s, void *, buf, int, len,
+ PRINT ("sys_recv ( %ld, %#lx, %lu, %lu )", SARG1, ARG2, ARG3, ARG4);
+ PRE_REG_READ4 (long, "recv", int, s, void *, buf, vki_size_t, len,
unsigned int, flags);
ML_ (generic_PRE_sys_recv) (tid, ARG1, ARG2, ARG3);
}
PRE(sys_recvfrom)
{
*flags |= SfMayBlock;
- PRINT("sys_recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_recvfrom ( %ld, %#lx, %lu, %lu, %#lx, %#lx )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "recvfrom",
- int, s, void *, buf, int, len, unsigned int, flags,
+ int, s, void *, buf, vki_size_t, len, unsigned int, flags,
struct sockaddr *, from, int *, fromlen);
ML_(generic_PRE_sys_recvfrom)(tid, ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
}
PRE(sys_sendmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_sendmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_sendmsg ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sendmsg",
- int, s, const struct msghdr *, msg, int, flags);
+ int, s, const struct msghdr *, msg, unsigned int, flags);
ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr *)ARG2);
}
PRE(sys_recvmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_recvmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
- PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags);
+ PRINT("sys_recvmsg ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
+ PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg,
+ unsigned int, flags);
ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)ARG2);
}
POST(sys_recvmsg)
PRE(sys_shutdown)
{
*flags |= SfMayBlock;
- PRINT("sys_shutdown ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_shutdown ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(int, "shutdown", int, s, int, how);
}
PRE(sys_bind)
{
- PRINT("sys_bind ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_bind ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "bind",
int, sockfd, struct sockaddr *, my_addr, int, addrlen);
ML_(generic_PRE_sys_bind)(tid, ARG1,ARG2,ARG3);
PRE(sys_listen)
{
- PRINT("sys_listen ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_listen ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "listen", int, s, int, backlog);
}
PRE(sys_getsockname)
{
- PRINT("sys_getsockname ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_getsockname ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getsockname",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getsockname)(tid, ARG1,ARG2,ARG3);
PRE(sys_getpeername)
{
- PRINT("sys_getpeername ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_getpeername ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getpeername",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getpeername)(tid, ARG1,ARG2,ARG3);
PRE(sys_socketpair)
{
- PRINT("sys_socketpair ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_socketpair ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "socketpair",
int, d, int, type, int, protocol, int*, sv);
ML_(generic_PRE_sys_socketpair)(tid, ARG1,ARG2,ARG3,ARG4);
if (ARG3 & VKI_O_CREAT) {
// 4-arg version
- PRINT("sys_openat ( %ld, %#lx(%s), %ld, %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
+ PRINT("sys_openat ( %ld, %#lx(%s), %ld, %ld )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "openat",
int, dfd, const char *, filename, int, flags, int, mode);
} else {
// 3-arg version
- PRINT("sys_openat ( %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_openat ( %ld, %#lx(%s), %ld )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3);
PRE_REG_READ3(long, "openat",
int, dfd, const char *, filename, int, flags);
}
PRE(sys_mkdirat)
{
*flags |= SfMayBlock;
- PRINT("sys_mkdirat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_mkdirat ( %ld, %#lx(%s), %ld )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3);
PRE_REG_READ3(long, "mkdirat",
int, dfd, const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "mkdirat(pathname)", ARG2 );
PRE(sys_mknodat)
{
- PRINT("sys_mknodat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
+ PRINT("sys_mknodat ( %ld, %#lx(%s), 0x%lx, 0x%lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4 );
PRE_REG_READ4(long, "mknodat",
int, dfd, const char *, pathname, int, mode, unsigned, dev);
PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
PRE(sys_fchownat)
{
- PRINT("sys_fchownat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
+ PRINT("sys_fchownat ( %ld, %#lx(%s), 0x%lx, 0x%lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "fchownat",
int, dfd, const char *, path,
vki_uid_t, owner, vki_gid_t, group);
PRE(sys_futimesat)
{
- PRINT("sys_futimesat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_futimesat ( %ld, %#lx(%s), %#lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3);
PRE_REG_READ3(long, "futimesat",
int, dfd, char *, filename, struct timeval *, tvp);
if (ARG2 != 0)
PRE(sys_utimensat)
{
- PRINT("sys_utimensat ( %ld, %#lx(%s), %#lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
+ PRINT("sys_utimensat ( %ld, %#lx(%s), %#lx, 0x%lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "utimensat",
int, dfd, char *, filename, struct timespec *, utimes, int, flags);
if (ARG2 != 0)
PRE(sys_newfstatat)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_newfstatat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_newfstatat ( %ld, %#lx(%s), %#lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3);
PRE_REG_READ3(long, "fstatat",
int, dfd, char *, file_name, struct stat *, buf);
PRE_MEM_RASCIIZ( "fstatat(file_name)", ARG2 );
PRE(sys_unlinkat)
{
*flags |= SfMayBlock;
- PRINT("sys_unlinkat ( %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2);
+ PRINT("sys_unlinkat ( %ld, %#lx(%s) )", SARG1, ARG2, (HChar*)ARG2);
PRE_REG_READ2(long, "unlinkat", int, dfd, const char *, pathname);
PRE_MEM_RASCIIZ( "unlinkat(pathname)", ARG2 );
}
PRE(sys_renameat)
{
- PRINT("sys_renameat ( %ld, %#lx(%s), %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4);
+ PRINT("sys_renameat ( %ld, %#lx(%s), %ld, %#lx(%s) )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3, ARG4, (HChar*)ARG4);
PRE_REG_READ4(long, "renameat",
int, olddfd, const char *, oldpath,
int, newdfd, const char *, newpath);
PRE(sys_linkat)
{
*flags |= SfMayBlock;
- PRINT("sys_linkat ( %ld, %#lx(%s), %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4,ARG5);
+ PRINT("sys_linkat ( %ld, %#lx(%s), %ld, %#lx(%s), %ld )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3, ARG4, (HChar*)ARG4, SARG5);
PRE_REG_READ5(long, "linkat",
int, olddfd, const char *, oldpath,
int, newdfd, const char *, newpath,
PRE(sys_symlinkat)
{
*flags |= SfMayBlock;
- PRINT("sys_symlinkat ( %#lx(%s), %ld, %#lx(%s) )",ARG1,(char*)ARG1,ARG2,ARG3,(char*)ARG3);
+ PRINT("sys_symlinkat ( %#lx(%s), %ld, %#lx(%s) )",
+ ARG1, (HChar*)ARG1, SARG2, ARG3, (HChar*)ARG3);
PRE_REG_READ3(long, "symlinkat",
const char *, oldpath, int, newdfd, const char *, newpath);
PRE_MEM_RASCIIZ( "symlinkat(oldpath)", ARG1 );
HChar name[30]; // large enough
Word saved = SYSNO;
- PRINT("sys_readlinkat ( %ld, %#lx(%s), %#lx, %llu )", ARG1,ARG2,(char*)ARG2,ARG3,(ULong)ARG4);
+ PRINT("sys_readlinkat ( %ld, %#lx(%s), %#lx, %lu )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "readlinkat",
- int, dfd, const char *, path, char *, buf, int, bufsiz);
+ int, dfd, const char *, path, char *, buf, vki_size_t, bufsiz);
PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
PRE_MEM_WRITE( "readlinkat(buf)", ARG3,ARG4 );
PRE(sys_fchmodat)
{
- PRINT("sys_fchmodat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_fchmodat ( %ld, %#lx(%s), %lu )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3);
PRE_REG_READ3(long, "fchmodat",
int, dfd, const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2 );
PRE(sys_faccessat)
{
- PRINT("sys_faccessat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_faccessat ( %ld, %#lx(%s), %ld )",
+ SARG1, ARG2, (HChar*)ARG2, SARG3);
PRE_REG_READ3(long, "faccessat",
int, dfd, const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "faccessat(pathname)", ARG2 );
PRE(sys_name_to_handle_at)
{
- PRINT("sys_name_to_handle_at ( %ld, %#lx(%s), %#lx, %#lx, %ld )", ARG1, ARG2, (char*)ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_name_to_handle_at ( %ld, %#lx(%s), %#lx, %#lx, %ld )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(int, "name_to_handle_at",
int, dfd, const char *, name,
struct vki_file_handle *, handle,
PRE(sys_open_by_handle_at)
{
*flags |= SfMayBlock;
- PRINT("sys_open_by_handle_at ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_open_by_handle_at ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(int, "open_by_handle_at",
int, mountdirfd,
struct vki_file_handle *, handle,
#if VG_WORDSIZE == 4
/* Note that the offset argument here is in lo+hi order on both
big and little endian platforms... */
- PRINT("sys_preadv ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,LOHI64(ARG4,ARG5));
+ PRINT("sys_preadv ( %lu, %#lx, %lu, %lld )",
+ ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5));
PRE_REG_READ5(ssize_t, "preadv",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count, vki_u32, offset_low,
vki_u32, offset_high);
#elif VG_WORDSIZE == 8
- PRINT("sys_preadv ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,(Long)ARG4);
+ PRINT("sys_preadv ( %lu, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(ssize_t, "preadv",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count, Word, offset);
#if VG_WORDSIZE == 4
/* Note that the offset argument here is in lo+hi order on both
big and little endian platforms... */
- PRINT("sys_pwritev ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,LOHI64(ARG4,ARG5));
+ PRINT("sys_pwritev ( %lu, %#lx, %lu, %lld )",
+ ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5));
PRE_REG_READ5(ssize_t, "pwritev",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count, vki_u32, offset_low,
vki_u32, offset_high);
#elif VG_WORDSIZE == 8
- PRINT("sys_pwritev ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,(Long)ARG4);
+ PRINT("sys_pwritev ( %lu, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(ssize_t, "pwritev",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count, Word, offset);
PRE(sys_process_vm_readv)
{
- PRINT("sys_process_vm_readv ( %lu, %#lx, %lu, %#lx, %lu, %lu )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_process_vm_readv ( %ld, %#lx, %lu, %#lx, %lu, %lu )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(ssize_t, "process_vm_readv",
vki_pid_t, pid,
const struct iovec *, lvec,
PRE(sys_process_vm_writev)
{
- PRINT("sys_process_vm_writev ( %lu, %#lx, %lu, %#lx, %lu, %lu )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_process_vm_writev ( %ld, %#lx, %lu, %#lx, %lu, %lu )",
+ SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(ssize_t, "process_vm_writev",
vki_pid_t, pid,
const struct iovec *, lvec,
PRE(sys_sendmmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_sendmmsg ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_sendmmsg ( %ld, %#lx, %ld, %ld )", SARG1, ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "sendmmsg",
int, s, const struct mmsghdr *, mmsg, int, vlen, int, flags);
ML_(linux_PRE_sys_sendmmsg)(tid, ARG1,ARG2,ARG3,ARG4);
PRE(sys_recvmmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_recvmmsg ( %ld, %#lx, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_recvmmsg ( %ld, %#lx, %ld, %ld, %#lx )",
+ SARG1, ARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, "recvmmsg",
int, s, struct mmsghdr *, mmsg, int, vlen,
int, flags, struct timespec *, timeout);
PRE(sys_request_key)
{
PRINT("sys_request_key ( %#lx(%s), %#lx(%s), %#lx(%s), %ld )",
- ARG1,(char*)ARG1,ARG2,(char*)ARG2,ARG3,(char*)ARG3,ARG4);
+ ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3, (HChar*)ARG3, SARG4);
PRE_REG_READ4(long, "request_key",
const char *, type, const char *, description,
const char *, callout_info, vki_key_serial_t, keyring);
PRE(sys_add_key)
{
- PRINT("sys_add_key ( %#lx(%s), %#lx(%s), %#lx, %ld, %ld )",
- ARG1,(char*)ARG1,ARG2,(char*)ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_add_key ( %#lx(%s), %#lx(%s), %#lx, %lu, %ld )",
+ ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "add_key",
const char *, type, const char *, description,
const void *, payload, vki_size_t, plen,
{
switch (ARG1 /* option */) {
case VKI_KEYCTL_GET_KEYRING_ID:
- PRINT("sys_keyctl ( KEYCTL_GET_KEYRING_ID, %ld, %ld )", ARG2,ARG3);
+ PRINT("sys_keyctl ( KEYCTL_GET_KEYRING_ID, %ld, %ld )", SARG2, SARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_GET_KEYRING_ID)",
int, option, vki_key_serial_t, id, int, create);
break;
PRE_MEM_RASCIIZ("keyctl(KEYCTL_JOIN_SESSION_KEYRING, name)", ARG2);
break;
case VKI_KEYCTL_UPDATE:
- PRINT("sys_keyctl ( KEYCTL_UPDATE, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
+ PRINT("sys_keyctl ( KEYCTL_UPDATE, %ld, %#lx, %lu )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_UPDATE)",
int, option, vki_key_serial_t, key,
const void *, payload, vki_size_t, plen);
PRE_MEM_READ("keyctl(KEYCTL_UPDATE, payload)", ARG3, ARG4);
break;
case VKI_KEYCTL_REVOKE:
- PRINT("sys_keyctl ( KEYCTL_REVOKE, %ld )", ARG2);
+ PRINT("sys_keyctl ( KEYCTL_REVOKE, %ld )", SARG2);
PRE_REG_READ2(long, "keyctl(KEYCTL_REVOKE)",
int, option, vki_key_serial_t, id);
break;
case VKI_KEYCTL_CHOWN:
- PRINT("sys_keyctl ( KEYCTL_CHOWN, %ld, %ld, %ld )", ARG2,ARG3,ARG4);
+ PRINT("sys_keyctl ( KEYCTL_CHOWN, %ld, %lu, %lu )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_CHOWN)",
int, option, vki_key_serial_t, id,
vki_uid_t, uid, vki_gid_t, gid);
break;
case VKI_KEYCTL_SETPERM:
- PRINT("sys_keyctl ( KEYCTL_SETPERM, %ld, %ld )", ARG2,ARG3);
+ PRINT("sys_keyctl ( KEYCTL_SETPERM, %ld, %lu )", SARG2, ARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_SETPERM)",
int, option, vki_key_serial_t, id, vki_key_perm_t, perm);
break;
case VKI_KEYCTL_DESCRIBE:
- PRINT("sys_keyctl ( KEYCTL_DESCRIBE, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
+ PRINT("sys_keyctl ( KEYCTL_DESCRIBE, %ld, %#lx, %lu )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_DESCRIBE)",
int, option, vki_key_serial_t, id,
char *, buffer, vki_size_t, buflen);
PRE_MEM_WRITE("keyctl(KEYCTL_DESCRIBE, buffer)", ARG3, ARG4);
break;
case VKI_KEYCTL_CLEAR:
- PRINT("sys_keyctl ( KEYCTL_CLEAR, %ld )", ARG2);
+ PRINT("sys_keyctl ( KEYCTL_CLEAR, %ld )", SARG2);
PRE_REG_READ2(long, "keyctl(KEYCTL_CLEAR)",
int, option, vki_key_serial_t, keyring);
break;
case VKI_KEYCTL_LINK:
- PRINT("sys_keyctl ( KEYCTL_LINK, %ld, %ld )", ARG2,ARG3);
+ PRINT("sys_keyctl ( KEYCTL_LINK, %ld, %ld )", SARG2, SARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_LINK)", int, option,
vki_key_serial_t, keyring, vki_key_serial_t, key);
break;
case VKI_KEYCTL_UNLINK:
- PRINT("sys_keyctl ( KEYCTL_UNLINK, %ld, %ld )", ARG2,ARG3);
+ PRINT("sys_keyctl ( KEYCTL_UNLINK, %ld, %ld )", SARG2, SARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_UNLINK)", int, option,
vki_key_serial_t, keyring, vki_key_serial_t, key);
break;
case VKI_KEYCTL_SEARCH:
PRINT("sys_keyctl ( KEYCTL_SEARCH, %ld, %#lx(%s), %#lx(%s), %ld )",
- ARG2,ARG3,(char*)ARG3,ARG4,(char*)ARG4,ARG5);
+ SARG2, ARG3, (HChar*)ARG3, ARG4, (HChar*)ARG4, SARG5);
PRE_REG_READ5(long, "keyctl(KEYCTL_SEARCH)",
int, option, vki_key_serial_t, keyring,
const char *, type, const char *, description,
PRE_MEM_RASCIIZ("sys_keyctl(KEYCTL_SEARCH, description)", ARG4);
break;
case VKI_KEYCTL_READ:
- PRINT("sys_keyctl ( KEYCTL_READ, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
+ PRINT("sys_keyctl ( KEYCTL_READ, %ld, %#lx, %lu )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_READ)",
int, option, vki_key_serial_t, keyring,
char *, buffer, vki_size_t, buflen);
PRE_MEM_WRITE("keyctl(KEYCTL_READ, buffer)", ARG3, ARG4);
break;
case VKI_KEYCTL_INSTANTIATE:
- PRINT("sys_keyctl ( KEYCTL_INSTANTIATE, %ld, %#lx, %ld, %ld )",
- ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_keyctl ( KEYCTL_INSTANTIATE, %ld, %#lx, %lu, %ld )",
+ SARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "keyctl(KEYCTL_INSTANTIATE)",
int, option, vki_key_serial_t, key,
char *, payload, vki_size_t, plen,
PRE_MEM_READ("keyctl(KEYCTL_INSTANTIATE, payload)", ARG3, ARG4);
break;
case VKI_KEYCTL_NEGATE:
- PRINT("sys_keyctl ( KEYCTL_NEGATE, %ld, %lu, %ld )", ARG2,ARG3,ARG4);
+ PRINT("sys_keyctl ( KEYCTL_NEGATE, %ld, %lu, %ld )", SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_NEGATE)",
int, option, vki_key_serial_t, key,
unsigned, timeout, vki_key_serial_t, keyring);
break;
case VKI_KEYCTL_SET_REQKEY_KEYRING:
- PRINT("sys_keyctl ( KEYCTL_SET_REQKEY_KEYRING, %ld )", ARG2);
+ PRINT("sys_keyctl ( KEYCTL_SET_REQKEY_KEYRING, %ld )", SARG2);
PRE_REG_READ2(long, "keyctl(KEYCTL_SET_REQKEY_KEYRING)",
int, option, int, reqkey_defl);
break;
case VKI_KEYCTL_SET_TIMEOUT:
- PRINT("sys_keyctl ( KEYCTL_SET_TIMEOUT, %ld, %ld )", ARG2,ARG3);
+ PRINT("sys_keyctl ( KEYCTL_SET_TIMEOUT, %ld, %lu )", SARG2, ARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_SET_TIMEOUT)",
int, option, vki_key_serial_t, key, unsigned, timeout);
break;
case VKI_KEYCTL_ASSUME_AUTHORITY:
- PRINT("sys_keyctl ( KEYCTL_ASSUME_AUTHORITY, %ld )", ARG2);
+ PRINT("sys_keyctl ( KEYCTL_ASSUME_AUTHORITY, %ld )", SARG2);
PRE_REG_READ2(long, "keyctl(KEYCTL_ASSUME_AUTHORITY)",
int, option, vki_key_serial_t, key);
break;
default:
- PRINT("sys_keyctl ( %ld ) ", ARG1);
+ PRINT("sys_keyctl ( %ld ) ", SARG1);
PRE_REG_READ1(long, "keyctl", int, option);
break;
}
PRE(sys_ioprio_set)
{
- PRINT("sys_ioprio_set ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_ioprio_set ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(int, "ioprio_set", int, which, int, who, int, ioprio);
}
PRE(sys_ioprio_get)
{
- PRINT("sys_ioprio_get ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_ioprio_get ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(int, "ioprio_get", int, which, int, who);
}
PRE(sys_init_module)
{
*flags |= SfMayBlock;
- PRINT("sys_init_module ( %#lx, %llu, %#lx(\"%s\") )",
- ARG1, (ULong)ARG2, ARG3, (char*)ARG3);
+ PRINT("sys_init_module ( %#lx, %lu, %#lx(\"%s\") )",
+ ARG1, ARG2, ARG3, (HChar*)ARG3);
PRE_REG_READ3(long, "init_module",
void *, umod, unsigned long, len, const char *, uargs);
PRE_MEM_READ( "init_module(umod)", ARG1, ARG2 );
PRE(sys_delete_module)
{
*flags |= SfMayBlock;
- PRINT("sys_delete_module ( %#lx(\"%s\"), 0x%lx )", ARG1,(char*)ARG1, ARG2);
+ PRINT("sys_delete_module ( %#lx(\"%s\"), 0x%lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "delete_module",
const char *, name_user, unsigned int, flags);
PRE_MEM_RASCIIZ("delete_module(name_user)", ARG1);
PRE(sys_splice)
{
*flags |= SfMayBlock;
- PRINT("sys_splice ( %ld, %#lx, %ld, %#lx, %ld, %ld )",
- ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_splice ( %ld, %#lx, %ld, %#lx, %lu, %#lx )",
+ SARG1, ARG2, SARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(vki_ssize_t, "splice",
int, fd_in, vki_loff_t *, off_in,
int, fd_out, vki_loff_t *, off_out,
PRE(sys_tee)
{
*flags |= SfMayBlock;
- PRINT("sys_tree ( %ld, %ld, %ld, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_tree ( %ld, %ld, %lu, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(vki_ssize_t, "tee",
int, fd_in, int, fd_out,
vki_size_t, len, unsigned int, flags);
{
Int fdfl;
*flags |= SfMayBlock;
- PRINT("sys_vmsplice ( %ld, %#lx, %ld, %ld )",
- ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_vmsplice ( %ld, %#lx, %lu, %lu )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(vki_ssize_t, "splice",
int, fd, struct vki_iovec *, iov,
unsigned long, nr_segs, unsigned int, flags);
#if defined(VGP_x86_linux)
PRE(sys_lookup_dcookie)
{
- PRINT("sys_lookup_dcookie (0x%llx, %#lx, %ld)",
+ PRINT("sys_lookup_dcookie (0x%llx, %#lx, %lu)",
MERGE64(ARG1,ARG2), ARG3, ARG4);
PRE_REG_READ4(long, "lookup_dcookie",
vki_u32, MERGE64_FIRST(cookie), vki_u32, MERGE64_SECOND(cookie),
PRE(sys_lookup_dcookie)
{
*flags |= SfMayBlock;
- PRINT("sys_lookup_dcookie ( %llu, %#lx, %llu )",
- (ULong)ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_lookup_dcookie ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "lookup_dcookie",
unsigned long long, cookie, char *, buf, vki_size_t, len);
case VKI_F_GETSIG:
case VKI_F_GETLEASE:
case VKI_F_GETPIPE_SZ:
- PRINT("sys_fcntl ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_fcntl ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "fcntl", unsigned int, fd, unsigned int, cmd);
break;
case VKI_F_SETOWN:
case VKI_F_SETSIG:
case VKI_F_SETPIPE_SZ:
- PRINT("sys_fcntl[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[ARG3=='arg'] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd, unsigned long, arg);
break;
case VKI_F_OFD_GETLK:
case VKI_F_OFD_SETLK:
case VKI_F_OFD_SETLKW:
- PRINT("sys_fcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[ARG3=='lock'] ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct flock64 *, lock);
break;
case VKI_F_SETOWN_EX:
- PRINT("sys_fcntl[F_SETOWN_EX] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[F_SETOWN_EX] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_f_owner_ex *, arg);
break;
case VKI_F_GETOWN_EX:
- PRINT("sys_fcntl[F_GETOWN_EX] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[F_GETOWN_EX] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_f_owner_ex *, arg);
break;
default:
- PRINT("sys_fcntl[UNKNOWN] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[UNKNOWN] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
I_die_here;
break;
}
case VKI_F_GETSIG:
case VKI_F_SETSIG:
case VKI_F_GETLEASE:
- PRINT("sys_fcntl64 ( %ld, %ld )", ARG1,ARG2);
+ PRINT("sys_fcntl64 ( %lu, %lu )", ARG1, ARG2);
PRE_REG_READ2(long, "fcntl64", unsigned int, fd, unsigned int, cmd);
break;
case VKI_F_SETFL:
case VKI_F_SETLEASE:
case VKI_F_NOTIFY:
- PRINT("sys_fcntl64[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl64[ARG3=='arg'] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl64",
unsigned int, fd, unsigned int, cmd, unsigned long, arg);
break;
case VKI_F_OFD_GETLK:
case VKI_F_OFD_SETLK:
case VKI_F_OFD_SETLKW:
- PRINT("sys_fcntl64[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl64[ARG3=='lock'] ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl64",
unsigned int, fd, unsigned int, cmd,
struct flock64 *, lock);
break;
case VKI_F_SETOWN_EX:
- PRINT("sys_fcntl[F_SETOWN_EX] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[F_SETOWN_EX] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_f_owner_ex *, arg);
break;
case VKI_F_GETOWN_EX:
- PRINT("sys_fcntl[F_GETOWN_EX] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_fcntl[F_GETOWN_EX] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_f_owner_ex *, arg);
/* V4L2 */
case VKI_V4L2_LOG_STATUS:
- PRINT("sys_ioctl ( %ld, 0x%lx )",ARG1,ARG2);
+ PRINT("sys_ioctl ( %lu, 0x%lx )", ARG1, ARG2);
PRE_REG_READ2(long, "ioctl",
unsigned int, fd, unsigned int, request);
return;
default:
- PRINT("sys_ioctl ( %ld, 0x%lx, 0x%lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_ioctl ( %lu, 0x%lx, 0x%lx )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "ioctl",
unsigned int, fd, unsigned int, request, unsigned long, arg);
break;
PRE(sys_kcmp)
{
- PRINT("kcmp ( %ld, %ld, %ld, %lu, %lu )", ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("kcmp ( %ld, %ld, %ld, %lu, %lu )", SARG1, SARG2, SARG3, ARG4, ARG5);
switch (ARG3) {
case VKI_KCMP_VM: case VKI_KCMP_FILES: case VKI_KCMP_FS:
case VKI_KCMP_SIGHAND: case VKI_KCMP_IO: case VKI_KCMP_SYSVSEM:
# endif
vg_assert2(
err == 0,
- "ML_(do_syscall_for_client_WRK): sigprocmask error %d",
- (Int)(err & 0xFFF)
+ "ML_(do_syscall_for_client_WRK): sigprocmask error %lu",
+ err & 0xFFF
);
}
sci->flags is zero.
*/
- PRINT("SYSCALL[%d,%d](%s) ",
+ PRINT("SYSCALL[%d,%u](%s) ",
VG_(getpid)(), tid, VG_SYSNUM_STRING(sysno));
/* Do any pre-syscall actions */
/* Be decorative, if required. */
if (VG_(clo_trace_syscalls)) {
- PRINT("SYSCALL[%d,%d](%s) ... [async] --> %s",
+ PRINT("SYSCALL[%d,%u](%s) ... [async] --> %s",
VG_(getpid)(), tid, VG_SYSNUM_STRING(sysno),
VG_(sr_as_string)(sci->status.sres));
}
if (p[0] != 0x44 || p[1] != 0x0 || p[2] != 0x0 || p[3] != 0x02)
VG_(message)(Vg_DebugMsg,
"?! restarting over syscall at %#llx %02x %02x %02x %02x\n",
- arch->vex.guest_CIA + 0ULL, p[0], p[1], p[2], p[3]);
+ (ULong)arch->vex.guest_CIA, p[0], p[1], p[2], p[3]);
vg_assert(p[0] == 0x44 && p[1] == 0x0 && p[2] == 0x0 && p[3] == 0x2);
}
if (p[3] != 0x44 || p[2] != 0x0 || p[1] != 0x0 || p[0] != 0x02)
VG_(message)(Vg_DebugMsg,
"?! restarting over syscall at %#llx %02x %02x %02x %02x\n",
- arch->vex.guest_CIA + 0ULL, p[3], p[2], p[1], p[0]);
+ arch->vex.guest_CIA, p[3], p[2], p[1], p[0]);
vg_assert(p[3] == 0x44 && p[2] == 0x0 && p[1] == 0x0 && p[0] == 0x2);
}
if (!valid) {
VG_(message)(Vg_DebugMsg,
"?! restarting over (Thumb) syscall that is not syscall "
- "at %#llx %02x %02x\n",
- arch->vex.guest_R15T - 1ULL, p[0], p[1]);
+ "at %#x %02x %02x\n",
+ arch->vex.guest_R15T - 1, p[0], p[1]);
}
vg_assert(valid);
// FIXME: NOTE, this really isn't right. We need to back up
if (!valid) {
VG_(message)(Vg_DebugMsg,
"?! restarting over (ARM) syscall that is not syscall "
- "at %#llx %02x %02x %02x %02x\n",
- arch->vex.guest_R15T + 0ULL, p[0], p[1], p[2], p[3]);
+ "at %#x %02x %02x %02x %02x\n",
+ arch->vex.guest_R15T, p[0], p[1], p[2], p[3]);
}
vg_assert(valid);
}
VG_(message)(
Vg_DebugMsg,
"?! restarting over syscall at %#llx %02x %02x %02x %02x\n",
- arch->vex.guest_PC + 0ULL, p[0], p[1], p[2], p[3]
+ arch->vex.guest_PC, p[0], p[1], p[2], p[3]
);
vg_assert(p[0] == 0x01 && p[1] == 0x00 && p[2] == 0x00 && p[3] == 0xD4);
if (VG_(clo_trace_signals))
VG_(message)( Vg_DebugMsg,
- "interrupted_syscall: tid=%d, ip=0x%llx, "
+ "interrupted_syscall: tid=%u, ip=%#lx, "
"restart=%s, sres.isErr=%s, sres.val=%lld\n",
- (Int)tid,
- (ULong)ip,
+ tid,
+ ip,
restart ? "True" : "False",
sr_isError(sres) ? "True" : "False",
(Long)(sr_isError(sres) ? sr_Err(sres) : sr_Res(sres)) );
VG_(acquire_BigLock)(tid, "wqthread_continue_NORETURN");
- PRINT("SYSCALL[%d,%d](%s) workq_ops() starting new workqueue item\n",
+ PRINT("SYSCALL[%d,%u](%s) workq_ops() starting new workqueue item\n",
VG_(getpid)(), tid, VG_SYSNUM_STRING(__NR_workq_ops));
vg_assert(VG_(is_valid_tid)(tid));
units rather than bytes, so that it can be used for files bigger than
2^32 bytes. */
SysRes r;
- PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )", ARG1, (ULong) ARG2,
- ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_mmap2 ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, SARG3, SARG4, SARG5, SARG6);
PRE_REG_READ6(long, "mmap2", unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
unsigned long, fd, unsigned long, offset);
PRE(sys_mmap)
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %lu, %lu, %lu, %ld )", ARG1, (ULong) ARG2,
- ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %lu )",
+ ARG1, ARG2, SARG3, SARG4, SARG5, ARG6);
PRE_REG_READ6(long, "mmap", unsigned long, start, vki_size_t, length,
int, prot, int, flags, int, fd, unsigned long, offset);
r = mips_PRE_sys_mmap(tid, ARG1, ARG2, ARG3, ARG4, ARG5, (Off64T) ARG6);
PRE (sys_lstat64)
{
- PRINT ("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (char *) ARG1, ARG2);
+ PRINT ("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar *) ARG1, ARG2);
PRE_REG_READ2 (long, "lstat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ ("lstat64(file_name)", ARG1);
PRE_MEM_WRITE ("lstat64(buf)", ARG2, sizeof (struct vki_stat64));
PRE (sys_stat64)
{
- PRINT ("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (char *) ARG1, ARG2);
+ PRINT ("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar *) ARG1, ARG2);
PRE_REG_READ2 (long, "stat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ ("stat64(file_name)", ARG1);
PRE_MEM_WRITE ("stat64(buf)", ARG2, sizeof (struct vki_stat64));
PRE (sys_fstatat64)
{
- PRINT ("sys_fstatat64 ( %ld, %#lx(%s), %#lx )", ARG1, ARG2, (char *) ARG2,
- ARG3);
- PRE_REG_READ3 (long, "fstatat64", int, dfd, char *, file_name,
- struct stat64 *, buf);
+ // ARG4 = int flags; Flags are or'ed together, therefore writing them
+ // as a hex constant is more meaningful.
+ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %#lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
+ PRE_REG_READ4(long, "fstatat64",
+ int, dfd, char *, file_name, struct stat64 *, buf, int, flags);
PRE_MEM_RASCIIZ ("fstatat64(file_name)", ARG2);
PRE_MEM_WRITE ("fstatat64(buf)", ARG3, sizeof (struct vki_stat64));
}
PRE (sys_fstat64)
{
- PRINT ("sys_fstat64 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT ("sys_fstat64 ( %lu, %#lx )", SARG1, ARG2);
PRE_REG_READ2 (long, "fstat64", unsigned long, fd, struct stat64 *, buf);
PRE_MEM_WRITE ("fstat64(buf)", ARG2, sizeof (struct vki_stat64));
}
/* Very much MIPS specific */
PRE (sys_cacheflush)
{
- PRINT ("cacheflush (%lx, %lx, %lx)", ARG1, ARG2, ARG3);
+ PRINT ("cacheflush (%lx, %ld, %ld)", ARG1, SARG2, SARG3);
PRE_REG_READ3(long, "cacheflush", unsigned long, addr,
int, nbytes, int, cache);
VG_ (discard_translations) ((Addr)ARG1, (ULong) ARG2,
PRE(sys_tee)
{
- PRINT("sys_tee ( %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_tee ( %ld, %ld, %lu, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "sys_tee", int, fdin, int, fdout, vki_size_t, len,
int, flags);
}
PRE(sys_splice)
{
- PRINT("sys_splice ( %ld, %ld, %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_splice ( %ld, %#lx, %ld, %#lx, %lu, %#lx )",
+ SARG1, ARG2, SARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "sys_splice", int, fdin, vki_loff_t, sizein, int,
fdout, vki_loff_t, sizeout, vki_size_t, len, int, flags);
PRE(sys_vmsplice)
{
- PRINT("sys_vmsplice ( %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_vmsplice ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "sys_vmsplice", int, fdin, struct vki_iovec *, v,
vki_size_t, len, int, flags);
}
PRE(sys_unshare)
{
- PRINT("sys_unshare ( %ld )", ARG1);
- PRE_REG_READ1(long, "sys_unshare", int, flags);
+ PRINT("sys_unshare ( %lu )", ARG1);
+ PRE_REG_READ1(long, "sys_unshare", unsigned long, flags);
}
PRE(sys_sched_rr_get_interval)
{
- PRINT("sys_sched_rr_get_interval ( %ld, %#lx)", ARG1, ARG2);
- PRE_REG_READ2(long, "sched_rr_get_interval", int, flags,
+ PRINT("sys_sched_rr_get_interval ( %ld, %#lx)", SARG1, ARG2);
+ PRE_REG_READ2(long, "sched_rr_get_interval", vki_pid_t, pid,
struct timespec *, timer);
*flags |= SfMayBlock;
}
PRE(sys_ustat)
{
- PRINT("sys_ustat ( %ld, %#lx)", ARG1, ARG2);
+ PRINT("sys_ustat ( %#lx, %#lx)", ARG1, ARG2);
PRE_REG_READ2(long, "ustat", int, flags, const void *, path);
}
PRE(sys_swapon)
{
- PRINT("sys_swapon ( %#lx, %ld )", ARG1, ARG2);
+ PRINT("sys_swapon ( %#lx, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "swapon", const void *, path, int, flags);
}
PRE(sys_sysfs)
{
- PRINT("sys_sysfs ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_sysfs ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sysfs", int, flags, int, desc, const void *, path);
}
{
PRINT("cacheflush (%lx, %lx, %lx)", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "cacheflush", unsigned long, addr,
- int, nbytes, int, cache);
+ unsigned long, nbytes, unsigned int, cache);
VG_ (discard_translations) ((Addr)ARG1, (ULong) ARG2,
"PRE(sys_cacheflush)");
SET_STATUS_Success(0);
PRE(sys_reboot)
{
- PRINT("sys_reboot ( %ld )", ARG1);
- PRE_REG_READ1(int, "reboot", int, flags);
+ PRINT("sys_reboot ( %ld, %ld, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
+ // An approximation. ARG4 is only read conditionally by the kernel
+ PRE_REG_READ4(int, "reboot",
+ int, magic1, int, magic2, unsigned int, cmd,
+ void *, arg);
+
*flags |= SfMayBlock;
}
PRE(sys_setdomainname)
{
- PRINT ("sys_setdomainname ( %#lx, %ld )", ARG1, ARG2);
+ PRINT ("sys_setdomainname ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2 (long, "setdomainname", const void *, name, int, len);
}
PRE(sys_sethostname)
{
- PRINT ("sys_sethostname ( %ld, %ld )", ARG1, ARG2);
+ PRINT ("sys_sethostname ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2 (long, "sethostname", const void *, name, int, len);
}
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
- PRE_REG_READ4(int, "ptrace", long, request, long, pid, long, addr,
- long, data);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
+ PRE_REG_READ4(int, "ptrace",
+ long, request, long, pid, unsigned long, addr,
+ unsigned long, data);
switch (ARG1) {
case VKI_PTRACE_PEEKTEXT:
case VKI_PTRACE_PEEKDATA:
PRE (sys_mmap)
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %lu, %lu, %lu, %ld )", ARG1, (ULong)ARG2,
- ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %lu )",
+ ARG1, ARG2, SARG3, SARG4, SARG5, ARG6);
PRE_REG_READ6(long, "mmap", unsigned long, start, vki_size_t, length,
int, prot, int, flags, int, fd, unsigned long, offset);
r = ML_(generic_PRE_sys_mmap)(tid, ARG1, ARG2, ARG3, ARG4, ARG5,
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ PRINT("sys_mmap ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
// Exactly like old_mmap() except:
// - the file offset is specified in 4K units rather than bytes,
// so that it can be used for files bigger than 2^32 bytes.
- PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ PRINT("sys_mmap2 ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap2",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
PRE(sys_lstat64)
{
- PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(sys_fstatat64)
{
- PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
+ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )", SARG1, ARG2, (HChar*)ARG2,
+ ARG3);
PRE_REG_READ3(long, "fstatat64",
int, dfd, char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
PRE(sys_fstat64)
{
- PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("sys_fstat64 ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
}
that takes a pointer to the signal mask so supports more signals.
*/
*flags |= SfMayBlock;
- PRINT("sys_sigsuspend ( %ld )", ARG1 );
+ PRINT("sys_sigsuspend ( %lu )", ARG1 );
PRE_REG_READ1(int, "sigsuspend", vki_old_sigset_t, mask);
}
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ PRINT("sys_mmap ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, "fadvise64",
int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
}
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace",
- long, request, long, pid, long, addr, long, data);
+ long, request, long, pid, unsigned long, addr,
+ unsigned long, data);
switch (ARG1) {
case VKI_PTRACE_PEEKTEXT:
case VKI_PTRACE_PEEKDATA:
a4 = args[4];
a5 = args[5];
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- a0, (ULong)a1, a2, a3, a4, a5 );
+ PRINT("sys_mmap ( %#lx, %lu, %ld, %ld, %ld, %ld )",
+ a0, a1, (Word)a2, (Word)a3, (Word)a4, (Word)a5 );
r = ML_(generic_PRE_sys_mmap)( tid, a0, a1, a2, a3, a4, (Off64T)a5 );
SET_STATUS_from_SysRes(r);
/* we cant use the LINX_ version for 64 bit */
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %ld, %ld, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_fadvise64 ( %ld, %ld, %ld, %ld )", SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, "fadvise64",
int, fd, vki_loff_t, offset, vki_loff_t, len, int, advice);
}
ThreadState *tst = VG_(get_ThreadState)(tid);
VG_(debugLog)(1, "syswrap-solaris",
- "thread_wrapper(tid=%lld): entry\n",
- (ULong)tidW);
+ "thread_wrapper(tid=%u): entry\n",
+ tid);
vg_assert(tst->status == VgTs_Init);
VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
if (0)
- VG_(printf)("thread tid %d started: stack = %p\n", tid, &tid);
+ VG_(printf)("thread tid %u started: stack = %p\n", tid, (void *)&tid);
/* Make sure error reporting is enabled in the new thread. */
tst->err_disablement_level = 0;
vg_assert(VG_(is_running_thread)(tid));
VG_(debugLog)(1, "syswrap-solaris",
- "thread_wrapper(tid=%lld): exit, schedreturncode %s\n",
- (ULong)tidW, VG_(name_of_VgSchedReturnCode)(ret));
+ "thread_wrapper(tid=%u): exit, schedreturncode %s\n",
+ tid, VG_(name_of_VgSchedReturnCode)(ret));
/* Return to caller, still holding the lock. */
return ret;
#endif
VG_(debugLog)(1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): pre-thread_wrapper\n",
+ tid);
tst = VG_(get_ThreadState)(tid);
vg_assert(tst);
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
- (ULong)tidW);
+ "run_a_thread_NORETURN(tid=%u): post-thread_wrapper\n",
+ tid);
c = count_living_daemon_threads(False);
vg_assert(c >= 1); /* Stay sane. */
);
VG_(debugLog)(
1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"WARNING: exiting thread has err_disablement_level = %u\n",
- (ULong)tidW, tst->err_disablement_level
+ tid, tst->err_disablement_level
);
}
tst->err_disablement_level = 0;
UInt daemon_threads = count_living_daemon_threads(True);
if (daemon_threads == 0)
VG_(debugLog)(1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"last one standing\n",
- (ULong) tidW);
+ tid);
else
VG_(debugLog)(1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"last non-daemon thread standing "
"[daemon threads=%u]\n",
- (ULong) tidW, daemon_threads);
+ tid, daemon_threads);
/* We are the last non-daemon thread standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
}
else {
VG_(debugLog)(1, "syswrap-solaris",
- "run_a_thread_NORETURN(tid=%lld): "
+ "run_a_thread_NORETURN(tid=%u): "
"not last one standing\n",
- (ULong)tidW);
+ tid);
/* OK, thread is dead, but others still exist. Just exit. */
}
if (0)
- VG_(printf)("stack for tid %d at %p; init_SP=%p\n",
+ VG_(printf)("stack for tid %u at %p; init_SP=%p\n",
tid,
(void*)tst->os_state.valgrind_stack_base,
(void*)tst->os_state.valgrind_stack_init_SP);
/* This seems to be a little bit dangerous but it is what the kernel
does. */
if (VG_(clo_trace_signals))
- VG_(dmsg)("restore_context, sigaltstack: tid %d, "
+ VG_(dmsg)("restore_context, sigaltstack: tid %u, "
"ss %p{%p,sz=%lu,flags=%#x}\n",
tid, &uc->uc_stack, uc->uc_stack.ss_sp,
(SizeT)uc->uc_stack.ss_size, uc->uc_stack.ss_flags);
if (tst->os_state.stk_id == (UWord)-1) {
/* This thread doesn't have a stack set yet. */
VG_(debugLog)(2, "syswrap-solaris",
- "Stack set to %#lx-%#lx (new) for thread %d.\n",
+ "Stack set to %#lx-%#lx (new) for thread %u.\n",
new_start, new_end, tid);
tst->os_state.stk_id = VG_(register_stack)(new_start, new_end);
}
else {
/* Change a thread stack. */
VG_(debugLog)(2, "syswrap-solaris",
- "Stack set to %#lx-%#lx (change) for thread %d.\n",
+ "Stack set to %#lx-%#lx (change) for thread %u.\n",
new_start, new_end, tid);
VG_(change_stack)(tst->os_state.stk_id, new_start, new_end);
}
/* void exit(int status); */
ThreadId t;
- PRINT("sys_exit( %ld )", ARG1);
+ PRINT("sys_exit( %ld )", SARG1);
PRE_REG_READ1(void, "exit", int, status);
for (t = 1; t < VG_N_THREADS; t++) {
{
/* int spawn(char *path, void *attrs, size_t attrsize,
char *argenv, size_t aesize); */
- PRINT("sys_spawn ( %#lx(%s), %#lx, %ld, %#lx, %ld )",
+ PRINT("sys_spawn ( %#lx(%s), %#lx, %lu, %#lx, %lu )",
ARG1, (HChar *) ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "spawn", const char *, path, void *, attrs,
size_t, attrsize, char *, argenv, size_t, aesize);
if (ARG2 & VKI_O_CREAT) {
/* 3-arg version */
PRINT("sys_open ( %#lx(%s), %ld, %ld )", ARG1, (HChar *) ARG1,
- ARG2, ARG3);
+ SARG2, ARG3);
PRE_REG_READ3(long, "open", const char *, filename,
int, flags, vki_mode_t, mode);
} else {
/* 2-arg version */
- PRINT("sys_open ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, ARG2);
+ PRINT("sys_open ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, SARG2);
PRE_REG_READ2(long, "open", const char *, filename, int, flags);
}
Int fd2 = (Int) ARG3;
PRINT("sys_linkat ( %d, %#lx(%s), %d, %#lx(%s), %ld )",
- fd1, ARG2, (HChar *) ARG2, fd2, ARG4, (HChar *) ARG4, ARG5);
+ fd1, ARG2, (HChar *) ARG2, fd2, ARG4, (HChar *) ARG4, SARG5);
PRE_REG_READ5(long, "linkat", int, fd1, const char *, path1,
int, fd2, const char *, path2, int, flags);
PRE_MEM_RASCIIZ("linkat(path1)", ARG2);
PRE(sys_lseek)
{
/* off_t lseek(int fildes, off_t offset, int whence); */
- PRINT("sys_lseek ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_lseek ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "lseek", int, fildes, vki_off_t, offset, int, whence);
/* Stay sane. */
if (ARG3 & VKI_MS_OPTIONSTR) {
/* 8-argument mount */
PRINT("sys_mount ( %#lx(%s), %#lx(%s), %ld, %#lx(%s), %#lx, %ld, "
- "%#lx(%s), %ld )", ARG1, (HChar *) ARG1, ARG2, (HChar *) ARG2, ARG3,
- ARG4, (HChar *) ARG4, ARG5, ARG6, ARG7, (HChar *) ARG7, ARG8);
+ "%#lx(%s), %ld )", ARG1, (HChar *) ARG1, ARG2, (HChar *) ARG2, SARG3,
+ ARG4, (HChar *) ARG4, ARG5, ARG6, ARG7, (HChar *) ARG7, SARG8);
PRE_REG_READ8(long, "mount", const char *, spec, const char *, dir,
int, mflag, char *, fstype, char *, dataptr, int, datalen,
char *, optptr, int, optlen);
else if (ARG3 & VKI_MS_DATA) {
/* 6-argument mount */
PRINT("sys_mount ( %#lx(%s), %#lx(%s), %ld, %#lx(%s), %#lx, %ld )",
- ARG1, (HChar *) ARG1, ARG2, (HChar *) ARG2, ARG3, ARG4,
- (HChar *) ARG4, ARG5, ARG6);
+ ARG1, (HChar *) ARG1, ARG2, (HChar *) ARG2, SARG3, ARG4,
+ (HChar *) ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "mount", const char *, spec, const char *, dir,
int, mflag, char *, fstype, char *, dataptr,
int, datalen);
else {
/* 4-argument mount */
PRINT("sys_mount ( %#lx(%s), %#lx(%s), %ld, %#lx(%s) )", ARG1,
- (HChar *) ARG1, ARG2, (HChar *) ARG2, ARG3, ARG4, (HChar *) ARG4);
+ (HChar *) ARG1, ARG2, (HChar *) ARG2, SARG3, ARG4, (HChar *) ARG4);
PRE_REG_READ4(long, "mount", const char *, spec, const char *, dir,
int, mflag, char *, fstype);
}
This is different from Linux, for example, where glibc sign-extends it. */
Int dfd = (Int) ARG1;
- PRINT("sys_readlinkat ( %d, %#lx(%s), %#lx, %lu )", dfd, ARG2,
- (HChar *) ARG2, ARG3, ARG4);
+ PRINT("sys_readlinkat ( %d, %#lx(%s), %#lx, %ld )", dfd, ARG2,
+ (HChar *) ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "readlinkat", int, dfd, const char *, path,
char *, buf, int, bufsiz);
PRE_MEM_RASCIIZ("readlinkat(path)", ARG2);
/* Note: We could use here the sys_newfstat generic wrapper, but the 'new'
in its name is rather confusing in the Solaris context, thus we provide
our own wrapper. */
- PRINT("sys_fstat ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_fstat ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "fstat", int, fildes, struct stat *, buf);
PRE_MEM_WRITE("fstat(buf)", ARG2, sizeof(struct vki_stat));
This is different from Linux, for example, where glibc sign-extends it. */
Int fd = (Int) ARG1;
- PRINT("sys_frealpathat ( %d, %#lx(%s), %#lx, %ld )",
+ PRINT("sys_frealpathat ( %d, %#lx(%s), %#lx, %lu )",
fd, ARG2, (HChar *) ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "frealpathat", int, fd, char *, path,
char *, buf, vki_size_t, buflen);
PRE(sys_stty)
{
/* int stty(int fd, const struct sgttyb *tty); */
- PRINT("sys_stty ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_stty ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "stty", int, fd,
const struct vki_sgttyb *, tty);
PRE_MEM_READ("stty(tty)", ARG2, sizeof(struct vki_sgttyb));
PRE(sys_gtty)
{
/* int gtty(int fd, struct sgttyb *tty); */
- PRINT("sys_gtty ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_gtty ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "gtty", int, fd, struct vki_sgttyb *, tty);
PRE_MEM_WRITE("gtty(tty)", ARG2, sizeof(struct vki_sgttyb));
switch (ARG1 /*flag*/) {
case 0:
/* Libc: pid_t getpgrp(void); */
- PRINT("sys_pgrpsys ( %ld )", ARG1);
+ PRINT("sys_pgrpsys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("pgrpsys", "getpgrp"), int, flag);
break;
case 1:
/* Libc: pid_t setpgrp(void); */
- PRINT("sys_pgrpsys ( %ld )", ARG1);
+ PRINT("sys_pgrpsys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("pgrpsys", "setpgrp"), int, flag);
break;
case 2:
/* Libc: pid_t getsid(pid_t pid); */
- PRINT("sys_pgrpsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_pgrpsys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("pgrpsys", "getsid"), int, flag,
vki_pid_t, pid);
break;
case 3:
/* Libc: pid_t setsid(void); */
- PRINT("sys_pgrpsys ( %ld )", ARG1);
+ PRINT("sys_pgrpsys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("pgrpsys", "setsid"), int, flag);
break;
case 4:
/* Libc: pid_t getpgid(pid_t pid); */
- PRINT("sys_pgrpsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_pgrpsys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("pgrpsys", "getpgid"), int, flag,
vki_pid_t, pid);
break;
case 5:
/* Libc: int setpgid(pid_t pid, pid_t pgid); */
- PRINT("sys_pgrpsys ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_pgrpsys ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC2("pgrpsys", "setpgid"), int, flag,
vki_pid_t, pid, vki_pid_t, pgid);
break;
default:
- VG_(unimplemented)("Syswrap of the pgrpsys call with flag %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the pgrpsys call with flag %ld.", SARG1);
/*NOTREACHED*/
break;
}
{
#if defined(SOLARIS_NEW_PIPE_SYSCALL)
/* int pipe(int fildes[2], int flags); */
- PRINT("sys_pipe ( %#lx, %ld )", ARG1, ARG2);
+ PRINT("sys_pipe ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "pipe", int *, fildes, int, flags);
PRE_MEM_WRITE("pipe(fildes)", ARG1, 2 * sizeof(int));
#else
Int fd = (Int) ARG1;
PRINT("sys_faccessat ( %d, %#lx(%s), %ld, %ld )", fd, ARG2,
- (HChar *) ARG2, ARG3, ARG4);
+ (HChar *) ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "faccessat", int, fd, const char *, path,
int, amode, int, flag);
PRE_MEM_RASCIIZ("faccessat(path)", ARG2);
Int fd = (Int) ARG1;
PRINT("sys_mknodat ( %d, %#lx(%s), %ld, %ld )", fd, ARG2,
- (HChar *) ARG2, ARG3, ARG4);
+ (HChar *) ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "mknodat", int, fd, const char *, fname,
vki_mode_t, fmode, vki_dev_t, dev);
PRE_MEM_RASCIIZ("mknodat(fname)", ARG2);
PRE(sys_sysi86)
{
/* int sysi86(int cmd, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3); */
- PRINT("sys_sysi86 ( %ld, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_sysi86 ( %ld, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "sysi86", int, cmd, uintptr_t, arg1, uintptr_t, arg2,
uintptr_t, arg3);
documentation). */
break;
default:
- VG_(unimplemented)("Syswrap of the sysi86 call with cmd %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the sysi86 call with cmd %ld.", SARG1);
/*NOTREACHED*/
break;
}
case VKI_SHMAT:
/* Libc: void *shmat(int shmid, const void *shmaddr, int shmflg); */
PRINT("sys_shmsys ( %ld, %ld, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, SC2("shmsys", "shmat"), int, opcode,
int, shmid, const void *, shmaddr, int, shmflg);
/* Libc: int shmctl(int shmid, int cmd, struct shmid_ds *buf); */
switch (ARG3 /* cmd */) {
case VKI_SHM_LOCK:
- PRINT("sys_shmsys ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_shmsys ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC3("shmsys", "shmctl", "lock"),
int, opcode, int, shmid, int, cmd);
break;
case VKI_SHM_UNLOCK:
- PRINT("sys_shmsys ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_shmsys ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC3("shmsys", "shmctl", "unlock"),
int, opcode, int, shmid, int, cmd);
break;
case VKI_IPC_RMID:
- PRINT("sys_shmsys ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_shmsys ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC3("shmsys", "shmctl", "rmid"),
int, opcode, int, shmid, int, cmd);
break;
case VKI_IPC_SET:
PRINT("sys_shmsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC3("shmsys", "shmctl", "set"),
int, opcode, int, shmid, int, cmd,
struct vki_shmid_ds *, buf);
break;
case VKI_IPC_STAT:
PRINT("sys_shmsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC3("shmsys", "shmctl", "stat"),
int, opcode, int, shmid, int, cmd,
struct vki_shmid_ds *, buf);
break;
case VKI_IPC_SET64:
PRINT("sys_shmsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC3("shmsys", "shmctl", "set64"),
int, opcode, int, shmid, int, cmd,
struct vki_shmid_ds64 *, buf);
break;
case VKI_IPC_STAT64:
PRINT("sys_shmsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC3("shmsys", "shmctl", "stat64"),
int, opcode, int, shmid, int, cmd,
struct vki_shmid_ds64 *, buf);
#if defined(SOLARIS_SHM_NEW)
case VKI_IPC_XSTAT64:
PRINT("sys_shmsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC3("shmsys", "shmctl", "xstat64"),
int, opcode, int, shmid, int, cmd,
struct vki_shmid_ds64 *, buf);
#endif /* SOLARIS_SHM_NEW */
default:
VG_(unimplemented)("Syswrap of the shmsys(shmctl) call with "
- "cmd %ld.", ARG3);
+ "cmd %ld.", SARG3);
/*NOTREACHED*/
break;
}
case VKI_SHMDT:
/* Libc: int shmdt(const void *shmaddr); */
- PRINT("sys_shmsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_shmsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("shmsys", "shmdt"), int, opcode,
const void *, shmaddr);
case VKI_SHMGET:
/* Libc: int shmget(key_t key, size_t size, int shmflg); */
- PRINT("sys_shmsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_shmsys ( %ld, %ld, %lu, %ld )",
+ SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("shmsys", "shmget"), int, opcode,
vki_key_t, key, vki_size_t, size, int, shmflg);
break;
case VKI_SHMIDS:
/* Libc: int shmids(int *buf, uint_t nids, uint_t *pnids); */
- PRINT("sys_shmsys ( %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_shmsys ( %ld, %#lx, %lu, %#lx )",
+ SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("shmsys", "shmids"), int, opcode,
int *, buf, vki_uint_t, nids, vki_uint_t *, pnids);
#if defined(SOLARIS_SHM_NEW)
case VKI_SHMADV:
/* Libc: int shmadv(int shmid, uint_t cmd, uint_t *advice); */
- PRINT("sys_shmsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_shmsys ( %ld, %ld, %lu, %ld )",
+ SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("shmsys", "shmadv"), int, opcode,
int, shmid, vki_uint_t, cmd, vki_uint_t *, advice);
break;
default:
VG_(unimplemented)("Syswrap of the shmsys(shmadv) call with "
- "cmd %ld.", ARG3);
+ "cmd %lu.", ARG3);
/*NOTREACHED*/
break;
}
/* Libc: int shmget_osm(key_t key, size_t size, int shmflg,
size_t granule_sz);
*/
- PRINT("sys_shmsys ( %ld, %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_shmsys ( %ld, %ld, %lu, %ld, %lu )",
+ SARG1, SARG2, ARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC2("shmsys", "shmget_osm"), int, opcode,
vki_key_t, key, vki_size_t, size, int, shmflg,
vki_size_t, granule_sz);
default:
VG_(unimplemented)("Syswrap of the shmsys call with opcode %ld.",
- ARG1);
+ SARG1);
/*NOTREACHED*/
break;
}
switch (ARG4) {
case VKI_IPC_STAT:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC3("semsys", "semctl", "stat"), int, opcode,
int, semid, int, semnum, int, cmd,
struct vki_semid_ds *, arg);
break;
case VKI_IPC_SET:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC3("semsys", "semctl", "set"), int, opcode,
int, semid, int, semnum, int, cmd,
struct vki_semid_ds *, arg);
break;
case VKI_IPC_STAT64:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC3("semsys", "semctl", "stat64"), int, opcode,
int, semid, int, semnum, int, cmd,
struct vki_semid64_ds *, arg);
break;
case VKI_IPC_SET64:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC3("semsys", "semctl", "set64"), int, opcode,
int, semid, int, semnum, int, cmd,
struct vki_semid64_ds *, arg);
break;
case VKI_IPC_RMID:
- PRINT("sys_semsys ( %ld, %ld, %ld )", ARG1, ARG3, ARG4);
+ PRINT("sys_semsys ( %ld, %ld, %ld )", SARG1, SARG3, SARG4);
PRE_REG_READ3(long, SC3("semsys", "semctl", "rmid"), int, opcode,
int, semid, int, cmd);
break;
case VKI_GETALL:
PRINT("sys_semsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG4, ARG5);
+ SARG1, SARG2, SARG4, ARG5);
PRE_REG_READ4(long, SC3("semsys", "semctl", "getall"), int, opcode,
int, semid, int, cmd, ushort_t *, arg);
break;
case VKI_SETALL:
PRINT("sys_semsys ( %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG4, ARG5);
+ SARG1, SARG2, SARG4, ARG5);
PRE_REG_READ4(long, SC3("semsys", "semctl", "setall"), int, opcode,
int, semid, int, cmd, ushort_t *, arg);
break;
case VKI_GETVAL:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, SC3("semsys", "semctl", "getval"), int, opcode,
int, semid, int, semnum, int, cmd);
break;
case VKI_SETVAL:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, SC3("semsys", "semctl", "setval"), int, opcode,
int, semid, int, semnum, int, cmd,
union vki_semun *, arg);
break;
case VKI_GETPID:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, SC3("semsys", "semctl", "getpid"), int, opcode,
int, semid, int, semnum, int, cmd);
break;
case VKI_GETNCNT:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, SC3("semsys", "semctl", "getncnt"),
int, opcode, int, semid, int, semnum, int, cmd);
break;
case VKI_GETZCNT:
PRINT("sys_semsys ( %ld, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, SC3("semsys", "semctl", "getzcnt"),
int, opcode, int, semid, int, semnum, int, cmd);
break;
default:
VG_(unimplemented)("Syswrap of the semsys(semctl) call "
- "with cmd %ld.", ARG4);
+ "with cmd %ld.", SARG4);
/*NOTREACHED*/
break;
}
break;
case VKI_SEMGET:
/* Libc: int semget(key_t key, int nsems, int semflg); */
- PRINT("sys_semsys ( %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_semsys ( %ld, %ld, %ld, %ld )", SARG1, SARG2, SARG3, SARG4);
PRE_REG_READ4(long, SC2("semsys", "semget"), int, opcode,
vki_key_t, key, int, nsems, int, semflg);
break;
case VKI_SEMOP:
/* Libc: int semop(int semid, struct sembuf *sops, size_t nsops); */
- PRINT("sys_semsys ( %ld, %ld, %#lx, %lu )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_semsys ( %ld, %ld, %#lx, %lu )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("semsys", "semop"), int, opcode, int, semid,
struct vki_sembuf *, sops, vki_size_t, nsops);
ML_(generic_PRE_sys_semop)(tid, ARG2, ARG3, ARG4);
break;
case VKI_SEMIDS:
/* Libc: int semids(int *buf, uint_t nids, uint_t *pnids); */
- PRINT("sys_semsys ( %ld, %#lx, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_semsys ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("semsys", "semids"), int, opcode, int *, buf,
vki_uint_t, nids, vki_uint_t *, pnids);
/* Libc: int semtimedop(int semid, struct sembuf *sops, size_t nsops,
const struct timespec *timeout);
*/
- PRINT("sys_semsys ( %ld, %ld, %#lx, %lu, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_semsys ( %ld, %ld, %#lx, %lu, %#lx )", SARG1, SARG2, ARG3,
ARG4, ARG5);
PRE_REG_READ5(long, SC2("semsys", "semtimedop"), int, opcode,
int, semid, struct vki_sembuf *, sops, vki_size_t, nsops,
ML_(generic_PRE_sys_semtimedop)(tid, ARG2, ARG3, ARG4, ARG5);
break;
default:
- VG_(unimplemented)("Syswrap of the semsys call with opcode %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the semsys call with opcode %ld.", SARG1);
/*NOTREACHED*/
break;
}
/* Handle 2-arg specially here (they do not use ARG3 at all). */
case VKI_TIOCNOTTY:
case VKI_TIOCSCTTY:
- PRINT("sys_ioctl ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_ioctl ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "ioctl", int, fd, int, request);
break;
/* And now come the 3-arg ones. */
default:
- PRINT("sys_ioctl ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_ioctl ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "ioctl", int, fd, int, request, intptr_t, arg);
break;
}
Int fd = (Int) ARG1;
PRINT("sys_fchownat ( %d, %#lx(%s), %ld, %ld, %ld )", fd,
- ARG2, (HChar *) ARG2, ARG3, ARG4, ARG5);
+ ARG2, (HChar *) ARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, "fchownat", int, fd, const char *, path,
vki_uid_t, owner, vki_gid_t, group, int, flag);
PRE(sys_fdsync)
{
/* int fdsync(int fd, int flag); */
- PRINT("sys_fdsync ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_fdsync ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "fdsync", int, fd, int, flag);
/* Be strict. */
#if defined(SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS)
/* int execve(uintptr_t file, const char **argv, const char **envp,
int flags); */
- PRINT("sys_execve ( %#lx, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_execve ( %#lx, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "execve", uintptr_t, file, const char **, argv,
const char **, envp, int, flags);
vg_assert(FAILURE);
#if defined(SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS)
if (ARG1_is_fd)
- VG_(message)(Vg_UserMsg, "execve(%ld, %#lx, %#lx, %ld) failed, "
- "errno %ld\n", ARG1, ARG2, ARG3, ARG4, ERR);
+ VG_(message)(Vg_UserMsg, "execve(%ld, %#lx, %#lx, %lu) failed, "
+ "errno %ld\n", SARG1, ARG2, ARG3, ARG4, ERR);
else
VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx, %ld) failed, errno"
- " %ld\n", ARG1, (HChar *) ARG1, ARG2, ARG3, ARG4, ERR);
+ " %lu\n", ARG1, (HChar *) ARG1, ARG2, ARG3, SARG4, ERR);
#else
- VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx) failed, errno %ld\n",
+ VG_(message)(Vg_UserMsg, "execve(%#lx(%s), %#lx, %#lx) failed, errno %lu\n",
ARG1, (HChar *) ARG1, ARG2, ARG3, ERR);
#endif /* SOLARIS_EXECVE_SYSCALL_TAKES_FLAGS */
VG_(message)(Vg_UserMsg, "EXEC FAILED: I can't recover from "
case VKI_F_GETFD:
case VKI_F_GETFL:
case VKI_F_GETXFL:
- PRINT("sys_fcntl ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_fcntl ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "fcntl", int, fildes, int, cmd);
break;
case VKI_F_SETFL:
case VKI_F_DUP2FD:
case VKI_F_BADFD:
- PRINT("sys_fcntl ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd, int, arg);
/* Check if a client program isn't going to poison any of V's output
fds. */
case VKI_F_ALLOCSP:
case VKI_F_FREESP:
case VKI_F_SETLK_NBMAND:
- PRINT("sys_fcntl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd,
struct flock *, lock);
pre_mem_read_flock(tid, (struct vki_flock*)ARG3);
/* This one uses ARG3 as "native lock" (input&output). */
case VKI_F_GETLK:
- PRINT("sys_fcntl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd,
struct flock *, lock);
pre_mem_read_flock(tid, (struct vki_flock*)ARG3);
case VKI_F_ALLOCSP64:
case VKI_F_FREESP64:
case VKI_F_SETLK64_NBMAND:
- PRINT("sys_fcntl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd,
struct flock64 *, lock);
pre_mem_read_flock64(tid, (struct vki_flock64*)ARG3);
/* This one uses ARG3 as "transitional 64b lock" (input&output). */
case VKI_F_GETLK64:
- PRINT("sys_fcntl ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd,
struct flock64 *, lock);
pre_mem_read_flock64(tid, (struct vki_flock64*)ARG3);
case VKI_F_SHARE:
case VKI_F_UNSHARE:
case VKI_F_SHARE_NBMAND:
- PRINT("sys_fcntl[ARG3=='fshare'] ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[ARG3=='fshare'] ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "fcntl", int, fildes, int, cmd,
struct fshare *, sh);
PRE_MEM_READ("fcntl(fshare)", ARG3, sizeof(struct vki_fshare));
break;
default:
- VG_(unimplemented)("Syswrap of the fcntl call with cmd %ld.", ARG2);
+ VG_(unimplemented)("Syswrap of the fcntl call with cmd %ld.", SARG2);
/*NOTREACHED*/
break;
}
*flags |= SfMayBlock;
PRINT("sys_unlinkat ( %d, %#lx(%s), %ld )", dfd, ARG2, (HChar *) ARG2,
- ARG3);
+ SARG3);
PRE_REG_READ3(long, "unlinkat", int, dirfd, const char *, pathname,
int, flags);
PRE_MEM_RASCIIZ("unlinkat(pathname)", ARG2);
Int fd = (Int) ARG1;
PRINT("sys_fstatat ( %d, %#lx(%s), %#lx, %ld )", fd, ARG2,
- (HChar *) ARG2, ARG3, ARG4);
+ (HChar *) ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "fstatat", int, fildes, const char *, path,
struct stat *, buf, int, flag);
if (ARG2) {
if (ARG3 & VKI_O_CREAT) {
/* 4-arg version */
PRINT("sys_openat ( %d, %#lx(%s), %ld, %ld )", fd, ARG2, (HChar *) ARG2,
- ARG3, ARG4);
+ SARG3, SARG4);
PRE_REG_READ4(long, "openat", int, fildes, const char *, filename,
int, flags, vki_mode_t, mode);
}
else {
/* 3-arg version */
PRINT("sys_openat ( %d, %#lx(%s), %ld )", fd, ARG2, (HChar *) ARG2,
- ARG3);
+ SARG3);
PRE_REG_READ3(long, "openat", int, fildes, const char *, filename,
int, flags);
}
switch (ARG1 /*code*/) {
case 0:
/* Libc: taskid_t settaskid(projid_t project, uint_t flags); */
- PRINT("sys_tasksys ( %ld, %ld, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_tasksys ( %ld, %ld, %lu )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, SC2("tasksys", "settaskid"), int, code,
vki_projid_t, projid, vki_uint_t, flags);
break;
case 1:
/* Libc: taskid_t gettaskid(void); */
- PRINT("sys_tasksys ( %ld )", ARG1);
+ PRINT("sys_tasksys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("tasksys", "gettaskid"), int, code);
break;
case 2:
/* Libc: projid_t getprojid(void); */
- PRINT("sys_tasksys ( %ld )", ARG1);
+ PRINT("sys_tasksys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("tasksys", "getprojid"), int, code);
break;
case 3:
/* Libproject: size_t projlist(id_t *idbuf, size_t idbufsz); */
- PRINT("sys_tasksys ( %ld, %#lx, %lu )", ARG1, ARG4, ARG5);
+ PRINT("sys_tasksys ( %ld, %#lx, %lu )", SARG1, ARG4, ARG5);
PRE_REG_READ3(long, SC2("tasksys", "projlist"), int, code,
vki_id_t *, idbuf, vki_size_t, idbufsz);
PRE_MEM_WRITE("tasksys(idbuf)", ARG4, ARG5);
break;
default:
- VG_(unimplemented)("Syswrap of the tasksys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the tasksys call with code %ld.", SARG1);
/*NOTREACHED*/
break;
}
switch (ARG1 /*which*/) {
case 0:
/* Libc: int lwp_park(timespec_t *timeout, id_t lwpid); */
- PRINT("sys_lwp_park ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_park ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("lwp_park", "lwp_park"), int, which,
timespec_t *, timeout, vki_id_t, lwpid);
if (ARG2) {
break;
case 1:
/* Libc: int lwp_unpark(id_t lwpid); */
- PRINT("sys_lwp_park ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_lwp_park ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("lwp_park", "lwp_unpark"), int, which,
vki_id_t, lwpid);
break;
case 2:
/* Libc: int lwp_unpark_all(id_t *lwpid, int nids); */
- PRINT("sys_lwp_park ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_park ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("lwp_park", "lwp_unpark_all"), int, which,
id_t *, lwpid, int, nids);
PRE_MEM_READ("lwp_park(lwpid)", ARG2, ARG3 * sizeof(vki_id_t));
break;
default:
- VG_(unimplemented)("Syswrap of the lwp_park call with which %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the lwp_park call with which %ld.", SARG1);
/*NOTREACHED*/
break;
}
int sfvcnt, size_t *xferred);
*/
PRINT("sys_sendfilev ( %ld, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, ARG3, SARG4, ARG5);
switch (ARG1 /*opcode*/) {
case VKI_SENDFILEV:
break;
default:
VG_(unimplemented)("Syswrap of the sendfilev call with "
- "opcode %ld.", ARG1);
+ "opcode %ld.", SARG1);
/*NOTREACHED*/
break;
}
PRE(sys_lwp_name)
{
/* int lwp_name(int opcode, id_t lwpid, char *name, size_t len); */
- PRINT("sys_lwp_name ( %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_lwp_name ( %ld, %ld, %#lx, %lu )", SARG1, SARG2, ARG3, ARG4);
switch (ARG1 /*opcode*/) {
case 0:
PRE_MEM_WRITE("lwp_name(name)", ARG3, ARG4);
break;
default:
- VG_(unimplemented)("Syswrap of the lwp_name call with opcode %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the lwp_name call with opcode %ld.", SARG1);
/*NOTREACHED*/
break;
}
/* Libc: int setppriv(priv_op_t op, priv_ptype_t type,
const priv_set_t *pset);
*/
- PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %lu )", ARG1, ARG2, ARG3,
+ PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %lu )", SARG1, SARG2, SARG3,
ARG4, ARG5);
PRE_REG_READ5(long, SC2("privsys", "setppriv"), int, code,
vki_priv_op_t, op, vki_priv_ptype_t, type,
/* Libc: int getppriv(priv_ptype_t type, priv_set_t *pset);
priv_set_t *pset -> void *buf
*/
- PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %lu )", ARG1, ARG2, ARG3,
+ PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %lu )", SARG1, SARG2, SARG3,
ARG4, ARG5);
PRE_REG_READ5(long, SC2("privsys", "getppriv"), int, code,
vki_priv_op_t, op, vki_priv_ptype_t, type, priv_set_t *, pset,
/* Libc: int getprivinfo(priv_impl_info_t *buf, size_t bufsize);
priv_impl_info_t *buf -> void *buf
*/
- PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3,
+ PRINT("sys_privsys ( %ld, %ld, %ld, %#lx, %lu )", SARG1, SARG2, SARG3,
ARG4, ARG5);
PRE_REG_READ5(long, SC2("privsys", "getprivinfo"), int, code,
vki_priv_op_t, op, vki_priv_ptype_t, type,
uint_t flag -> priv_op_t op
uint_t val -> priv_ptype_t type
*/
- PRINT("sys_privsys ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_privsys ( %ld, %lu, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, SC2("privsys", "setpflags"), int, code,
vki_uint_t, flag, vki_uint_t, val);
break;
/* Libc: uint_t getpflags(uint_t flag);
uint_t flag -> priv_op_t op
*/
- PRINT("sys_privsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_privsys ( %ld, %lu )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("privsys", "setpflags"), int, code,
vki_uint_t, flag);
break;
case VKI_PRIVSYS_ISSETUGID:
/* Libc: int issetugid(void); */
- PRINT("sys_privsys ( %ld )", ARG1);
+ PRINT("sys_privsys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("privsys", "issetugid"), int, code);
break;
case VKI_PRIVSYS_PFEXEC_REG:
/* Libc: int register_pfexec(int did);
int did -> priv_op_t op
*/
- PRINT("sys_privsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_privsys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("privsys", "register_pfexec"), int, code,
int, did);
break;
case VKI_PRIVSYS_PFEXEC_UNREG:
/* Libc: int unregister_pfexec(int did); */
- PRINT("sys_privsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_privsys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("privsys", "unregister_pfexec"), int, code,
int, did);
break;
default:
- VG_(unimplemented)("Syswrap of the privsys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the privsys call with code %ld.", SARG1);
/*NOTREACHED*/
break;
}
PRE(sys_ucredsys)
{
/* Kernel: int ucredsys(int code, int obj, void *buf); */
- PRINT("sys_ucredsys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_ucredsys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
switch (ARG1 /*code*/) {
case VKI_UCREDSYS_UCREDGET:
break;
default:
- VG_(unimplemented)("Syswrap of the ucredsys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the ucredsys call with code %ld.", SARG1);
/*NOTREACHED*/
break;
}
struct vki_strbuf *ctrlptr = (struct vki_strbuf *)ARG2;
struct vki_strbuf *dataptr = (struct vki_strbuf *)ARG3;
*flags |= SfMayBlock;
- PRINT("sys_getmsg ( %ld, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_getmsg ( %ld, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "getmsg", int, fildes, struct vki_strbuf *, ctlptr,
struct vki_strbuf *, dataptr, int *, flagsp);
if (ctrlptr) {
struct vki_strbuf *ctrlptr = (struct vki_strbuf *)ARG2;
struct vki_strbuf *dataptr = (struct vki_strbuf *)ARG3;
*flags |= SfMayBlock;
- PRINT("sys_putmsg ( %ld, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_putmsg ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "putmsg", int, fildes, struct vki_strbuf *, ctrlptr,
struct vki_strbuf *, dataptr, int, flags);
if (ctrlptr) {
PRE(sys_sigprocmask)
{
/* int sigprocmask(int how, const sigset_t *set, sigset_t *oset); */
- PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigprocmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oset);
if (ARG2)
{
/* int sigaction(int signal, const struct sigaction *act,
struct sigaction *oact); */
- PRINT("sys_sigaction ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_sigaction ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigaction", int, signal,
const struct sigaction *, act, struct sigaction *, oact);
PRE(sys_sigpending)
{
/* int sigpending(int flag, sigset_t *setp); */
- PRINT("sys_sigpending ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_sigpending ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "sigpending", int, flag, sigset_t *, setp);
PRE_MEM_WRITE("sigpending(setp)", ARG2, sizeof(vki_sigset_t));
}
{
/* Kernel: int getsetcontext(int flag, void *arg) */
ThreadState *tst = VG_(get_ThreadState)(tid);
- PRINT("sys_getsetcontext ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_getsetcontext ( %ld, %#lx )", SARG1, ARG2);
switch (ARG1 /*flag*/) {
case VKI_GETCONTEXT:
/* Libc: int getcontext(ucontext_t *ucp); */
}
break;
default:
- VG_(unimplemented)("Syswrap of the context call with flag %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the context call with flag %ld.", SARG1);
/*NOTREACHED*/
break;
}
Int fd = (Int) ARG1;
PRINT("sys_fchmodat ( %d, %#lx(%s), %ld, %ld )",
- fd, ARG2, (HChar *) ARG2, ARG3, ARG4);
+ fd, ARG2, (HChar *) ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "fchmodat",
int, fd, const char *, path, vki_mode_t, mode, int, flag);
Int fd = (Int) ARG1;
*flags |= SfMayBlock;
- PRINT("sys_mkdirat ( %d, %#lx(%s), %ld )", fd, ARG2, (HChar *) ARG2, ARG3);
+ PRINT("sys_mkdirat ( %d, %#lx(%s), %ld )", fd, ARG2, (HChar *) ARG2, SARG3);
PRE_REG_READ3(long, "mkdirat", int, fd, const char *, path,
vki_mode_t, mode);
PRE_MEM_RASCIIZ("mkdirat(path)", ARG2);
{
/* int fstatvfs(int fd, struct statvfs *buf); */
*flags |= SfMayBlock;
- PRINT("sys_fstatvfs ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_fstatvfs ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "fstatvfs", int, fd, struct vki_statvfs *, buf);
PRE_MEM_WRITE("fstatvfs(buf)", ARG2, sizeof(struct vki_statvfs));
{
/* int nfssys(enum nfssys_op opcode, void *arg); */
*flags |= SfMayBlock;
- PRINT("sys_nfssys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_nfssys ( %ld, %#lx )", SARG1, ARG2);
switch (ARG1 /*opcode*/) {
case VKI_NFS_REVAUTH:
sizeof(struct vki_nfs_revauth_args));
break;
default:
- VG_(unimplemented)("Syswrap of the nfssys call with opcode %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the nfssys call with opcode %ld.", SARG1);
/*NOTREACHED*/
break;
}
{
/* int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options); */
*flags |= SfMayBlock;
- PRINT("sys_waitid( %ld, %ld, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_waitid( %ld, %ld, %#lx, %ld )", SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "waitid", vki_idtype_t, idtype, vki_id_t, id,
siginfo_t *, infop, int, options);
PRE_MEM_WRITE("waitid(infop)", ARG3, sizeof(vki_siginfo_t));
switch (ARG1 /*code*/) {
case 0:
/* Libc: int futimens(int fd, const timespec_t times[2]); */
- PRINT("sys_utimesys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_utimesys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "utimesys", int, code, int, fd,
const vki_timespec_t *, times);
if (ARG3)
Int fd = (Int) ARG2;
PRINT("sys_utimesys ( %ld, %d, %#lx(%s), %#lx, %ld )",
- ARG1, fd, ARG3, (HChar *) ARG3, ARG4, ARG5);
+ SARG1, fd, ARG3, (HChar *) ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "utimesys", int, code, int, fd, const char *, path,
const vki_timespec_t *, times, int, flag);
if (ARG3)
break;
}
default:
- VG_(unimplemented)("Syswrap of the utimesys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the utimesys call with code %ld.", SARG1);
/*NOTREACHED*/
break;
}
Int fd = (Int) ARG1;
PRINT("sys_utimensat ( %d, %#lx(%s), %#lx, %ld )",
- fd, ARG2, (HChar *) ARG2, ARG3, ARG4);
+ fd, ARG2, (HChar *) ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "utimensat", int, fd, const char *, path,
const vki_timespec_t *, times, int, flag);
if (ARG2)
/* Static (const) mask accessible from outside of this function. */
static vki_sigset_t block_all;
- PRINT("sys_sigresend( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_sigresend( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sigresend", int, signal, vki_siginfo_t *, siginfo,
vki_sigset_t *, mask);
VG_(do_sys_sigprocmask)(tid, VKI_SIG_SETMASK, (vki_sigset_t*)ARG4, NULL);
if (VG_(clo_trace_signals))
- VG_(message)(Vg_DebugMsg, "sigresend: resent signal %ld\n", ARG1);
+ VG_(message)(Vg_DebugMsg, "sigresend: resent signal %lu\n", ARG1);
}
static void mem_priocntlsys_parm_ok(ThreadId tid, Bool pre, Bool reade,
if (ARG1 != 1) {
/* Only the first version of priocntlsys is supported by the code below.
*/
- VG_(unimplemented)("Syswrap of the priocntlsys where pc_version=%ld.",
+ VG_(unimplemented)("Syswrap of the priocntlsys where pc_version=%lu.",
ARG1);
/*NOTREACHED*/
}
- PRINT("sys_priocntlsys ( %ld, %#lx, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_priocntlsys ( %ld, %#lx, %ld, %#lx, %#lx )", SARG1, ARG2, SARG3,
ARG4, ARG5);
PRE_REG_READ5(long, "priocntlsys", int, pc_version, procset_t *, psp,
int, cmd, void *, arg, void *, arg2);
break;
case VKI_PC_ADMIN:
default:
- VG_(unimplemented)("Syswrap of the priocntlsys call with cmd %ld.", ARG3);
+ VG_(unimplemented)("Syswrap of the priocntlsys call with cmd %ld.", SARG3);
/*NOTREACHED*/
break;
}
PRE(sys_pathconf)
{
/* long pathconf(const char *path, int name); */
- PRINT("sys_pathconf ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, ARG2);
+ PRINT("sys_pathconf ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, SARG2);
PRE_REG_READ2(long, "pathconf", const char *, path, int, name);
PRE_MEM_RASCIIZ("pathconf(path)", ARG1);
}
vg_assert(sizeof(offset) == sizeof(ARG6));
PRINT("sys_mmap ( %#lx, %#lx, %#lx, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ ARG1, ARG2, ARG3, ARG4, SARG5, ARG6);
PRE_REG_READ6(long, "mmap", void *, start, vki_size_t, length,
int, prot, int, flags, int, fd, vki_off_t, offset);
{
/* int mmapobj(int fd, uint_t flags, mmapobj_result_t *storage,
uint_t *elements, void *arg); */
- PRINT("sys_mmapobj ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_mmapobj ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
ARG4, ARG5);
PRE_REG_READ5(long, "mmapobj", int, fd, vki_uint_t, flags,
mmapobj_result_t *, storage, uint_t *, elements,
/* For now, supported is only MMOBJ_INTERPRET and no MMOBJ_PADDING. */
if (ARG2 != VKI_MMOBJ_INTERPRET) {
- VG_(unimplemented)("Syswrap of the mmapobj call with flags %ld.", ARG2);
+ VG_(unimplemented)("Syswrap of the mmapobj call with flags %lu.", ARG2);
/*NOTREACHED*/
return;
}
/* int memcntl(caddr_t addr, size_t len, int cmd, caddr_t arg,
int attr, int mask); */
PRINT("sys_memcntl ( %#lx, %#lx, %ld, %#lx, %#lx, %#lx )", ARG1, ARG2,
- ARG3, ARG4, ARG5, ARG6);
+ SARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "memcntl", void *, addr, vki_size_t, len, int, cmd,
void *, arg, int, attr, int, mask);
struct vki_strbuf *ctrlptr = (struct vki_strbuf *)ARG2;
struct vki_strbuf *dataptr = (struct vki_strbuf *)ARG3;
*flags |= SfMayBlock;
- PRINT("sys_getpmsg ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_getpmsg ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
ARG4, ARG5);
PRE_REG_READ5(long, "getpmsg", int, fildes, struct vki_strbuf *, ctlptr,
struct vki_strbuf *, dataptr, int *, bandp, int *, flagsp);
struct vki_strbuf *ctrlptr = (struct vki_strbuf *)ARG2;
struct vki_strbuf *dataptr = (struct vki_strbuf *)ARG3;
*flags |= SfMayBlock;
- PRINT("sys_putpmsg ( %ld, %#lx, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4,
- ARG5);
+ PRINT("sys_putpmsg ( %ld, %#lx, %#lx, %ld, %ld )", SARG1, ARG2, ARG3, SARG4,
+ SARG5);
PRE_REG_READ5(long, "putpmsg", int, fildes, struct vki_strbuf *, ctrlptr,
struct vki_strbuf *, dataptr, int, band, int, flags);
if (ctrlptr) {
*flags |= SfMayBlock;
PRINT("sys_rename ( %#lx(%s), %#lx(%s) )",
- ARG1, (HChar *) ARG1, ARG2, (char *) ARG2);
+ ARG1, (HChar *) ARG1, ARG2, (HChar *) ARG2);
PRE_REG_READ2(long, "rename", const char *, from, const char *, to);
PRE_MEM_RASCIIZ("rename(from)", ARG1);
PRE(sys_setegid)
{
/* int setegid(gid_t egid); */
- PRINT("sys_setegid ( %ld )", ARG1);
+ PRINT("sys_setegid ( %ld )", SARG1);
PRE_REG_READ1(long, "setegid", vki_gid_t, egid);
}
PRE(sys_sysconfig)
{
/* long sysconf(int name); */
- PRINT("sys_sysconfig ( %ld )", ARG1);
+ PRINT("sys_sysconfig ( %ld )", SARG1);
PRE_REG_READ1(long, "sysconf", int, name);
if (ARG1 == VKI_CONFIG_OPEN_FILES)
PRE(sys_systeminfo)
{
/* int sysinfo(int command, char *buf, long count); */
- PRINT("sys_systeminfo ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_systeminfo ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "sysinfo", int, command, char *, buf, long, count);
switch (ARG1 /*command*/) {
break;
default:
- VG_(unimplemented)("Syswrap of the sysinfo call with command %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the sysinfo call with command %ld.", SARG1);
/*NOTREACHED*/
break;
}
PRE(sys_seteuid)
{
/* int seteuid(uid_t euid); */
- PRINT("sys_seteuid ( %ld )", ARG1);
+ PRINT("sys_seteuid ( %ld )", SARG1);
PRE_REG_READ1(long, "seteuid", vki_uid_t, euid);
}
/* int64_t forksys(int subcode, int flags); */
Int fds[2];
Int res;
- PRINT("sys_forksys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_forksys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "forksys", int, subcode, int, flags);
if (ARG1 == 1) {
if (ARG1 != 0 && ARG1 != 2) {
VG_(unimplemented)("Syswrap of the forksys call where subcode=%ld.",
- ARG1);
+ SARG1);
/*NOTREACHED*/
}
PRE(sys_lwp_detach)
{
/* int lwp_detach(id_t lwpid); */
- PRINT("sys_lwp_detach ( %ld )", ARG1);
+ PRINT("sys_lwp_detach ( %ld )", SARG1);
PRE_REG_READ1(long, "lwp_detach", vki_id_t, lwpid);
}
PRE(sys_fchroot)
{
/* int fchroot(int fd); */
- PRINT("sys_fchroot ( %ld )", ARG1);
+ PRINT("sys_fchroot ( %ld )", SARG1);
PRE_REG_READ1(long, "fchroot", int, fd);
/* Be strict. */
{
/* int lwp_suspend(id_t lwpid); */
ThreadState *tst = VG_(get_ThreadState)(tid);
- PRINT("sys_lwp_suspend ( %ld )", ARG1);
+ PRINT("sys_lwp_suspend ( %ld )", SARG1);
PRE_REG_READ1(long, "lwp_suspend", vki_id_t, lwpid);
if (ARG1 == tst->os_state.lwpid) {
PRE(sys_lwp_continue)
{
/* int lwp_continue(id_t target_lwp); */
- PRINT("sys_lwp_continue ( %ld )", ARG1);
+ PRINT("sys_lwp_continue ( %ld )", SARG1);
PRE_REG_READ1(long, "lwp_continue", vki_id_t, target_lwp);
}
*flags |= SfPollAfter;
if (VG_(clo_trace_signals))
- VG_(message)(Vg_DebugMsg, "%s: sending signal %ld to thread %ld\n",
+ VG_(message)(Vg_DebugMsg, "%s: sending signal %lu to thread %lu\n",
syscall_name, signo, target_lwp);
/* If we're sending SIGKILL, check to see if the target is one of our
void *value, int si_code, timespec_t *timeout);
*/
PRINT("sys_lwp_sigqueue ( %ld, %ld, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
+ SARG1, SARG2, SARG3, ARG4, SARG5, ARG6);
PRE_REG_READ6(long, "lwp_sigqueue", vki_pid_t, target_pid,
vki_id_t, target_lwp, int, signal, void *, value, int, si_code,
vki_timespec_t *, timeout);
/* Signal is sent to a different process. */
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "lwp_sigqueue: sending signal %ld to "
- "process %ld, thread %ld\n", ARG3, ARG1, ARG2);
+ "process %ld, thread %ld\n", SARG3, SARG1, SARG2);
*flags |= SfMayBlock;
}
}
{
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "lwp_sigqueue: sent signal %ld to process %ld, "
- "thread %ld\n", ARG3, ARG1, ARG2);
+ "thread %ld\n", SARG3, SARG1, SARG2);
}
#else
int si_code, timespec_t *timeout);
*/
PRINT("sys_lwp_sigqueue ( %ld, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, ARG3, SARG4, ARG5);
PRE_REG_READ5(long, "lwp_sigqueue", vki_id_t, target_lwp, int, signal,
void *, value, int, si_code, vki_timespec_t *, timeout);
POST(sys_lwp_sigqueue)
{
if (VG_(clo_trace_signals))
- VG_(message)(Vg_DebugMsg, "lwp_sigqueue: sent signal %ld to thread %ld\n",
+ VG_(message)(Vg_DebugMsg, "lwp_sigqueue: sent signal %lu to thread %lu\n",
ARG2, ARG1);
}
PRE(sys_lwp_kill)
{
/* int lwp_kill(id_t target_lwp, int signal); */
- PRINT("sys_lwp_kill ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_lwp_kill ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "lwp_kill", vki_id_t, target_lwp, int, signal);
do_lwp_sigqueue("lwp_kill", ARG1, ARG2, status, flags);
POST(sys_lwp_kill)
{
if (VG_(clo_trace_signals))
- VG_(message)(Vg_DebugMsg, "lwp_kill: sent signal %ld to thread %ld\n",
+ VG_(message)(Vg_DebugMsg, "lwp_kill: sent signal %lu to thread %lu\n",
ARG2, ARG1);
}
#endif /* SOLARIS_LWP_SIGQUEUE_SYSCALL */
/* int64_t lwp_sigmask(int how, uint_t bits0, uint_t bits1, uint_t bits2,
uint_t bits3); */
vki_sigset_t sigset;
- PRINT("sys_lwp_sigmask ( %ld, %#lx, %#lx, %#lx, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_lwp_sigmask ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
ARG4, ARG5);
PRE_REG_READ5(long, "lwp_sigmask", int, how, vki_uint_t, bits0,
vki_uint_t, bits1, vki_uint_t, bits2, vki_uint_t, bits3);
/* int lwp_private(int cmd, int which, uintptr_t base); */
ThreadState *tst = VG_(get_ThreadState)(tid);
Int supported_base, supported_sel;
- PRINT("sys_lwp_private ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_private ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "lwp_private", int, cmd, int, which,
uintptr_t, base);
#endif
if (ARG2 != supported_base) {
VG_(unimplemented)("Syswrap of the lwp_private call where which=%ld.",
- ARG2);
+ SARG2);
/*NOTREACHED*/
}
}
default:
VG_(unimplemented)("Syswrap of the lwp_private call where cmd=%ld.",
- ARG1);
+ SARG1);
/*NOTREACHED*/
break;
}
{
/* int lwp_wait(id_t lwpid, id_t *departed); */
*flags |= SfMayBlock;
- PRINT("sys_lwp_wait ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_lwp_wait ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "lwp_wait", vki_id_t, lwpid, id_t *, departed);
if (ARG2)
PRE_MEM_WRITE("lwp_wait(departed)", ARG2, sizeof(vki_id_t));
/* int lwp_mutex_wakeup(lwp_mutex_t *lp, int release_all); */
vki_lwp_mutex_t *lp = (vki_lwp_mutex_t*)ARG1;
*flags |= SfMayBlock;
- PRINT("sys_lwp_mutex_wakeup ( %#lx, %ld )", ARG1, ARG2);
+ PRINT("sys_lwp_mutex_wakeup ( %#lx, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "lwp_mutex_wakeup", lwp_mutex_t *, lp,
int, release_all);
PRE_FIELD_READ("lwp_mutex_wakeup(lp->mutex_type)", lp->vki_mutex_type);
{
/* ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); */
*flags |= SfMayBlock;
- PRINT("sys_pread ( %ld, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_pread ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "pread", int, fildes, void *, buf,
vki_size_t, nbyte, vki_off_t, offset);
PRE_MEM_WRITE("pread(buf)", ARG2, ARG3);
/* ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
off_t offset); */
*flags |= SfMayBlock;
- PRINT("sys_pwrite ( %ld, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_pwrite ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "pwrite", int, fildes, const void *, buf,
vki_size_t, nbyte, vki_off_t, offset);
PRE_MEM_READ("pwrite(buf)", ARG2, ARG3);
PRE(sys_getpagesizes)
{
/* int getpagesizes(int legacy, size_t *buf, int nelem); */
- PRINT("sys_getpagesizes ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_getpagesizes ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "getpagesizes", int, legacy, size_t *, buf,
int, nelem);
if (ARG2)
case VKI__RUSAGESYS_GETRUSAGE_CHLD:
case VKI__RUSAGESYS_GETRUSAGE_LWP:
/* Libc: int getrusage(int who, struct rusage *r_usage); */
- PRINT("sys_rusagesys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_rusagesys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("rusagesys", "getrusage"), int, code,
struct vki_rusage *, r_usage);
PRE_MEM_WRITE("rusagesys(r_usage)", ARG2, sizeof(struct vki_rusage));
case VKI__RUSAGESYS_GETVMUSAGE:
/* Libc: int getvmusage(uint_t flags, time_t age,
vmusage_t *buf, size_t *nres); */
- PRINT("sys_rusagesys ( %ld, %ld, %ld, %#lx, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_rusagesys ( %ld, %lu, %ld, %#lx, %#lx )",
+ SARG1, ARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, SC2("rusagesys", "getvmusage"), int, code,
vki_uint_t, flags, vki_time_t, age,
vki_vmusage_t *, buf, vki_size_t *, nres);
break;
default:
- VG_(unimplemented)("Syswrap of the rusagesys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the rusagesys call with code %ld.", SARG1);
/*NOTREACHED*/
break;
}
*flags |= SfMayBlock;
switch (opcode) {
case VKI_PORT_CREATE:
- PRINT("sys_port ( %ld )", ARG1);
+ PRINT("sys_port ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("port", "create"), int, opcode);
break;
case VKI_PORT_ASSOCIATE:
case VKI_PORT_DISSOCIATE:
- PRINT("sys_port ( %ld, %ld, %ld, %#lx, %ld, %#lx )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_port ( %ld, %ld, %ld, %#lx, %ld, %#lx )", SARG1, SARG2, SARG3,
+ ARG4, SARG5, ARG6);
if (opcode == VKI_PORT_ASSOCIATE) {
PRE_REG_READ6(long, SC2("port", "associate"), int, opcode, int, a0,
int, a1, uintptr_t, a2, int, a3, void *, a4);
break;
default:
VG_(unimplemented)("Syswrap of the port_associate/dissociate call "
- "type %ld.", ARG3);
+ "type %ld.", SARG3);
/*NOTREACHED*/
break;
}
break;
case VKI_PORT_SEND:
- PRINT("sys_port ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_port ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, SC2("port", "send"), int, opcode, int, a0, int, a1,
void *, a2);
break;
case VKI_PORT_SENDN:
- PRINT("sys_port ( %ld, %#lx, %#lx, %lu, %lx, %#lx)", ARG1, ARG2, ARG3,
+ PRINT("sys_port ( %ld, %#lx, %#lx, %lu, %lx, %#lx)", SARG1, ARG2, ARG3,
ARG4, ARG5, ARG6);
PRE_REG_READ6(long, SC2("port", "sendn"), int, opcode, int *, a0,
int *, a1, vki_uint_t, a2, int, a3, void *, a4);
PRE_MEM_WRITE("port(errors)", ARG3, ARG4 * sizeof(int));
break;
case VKI_PORT_GET:
- PRINT("sys_port ( %ld, %ld, %#lx, %ld, %ld, %#lx )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_port ( %ld, %ld, %#lx, %ld, %ld, %#lx )", SARG1, SARG2, ARG3,
+ SARG4, SARG5, ARG6);
PRE_REG_READ6(long, SC2("port", "get"), int, opcode, int, a0,
port_event_t *, a1, vki_time_t, a2, long, a3,
timespec_t *, a4);
PRE_MEM_WRITE("port(uevp)", ARG3, sizeof(vki_port_event_t));
break;
case VKI_PORT_GETN:
- PRINT("sys_port ( %ld, %ld, %#lx, %lu, %lu, %#lx )", ARG1, ARG2, ARG3,
+ PRINT("sys_port ( %ld, %ld, %#lx, %lu, %lu, %#lx )", SARG1, SARG2, ARG3,
ARG4, ARG5, ARG6);
PRE_REG_READ6(long, SC2("port", "getn"), int, opcode, int, a0,
port_event_t *, a1, vki_uint_t, a2, vki_uint_t, a3,
PRE_MEM_WRITE("port(uevp)", ARG3, ARG4 * sizeof(vki_port_event_t));
break;
case VKI_PORT_ALERT:
- PRINT("sys_port ( %ld, %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4,
+ PRINT("sys_port ( %ld, %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, SARG4,
ARG5);
PRE_REG_READ5(long, SC2("port", "alert"), int, opcode, int, a0, int, a1,
int, a2, void *, a3);
break;
case VKI_PORT_DISPATCH:
- PRINT("sys_port ( %ld, %ld, %ld, %ld, %#lx, %#lx )", ARG2, ARG1, ARG3,
- ARG4, ARG5, ARG6);
+ // FIXME: check order: SARG2, SARG1 or SARG1, SARG2 ??
+ PRINT("sys_port ( %ld, %ld, %ld, %ld, %#lx, %#lx )", SARG2, SARG1, SARG3,
+ SARG4, ARG5, ARG6);
PRE_REG_READ6(long, SC2("port", "dispatch"), int, opcode, int, a0,
int, a1, int, a2, uintptr_t, a3, void *, a4);
break;
default:
- VG_(unimplemented)("Syswrap of the port call with opcode %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the port call with opcode %ld.", SARG1);
/*NOTREACHED*/
break;
}
case VKI_PORT_DISPATCH:
break;
default:
- VG_(unimplemented)("Syswrap of the port call with opcode %ld.", ARG2);
+ VG_(unimplemented)("Syswrap of the port call with opcode %lu.", ARG1);
/*NOTREACHED*/
break;
}
switch (ARG1 /*op*/) {
case VKI_TSOL_SYSLABELING:
/* Libc: int is_system_labeled(void); */
- PRINT("sys_labelsys ( %ld )", ARG1);
+ PRINT("sys_labelsys ( %ld )", SARG1);
PRE_REG_READ1(long, SC2("labelsys", "syslabeling"), int, op);
break;
case VKI_TSOL_TNRH:
/* Libtsnet: int tnrh(int cmd, tsol_rhent_t *buf); */
- PRINT("sys_labelsys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_labelsys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, SC2("labelsys", "tnrh"), int, op, int, cmd,
vki_tsol_rhent_t *, buf);
if (ARG2 != VKI_TNDB_FLUSH)
case VKI_TSOL_TNRHTP:
/* Libtsnet: int tnrhtp(int cmd, tsol_tpent_t *buf); */
- PRINT("sys_labelsys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_labelsys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, SC2("labelsys", "tnrhtp"), int, op, int, cmd,
vki_tsol_tpent_t *, buf);
if (ARG2 != VKI_TNDB_FLUSH)
case VKI_TSOL_TNMLP:
/* Libtsnet: int tnmlp(int cmd, tsol_mlpent_t *buf); */
- PRINT("sys_labelsys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_labelsys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, SC2("labelsys", "tnmlp"), int, op, int, cmd,
vki_tsol_mlpent_t *, buf);
PRE_MEM_READ("labelsys(buf)", ARG3, sizeof(vki_tsol_mlpent_t));
case VKI_TSOL_GETLABEL:
/* Libtsol: int getlabel(const char *path, bslabel_t *label); */
PRINT("sys_labelsys ( %ld, %#lx(%s), %#lx )",
- ARG1, ARG2, (HChar *) ARG2, ARG3);
+ SARG1, ARG2, (HChar *) ARG2, ARG3);
PRE_REG_READ3(long, SC2("labelsys", "getlabel"), int, op,
const char *, path, vki_bslabel_t *, label);
PRE_MEM_RASCIIZ("labelsys(path)", ARG2);
case VKI_TSOL_FGETLABEL:
/* Libtsol: int fgetlabel(int fd, bslabel_t *label); */
- PRINT("sys_labelsys ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_labelsys ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, SC2("labelsys", "fgetlabel"), int, op,
int, fd, vki_bslabel_t *, label);
/* Be strict. */
#if defined(SOLARIS_TSOL_CLEARANCE)
case VKI_TSOL_GETCLEARANCE:
/* Libtsol: int getclearance(bslabel_t *clearance); */
- PRINT("sys_labelsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_labelsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("labelsys", "getclearance"), int, op,
vki_bslabel_t *, clearance);
PRE_MEM_WRITE("labelsys(clearance)", ARG2, sizeof(vki_bslabel_t));
case VKI_TSOL_SETCLEARANCE:
/* Libtsol: int setclearance(bslabel_t *clearance); */
- PRINT("sys_labelsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_labelsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("labelsys", "setclearance"), int, op,
vki_bslabel_t *, clearance);
PRE_MEM_READ("labelsys(clearance)", ARG2, sizeof(vki_bslabel_t));
#endif /* SOLARIS_TSOL_CLEARANCE */
default:
- VG_(unimplemented)("Syswrap of the labelsys call with op %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the labelsys call with op %ld.", SARG1);
/*NOTREACHED*/
break;
}
PRE(sys_acl)
{
/* int acl(char *pathp, int cmd, int nentries, void *aclbufp); */
- PRINT("sys_acl ( %#lx(%s), %ld, %ld, %#lx )", ARG1, (HChar *) ARG1, ARG2,
- ARG3, ARG4);
+ PRINT("sys_acl ( %#lx(%s), %ld, %ld, %#lx )", ARG1, (HChar *) ARG1, SARG2,
+ SARG3, ARG4);
PRE_REG_READ4(long, "acl", char *, pathp, int, cmd,
int, nentries, void *, aclbufp);
case VKI_ACE_GETACLCNT:
break;
default:
- VG_(unimplemented)("Syswrap of the acl call with cmd %ld.", ARG2);
+ VG_(unimplemented)("Syswrap of the acl call with cmd %ld.", SARG2);
/*NOTREACHED*/
break;
}
switch (ARG1 /*code*/) {
case VKI_BSM_GETAUID:
/* Libbsm: int getauid(au_id_t *auid); */
- PRINT("sys_auditsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_auditsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("auditsys", "getauid"), long, code,
vki_au_id_t *, auid);
PRE_MEM_WRITE("auditsys(auid)", ARG2, sizeof(vki_au_id_t));
break;
case VKI_BSM_SETAUID:
/* Libbsm: int setauid(au_id_t *auid); */
- PRINT("sys_auditsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_auditsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("auditsys", "setauid"), long, code,
vki_au_id_t *, auid);
PRE_MEM_READ("auditsys(auid)", ARG2, sizeof(vki_au_id_t));
break;
case VKI_BSM_GETAUDIT:
/* Libbsm: int getaudit(auditinfo_t *ai); */
- PRINT("sys_auditsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_auditsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("auditsys", "getaudit"), long, code,
vki_auditinfo_t *, ai);
PRE_MEM_WRITE("auditsys(ai)", ARG2, sizeof(vki_auditinfo_t));
break;
case VKI_BSM_SETAUDIT:
/* Libbsm: int setaudit(auditinfo_t *ai); */
- PRINT("sys_auditsys ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_auditsys ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("auditsys", "setaudit"), long, code,
vki_auditinfo_t *, ai);
PRE_MEM_READ("auditsys(ai)", ARG2, sizeof(vki_auditinfo_t));
break;
case VKI_BSM_AUDIT:
/* Libbsm: int audit(void *record, int length); */
- PRINT("sys_auditsys ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_auditsys ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("auditsys", "audit"), long, code,
void *, record, int, length);
PRE_MEM_READ("auditsys(record)", ARG2, ARG3);
case VKI_BSM_AUDITCTL:
/* Libbsm: int auditon(int cmd, caddr_t data, int length); */
PRINT("sys_auditsys ( %ld, %ld, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, ARG3, SARG4);
switch (ARG2 /*cmd*/) {
case VKI_A_GETPOLICY:
break;
default:
VG_(unimplemented)("Syswrap of the auditsys(auditctl) call "
- "with cmd %ld.", ARG2);
+ "with cmd %lu.", ARG2);
/*NOTREACHED*/
break;
}
break;
case VKI_BSM_GETAUDIT_ADDR:
/* Libbsm: int getaudit_addr(auditinfo_addr_t *ai, int len); */
- PRINT("sys_auditsys ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_auditsys ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("auditsys", "getaudit_addr"), long, code,
vki_auditinfo_addr_t *, ai, int, len);
PRE_MEM_WRITE("auditsys(ai)", ARG2, ARG3);
break;
case VKI_BSM_SETAUDIT_ADDR:
/* Libbsm: int setaudit_addr(auditinfo_addr_t *ai, int len); */
- PRINT("sys_auditsys ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_auditsys ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("auditsys", "setaudit_addr"), long, code,
vki_auditinfo_addr_t *, ai, int, len);
PRE_MEM_READ("auditsys(ai)", ARG2, ARG3);
break;
case VKI_BSM_AUDITDOOR:
/* Libbsm: int auditdoor(int fd); */
- PRINT("sys_auditsys ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_auditsys ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("auditsys", "door"), long, code, int, fd);
/* Be strict. */
SET_STATUS_Failure(VKI_EBADF);
break;
default:
- VG_(unimplemented)("Syswrap of the auditsys call with code %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the auditsys call with code %lu.", ARG1);
/*NOTREACHED*/
break;
}
PRE(sys_p_online)
{
/* int p_online(processorid_t processorid, int flag); */
- PRINT("sys_p_online ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_p_online ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "p_online", vki_processorid_t, processorid, int, flag);
}
int si_code, timespec_t *timeout);
*/
PRINT("sys_sigqueue ( %ld, %ld, %#lx, %ld, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, ARG3, SARG4, ARG5);
PRE_REG_READ5(long, "sigqueue", vki_pid_t, pid, int, signo,
void *, value, int, si_code,
vki_timespec_t *, timeout);
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg,
- "sigqueue: signal %ld queued for pid %ld\n",
+ "sigqueue: signal %lu queued for pid %lu\n",
ARG2, ARG1);
/* Check to see if this gave us a pending signal. */
PRE(sys_clock_gettime)
{
/* int clock_gettime(clockid_t clock_id, struct timespec *tp); */
- PRINT("sys_clock_gettime ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_clock_gettime ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "clock_gettime", vki_clockid_t, clock_id,
struct timespec *, tp);
PRE_MEM_WRITE("clock_gettime(tp)", ARG2, sizeof(struct vki_timespec));
PRE(sys_clock_settime)
{
/* int clock_settime(clockid_t clock_id, const struct timespec *tp); */
- PRINT("sys_clock_settime ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_clock_settime ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "clock_settime", vki_clockid_t, clock_id,
const struct timespec *, tp);
PRE_MEM_READ("clock_settime(tp)", ARG2, sizeof(struct vki_timespec));
PRE(sys_clock_getres)
{
/* int clock_getres(clockid_t clock_id, struct timespec *res); */
- PRINT("sys_clock_getres ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_clock_getres ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "clock_getres", vki_clockid_t, clock_id,
struct timespec *, res);
/* int timer_create(clockid_t clock_id,
struct sigevent *evp, timer_t *timerid);
*/
- PRINT("sys_timer_create ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_timer_create ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "timer_create", vki_clockid_t, clock_id,
struct vki_sigevent *, evp, vki_timer_t *, timerid);
PRE(sys_timer_delete)
{
/* int timer_delete(timer_t timerid); */
- PRINT("sys_timer_delete ( %ld )", ARG1);
+ PRINT("sys_timer_delete ( %ld )", SARG1);
PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid);
}
struct itimerspec *ovalue);
*/
PRINT("sys_timer_settime ( %ld, %ld, %#lx, %#lx )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "timer_settime", vki_timer_t, timerid,
int, flags, const struct vki_itimerspec *, value,
struct vki_itimerspec *, ovalue);
PRE(sys_timer_gettime)
{
/* int timer_gettime(timer_t timerid, struct itimerspec *value); */
- PRINT("sys_timer_gettime ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_timer_gettime ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "timer_gettime", vki_timer_t, timerid,
struct vki_itimerspec *, value);
PRE_MEM_WRITE("timer_gettime(value)",
PRE(sys_timer_getoverrun)
{
/* int timer_getoverrun(timer_t timerid); */
- PRINT("sys_timer_getoverrun ( %ld )", ARG1);
+ PRINT("sys_timer_getoverrun ( %ld )", SARG1);
PRE_REG_READ1(long, "timer_getoverrun", vki_timer_t, timerid);
}
PRE(sys_facl)
{
/* int facl(int fildes, int cmd, int nentries, void *aclbufp); */
- PRINT("sys_facl ( %ld, %ld, %ld, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_facl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "facl", int, fildes, int, cmd,
int, nentries, void *, aclbufp);
case VKI_ACE_GETACLCNT:
break;
default:
- VG_(unimplemented)("Syswrap of the facl call with cmd %ld.", ARG2);
+ VG_(unimplemented)("Syswrap of the facl call with cmd %ld.", SARG2);
/*NOTREACHED*/
break;
}
*flags |= SfMayBlock | SfPostOnFail;
PRINT("sys_door ( %#lx, %#lx, %#lx, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ ARG4, ARG5, SARG6);
/* Macro PRE_REG_READ6 cannot be simply used because not all ARGs are used
in door() syscall variants. Note that ARG6 (subcode) is used always. */
VG_(unimplemented)("DOOR_SETPARAM");
break;
default:
- VG_(unimplemented)("Syswrap of the door call with subcode %ld.", ARG6);
+ VG_(unimplemented)("Syswrap of the door call with subcode %ld.", SARG6);
/*NOTREACHED*/
break;
}
*flags |= SfMayBlock;
switch (ARG1 /*subcode*/) {
case 0:
- PRINT("sys_lwp_rwlock ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_rwlock ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, SC2("lwp_rwlock", "rdlock"), int, subcode,
lwp_rwlock_t *, rwlp, timespec_t *, tsp);
break;
case 1:
- PRINT("sys_lwp_rwlock ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_rwlock ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, SC2("lwp_rwlock", "wrlock"), int, subcode,
lwp_rwlock_t *, rwlp, timespec_t *, tsp);
break;
case 2:
- PRINT("sys_lwp_rwlock ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_lwp_rwlock ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("lwp_rwlock", "tryrdlock"), int, subcode,
lwp_rwlock_t *, rwlp);
break;
case 3:
- PRINT("sys_lwp_rwlock ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_lwp_rwlock ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("lwp_rwlock", "trywrlock"), int, subcode,
lwp_rwlock_t *, rwlp);
break;
PRE_MEM_READ("lwp_rwlock(tsp)", ARG3, sizeof(vki_timespec_t));
break;
case 4:
- PRINT("sys_lwp_rwlock( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_lwp_rwlock( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("lwp_rwlock", "unlock"), int, subcode,
lwp_rwlock_t *, rwlp);
PRE_FIELD_READ("lwp_rwlock(rwlp->mutex.mutex_type)",
break;
default:
VG_(unimplemented)("Syswrap of the lwp_rwlock_sys call with subcode %ld.",
- ARG1);
+ SARG1);
/*NOTREACHED*/
break;
}
int check_park); */
vki_lwp_sema_t *sema = (vki_lwp_sema_t*)ARG1;
*flags |= SfMayBlock;
- PRINT("sys_lwp_sema_timewait ( %#lx, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_lwp_sema_timewait ( %#lx, %#lx, %ld )", ARG1, ARG2, SARG3);
PRE_REG_READ3(long, "lwp_sema_timedwait", lwp_sema_t *, sema,
timespec_t *, timeout, int, check_park);
int flags);
Kernel: zoneid_t zone_create(zone_def *zd);
*/
- PRINT("sys_zone ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("zone", "create"), int, cmd,
vki_zone_def *, zd);
break;
case VKI_ZONE_DESTROY:
/* Libc: int zone_destroy(zoneid_t zoneid); */
- PRINT("sys_zone ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("zone", "destroy"), int, cmd,
vki_zoneid_t, zoneid);
break;
void *valp, size_t size);
*/
PRINT("sys_zone ( %ld, %ld, %ld, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ SARG1, SARG2, SARG3, ARG4, SARG5);
PRE_REG_READ5(long, SC2("zone", "getattr"), int, cmd,
vki_zoneid_t, zoneid, int, attr, void *, valp,
vki_size_t, size);
break;
case VKI_ZONE_ENTER:
/* Libc: int zone_enter(zoneid_t zoneid); */
- PRINT("sys_zone ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("zone", "enter"), int, cmd,
vki_zoneid_t, zoneid);
break;
case VKI_ZONE_LIST:
/* Libc: int zone_list(zoneid_t *zonelist, uint_t *numzones); */
- PRINT("sys_zone ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_zone ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, SC2("zone", "list"), int, cmd,
vki_zoneid_t *, zonelist, vki_uint_t *, numzones);
break;
case VKI_ZONE_SHUTDOWN:
/* Libc: int zone_shutdown(zoneid_t zoneid); */
- PRINT("sys_zone ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("zone", "shutdown"), int, cmd,
vki_zoneid_t, zoneid);
break;
case VKI_ZONE_LOOKUP:
/* Libc: zoneid_t zone_lookup(const char *name); */
- PRINT("sys_zone ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, SC2("zone", "lookup"), int, cmd,
const char *, name);
if (ARG2)
break;
case VKI_ZONE_BOOT:
/* Libc: int zone_boot(zoneid_t zoneid); */
- PRINT("sys_zone ( %ld, %ld )", ARG1, ARG2);
+ PRINT("sys_zone ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, SC2("zone", "boot"), int, cmd,
vki_zoneid_t, zoneid);
break;
/* Libc: int zone_setattr(zoneid_t zoneid, int attr, void *valp,
size_t size);
*/
- PRINT("sys_zone ( %ld, %ld, %ld, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_zone ( %ld, %ld, %ld, %#lx, %lu )",
+ SARG1, SARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, SC2("zone", "setattr"), int, cmd,
vki_zoneid_t, zoneid, int, attr, void *, valp,
vki_size_t, size);
/* Libc: int zone_add_datalink(zoneid_t zoneid,
datalink_id_t linkid);
*/
- PRINT("sys_zone ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_zone ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC2("zone", "add_datalink"), int, cmd,
vki_zoneid_t, zoneid, vki_datalink_id_t, linkid);
break;
/* Libc: int zone_remove_datalink(zoneid_t zoneid,
datalink_id_t linkid);
*/
- PRINT("sys_zone ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_zone ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, SC2("zone", "del_datalink"), int, cmd,
vki_zoneid_t, zoneid, vki_datalink_id_t, linkid);
break;
/* Libc: int zone_check_datalink(zoneid_t *zoneidp,
datalink_id_t linkid);
*/
- PRINT("sys_zone ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_zone ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, SC2("zone", "check_datalink"), int, cmd,
vki_zoneid_t *, zoneidp, vki_datalink_id_t, linkid);
PRE_MEM_WRITE("zone(zoneidp)", ARG2, sizeof(vki_zoneid_t));
/* Libc: int zone_list_datalink(zoneid_t zoneid, int *dlnump,
datalink_id_t *linkids);
*/
- PRINT("sys_zone ( %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_zone ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, SC2("zone", "list_datalink"), int, cmd,
vki_zoneid_t, zoneid, int *, dlnump,
vki_datalink_id_t *, linkids);
/* Libc: int zone_list_defunct(uint64_t *uniqidlist,
uint_t *numzones);
*/
- PRINT("sys_zone ( %ld, %#lx, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_zone ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, SC2("zone", "list_defunct"), int, cmd,
vki_uint64_t *, uniqidlist, vki_uint_t *, numzones);
Kernel: ssize_t zone_getattr_defunct(uint64_t *uniqid, int attr,
void *valp, size_t size);
*/
- PRINT("sys_zone ( %ld, %#lx, %ld, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_zone ( %ld, %#lx, %ld, %#lx, %lu )",
+ SARG1, ARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, SC2("zone", "getattr_defunct"), int, cmd,
vki_uint64_t *, uniqid, int, attr,
void *, valp, vki_size_t, size);
break;
#endif /* SOLARIS_ZONE_DEFUNCT */
default:
- VG_(unimplemented)("Syswrap of the zone call with cmd %ld.", ARG1);
+ VG_(unimplemented)("Syswrap of the zone call with cmd %ld.", SARG1);
/*NOTREACHED*/
break;
}
{
/* int so_socket(int family, int type, int protocol, char *devpath,
int version); */
- PRINT("sys_so_socket ( %ld, %ld, %ld, %#lx(%s), %ld)", ARG1, ARG2, ARG3,
- ARG4, (HChar *) ARG4, ARG5);
+ PRINT("sys_so_socket ( %ld, %ld, %ld, %#lx(%s), %ld)", SARG1, SARG2, SARG3,
+ ARG4, (HChar *) ARG4, SARG5);
PRE_REG_READ5(long, "socket", int, family, int, type, int, protocol,
char *, devpath, int, version);
if (ARG4)
{
/* int bind(int s, struct sockaddr *name, socklen_t namelen,
int version); */
- PRINT("sys_bind ( %ld, %#lx, %lu, %ld )",ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_bind ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "bind", int, s, struct sockaddr *, name,
vki_socklen_t, namelen, int, version);
ML_(generic_PRE_sys_bind)(tid, ARG1, ARG2, ARG3);
PRE(sys_listen)
{
/* int listen(int s, int backlog, int version); */
- PRINT("sys_listen ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_listen ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "listen", int, s, int, backlog, int, version);
}
/* int accept(int s, struct sockaddr *addr, socklen_t *addrlen,
int version, int flags); */
*flags |= SfMayBlock;
- PRINT("sys_accept ( %ld, %#lx, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4,
- ARG5);
+ PRINT("sys_accept ( %ld, %#lx, %#lx, %ld, %ld )", SARG1, ARG2, ARG3, SARG4,
+ SARG5);
PRE_REG_READ5(long, "accept", int, s, struct sockaddr *, addr,
socklen_t *, addrlen, int, version, int, flags);
#else
/* int accept(int s, struct sockaddr *addr, socklen_t *addrlen,
int version); */
*flags |= SfMayBlock;
- PRINT("sys_accept ( %ld, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_accept ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "accept", int, s, struct sockaddr *, addr,
socklen_t *, addrlen, int, version);
#endif /* SOLARIS_NEW_ACCEPT_SYSCALL */
/* int connect(int s, struct sockaddr *name, socklen_t namelen,
int version); */
*flags |= SfMayBlock;
- PRINT("sys_connect ( %ld, %#lx, %lu, %ld )",ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_connect ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "connect", int, s, struct sockaddr *, name,
vki_socklen_t, namelen, int, version);
ML_(generic_PRE_sys_connect)(tid, ARG1, ARG2, ARG3);
Libc: int shutdown(int sock, int how);
*/
*flags |= SfMayBlock;
- PRINT("sys_shutdown ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_shutdown ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(int, "shutdown", int, sock, int, how, int, version);
/* Be strict. */
{
/* ssize_t recv(int s, void *buf, size_t len, int flags); */
*flags |= SfMayBlock;
- PRINT("sys_recv ( %ld, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_recv ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "recv", int, s, void *, buf, vki_size_t, len,
int, flags);
ML_(generic_PRE_sys_recv)(tid, ARG1, ARG2, ARG3);
/* ssize_t recvfrom(int s, void *buf, size_t len, int flags,
struct sockaddr *from, socklen_t *fromlen); */
*flags |= SfMayBlock;
- PRINT("sys_recvfrom ( %ld, %#lx, %lu, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_recvfrom ( %ld, %#lx, %lu, %ld, %#lx, %#lx )", SARG1, ARG2, ARG3,
+ SARG4, ARG5, ARG6);
PRE_REG_READ6(long, "recvfrom", int, s, void *, buf, vki_size_t, len,
int, flags, struct sockaddr *, from, socklen_t *, fromlen);
ML_(generic_PRE_sys_recvfrom)(tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
{
/* ssize_t recvmsg(int s, struct msghdr *msg, int flags); */
*flags |= SfMayBlock;
- PRINT("sys_recvmsg ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_recvmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr*)ARG2);
}
{
/* ssize_t send(int s, const void *msg, size_t len, int flags); */
*flags |= SfMayBlock;
- PRINT("sys_send ( %ld, %#lx, %lu, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_send ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "send", int, s, const void *, msg, vki_size_t, len,
int, flags);
ML_(generic_PRE_sys_send)(tid, ARG1, ARG2, ARG3);
{
/* ssize_t sendmsg(int s, const struct msghdr *msg, int flags); */
*flags |= SfMayBlock;
- PRINT("sys_sendmsg ( %ld, %#lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("sys_sendmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "sendmsg", int, s, const struct msghdr *, msg,
int, flags);
ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr*)ARG2);
/* ssize_t sendto(int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, int tolen); */
*flags |= SfMayBlock;
- PRINT("sys_sendto ( %ld, %#lx, %lu, %ld, %#lx, %ld )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_sendto ( %ld, %#lx, %lu, %ld, %#lx, %ld )", SARG1, ARG2, ARG3,
+ SARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendto", int, s, const void *, msg, vki_size_t, len,
int, flags, const struct sockaddr *, to, int, tolen);
ML_(generic_PRE_sys_sendto)(tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
*/
*flags |= SfMayBlock;
PRINT("sys_getpeername ( %ld, %#lx, %#lx, %ld )",
- ARG1, ARG2, ARG3, ARG4);
+ SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "getpeername", int, s, struct vki_sockaddr *, name,
vki_socklen_t *, namelen, int, version);
ML_(buf_and_len_pre_check)(tid, ARG2, ARG3, "getpeername(name)",
{
/* int getsockname(int s, struct sockaddr *name, socklen_t *namelen,
int version); */
- PRINT("sys_getsockname ( %ld, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_getsockname ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "getsockname", int, s, struct sockaddr *, name,
socklen_t *, namelen, int, version);
ML_(generic_PRE_sys_getsockname)(tid, ARG1, ARG2, ARG3);
{
/* int getsockopt(int s, int level, int optname, void *optval,
socklen_t *optlen, int version); */
- PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx, %ld )", ARG1, ARG2,
- ARG3, ARG4, ARG5, ARG6);
+ PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx, %ld )", SARG1, SARG2,
+ SARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "getsockopt", int, s, int, level, int, optname,
void *, optval, socklen_t *, option, int, version);
if (ARG4)
{
/* int setsockopt(int s, int level, int optname, const void *optval,
socklen_t optlen, int version); */
- PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %lu, %ld )", ARG1, ARG2, ARG3,
- ARG4, ARG5, ARG6);
+ PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %lu, %ld )", SARG1, SARG2,
+ SARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "setsockopt", int, s, int, level, int, optname,
const void *, optval, vki_socklen_t, optlen, int, version);
ML_(generic_PRE_sys_setsockopt)(tid, ARG1, ARG2, ARG3, ARG4, ARG5);
{
/* int umount2(const char *file, int mflag); */
*flags |= SfMayBlock;
- PRINT("sys_umount2 ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, ARG2);
+ PRINT("sys_umount2 ( %#lx(%s), %ld )", ARG1, (HChar *) ARG1, SARG2);
PRE_REG_READ2(long, "umount2", const char *, file, int, mflag);
PRE_MEM_RASCIIZ("umount2(file)", ARG1);
}
/* High half word64 is syscall return value. */
if (debug)
- VG_(printf)("ret: 0x%lx\n", ret);
+ VG_(printf)("ret: 0x%llx\n", (ULong)ret);
res = VG_(mk_SysRes_tilegx_linux) (/*val */ ret);
PRE(sys_arch_prctl)
{
- PRINT( "arch_prctl ( %ld, %lx )", ARG1, ARG2 );
+ PRINT( "arch_prctl ( %ld, %lx )", SARG1, ARG2 );
vg_assert(VG_(is_valid_tid)(tid));
vg_assert(tid >= 1 && tid < VG_N_THREADS);
// space, and we should therefore not check anything it points to.
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace",
- long, request, long, pid, long, addr, long, data);
+ long, request, long, pid, unsigned long, addr, unsigned long, data);
switch (ARG1) {
case VKI_PTRACE_PEEKTEXT:
case VKI_PTRACE_PEEKDATA:
PRE(sys_socket)
{
- PRINT("sys_socket ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_socket ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "socket", int, domain, int, type, int, protocol);
}
POST(sys_socket)
PRE(sys_setsockopt)
{
- PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %ld )", SARG1, SARG2, SARG3,
+ ARG4, SARG5);
PRE_REG_READ5(long, "setsockopt",
int, s, int, level, int, optname,
const void *, optval, int, optlen);
PRE(sys_getsockopt)
{
- PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %#lx )", SARG1, SARG2, SARG3,
+ ARG4, ARG5);
PRE_REG_READ5(long, "getsockopt",
int, s, int, level, int, optname,
void *, optval, int, *optlen);
PRE(sys_connect)
{
*flags |= SfMayBlock;
- PRINT("sys_connect ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_connect ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "connect",
int, sockfd, struct sockaddr *, serv_addr, int, addrlen);
ML_(generic_PRE_sys_connect)(tid, ARG1,ARG2,ARG3);
PRE(sys_accept)
{
*flags |= SfMayBlock;
- PRINT("sys_accept ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_accept ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "accept",
- int, s, struct sockaddr *, addr, int, *addrlen);
+ int, s, struct sockaddr *, addr, int *, addrlen);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept)
PRE(sys_accept4)
{
*flags |= SfMayBlock;
- PRINT("sys_accept4 ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_accept4 ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "accept4",
- int, s, struct sockaddr *, addr, int, *addrlen, int, flags);
+ int, s, struct sockaddr *, addr, int *, addrlen, int, flags);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
}
POST(sys_accept4)
PRE(sys_sendto)
{
*flags |= SfMayBlock;
- PRINT("sys_sendto ( %ld, %#lx, %ld, %lu, %#lx, %ld )",ARG1,ARG2,ARG3,
- ARG4,ARG5,ARG6);
+ PRINT("sys_sendto ( %ld, %#lx, %ld, %lu, %#lx, %ld )", SARG1, ARG2, SARG3,
+ ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendto",
int, s, const void *, msg, int, len,
unsigned int, flags,
PRE(sys_recvfrom)
{
*flags |= SfMayBlock;
- PRINT("sys_recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )",ARG1,ARG2,ARG3,
- ARG4,ARG5,ARG6);
+ PRINT("sys_recvfrom ( %ld, %#lx, %ld, %lu, %#lx, %#lx )", SARG1, ARG2, SARG3,
+ ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "recvfrom",
int, s, void *, buf, int, len, unsigned int, flags,
struct sockaddr *, from, int *, fromlen);
PRE(sys_sendmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_sendmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_sendmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "sendmsg",
int, s, const struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_sendmsg)(tid, "msg", ARG2);
PRE(sys_recvmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_recvmsg ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_recvmsg ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "recvmsg", int, s, struct msghdr *, msg, int, flags);
ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr *) ARG2);
}
PRE(sys_shutdown)
{
*flags |= SfMayBlock;
- PRINT("sys_shutdown ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_shutdown ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(int, "shutdown", int, s, int, how);
}
PRE(sys_bind)
{
- PRINT("sys_bind ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_bind ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "bind",
int, sockfd, struct sockaddr *, my_addr, int, addrlen);
ML_(generic_PRE_sys_bind)(tid, ARG1,ARG2,ARG3);
PRE(sys_listen)
{
- PRINT("sys_listen ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_listen ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "listen", int, s, int, backlog);
}
PRE(sys_getsockname)
{
- PRINT("sys_getsockname ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_getsockname ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getsockname",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getsockname)(tid, ARG1,ARG2,ARG3);
PRE(sys_getpeername)
{
- PRINT("sys_getpeername ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_getpeername ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "getpeername",
int, s, struct sockaddr *, name, int *, namelen);
ML_(generic_PRE_sys_getpeername)(tid, ARG1,ARG2,ARG3);
PRE(sys_socketpair)
{
- PRINT("sys_socketpair ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_socketpair ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "socketpair",
int, d, int, type, int, protocol, int*, sv);
ML_(generic_PRE_sys_socketpair)(tid, ARG1,ARG2,ARG3,ARG4);
PRE(sys_semget)
{
- PRINT("sys_semget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_semget ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semget", vki_key_t, key, int, nsems, int, semflg);
}
PRE(sys_semop)
{
*flags |= SfMayBlock;
- PRINT("sys_semop ( %ld, %#lx, %lu )",ARG1,ARG2,ARG3);
+ PRINT("sys_semop ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "semop",
int, semid, struct sembuf *, sops, unsigned, nsoops);
ML_(generic_PRE_sys_semop)(tid, ARG1,ARG2,ARG3);
PRE(sys_semtimedop)
{
*flags |= SfMayBlock;
- PRINT("sys_semtimedop ( %ld, %#lx, %lu, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semtimedop ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "semtimedop",
int, semid, struct sembuf *, sops, unsigned, nsoops,
struct timespec *, timeout);
switch (ARG3 & ~VKI_IPC_64) {
case VKI_IPC_INFO:
case VKI_SEM_INFO:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct seminfo *, arg);
break;
case VKI_IPC_STAT:
case VKI_SEM_STAT:
case VKI_IPC_SET:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, struct semid_ds *, arg);
break;
case VKI_GETALL:
case VKI_SETALL:
- PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#lx )", SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
default:
- PRINT("sys_semctl ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_semctl ( %ld, %ld, %ld )", SARG1, SARG2, SARG3);
PRE_REG_READ3(long, "semctl",
int, semid, int, semnum, int, cmd);
break;
PRE(sys_msgget)
{
- PRINT("sys_msgget ( %ld, %ld )",ARG1,ARG2);
+ PRINT("sys_msgget ( %ld, %ld )", SARG1, SARG2);
PRE_REG_READ2(long, "msgget", vki_key_t, key, int, msgflg);
}
PRE(sys_msgsnd)
{
- PRINT("sys_msgsnd ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_msgsnd ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "msgsnd",
int, msqid, struct msgbuf *, msgp, vki_size_t, msgsz,
int, msgflg);
PRE(sys_msgrcv)
{
- PRINT("sys_msgrcv ( %ld, %#lx, %ld, %ld, %ld )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_msgrcv ( %ld, %#lx, %lu, %ld, %ld )", SARG1, ARG2, ARG3,
+ SARG4, SARG5);
PRE_REG_READ5(long, "msgrcv",
int, msqid, struct msgbuf *, msgp, vki_size_t, msgsz,
long, msgytp, int, msgflg);
PRE(sys_msgctl)
{
- PRINT("sys_msgctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_msgctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "msgctl",
int, msqid, int, cmd, struct msqid_ds *, buf);
ML_(linux_PRE_sys_msgctl)(tid, ARG1,ARG2,ARG3);
PRE(sys_shmget)
{
- PRINT("sys_shmget ( %ld, %ld, %ld )",ARG1,ARG2,ARG3);
+ PRINT("sys_shmget ( %ld, %lu, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmget", vki_key_t, key, vki_size_t, size, int, shmflg);
}
PRE(wrap_sys_shmat)
{
UWord arg2tmp;
- PRINT("wrap_sys_shmat ( %ld, %#lx, %ld )",ARG1,ARG2,ARG3);
+ PRINT("wrap_sys_shmat ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmat",
int, shmid, const void *, shmaddr, int, shmflg);
arg2tmp = ML_(generic_PRE_sys_shmat)(tid, ARG1,ARG2,ARG3);
PRE(sys_shmctl)
{
- PRINT("sys_shmctl ( %ld, %ld, %#lx )",ARG1,ARG2,ARG3);
+ PRINT("sys_shmctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "shmctl",
int, shmid, int, cmd, struct shmid_ds *, buf);
ML_(generic_PRE_sys_shmctl)(tid, ARG1,ARG2|VKI_IPC_64,ARG3);
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4);
PRE_REG_READ4(long, "fadvise64",
int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
}
{
SysRes r;
- PRINT("sys_mmap ( %#lx, %llu, %ld, %ld, %d, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, (Int)ARG5, ARG6 );
+ PRINT("sys_mmap ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
------------------------------------------------------------ */
PRE(sys_cacheflush)
{
- PRINT("cacheflush (%lx, %lx, %lx)", ARG1, ARG2, ARG3);
+ PRINT("cacheflush (%lx, %ld, %ld)", ARG1, SARG2, SARG3);
PRE_REG_READ3(long, "cacheflush", unsigned long, addr,
int, nbytes, int, cache);
VG_ (discard_translations) ((Addr)ARG1, (ULong) ARG2,
PRE(sys_set_dataplane)
{
*flags |= SfMayBlock;
- PRINT("sys_set_dataplane ( %ld )", ARG1);
+ PRINT("sys_set_dataplane ( %lu )", ARG1);
PRE_REG_READ1(long, "set_dataplane", unsigned long, flag);
}
tst = VG_(get_ThreadState)(tid);
- if (0) VG_(printf)("wqthread_hijack reuse %s: tid %d, tst %p, "
+ if (0) VG_(printf)("wqthread_hijack reuse %s: tid %u, tst %p, "
"tst->os_state.pthread %#lx, self %#lx\n",
tst->os_state.pthread == self ? "SAME" : "DIFF",
tid, tst, tst->os_state.pthread, self);
if (flags & VKI_CLONE_SETTLS) {
if (debug)
- VG_(printf)("clone child has SETTLS: tls info at %p: idx=%d "
+ VG_(printf)("clone child has SETTLS: tls info at %p: idx=%u "
"base=%#lx limit=%x; esp=%#x fs=%x gs=%x\n",
tlsinfo, tlsinfo->entry_number,
tlsinfo->base_addr, tlsinfo->limit,
vg_assert(8 == sizeof(VexGuestX86SegDescr));
if (0)
- VG_(printf)("translate_to_hw_format: base %#lx, limit %d\n",
+ VG_(printf)("translate_to_hw_format: base %#lx, limit %u\n",
inn->base_addr, inn->limit );
/* Allow LDTs to be cleared by the user. */
UChar* ldt;
if (0)
- VG_(printf)("read_ldt: tid = %d, ptr = %p, bytecount = %d\n",
+ VG_(printf)("read_ldt: tid = %u, ptr = %p, bytecount = %u\n",
tid, ptr, bytecount );
vg_assert(sizeof(HWord) == sizeof(VexGuestX86SegDescr*));
vki_modify_ldt_t* ldt_info;
if (0)
- VG_(printf)("write_ldt: tid = %d, ptr = %p, "
- "bytecount = %d, oldmode = %d\n",
+ VG_(printf)("write_ldt: tid = %u, ptr = %p, "
+ "bytecount = %u, oldmode = %d\n",
tid, ptr, bytecount, oldmode );
vg_assert(8 == sizeof(VexGuestX86SegDescr));
a4 = arg_struct[3];
a5 = arg_struct[4];
- PRINT("old_select ( %d, %#x, %#x, %#x, %#x )", a1,a2,a3,a4,a5);
+ PRINT("old_select ( %d, %#x, %#x, %#x, %#x )", (Int)a1,a2,a3,a4,a5);
if (a2 != (Addr)NULL)
PRE_MEM_READ( "old_select(readfds)", a2, a1/8 /* __FD_SETSIZE/8 */ );
if (a3 != (Addr)NULL)
PRE(sys_modify_ldt)
{
- PRINT("sys_modify_ldt ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
+ PRINT("sys_modify_ldt ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
PRE_REG_READ3(int, "modify_ldt", int, func, void *, ptr,
unsigned long, bytecount);
// space, and we should therefore not check anything it points to.
PRE(sys_ptrace)
{
- PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int, "ptrace",
- long, request, long, pid, long, addr, long, data);
+ long, request, long, pid, unsigned long, addr,
+ unsigned long, data);
switch (ARG1) {
case VKI_PTRACE_PEEKTEXT:
case VKI_PTRACE_PEEKDATA:
a5 = args[5-1];
a6 = args[6-1];
- PRINT("old_mmap ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- a1, (ULong)a2, a3, a4, a5, a6 );
+ PRINT("old_mmap ( %#lx, %lu, %ld, %ld, %ld, %ld )",
+ a1, a2, (Word)a3, (Word)a4, (Word)a5, (Word)a6 );
r = ML_(generic_PRE_sys_mmap)( tid, a1, a2, a3, a4, a5, (Off64T)a6 );
SET_STATUS_from_SysRes(r);
// pagesize or 4K-size units in offset? For ppc32/64-linux, this is
// 4K-sized. Assert that the page size is 4K here for safety.
vg_assert(VKI_PAGE_SIZE == 4096);
- PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
- ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
+ PRINT("sys_mmap2 ( %#lx, %lu, %lu, %lu, %lu, %lu )",
+ ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
PRE_REG_READ6(long, "mmap2",
unsigned long, start, unsigned long, length,
unsigned long, prot, unsigned long, flags,
// things, eventually, I think. --njn
PRE(sys_lstat64)
{
- PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(sys_stat64)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
PRE(sys_fstatat64)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
- PRE_REG_READ3(long, "fstatat64",
- int, dfd, char *, file_name, struct stat64 *, buf);
+ // ARG4 = int flags; Flags are or'ed together, therefore writing them
+ // as a hex constant is more meaningful.
+ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %#lx )",
+ SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
+ PRE_REG_READ4(long, "fstatat64",
+ int, dfd, char *, file_name, struct stat64 *, buf, int, flags);
PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
}
PRE(sys_fstat64)
{
- PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
+ PRINT("sys_fstat64 ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
}
that takes a pointer to the signal mask so supports more signals.
*/
*flags |= SfMayBlock;
- PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 );
+ PRINT("sys_sigsuspend ( %ld, %ld, %lu )", SARG1, SARG2, ARG3 );
PRE_REG_READ3(int, "sigsuspend",
int, history0, int, history1,
vki_old_sigset_t, mask);
PRE(sys_vm86)
{
- PRINT("sys_vm86 ( %ld, %#lx )", ARG1,ARG2);
+ PRINT("sys_vm86 ( %lu, %#lx )", ARG1, ARG2);
PRE_REG_READ2(int, "vm86", unsigned long, fn, struct vm86plus_struct *, v86);
if (ARG1 == VKI_VM86_ENTER || ARG1 == VKI_VM86_ENTER_NO_BYPASS)
PRE_MEM_WRITE( "vm86(v86)", ARG2, sizeof(struct vki_vm86plus_struct));
if (eflags != ~VKI_UC_GUEST_EFLAGS_NEG(uc)) {
VG_(debugLog)(1, "syswrap-solaris",
"The eflags value was restored from an "
- "explicitly set value in thread %d.\n", tid);
+ "explicitly set value in thread %u.\n", tid);
ok_restore = True;
}
else {
/* Check ok, the full restoration is possible. */
VG_(debugLog)(1, "syswrap-solaris",
"The CC_* guest state values were fully "
- "restored in thread %d.\n", tid);
+ "restored in thread %u.\n", tid);
ok_restore = True;
tst->arch.vex.guest_CC_OP = VKI_UC_GUEST_CC_OP(uc);
VG_(debugLog)(1, "syswrap-solaris",
"Cannot fully restore the CC_* guest state "
"values, using approximate eflags in thread "
- "%d.\n", tid);
+ "%u.\n", tid);
}
}
note = LibVEX_GuestX86_put_x87((UChar*)&fs->state, &tst->arch.vex);
if (note != EmNote_NONE)
VG_(message)(Vg_UserMsg,
- "Error restoring x87 state in thread %d: %s.\n",
+ "Error restoring x87 state in thread %u: %s.\n",
tid, LibVEX_EmNote_string(note));
/* SSE */
note = LibVEX_GuestX86_put_mxcsr(fs->mxcsr, &tst->arch.vex);
if (note != EmNote_NONE)
VG_(message)(Vg_UserMsg,
- "Error restoring mxcsr state in thread %d: %s.\n",
+ "Error restoring mxcsr state in thread %u: %s.\n",
tid, LibVEX_EmNote_string(note));
/* XMM registers */
#define COPY_IN_XMM(src, dest) \
{
/* int fstatat64(int fildes, const char *path, struct stat64 *buf,
int flag); */
- PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %ld )", ARG1, ARG2,
- (char*)ARG2, ARG3, ARG4);
+ PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx, %ld )", SARG1, ARG2,
+ (HChar*)ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "fstatat64", int, fildes, const char *, path,
struct stat64 *, buf, int, flag);
if (ARG2)
if (ARG3 & VKI_O_CREAT) {
/* 4-arg version */
- PRINT("sys_openat64 ( %ld, %#lx(%s), %ld, %ld )", ARG1, ARG2,
- (char*)ARG2, ARG3, ARG4);
+ PRINT("sys_openat64 ( %ld, %#lx(%s), %ld, %ld )", SARG1, ARG2,
+ (HChar*)ARG2, SARG3, SARG4);
PRE_REG_READ4(long, "openat64", int, fildes, const char *, filename,
int, flags, vki_mode_t, mode);
}
else {
/* 3-arg version */
- PRINT("sys_openat64 ( %ld, %#lx(%s), %ld )", ARG1, ARG2, (char*)ARG2,
- ARG3);
+ PRINT("sys_openat64 ( %ld, %#lx(%s), %ld )", SARG1, ARG2, (HChar*)ARG2,
+ SARG3);
PRE_REG_READ3(long, "openat64", int, fildes, const char *, filename,
int, flags);
}
PRE(sys_llseek32)
{
/* offset_t llseek(int fildes, offset_t offset, int whence); */
- PRINT("sys_llseek32 ( %ld, %#lx, %#lx, %ld )", ARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_llseek32 ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "llseek", int, fildes, vki_u32, offset_low,
vki_u32, offset_high, int, whence);
vg_assert(sizeof(u) == sizeof(offset));
PRINT("sys_mmap ( %#lx, %#lx, %#lx, %#lx, %ld, %#lx, %#lx )",
- ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
+ ARG1, ARG2, ARG3, ARG4, SARG5, ARG6, ARG7);
PRE_REG_READ7(long, "mmap", void *, start, vki_size_t, length,
int, prot, int, flags, int, fd, uint32_t, offlo,
uint32_t, offhi);
PRE(sys_stat64)
{
/* int stat64(const char *path, struct stat64 *buf); */
- PRINT("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (char*)ARG1, ARG2);
+ PRINT("sys_stat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "stat64", const char *, path, struct stat64 *, buf);
PRE_MEM_RASCIIZ("stat64(path)", ARG1);
PRE(sys_lstat64)
{
/* int lstat64(const char *path, struct stat64 *buf); */
- PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (char*)ARG1, ARG2);
+ PRINT("sys_lstat64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "lstat64", const char *, path, struct stat64 *, buf);
PRE_MEM_RASCIIZ("lstat64(path)", ARG1);
PRE(sys_fstat64)
{
/* int fstat64(int fildes, struct stat64 *buf); */
- PRINT("sys_fstat64 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_fstat64 ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "fstat64", int, fildes, struct stat64 *, buf);
PRE_MEM_WRITE("fstat64(buf)", ARG2, sizeof(struct vki_stat64));
{
/* int fstatvfs64(int fd, struct statvfs64 *buf); */
*flags |= SfMayBlock;
- PRINT("sys_fstatvfs64 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_fstatvfs64 ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "fstatvfs64", int, fd, struct vki_statvfs64 *, buf);
PRE_MEM_WRITE("fstatvfs64(buf)", ARG2, sizeof(struct vki_statvfs64));
{
/* int setrlimit64(int resource, struct rlimit64 *rlim); */
struct vki_rlimit64 *limit = (struct vki_rlimit64 *)ARG2;
- PRINT("sys_setrlimit64 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_setrlimit64 ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "setrlimit64", int, resource, struct rlimit64 *, rlim);
PRE_MEM_READ("setrlimit64(rlim)", ARG2, sizeof(struct vki_rlimit64));
PRE(sys_getrlimit64)
{
/* int getrlimit64(int resource, struct rlimit64 *rlim); */
- PRINT("sys_getrlimit64 ( %ld, %#lx )", ARG1, ARG2);
+ PRINT("sys_getrlimit64 ( %ld, %#lx )", SARG1, ARG2);
PRE_REG_READ2(long, "getrlimit64",
int, resource, struct rlimit64 *, rlim);
PRE_MEM_WRITE("getrlimit64(rlim)", ARG2, sizeof(struct vki_rlimit64));
uint32_t offset_1, uint32_t offset_2);
*/
*flags |= SfMayBlock;
- PRINT("sys_pread64 ( %ld, %#lx, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_pread64 ( %ld, %#lx, %lu, %#lx, %#lx )",
+ SARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "pread64", int, fd, void *, buf, vki_size32_t, count,
vki_uint32_t, offset_1, vki_uint32_t, offset_2);
PRE_MEM_WRITE("pread64(buf)", ARG2, ARG3);
uint32_t offset_1, uint32_t offset_2);
*/
*flags |= SfMayBlock;
- PRINT("sys_pwrite64 ( %ld, %#lx, %ld, %ld, %ld )",
- ARG1, ARG2, ARG3, ARG4, ARG5);
+ PRINT("sys_pwrite64 ( %ld, %#lx, %lu, %#lx, %#lx )",
+ SARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "pwrite64", int, fd, void *, buf, vki_size32_t, count,
vki_uint32_t, offset_1, vki_uint32_t, offset_2);
PRE_MEM_READ("pwrite64(buf)", ARG2, ARG3);
if (ARG2 & VKI_O_CREAT) {
/* 3-arg version */
- PRINT("sys_open64 ( %#lx(%s), %ld, %ld )", ARG1, (char*)ARG1, ARG2,
- ARG3);
+ PRINT("sys_open64 ( %#lx(%s), %#lx, %ld )", ARG1, (HChar*)ARG1, ARG2,
+ SARG3);
PRE_REG_READ3(long, "open64", const char *, filename, int, flags,
vki_mode_t, mode);
}
else {
/* 2-arg version */
- PRINT("sys_open64 ( %#lx(%s), %ld )", ARG1, (char*)ARG1, ARG2);
+ PRINT("sys_open64 ( %#lx(%s), %#lx )", ARG1, (HChar*)ARG1, ARG2);
PRE_REG_READ2(long, "open64", const char *, filename, int, flags);
}
PRE_MEM_RASCIIZ("open(filename)", ARG1);
/*MOD*/SyscallArgs* args,
/*OUT*/SyscallStatus* status,
/*OUT*/UWord* flags,
- const HChar* hypercall,
+ const HChar* hypercall,
UWord subop)
{
- VG_(dmsg)("WARNING: unhandled %s subop: %ld\n",
+ VG_(dmsg)("WARNING: unhandled %s subop: %lu\n",
hypercall, subop);
if (VG_(clo_verbosity) > 1) {
VG_(get_and_pp_StackTrace)(tid, VG_(clo_backtrace_size));
PRE(memory_op)
{
- PRINT("__HYPERVISOR_memory_op ( %ld, %lx )", ARG1, ARG2);
+ PRINT("__HYPERVISOR_memory_op ( %lu, %#lx )", ARG1, ARG2);
switch (ARG1) {
PRE(mmuext_op)
{
+ PRINT("__HYPERVISOR_mmuext_op ( %#lx, %ld, %#lx, %lu )",
+ ARG1, SARG2, ARG3, ARG4);
+
struct vki_xen_mmuext_op *ops = (struct vki_xen_mmuext_op *)ARG1;
unsigned int i, nr = ARG2;
/* XXX assuming flask, only actual XSM right now */
struct vki_xen_flask_op *op = (struct vki_xen_flask_op *)ARG1;
- PRINT("__HYPERVISOR_xsm_op ( %d )", op->cmd);
+ PRINT("__HYPERVISOR_xsm_op ( %u )", op->cmd);
/*
* Common part of xen_flask_op:
PRE(sched_op)
{
- PRINT("__HYPERVISOR_sched_op ( %ld, %lx )", ARG1, ARG2);
+ PRINT("__HYPERVISOR_sched_op ( %ld, %#lx )", SARG1, ARG2);
void *arg = (void *)(unsigned long)ARG2;
#define __PRE_XEN_SCHEDOP_READ(_schedop, _type, _field) \
/*OUT*/UWord* flags,
__vki_u32 cmd, void *arg, int compat)
{
- PRINT("__HYPERVISOR_event_channel_op%s ( %d, %p )",
+ PRINT("__HYPERVISOR_event_channel_op%s ( %u, %p )",
compat ? "_compat" : "", cmd, arg);
switch (cmd) {
{
int cmd = ARG1;
- PRINT("__HYPERVISOR_physdev_op ( %ld, %lx )", ARG1, ARG2);
+ PRINT("__HYPERVISOR_physdev_op ( %ld, %#lx )", SARG1, ARG2);
#define PRE_XEN_PHYSDEVOP_READ(_op, _field) \
PRE_MEM_READ("XEN_PHYSDEVOP_" #_op " ." #_field, \
PRE(xen_version)
{
- PRINT("__HYPERVISOR_xen_version ( %ld, %lx )", ARG1, ARG2);
+ PRINT("__HYPERVISOR_xen_version ( %ld, %#lx )", SARG1, ARG2);
switch (ARG1) {
case VKI_XENVER_version:
PRE(grant_table_op)
{
- PRINT("__HYPERVISOR_grant_table_op ( %ld, 0x%lx, %ld )", ARG1, ARG2, ARG3);
+ PRINT("__HYPERVISOR_grant_table_op ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
switch (ARG1) {
case VKI_XEN_GNTTABOP_setup_table: {
struct vki_xen_gnttab_setup_table *gst =
PRE(sysctl) {
struct vki_xen_sysctl *sysctl = (struct vki_xen_sysctl *)ARG1;
- PRINT("__HYPERVISOR_sysctl ( %d )", sysctl->cmd);
+ PRINT("__HYPERVISOR_sysctl ( %u )", sysctl->cmd);
/*
* Common part of xen_sysctl:
{
struct vki_xen_domctl *domctl = (struct vki_xen_domctl *)ARG1;
- PRINT("__HYPERVISOR_domctl ( %d ) on dom%d", domctl->cmd, domctl->domain);
+ PRINT("__HYPERVISOR_domctl ( %u ) on dom%d", domctl->cmd, domctl->domain);
/*
* Common part of xen_domctl:
unsigned long op = ARG1;
void *arg = (void *)(unsigned long)ARG2;
- PRINT("__HYPERVISOR_hvm_op ( %ld, %p )", op, arg);
+ PRINT("__HYPERVISOR_hvm_op ( %ld, %#lx )", SARG1, ARG2);
#define __PRE_XEN_HVMOP_READ(_hvm_op, _type, _field) \
PRE_MEM_READ("XEN_HVMOP_" # _hvm_op " " #_field, \
{
struct vki_xen_tmem_op *tmem = (struct vki_xen_tmem_op *)ARG1;
- PRINT("__HYPERVISOR_tmem_op ( %d )", tmem->cmd);
+ PRINT("__HYPERVISOR_tmem_op ( %u )", tmem->cmd);
/* Common part for xen_tmem_op:
* vki_uint32_t cmd;
projects / thirdparty / valgrind.git / commitdiff
