PRE(sys_iopl)
{
- PRINT("sys_iopl ( %lu )", ARG1);
+ PRINT("sys_iopl ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "iopl", unsigned long, level);
}
PRE(sys_fsync)
{
*flags |= SfMayBlock;
- PRINT("sys_fsync ( %lu )", ARG1);
+ PRINT("sys_fsync ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "fsync", unsigned int, fd);
}
PRE(sys_fdatasync)
{
*flags |= SfMayBlock;
- PRINT("sys_fdatasync ( %lu )", ARG1);
+ PRINT("sys_fdatasync ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "fdatasync", unsigned int, fd);
}
PRE(sys_msync)
{
*flags |= SfMayBlock;
- PRINT("sys_msync ( %#lx, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_msync ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", 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 )", SARG1, ARG2, ARG3,
- ARG4, ARG5);
+ PRINT("sys_getpmsg ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x )", SARG1,
+ ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(int, "getpmsg",
int, fd, struct strbuf *, ctrl, struct strbuf *, data,
int *, bandp, int *, flagsp);
- ctrl = (struct vki_pmsg_strbuf *)ARG2;
- data = (struct vki_pmsg_strbuf *)ARG3;
+ ctrl = (struct vki_pmsg_strbuf *)(Addr)ARG2;
+ data = (struct vki_pmsg_strbuf *)(Addr)ARG3;
if (ctrl && ctrl->maxlen > 0)
PRE_MEM_WRITE( "getpmsg(ctrl)", (Addr)ctrl->buf, ctrl->maxlen);
if (data && data->maxlen > 0)
struct vki_pmsg_strbuf *ctrl;
struct vki_pmsg_strbuf *data;
vg_assert(SUCCESS);
- ctrl = (struct vki_pmsg_strbuf *)ARG2;
- data = (struct vki_pmsg_strbuf *)ARG3;
+ ctrl = (struct vki_pmsg_strbuf *)(Addr)ARG2;
+ data = (struct vki_pmsg_strbuf *)(Addr)ARG3;
if (RES == 0 && ctrl && ctrl->len > 0) {
POST_MEM_WRITE( (Addr)ctrl->buf, ctrl->len);
}
struct vki_pmsg_strbuf *ctrl;
struct vki_pmsg_strbuf *data;
*flags |= SfMayBlock;
- PRINT("sys_putpmsg ( %ld, %#lx, %#lx, %ld, %ld )", SARG1, ARG2, ARG3,
- SARG4, SARG5);
+ PRINT("sys_putpmsg ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD
+ "x, %ld, %ld )", SARG1, ARG2, ARG3, SARG4, SARG5);
PRE_REG_READ5(int, "putpmsg",
int, fd, struct strbuf *, ctrl, struct strbuf *, data,
int, band, int, flags);
- ctrl = (struct vki_pmsg_strbuf *)ARG2;
- data = (struct vki_pmsg_strbuf *)ARG3;
+ ctrl = (struct vki_pmsg_strbuf *)(Addr)ARG2;
+ data = (struct vki_pmsg_strbuf *)(Addr)ARG3;
if (ctrl && ctrl->len > 0)
PRE_MEM_READ( "putpmsg(ctrl)", (Addr)ctrl->buf, ctrl->len);
if (data && data->len > 0)
PRE(sys_getitimer)
{
- struct vki_itimerval *value = (struct vki_itimerval*)ARG2;
- PRINT("sys_getitimer ( %ld, %#lx )", SARG1, ARG2);
+ struct vki_itimerval *value = (struct vki_itimerval*)(Addr)ARG2;
+ PRINT("sys_getitimer ( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(long, "getitimer", int, which, struct itimerval *, value);
PRE_timeval_WRITE( "getitimer(&value->it_interval)", &(value->it_interval));
POST(sys_getitimer)
{
if (ARG2 != (Addr)NULL) {
- struct vki_itimerval *value = (struct vki_itimerval*)ARG2;
+ struct vki_itimerval *value = (struct vki_itimerval*)(Addr)ARG2;
POST_timeval_WRITE( &(value->it_interval) );
POST_timeval_WRITE( &(value->it_value) );
}
PRE(sys_setitimer)
{
- PRINT("sys_setitimer ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sys_setitimer ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setitimer",
int, which,
struct itimerval *, value, struct itimerval *, ovalue);
if (ARG2 != (Addr)NULL) {
- struct vki_itimerval *value = (struct vki_itimerval*)ARG2;
+ struct vki_itimerval *value = (struct vki_itimerval*)(Addr)ARG2;
PRE_timeval_READ( "setitimer(&value->it_interval)",
&(value->it_interval));
PRE_timeval_READ( "setitimer(&value->it_value)",
&(value->it_value));
}
if (ARG3 != (Addr)NULL) {
- struct vki_itimerval *ovalue = (struct vki_itimerval*)ARG3;
+ struct vki_itimerval *ovalue = (struct vki_itimerval*)(Addr)ARG3;
PRE_timeval_WRITE( "setitimer(&ovalue->it_interval)",
&(ovalue->it_interval));
PRE_timeval_WRITE( "setitimer(&ovalue->it_value)",
POST(sys_setitimer)
{
if (ARG3 != (Addr)NULL) {
- struct vki_itimerval *ovalue = (struct vki_itimerval*)ARG3;
+ struct vki_itimerval *ovalue = (struct vki_itimerval*)(Addr)ARG3;
POST_timeval_WRITE( &(ovalue->it_interval) );
POST_timeval_WRITE( &(ovalue->it_value) );
}
PRE(sys_chroot)
{
- PRINT("sys_chroot ( %#lx )", ARG1);
+ PRINT("sys_chroot ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "chroot", const char *, path);
PRE_MEM_RASCIIZ( "chroot(path)", ARG1 );
}
PRE(sys_madvise)
{
*flags |= SfMayBlock;
- PRINT("sys_madvise ( %#lx, %lu, %ld )", ARG1, ARG2, SARG3);
+ PRINT("sys_madvise ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %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, %lu, %lu, %#lx, %#lx )",
+ PRINT("sys_mremap ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
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, %lu, %lu, 0x%lx )",
+ PRINT("sys_mremap ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u, 0x%" FMT_REGWORD "x )",
ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(unsigned long, "mremap",
unsigned long, old_addr, unsigned long, old_size,
PRE(sys_mlock)
{
*flags |= SfMayBlock;
- PRINT("sys_mlock ( %#lx, %lu )", ARG1, ARG2);
+ PRINT("sys_mlock ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(long, "mlock", unsigned long, addr, vki_size_t, len);
}
PRE(sys_munlock)
{
*flags |= SfMayBlock;
- PRINT("sys_munlock ( %#lx, %lu )", ARG1, ARG2);
+ PRINT("sys_munlock ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(long, "munlock", unsigned long, addr, vki_size_t, len);
}
PRE(sys_mlockall)
{
*flags |= SfMayBlock;
- PRINT("sys_mlockall ( %lx )", ARG1);
+ PRINT("sys_mlockall ( %" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "mlockall", int, flags);
}
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_pwrite64 ( %lu, %#lx, %lu, %lld )",
- ARG1, ARG2, ARG3, (Long)MERGE64(ARG4,ARG5));
+ PRINT("sys_pwrite64 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u, %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));
PRE(sys_fstatfs)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fstatfs ( %lu, %#lx )", ARG1, ARG2);
+ PRINT("sys_fstatfs ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", 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 ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fstatfs64 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", 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 );
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_pread64 ( %lu, %#lx, %lu, %lld )",
- ARG1, ARG2, ARG3, (Long)MERGE64(ARG4,ARG5));
+ PRINT("sys_pread64 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u, %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));
PRE(sys_mknod)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_mknod ( %#lx(%s), %#lx, %#lx )", ARG1, (HChar*)ARG1, ARG2, ARG3 );
+ PRINT("sys_mknod ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1, (HChar*)(Addr)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 ( %lu, %lu )", ARG1, ARG2 );
+ PRINT("sys_flock ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2 );
PRE_REG_READ2(long, "flock", unsigned int, fd, unsigned int, operation);
}
SysRes res;
Bool setuid_allowed, trace_this_child;
- PRINT("sys_execve ( %#lx(%s), %#lx, %#lx )", ARG1, (HChar*)ARG1, ARG2, ARG3);
+ PRINT("sys_execve ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1, (HChar*)(Addr)ARG1, ARG2, ARG3);
PRE_REG_READ3(vki_off_t, "execve",
char *, filename, char **, argv, char **, envp);
PRE_MEM_RASCIIZ( "execve(filename)", ARG1 );
if (ARG2 != 0) {
/* At least the terminating NULL must be addressable. */
- if (!ML_(safe_to_deref)((HChar **) ARG2, sizeof(HChar *))) {
+ if (!ML_(safe_to_deref)((HChar **) (Addr)ARG2, sizeof(HChar *))) {
SET_STATUS_Failure(VKI_EFAULT);
return;
}
}
if (ARG3 != 0) {
/* At least the terminating NULL must be addressable. */
- if (!ML_(safe_to_deref)((HChar **) ARG3, sizeof(HChar *))) {
+ if (!ML_(safe_to_deref)((HChar **) (Addr)ARG3, sizeof(HChar *))) {
SET_STATUS_Failure(VKI_EFAULT);
return;
}
// debug-only printing
if (0) {
- VG_(printf)("ARG1 = %p(%s)\n", (void*)ARG1, (HChar*)ARG1);
+ VG_(printf)("ARG1 = %p(%s)\n", (void*)(Addr)ARG1, (HChar*)(Addr)ARG1);
if (ARG2) {
VG_(printf)("ARG2 = ");
Int q;
- HChar** vec = (HChar**)ARG2;
+ HChar** vec = (HChar**)(Addr)ARG2;
for (q = 0; vec[q]; q++)
VG_(printf)("%p(%s) ", vec[q], vec[q]);
VG_(printf)("\n");
// Decide whether or not we want to follow along
{ // Make 'child_argv' be a pointer to the child's arg vector
// (skipping the exe name)
- const HChar** child_argv = (const HChar**)ARG2;
+ const HChar** child_argv = (const HChar**)(Addr)ARG2;
if (child_argv && child_argv[0] == NULL)
child_argv = NULL;
- trace_this_child = VG_(should_we_trace_this_child)( (HChar*)ARG1, child_argv );
+ trace_this_child = VG_(should_we_trace_this_child)( (HChar*)(Addr)ARG1,
+ child_argv );
}
// Do the important checks: it is a file, is executable, permissions are
// ok, etc. We allow setuid executables to run only in the case when
// we are not simulating them, that is, they to be run natively.
setuid_allowed = trace_this_child ? False : True;
- res = VG_(pre_exec_check)((const HChar *)ARG1, NULL, setuid_allowed);
+ res = VG_(pre_exec_check)((const HChar *)(Addr)ARG1, NULL, setuid_allowed);
if (sr_isError(res)) {
SET_STATUS_Failure( sr_Err(res) );
return;
}
/* After this point, we can't recover if the execve fails. */
- VG_(debugLog)(1, "syswrap", "Exec of %s\n", (HChar*)ARG1);
+ VG_(debugLog)(1, "syswrap", "Exec of %s\n", (HChar*)(Addr)ARG1);
// Terminate gdbserver if it is active.
}
} else {
- path = (HChar*)ARG1;
+ path = (HChar*)(Addr)ARG1;
}
// Set up the child's environment.
if (ARG3 == 0) {
envp = NULL;
} else {
- envp = VG_(env_clone)( (HChar**)ARG3 );
+ envp = VG_(env_clone)( (HChar**)(Addr)ARG3 );
if (envp == NULL) goto hosed;
VG_(env_remove_valgrind_env_stuff)( envp, True /*ro_strings*/, NULL );
}
// are omitted.
//
if (!trace_this_child) {
- argv = (HChar**)ARG2;
+ argv = (HChar**)(Addr)ARG2;
} else {
vg_assert( VG_(args_for_valgrind) );
vg_assert( VG_(args_for_valgrind_noexecpass) >= 0 );
// name of client exe
tot_args++;
// args for client exe, skipping [0]
- arg2copy = (HChar**)ARG2;
+ arg2copy = (HChar**)(Addr)ARG2;
if (arg2copy && arg2copy[0]) {
for (i = 1; arg2copy[i]; i++)
tot_args++;
continue;
argv[j++] = * (HChar**) VG_(indexXA)( VG_(args_for_valgrind), i );
}
- argv[j++] = (HChar*)ARG1;
+ argv[j++] = (HChar*)(Addr)ARG1;
if (arg2copy && arg2copy[0])
for (i = 1; arg2copy[i]; i++)
argv[j++] = arg2copy[i];
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 %lu\n",
- ARG1, (HChar*)ARG1, ARG2, ARG3, ERR);
+ VG_(message)(Vg_UserMsg, "execve(%#" FMT_REGWORD "x(%s), %#" FMT_REGWORD
+ "x, %#" FMT_REGWORD "x) failed, errno %lu\n",
+ ARG1, (HChar*)(Addr)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, (HChar*)ARG1, SARG2);
+ PRINT("sys_access ( %#" FMT_REGWORD "x(%s), %ld )", ARG1,
+ (HChar*)(Addr)ARG1, SARG2);
PRE_REG_READ2(long, "access", const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "access(pathname)", ARG1 );
}
PRE(sys_alarm)
{
- PRINT("sys_alarm ( %lu )", ARG1);
+ PRINT("sys_alarm ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(unsigned long, "alarm", unsigned int, seconds);
}
Both will seg fault if you shrink it back into a text segment.
*/
- PRINT("sys_brk ( %#lx )", ARG1);
+ PRINT("sys_brk ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(unsigned long, "brk", unsigned long, end_data_segment);
brk_new = do_brk(ARG1, tid);
PRE(sys_chdir)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_chdir ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sys_chdir ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)(Addr)ARG1);
PRE_REG_READ1(long, "chdir", const char *, path);
PRE_MEM_RASCIIZ( "chdir(path)", ARG1 );
}
PRE(sys_chmod)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_chmod ( %#lx(%s), %lu )", ARG1, (HChar*)ARG1, ARG2);
+ PRINT("sys_chmod ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )", ARG1,
+ (HChar*)(Addr)ARG1, ARG2);
PRE_REG_READ2(long, "chmod", const char *, path, vki_mode_t, mode);
PRE_MEM_RASCIIZ( "chmod(path)", ARG1 );
}
PRE(sys_chown)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_chown ( %#lx(%s), 0x%lx, 0x%lx )", ARG1,(char*)ARG1,ARG2,ARG3);
+ PRINT("sys_chown ( %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", ARG1,(char*)(Addr)ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "chown",
const char *, path, vki_uid_t, owner, vki_gid_t, group);
PRE_MEM_RASCIIZ( "chown(path)", ARG1 );
PRE(sys_lchown)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_lchown ( %#lx(%s), 0x%lx, 0x%lx )", ARG1,(char*)ARG1,ARG2,ARG3);
+ PRINT("sys_lchown ( %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", ARG1,(char*)(Addr)ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "lchown",
const char *, path, vki_uid_t, owner, vki_gid_t, group);
PRE_MEM_RASCIIZ( "lchown(path)", ARG1 );
PRE(sys_close)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_close ( %lu )", ARG1);
+ PRINT("sys_close ( %" FMT_REGWORD "u )", 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 ( %lu )", ARG1);
+ PRINT("sys_dup ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "dup", unsigned int, oldfd);
}
PRE(sys_dup2)
{
- PRINT("sys_dup2 ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_dup2 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", 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 ( %lu )", ARG1);
+ PRINT("sys_fchdir ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "fchdir", unsigned int, fd);
}
PRE(sys_fchown)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_fchown ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fchown ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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 ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_fchmod ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(long, "fchmod", unsigned int, fildes, vki_mode_t, mode);
}
PRE(sys_newfstat)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_newfstat ( %lu, %#lx )", ARG1, ARG2);
+ PRINT("sys_newfstat ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", 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 ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_ftruncate ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(long, "ftruncate", unsigned int, fd, unsigned long, length);
}
PRE(sys_truncate)
{
*flags |= SfMayBlock;
- PRINT("sys_truncate ( %#lx(%s), %lu )", ARG1, (HChar*)ARG1, ARG2);
+ PRINT("sys_truncate ( %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",
+ ARG1, (HChar*)(Addr)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 ( %lu, %llu )", ARG1, MERGE64(ARG2,ARG3));
+ PRINT("sys_ftruncate64 ( %" FMT_REGWORD "u, %llu )", ARG1,
+ MERGE64(ARG2,ARG3));
PRE_REG_READ3(long, "ftruncate64",
unsigned int, fd,
UWord, MERGE64_FIRST(length), UWord, MERGE64_SECOND(length));
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_truncate64 ( %#lx, %lld )", ARG1, (Long)MERGE64(ARG2, ARG3));
+ PRINT("sys_truncate64 ( %#" FMT_REGWORD "x, %lld )", ARG1,
+ (Long)MERGE64(ARG2, ARG3));
PRE_REG_READ3(long, "truncate64",
const char *, path,
UWord, MERGE64_FIRST(length), UWord, MERGE64_SECOND(length));
PRE(sys_getdents)
{
*flags |= SfMayBlock;
- PRINT("sys_getdents ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_getdents ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u )", 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 ( %lu, %#lx, %lu )",ARG1, ARG2, ARG3);
+ PRINT("sys_getdents64 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )",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 )", SARG1, ARG2);
+ PRINT("sys_getgroups ( %ld, %#" FMT_REGWORD "x )", 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) );
// (which includes the ending '\0' character), or a negative error
// value.
// Is this Linux-specific? If so it should be moved to syswrap-linux.c.
- PRINT("sys_getcwd ( %#lx, %llu )", ARG1,(ULong)ARG2);
+ PRINT("sys_getcwd ( %#" FMT_REGWORD "x, %llu )", ARG1,(ULong)ARG2);
PRE_REG_READ2(long, "getcwd", char *, buf, unsigned long, size);
PRE_MEM_WRITE( "getcwd(buf)", ARG1, ARG2 );
}
PRE(sys_old_getrlimit)
{
- PRINT("sys_old_getrlimit ( %lu, %#lx )", ARG1, ARG2);
+ PRINT("sys_old_getrlimit ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
+ 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 ( %lu, %#lx )", ARG1, ARG2);
+ PRINT("sys_getrlimit ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", 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 )", SARG1, ARG2);
+ PRINT("sys_getrusage ( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(long, "getrusage", int, who, struct rusage *, usage);
PRE_MEM_WRITE( "getrusage(usage)", ARG2, sizeof(struct vki_rusage) );
}
PRE(sys_gettimeofday)
{
- PRINT("sys_gettimeofday ( %#lx, %#lx )", ARG1,ARG2);
+ PRINT("sys_gettimeofday ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ ARG1,ARG2);
PRE_REG_READ2(long, "gettimeofday",
struct timeval *, tv, struct timezone *, tz);
// GrP fixme does darwin write to *tz anymore?
if (ARG1 != 0)
- PRE_timeval_WRITE( "gettimeofday(tv)", ARG1 );
+ PRE_timeval_WRITE( "gettimeofday(tv)", (Addr)ARG1 );
if (ARG2 != 0)
PRE_MEM_WRITE( "gettimeofday(tz)", ARG2, sizeof(struct vki_timezone) );
}
vg_assert(SUCCESS);
if (RES == 0) {
if (ARG1 != 0)
- POST_timeval_WRITE( ARG1 );
+ POST_timeval_WRITE( (Addr)ARG1 );
if (ARG2 != 0)
POST_MEM_WRITE( ARG2, sizeof(struct vki_timezone) );
}
PRE(sys_settimeofday)
{
- PRINT("sys_settimeofday ( %#lx, %#lx )", ARG1,ARG2);
+ PRINT("sys_settimeofday ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ ARG1,ARG2);
PRE_REG_READ2(long, "settimeofday",
struct timeval *, tv, struct timezone *, tz);
if (ARG1 != 0)
- PRE_timeval_READ( "settimeofday(tv)", ARG1 );
+ PRE_timeval_READ( "settimeofday(tv)", (Addr)ARG1 );
if (ARG2 != 0) {
PRE_MEM_READ( "settimeofday(tz)", ARG2, sizeof(struct vki_timezone) );
/* maybe should warn if tz->tz_dsttime is non-zero? */
PRE(sys_link)
{
*flags |= SfMayBlock;
- PRINT("sys_link ( %#lx(%s), %#lx(%s) )", ARG1,(char*)ARG1,ARG2,(char*)ARG2);
+ PRINT("sys_link ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s) )", ARG1,
+ (char*)(Addr)ARG1,ARG2,(char*)(Addr)ARG2);
PRE_REG_READ2(long, "link", const char *, oldpath, const char *, newpath);
PRE_MEM_RASCIIZ( "link(oldpath)", ARG1);
PRE_MEM_RASCIIZ( "link(newpath)", ARG2);
PRE(sys_newlstat)
{
- PRINT("sys_newlstat ( %#lx(%s), %#lx )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_newlstat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )", ARG1,
+ (char*)(Addr)ARG1,ARG2);
PRE_REG_READ2(long, "lstat", char *, file_name, struct stat *, buf);
PRE_MEM_RASCIIZ( "lstat(file_name)", ARG1 );
PRE_MEM_WRITE( "lstat(buf)", ARG2, sizeof(struct vki_stat) );
PRE(sys_mkdir)
{
*flags |= SfMayBlock;
- PRINT("sys_mkdir ( %#lx(%s), %ld )", ARG1, (HChar*)ARG1, SARG2);
+ PRINT("sys_mkdir ( %#" FMT_REGWORD "x(%s), %ld )", ARG1,
+ (HChar*)(Addr)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, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_mprotect ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "mprotect",
unsigned long, addr, vki_size_t, len, unsigned long, prot);
PRE(sys_munmap)
{
- if (0) VG_(printf)(" munmap( %#lx )\n", ARG1);
- PRINT("sys_munmap ( %#lx, %llu )", ARG1,(ULong)ARG2);
+ if (0) VG_(printf)(" munmap( %#" FMT_REGWORD "x )\n", ARG1);
+ PRINT("sys_munmap ( %#" FMT_REGWORD "x, %llu )", ARG1,(ULong)ARG2);
PRE_REG_READ2(long, "munmap", unsigned long, start, vki_size_t, length);
if (!ML_(valid_client_addr)(ARG1, ARG2, tid, "munmap"))
PRE(sys_mincore)
{
- PRINT("sys_mincore ( %#lx, %llu, %#lx )", ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_mincore ( %#" FMT_REGWORD "x, %llu, %#" FMT_REGWORD "x )",
+ ARG1, (ULong)ARG2, ARG3);
PRE_REG_READ3(long, "mincore",
unsigned long, start, vki_size_t, length,
unsigned char *, vec);
PRE(sys_nanosleep)
{
*flags |= SfMayBlock|SfPostOnFail;
- PRINT("sys_nanosleep ( %#lx, %#lx )", ARG1,ARG2);
+ PRINT("sys_nanosleep ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(long, "nanosleep",
struct timespec *, req, struct timespec *, rem);
PRE_MEM_READ( "nanosleep(req)", ARG1, sizeof(struct vki_timespec) );
{
if (ARG2 & VKI_O_CREAT) {
// 3-arg version
- PRINT("sys_open ( %#lx(%s), %ld, %ld )",ARG1, (HChar*)ARG1, SARG2, SARG3);
+ PRINT("sys_open ( %#" FMT_REGWORD "x(%s), %ld, %ld )",ARG1,
+ (HChar*)(Addr)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, (HChar*)ARG1, SARG2);
+ PRINT("sys_open ( %#" FMT_REGWORD "x(%s), %ld )",ARG1,
+ (HChar*)(Addr)ARG1, SARG2);
PRE_REG_READ2(long, "open",
const char *, filename, int, flags);
}
cloned fd back to the start. */
{
HChar name[30]; // large enough
- HChar* arg1s = (HChar*) ARG1;
+ HChar* arg1s = (HChar*) (Addr)ARG1;
SysRes sres;
VG_(sprintf)(name, "/proc/%d/cmdline", VG_(getpid)());
}
/* Handle also the case of /proc/self/auxv or /proc/<pid>/auxv. */
- if (ML_(handle_auxv_open)(status, (const HChar *)ARG1, ARG2))
+ if (ML_(handle_auxv_open)(status, (const HChar *)(Addr)ARG1, ARG2))
return;
#endif // defined(VGO_linux)
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)(Addr)ARG1);
}
}
PRE(sys_read)
{
*flags |= SfMayBlock;
- PRINT("sys_read ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_read ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", 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 ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_write ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", 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, (HChar*)ARG1, SARG2);
+ PRINT("sys_creat ( %#" FMT_REGWORD "x(%s), %ld )", ARG1,
+ (HChar*)(Addr)ARG1, SARG2);
PRE_REG_READ2(long, "creat", const char *, pathname, int, mode);
PRE_MEM_RASCIIZ( "creat(pathname)", ARG1 );
}
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)(Addr)ARG1);
}
}
int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
*/
UInt i;
- struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+ struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;
*flags |= SfMayBlock;
- PRINT("sys_poll ( %#lx, %lu, %ld )\n", ARG1, ARG2, SARG3);
+ PRINT("sys_poll ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %ld )\n",
+ ARG1, ARG2, SARG3);
PRE_REG_READ3(long, "poll",
struct vki_pollfd *, ufds, unsigned int, nfds, long, timeout);
{
if (RES >= 0) {
UInt i;
- struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+ struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;
for (i = 0; i < ARG2; i++)
POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
}
FUSE_COMPATIBLE_MAY_BLOCK();
Word saved = SYSNO;
- PRINT("sys_readlink ( %#lx(%s), %#lx, %llu )", ARG1,(char*)ARG1,ARG2,(ULong)ARG3);
+ PRINT("sys_readlink ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %llu )",
+ ARG1, (char*)(Addr)ARG1, ARG2, (ULong)ARG3);
PRE_REG_READ3(long, "readlink",
const char *, path, char *, buf, int, bufsiz);
PRE_MEM_RASCIIZ( "readlink(path)", ARG1 );
* /proc/<pid>/exe, or equivalent on Solaris.
*/
HChar name[30]; // large enough
- HChar* arg1s = (HChar*) ARG1;
+ HChar* arg1s = (HChar*) (Addr)ARG1;
VG_(sprintf)(name, PID_EXEPATH, VG_(getpid)());
if (ML_(safe_to_deref)(arg1s, 1)
&& (VG_STREQ(arg1s, name) || VG_STREQ(arg1s, SELF_EXEPATH))) {
Int i;
struct vki_iovec * vec;
*flags |= SfMayBlock;
- PRINT("sys_readv ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_readv ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "readv",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count);
if (ARG2 != 0) {
/* ToDo: don't do any of the following if the vector is invalid */
- vec = (struct vki_iovec *)ARG2;
+ vec = (struct vki_iovec *)(Addr)ARG2;
for (i = 0; i < (Int)ARG3; i++)
PRE_MEM_WRITE( "readv(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
vg_assert(SUCCESS);
if (RES > 0) {
Int i;
- struct vki_iovec * vec = (struct vki_iovec *)ARG2;
+ struct vki_iovec * vec = (struct vki_iovec *)(Addr)ARG2;
Int remains = RES;
/* RES holds the number of bytes read. */
PRE(sys_rename)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_rename ( %#lx(%s), %#lx(%s) )", ARG1,(char*)ARG1,ARG2,(char*)ARG2);
+ PRINT("sys_rename ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s) )", ARG1,
+ (char*)(Addr)ARG1,ARG2,(char*)(Addr)ARG2);
PRE_REG_READ2(long, "rename", const char *, oldpath, const char *, newpath);
PRE_MEM_RASCIIZ( "rename(oldpath)", ARG1 );
PRE_MEM_RASCIIZ( "rename(newpath)", ARG2 );
PRE(sys_rmdir)
{
*flags |= SfMayBlock;
- PRINT("sys_rmdir ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sys_rmdir ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)(Addr)ARG1);
PRE_REG_READ1(long, "rmdir", const char *, pathname);
PRE_MEM_RASCIIZ( "rmdir(pathname)", ARG1 );
}
PRE(sys_select)
{
*flags |= SfMayBlock;
- PRINT("sys_select ( %ld, %#lx, %#lx, %#lx, %#lx )", SARG1, ARG2, ARG3,
- ARG4, ARG5);
+ PRINT("sys_select ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x )", 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_MEM_READ( "select(exceptfds)",
ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );
if (ARG5 != 0)
- PRE_timeval_READ( "select(timeout)", ARG5 );
+ PRE_timeval_READ( "select(timeout)", (Addr)ARG5 );
}
PRE(sys_setgid)
{
- PRINT("sys_setgid ( %lu )", ARG1);
+ PRINT("sys_setgid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setgid", vki_gid_t, gid);
}
PRE(sys_setgroups)
{
- PRINT("setgroups ( %llu, %#lx )", (ULong)ARG1, ARG2);
+ PRINT("setgroups ( %llu, %#" FMT_REGWORD "x )", (ULong)ARG1, ARG2);
PRE_REG_READ2(long, "setgroups", int, size, vki_gid_t *, list);
if (ARG1 > 0)
PRE_MEM_READ( "setgroups(list)", ARG2, ARG1 * sizeof(vki_gid_t) );
PRE(sys_setregid)
{
- PRINT("sys_setregid ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_setregid ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", ARG1, ARG2);
PRE_REG_READ2(long, "setregid", vki_gid_t, rgid, vki_gid_t, egid);
}
PRE(sys_setreuid)
{
- PRINT("sys_setreuid ( 0x%lx, 0x%lx )", ARG1, ARG2);
+ PRINT("sys_setreuid ( 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )",
+ ARG1, ARG2);
PRE_REG_READ2(long, "setreuid", vki_uid_t, ruid, vki_uid_t, euid);
}
PRE(sys_setrlimit)
{
UWord arg1 = ARG1;
- PRINT("sys_setrlimit ( %lu, %#lx )", ARG1, ARG2);
+ PRINT("sys_setrlimit ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(long, "setrlimit",
unsigned int, resource, struct rlimit *, rlim);
PRE_MEM_READ( "setrlimit(rlim)", ARG2, sizeof(struct vki_rlimit) );
VKI_PROT_READ)) {
SET_STATUS_Failure( VKI_EFAULT );
}
- else if (((struct vki_rlimit *)ARG2)->rlim_cur
- > ((struct vki_rlimit *)ARG2)->rlim_max) {
+ else if (((struct vki_rlimit *)(Addr)ARG2)->rlim_cur
+ > ((struct vki_rlimit *)(Addr)ARG2)->rlim_max) {
SET_STATUS_Failure( VKI_EINVAL );
}
else if (arg1 == VKI_RLIMIT_NOFILE) {
- if (((struct vki_rlimit *)ARG2)->rlim_cur > VG_(fd_hard_limit) ||
- ((struct vki_rlimit *)ARG2)->rlim_max != VG_(fd_hard_limit)) {
+ if (((struct vki_rlimit *)(Addr)ARG2)->rlim_cur > VG_(fd_hard_limit) ||
+ ((struct vki_rlimit *)(Addr)ARG2)->rlim_max != VG_(fd_hard_limit)) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
- VG_(fd_soft_limit) = ((struct vki_rlimit *)ARG2)->rlim_cur;
+ VG_(fd_soft_limit) = ((struct vki_rlimit *)(Addr)ARG2)->rlim_cur;
SET_STATUS_Success( 0 );
}
}
else if (arg1 == VKI_RLIMIT_DATA) {
- if (((struct vki_rlimit *)ARG2)->rlim_cur > VG_(client_rlimit_data).rlim_max ||
- ((struct vki_rlimit *)ARG2)->rlim_max > VG_(client_rlimit_data).rlim_max) {
+ if (((struct vki_rlimit *)(Addr)ARG2)->rlim_cur
+ > VG_(client_rlimit_data).rlim_max ||
+ ((struct vki_rlimit *)(Addr)ARG2)->rlim_max
+ > VG_(client_rlimit_data).rlim_max) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
- VG_(client_rlimit_data) = *(struct vki_rlimit *)ARG2;
+ VG_(client_rlimit_data) = *(struct vki_rlimit *)(Addr)ARG2;
SET_STATUS_Success( 0 );
}
}
else if (arg1 == VKI_RLIMIT_STACK && tid == 1) {
- if (((struct vki_rlimit *)ARG2)->rlim_cur > VG_(client_rlimit_stack).rlim_max ||
- ((struct vki_rlimit *)ARG2)->rlim_max > VG_(client_rlimit_stack).rlim_max) {
+ if (((struct vki_rlimit *)(Addr)ARG2)->rlim_cur
+ > VG_(client_rlimit_stack).rlim_max ||
+ ((struct vki_rlimit *)(Addr)ARG2)->rlim_max
+ > VG_(client_rlimit_stack).rlim_max) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
TODO: All platforms should set VG_(clstk_max_size) as part of their
setup_client_stack(). */
if ((VG_(clstk_max_size) == 0)
- || (((struct vki_rlimit *) ARG2)->rlim_cur <= VG_(clstk_max_size)))
- VG_(threads)[tid].client_stack_szB = ((struct vki_rlimit *)ARG2)->rlim_cur;
+ || (((struct vki_rlimit *) (Addr)ARG2)->rlim_cur <= VG_(clstk_max_size)))
+ VG_(threads)[tid].client_stack_szB = ((struct vki_rlimit *)(Addr)ARG2)->rlim_cur;
- VG_(client_rlimit_stack) = *(struct vki_rlimit *)ARG2;
+ VG_(client_rlimit_stack) = *(struct vki_rlimit *)(Addr)ARG2;
SET_STATUS_Success( 0 );
}
}
PRE(sys_setuid)
{
- PRINT("sys_setuid ( %lu )", ARG1);
+ PRINT("sys_setuid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setuid", vki_uid_t, uid);
}
PRE(sys_newstat)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_newstat ( %#lx(%s), %#lx )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_newstat ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",
+ ARG1,(char*)(Addr)ARG1,ARG2);
PRE_REG_READ2(long, "stat", char *, file_name, struct stat *, buf);
PRE_MEM_RASCIIZ( "stat(file_name)", ARG1 );
PRE_MEM_WRITE( "stat(buf)", ARG2, sizeof(struct vki_stat) );
PRE(sys_statfs)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_statfs ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_statfs ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",
+ ARG1, (char*)(Addr)ARG1, ARG2);
PRE_REG_READ2(long, "statfs", const char *, path, struct statfs *, buf);
PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_statfs) );
PRE(sys_statfs64)
{
- PRINT("sys_statfs64 ( %#lx(%s), %llu, %#lx )",ARG1,(char*)ARG1,(ULong)ARG2,ARG3);
+ PRINT("sys_statfs64 ( %#" FMT_REGWORD "x(%s), %llu, %#" FMT_REGWORD "x )",
+ ARG1, (char*)(Addr)ARG1, (ULong)ARG2, ARG3);
PRE_REG_READ3(long, "statfs64",
const char *, path, vki_size_t, size, struct statfs64 *, buf);
PRE_MEM_RASCIIZ( "statfs64(path)", ARG1 );
PRE(sys_symlink)
{
*flags |= SfMayBlock;
- PRINT("sys_symlink ( %#lx(%s), %#lx(%s) )",ARG1,(char*)ARG1,ARG2,(char*)ARG2);
+ PRINT("sys_symlink ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s) )",
+ ARG1, (char*)(Addr)ARG1, ARG2, (char*)(Addr)ARG2);
PRE_REG_READ2(long, "symlink", const char *, oldpath, const char *, newpath);
PRE_MEM_RASCIIZ( "symlink(oldpath)", ARG1 );
PRE_MEM_RASCIIZ( "symlink(newpath)", ARG2 );
PRE(sys_time)
{
/* time_t time(time_t *t); */
- PRINT("sys_time ( %#lx )",ARG1);
+ PRINT("sys_time ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(long, "time", int *, t);
if (ARG1 != 0) {
PRE_MEM_WRITE( "time(t)", ARG1, sizeof(vki_time_t) );
PRE(sys_times)
{
- PRINT("sys_times ( %#lx )", ARG1);
+ PRINT("sys_times ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "times", struct tms *, buf);
if (ARG1 != 0) {
PRE_MEM_WRITE( "times(buf)", ARG1, sizeof(struct vki_tms) );
PRE(sys_unlink)
{
*flags |= SfMayBlock;
- PRINT("sys_unlink ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sys_unlink ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)(Addr)ARG1);
PRE_REG_READ1(long, "unlink", const char *, pathname);
PRE_MEM_RASCIIZ( "unlink(pathname)", ARG1 );
}
PRE(sys_newuname)
{
- PRINT("sys_newuname ( %#lx )", ARG1);
+ PRINT("sys_newuname ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "uname", struct new_utsname *, buf);
PRE_MEM_WRITE( "uname(buf)", ARG1, sizeof(struct vki_new_utsname) );
}
PRE(sys_waitpid)
{
*flags |= SfMayBlock;
- PRINT("sys_waitpid ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_waitpid ( %ld, %#" FMT_REGWORD "x, %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 )", SARG1, ARG2, SARG3, ARG4);
+ PRINT("sys_wait4 ( %ld, %#" FMT_REGWORD "x, %ld, %#" FMT_REGWORD "x )",
+ 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 ( %lu, %#lx, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_writev ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(ssize_t, "writev",
unsigned long, fd, const struct iovec *, vector,
unsigned long, count);
ARG2, ARG3 * sizeof(struct vki_iovec) );
if (ARG2 != 0) {
/* ToDo: don't do any of the following if the vector is invalid */
- vec = (struct vki_iovec *)ARG2;
+ vec = (struct vki_iovec *)(Addr)ARG2;
for (i = 0; i < (Int)ARG3; i++)
PRE_MEM_READ( "writev(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
PRE(sys_utimes)
{
FUSE_COMPATIBLE_MAY_BLOCK();
- PRINT("sys_utimes ( %#lx(%s), %#lx )", ARG1,(char*)ARG1,ARG2);
+ PRINT("sys_utimes ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",
+ ARG1, (char*)(Addr)ARG1, ARG2);
PRE_REG_READ2(long, "utimes", char *, filename, struct timeval *, tvp);
PRE_MEM_RASCIIZ( "utimes(filename)", ARG1 );
if (ARG2 != 0) {
- PRE_timeval_READ( "utimes(tvp[0])", ARG2 );
- PRE_timeval_READ( "utimes(tvp[1])", ARG2+sizeof(struct vki_timeval) );
+ PRE_timeval_READ( "utimes(tvp[0])", (Addr)ARG2 );
+ PRE_timeval_READ( "utimes(tvp[1])",
+ (Addr)ARG2+sizeof(struct vki_timeval) );
}
}
PRE(sys_acct)
{
- PRINT("sys_acct ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sys_acct ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)(Addr)ARG1);
PRE_REG_READ1(long, "acct", const char *, filename);
PRE_MEM_RASCIIZ( "acct(filename)", ARG1 );
}
PRE(sys_sigaltstack)
{
- PRINT("sigaltstack ( %#lx, %#lx )",ARG1,ARG2);
+ PRINT("sigaltstack ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",ARG1,ARG2);
PRE_REG_READ2(int, "sigaltstack",
const vki_stack_t *, ss, vki_stack_t *, oss);
if (ARG1 != 0) {
- const vki_stack_t *ss = (vki_stack_t *)ARG1;
+ const vki_stack_t *ss = (vki_stack_t *)(Addr)ARG1;
PRE_MEM_READ( "sigaltstack(ss)", (Addr)&ss->ss_sp, sizeof(ss->ss_sp) );
PRE_MEM_READ( "sigaltstack(ss)", (Addr)&ss->ss_flags, sizeof(ss->ss_flags) );
PRE_MEM_READ( "sigaltstack(ss)", (Addr)&ss->ss_size, sizeof(ss->ss_size) );
}
/* Be safe. */
- if (ARG1 && !ML_(safe_to_deref((void*)ARG1, sizeof(vki_stack_t)))) {
+ if (ARG1 && !ML_(safe_to_deref((void*)(Addr)ARG1, sizeof(vki_stack_t)))) {
SET_STATUS_Failure(VKI_EFAULT);
return;
}
- if (ARG2 && !ML_(safe_to_deref((void*)ARG2, sizeof(vki_stack_t)))) {
+ if (ARG2 && !ML_(safe_to_deref((void*)(Addr)ARG2, sizeof(vki_stack_t)))) {
SET_STATUS_Failure(VKI_EFAULT);
return;
}
SET_STATUS_from_SysRes(
- VG_(do_sys_sigaltstack) (tid, (vki_stack_t*)ARG1,
- (vki_stack_t*)ARG2)
+ VG_(do_sys_sigaltstack) (tid, (vki_stack_t*)(Addr)ARG1,
+ (vki_stack_t*)(Addr)ARG2)
);
}
POST(sys_sigaltstack)
PRE(sys_sethostname)
{
- PRINT("sys_sethostname ( %#lx, %ld )", ARG1, SARG2);
+ PRINT("sys_sethostname ( %#" FMT_REGWORD "x, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "sethostname", char *, name, int, len);
PRE_MEM_READ( "sethostname(name)", ARG1, ARG2 );
}
UInt cloneflags;
Bool badarg = False;
- PRINT("sys_clone ( %lx, %#lx, %#lx, %#lx, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_clone ( %" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD
+ "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3,
+ ARG4, ARG5);
// Order of arguments differs between platforms.
#if defined(VGP_x86_linux) \
do_clone(tid,
ARG_FLAGS, /* flags */
(Addr)ARG_CHILD_STACK, /* child ESP */
- (Int*)ARG3, /* parent_tidptr */
- (Int*)ARG_CHILD_TIDPTR, /* child_tidptr */
+ (Int*)(Addr)ARG3, /* parent_tidptr */
+ (Int*)(Addr)ARG_CHILD_TIDPTR, /* child_tidptr */
(Addr)ARG_TLS)); /* set_tls */
break;
SET_STATUS_from_SysRes(
ML_(do_fork_clone)(tid,
cloneflags, /* flags */
- (Int*)ARG3, /* parent_tidptr */
- (Int*)ARG_CHILD_TIDPTR, /* child_tidptr */
+ (Int*)(Addr)ARG3, /* parent_tidptr */
+ (Int*)(Addr)ARG_CHILD_TIDPTR, /* child_tidptr */
(Addr)ARG_CHILD_STACK));
break;
default:
/* should we just ENOSYS? */
- VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%lx\n", ARG_FLAGS);
+ VG_(message)(Vg_UserMsg, "Unsupported clone() flags: 0x%" FMT_REGWORD
+ "x\n", ARG_FLAGS);
VG_(message)(Vg_UserMsg, "\n");
VG_(message)(Vg_UserMsg, "The only supported clone() uses are:\n");
VG_(message)(Vg_UserMsg, " - via a threads library (LinuxThreads or NPTL)\n");
// We are conservative and check everything, except the memory pointed to
// by 'data'.
*flags |= SfMayBlock;
- PRINT("sys_mount( %#lx(%s), %#lx(%s), %#lx(%s), %#lx, %#lx )",
- ARG1,(HChar*)ARG1, ARG2,(HChar*)ARG2, ARG3,(HChar*)ARG3, ARG4, ARG5);
+ PRINT("sys_mount( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s), %#"
+ FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ ARG1, (HChar*)(Addr)ARG1, ARG2, (HChar*)(Addr)ARG2, ARG3,
+ (HChar*)(Addr)ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "mount",
char *, source, char *, target, char *, type,
unsigned long, flags, void *, data);
PRE(sys_oldumount)
{
- PRINT("sys_oldumount( %#lx )", ARG1);
+ PRINT("sys_oldumount( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "umount", char *, path);
PRE_MEM_RASCIIZ( "umount(path)", ARG1);
}
PRE(sys_umount)
{
- PRINT("sys_umount( %#lx, %ld )", ARG1, SARG2);
+ PRINT("sys_umount( %#" FMT_REGWORD "x, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "umount2", char *, path, int, flags);
PRE_MEM_RASCIIZ( "umount2(path)", ARG1);
}
*/
PRE(sys_pivot_root)
{
- PRINT("sys_pivot_root ( %s %s )", (HChar*)ARG1, (HChar*)ARG2);
+ PRINT("sys_pivot_root ( %s %s )", (HChar*)(Addr)ARG1, (HChar*)(Addr)ARG2);
PRE_REG_READ2(int, "pivot_root", char *, new_root, char *, old_root);
PRE_MEM_RASCIIZ( "pivot_root(new_root)", ARG1);
PRE_MEM_RASCIIZ( "pivot_root(old_root)", ARG2);
PRE(sys_setfsuid16)
{
- PRINT("sys_setfsuid16 ( %lu )", ARG1);
+ PRINT("sys_setfsuid16 ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setfsuid16", vki_old_uid_t, uid);
}
PRE(sys_setfsuid)
{
- PRINT("sys_setfsuid ( %lu )", ARG1);
+ PRINT("sys_setfsuid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setfsuid", vki_uid_t, uid);
}
PRE(sys_setfsgid16)
{
- PRINT("sys_setfsgid16 ( %lu )", ARG1);
+ PRINT("sys_setfsgid16 ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setfsgid16", vki_old_gid_t, gid);
}
PRE(sys_setfsgid)
{
- PRINT("sys_setfsgid ( %lu )", ARG1);
+ PRINT("sys_setfsgid ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setfsgid", vki_gid_t, gid);
}
PRE(sys_setresuid16)
{
- PRINT("sys_setresuid16 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresuid16 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresuid ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresuid",
vki_uid_t, ruid, vki_uid_t, euid, vki_uid_t, suid);
}
PRE(sys_getresuid16)
{
- PRINT("sys_getresuid16 ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_getresuid16 ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresuid16",
vki_old_uid_t *, ruid, vki_old_uid_t *, euid,
vki_old_uid_t *, suid);
PRE(sys_getresuid)
{
- PRINT("sys_getresuid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_getresuid ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresuid",
vki_uid_t *, ruid, vki_uid_t *, euid, vki_uid_t *, suid);
PRE_MEM_WRITE( "getresuid(ruid)", ARG1, sizeof(vki_uid_t) );
PRE(sys_setresgid16)
{
- PRINT("sys_setresgid16 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresgid16 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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 ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_setresgid ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "setresgid",
vki_gid_t, rgid, vki_gid_t, egid, vki_gid_t, sgid);
}
PRE(sys_getresgid16)
{
- PRINT("sys_getresgid16 ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_getresgid16 ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresgid16",
vki_old_gid_t *, rgid, vki_old_gid_t *, egid,
vki_old_gid_t *, sgid);
PRE(sys_getresgid)
{
- PRINT("sys_getresgid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_getresgid ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", ARG1,ARG2,ARG3);
PRE_REG_READ3(long, "getresgid",
vki_gid_t *, rgid, vki_gid_t *, egid, vki_gid_t *, sgid);
PRE_MEM_WRITE( "getresgid(rgid)", ARG1, sizeof(vki_gid_t) );
PRE(sys_llseek)
{
- PRINT("sys_llseek ( %lu, 0x%lx, 0x%lx, %#lx, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_llseek ( %" FMT_REGWORD "u, 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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_adjtimex)
{
- struct vki_timex *tx = (struct vki_timex *)ARG1;
- PRINT("sys_adjtimex ( %#lx )", ARG1);
+ struct vki_timex *tx = (struct vki_timex *)(Addr)ARG1;
+ PRINT("sys_adjtimex ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "adjtimex", struct timex *, buf);
if (ML_(safe_to_deref) (tx, sizeof(struct vki_timex))) {
PRE(sys_clock_adjtime)
{
- struct vki_timex *tx = (struct vki_timex *)ARG2;
- PRINT("sys_clock_adjtime ( %ld, %#lx )", SARG1,ARG2);
+ struct vki_timex *tx = (struct vki_timex *)(Addr)ARG2;
+ PRINT("sys_clock_adjtime ( %ld, %#" FMT_REGWORD "x )", 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 ( %lu, %lu, %ld )", ARG1, ARG2, SARG3 );
+ PRINT("sys_ioperm ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %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)", SARG1, ARG2, SARG3);
+ PRINT("sys_syslog (%ld, %#" FMT_REGWORD "x, %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_sysinfo)
{
- PRINT("sys_sysinfo ( %#lx )",ARG1);
+ PRINT("sys_sysinfo ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(long, "sysinfo", struct sysinfo *, info);
PRE_MEM_WRITE( "sysinfo(info)", ARG1, sizeof(struct vki_sysinfo) );
}
PRE(sys_sysctl)
{
struct __vki_sysctl_args *args;
- PRINT("sys_sysctl ( %#lx )", ARG1 );
- args = (struct __vki_sysctl_args *)ARG1;
+ PRINT("sys_sysctl ( %#" FMT_REGWORD "x )", ARG1 );
+ args = (struct __vki_sysctl_args *)(Addr)ARG1;
PRE_REG_READ1(long, "sysctl", struct __sysctl_args *, args);
PRE_MEM_WRITE( "sysctl(args)", ARG1, sizeof(struct __vki_sysctl_args) );
if (!VG_(am_is_valid_for_client)(ARG1, sizeof(struct __vki_sysctl_args),
POST(sys_sysctl)
{
struct __vki_sysctl_args *args;
- args = (struct __vki_sysctl_args *)ARG1;
+ args = (struct __vki_sysctl_args *)(Addr)ARG1;
if (args->oldlenp != NULL) {
POST_MEM_WRITE((Addr)args->oldlenp, sizeof(*args->oldlenp));
POST_MEM_WRITE((Addr)args->oldval, 1 + *args->oldlenp);
PRE_REG_READ2(int, "prctl", int, option, char *, name);
/* The name can be up to TASK_COMM_LEN(16) bytes long, including
the terminating null byte. So do not check more than 16 bytes. */
- if (ML_(safe_to_deref)((const HChar *) ARG2, VKI_TASK_COMM_LEN)) {
- SizeT len = VG_(strnlen)((const HChar *) ARG2, VKI_TASK_COMM_LEN);
+ if (ML_(safe_to_deref)((const HChar *) (Addr)ARG2, VKI_TASK_COMM_LEN)) {
+ SizeT len = VG_(strnlen)((const HChar *) (Addr)ARG2,
+ VKI_TASK_COMM_LEN);
if (len < VKI_TASK_COMM_LEN) {
PRE_MEM_RASCIIZ("prctl(set-name)", ARG2);
} else {
} else {
/* Do it the slow way, one byte at a time, while checking for
terminating '\0'. */
- const HChar *name = (const HChar *) ARG2;
+ const HChar *name = (const HChar *) (Addr)ARG2;
for (UInt i = 0; i < VKI_TASK_COMM_LEN; i++) {
PRE_MEM_READ("prctl(set-name)", (Addr) &name[i], 1);
if (!ML_(safe_to_deref)(&name[i], 1) || name[i] == '\0') {
break;
case VKI_PR_SET_NAME:
{
- const HChar* new_name = (const HChar*) ARG2;
+ const HChar* new_name = (const HChar*) (Addr)ARG2;
if (new_name) { // Paranoia
ThreadState* tst = VG_(get_ThreadState)(tid);
SizeT new_len = VG_(strnlen)(new_name, VKI_TASK_COMM_LEN);
PRE(sys_sendfile)
{
*flags |= SfMayBlock;
- PRINT("sys_sendfile ( %ld, %ld, %#lx, %lu )", SARG1,SARG2,ARG3,ARG4);
+ PRINT("sys_sendfile ( %ld, %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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 )",SARG1,SARG2,ARG3,ARG4);
+ PRINT("sendfile64 ( %ld, %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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,SARG2,SARG3,ARG4,ARG5);
+ PRINT("sys_futex ( %#" FMT_REGWORD "x, %ld, %ld, %#" FMT_REGWORD
+ "x, %#" FMT_REGWORD "x )", 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:
SET_STATUS_Failure( VKI_EFAULT );
return;
}
- if (*(vki_u32 *)ARG1 != ARG3) {
+ if (*(vki_u32 *)(Addr)ARG1 != ARG3) {
PRE_REG_READ4(long, "futex",
vki_u32 *, futex, int, op, int, val,
struct timespec *, utime);
PRE(sys_set_robust_list)
{
- PRINT("sys_set_robust_list ( %#lx, %lu )", ARG1,ARG2);
+ PRINT("sys_set_robust_list ( %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", 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, %#lx )", SARG1,ARG2,ARG3);
+ PRINT("sys_get_robust_list ( %ld, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "get_robust_list",
int, pid,
struct vki_robust_list_head **, head_ptr,
PRE(sys_pselect6)
{
*flags |= SfMayBlock | SfPostOnFail;
- PRINT("sys_pselect6 ( %ld, %#lx, %#lx, %#lx, %#lx, %#lx )",
+ PRINT("sys_pselect6 ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "pselect6",
int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
PRE_MEM_READ( "pselect6(timeout)", ARG5, sizeof(struct vki_timeval) );
if (ARG6 != 0) {
const struct pselect_sized_sigset *pss =
- (struct pselect_sized_sigset *)ARG6;
+ (struct pselect_sized_sigset *)(Addr)ARG6;
PRE_MEM_READ( "pselect6(sig)", ARG6, sizeof(*pss) );
if (!ML_(safe_to_deref)(pss, sizeof(*pss))) {
ARG6 = 1; /* Something recognisable to POST() hook. */
POST(sys_pselect6)
{
if (ARG6 != 0 && ARG6 != 1) {
- VG_(free)((struct pselect_adjusted_sigset *)ARG6);
+ VG_(free)((struct pselect_adjusted_sigset *)(Addr)ARG6);
}
}
PRE(sys_ppoll)
{
UInt i;
- struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+ struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;
*flags |= SfMayBlock | SfPostOnFail;
- PRINT("sys_ppoll ( %#lx, %lu, %#lx, %#lx, %lu )\n", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_ppoll ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD
+ "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )\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,
if (ARG3)
PRE_MEM_READ( "ppoll(tsp)", ARG3, sizeof(struct vki_timespec) );
if (ARG4 != 0 && sizeof(vki_sigset_t) == ARG5) {
- const vki_sigset_t *guest_sigmask = (vki_sigset_t *)ARG4;
+ const vki_sigset_t *guest_sigmask = (vki_sigset_t *)(Addr)ARG4;
PRE_MEM_READ( "ppoll(sigmask)", ARG4, ARG5);
if (!ML_(safe_to_deref)(guest_sigmask, sizeof(*guest_sigmask))) {
ARG4 = 1; /* Something recognisable to POST() hook. */
vg_assert(SUCCESS || FAILURE);
if (SUCCESS && (RES >= 0)) {
UInt i;
- struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+ struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;
for (i = 0; i < ARG2; i++)
POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
}
if (ARG4 != 0 && ARG5 == sizeof(vki_sigset_t) && ARG4 != 1) {
- VG_(free)((vki_sigset_t *) ARG4);
+ VG_(free)((vki_sigset_t *) (Addr)ARG4);
}
}
"EPOLL_CTL_DEL",
"EPOLL_CTL_MOD"
};
- PRINT("sys_epoll_ctl ( %ld, %s, %ld, %#lx )",
+ PRINT("sys_epoll_ctl ( %ld, %s, %ld, %#" FMT_REGWORD "x )",
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);
PRE(sys_epoll_wait)
{
*flags |= SfMayBlock;
- PRINT("sys_epoll_wait ( %ld, %#lx, %ld, %ld )", SARG1, ARG2, SARG3, SARG4);
+ PRINT("sys_epoll_wait ( %ld, %#" FMT_REGWORD "x, %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, %lu )",
+ PRINT("sys_epoll_pwait ( %ld, %#" FMT_REGWORD "x, %ld, %ld, %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u )",
SARG1, ARG2, SARG3, SARG4, ARG5, ARG6);
PRE_REG_READ6(long, "epoll_pwait",
int, epfd, struct vki_epoll_event *, events,
PRE(sys_eventfd)
{
- PRINT("sys_eventfd ( %lu )", ARG1);
+ PRINT("sys_eventfd ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "sys_eventfd", unsigned int, count);
}
POST(sys_eventfd)
PRE(sys_eventfd2)
{
- PRINT("sys_eventfd2 ( %lu, %ld )", ARG1, SARG2);
+ PRINT("sys_eventfd2 ( %" FMT_REGWORD "u, %ld )", ARG1, SARG2);
PRE_REG_READ2(long, "sys_eventfd2", unsigned int, count, int, flags);
}
POST(sys_eventfd2)
PRE(sys_prlimit64)
{
- PRINT("sys_prlimit64 ( %ld, %lu, %#lx, %#lx )", SARG1,ARG2,ARG3,ARG4);
+ PRINT("sys_prlimit64 ( %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", SARG1,ARG2,ARG3,ARG4);
PRE_REG_READ4(long, "prlimit64",
vki_pid_t, pid, unsigned int, resource,
const struct rlimit64 *, new_rlim,
PRE_MEM_WRITE( "rlimit64(old_rlim)", ARG4, sizeof(struct vki_rlimit64) );
if (ARG3 &&
- ((struct vki_rlimit64 *)ARG3)->rlim_cur > ((struct vki_rlimit64 *)ARG3)->rlim_max) {
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur
+ > ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max) {
SET_STATUS_Failure( VKI_EINVAL );
}
else if (ARG1 == 0 || ARG1 == VG_(getpid)()) {
case VKI_RLIMIT_NOFILE:
SET_STATUS_Success( 0 );
if (ARG4) {
- ((struct vki_rlimit64 *)ARG4)->rlim_cur = VG_(fd_soft_limit);
- ((struct vki_rlimit64 *)ARG4)->rlim_max = VG_(fd_hard_limit);
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_cur = VG_(fd_soft_limit);
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_max = VG_(fd_hard_limit);
}
if (ARG3) {
- if (((struct vki_rlimit64 *)ARG3)->rlim_cur > VG_(fd_hard_limit) ||
- ((struct vki_rlimit64 *)ARG3)->rlim_max != VG_(fd_hard_limit)) {
+ if (((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur
+ > VG_(fd_hard_limit) ||
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max
+ != VG_(fd_hard_limit)) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
- VG_(fd_soft_limit) = ((struct vki_rlimit64 *)ARG3)->rlim_cur;
+ VG_(fd_soft_limit) =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur;
}
}
break;
case VKI_RLIMIT_DATA:
SET_STATUS_Success( 0 );
if (ARG4) {
- ((struct vki_rlimit64 *)ARG4)->rlim_cur = VG_(client_rlimit_data).rlim_cur;
- ((struct vki_rlimit64 *)ARG4)->rlim_max = VG_(client_rlimit_data).rlim_max;
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_cur =
+ VG_(client_rlimit_data).rlim_cur;
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_max =
+ VG_(client_rlimit_data).rlim_max;
}
if (ARG3) {
- if (((struct vki_rlimit64 *)ARG3)->rlim_cur > VG_(client_rlimit_data).rlim_max ||
- ((struct vki_rlimit64 *)ARG3)->rlim_max > VG_(client_rlimit_data).rlim_max) {
+ if (((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur
+ > VG_(client_rlimit_data).rlim_max ||
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max
+ > VG_(client_rlimit_data).rlim_max) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
- VG_(client_rlimit_data).rlim_cur = ((struct vki_rlimit64 *)ARG3)->rlim_cur;
- VG_(client_rlimit_data).rlim_max = ((struct vki_rlimit64 *)ARG3)->rlim_max;
+ VG_(client_rlimit_data).rlim_cur =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur;
+ VG_(client_rlimit_data).rlim_max =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max;
}
}
break;
case VKI_RLIMIT_STACK:
SET_STATUS_Success( 0 );
if (ARG4) {
- ((struct vki_rlimit64 *)ARG4)->rlim_cur = VG_(client_rlimit_stack).rlim_cur;
- ((struct vki_rlimit64 *)ARG4)->rlim_max = VG_(client_rlimit_stack).rlim_max;
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_cur =
+ VG_(client_rlimit_stack).rlim_cur;
+ ((struct vki_rlimit64 *)(Addr)ARG4)->rlim_max =
+ VG_(client_rlimit_stack).rlim_max;
}
if (ARG3) {
- if (((struct vki_rlimit64 *)ARG3)->rlim_cur > VG_(client_rlimit_stack).rlim_max ||
- ((struct vki_rlimit64 *)ARG3)->rlim_max > VG_(client_rlimit_stack).rlim_max) {
+ if (((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur
+ > VG_(client_rlimit_stack).rlim_max ||
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max
+ > VG_(client_rlimit_stack).rlim_max) {
SET_STATUS_Failure( VKI_EPERM );
}
else {
- VG_(threads)[tid].client_stack_szB = ((struct vki_rlimit64 *)ARG3)->rlim_cur;
- VG_(client_rlimit_stack).rlim_cur = ((struct vki_rlimit64 *)ARG3)->rlim_cur;
- VG_(client_rlimit_stack).rlim_max = ((struct vki_rlimit64 *)ARG3)->rlim_max;
+ VG_(threads)[tid].client_stack_szB =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur;
+ VG_(client_rlimit_stack).rlim_cur =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_cur;
+ VG_(client_rlimit_stack).rlim_max =
+ ((struct vki_rlimit64 *)(Addr)ARG3)->rlim_max;
}
}
break;
PRE(sys_set_tid_address)
{
- PRINT("sys_set_tid_address ( %#lx )", ARG1);
+ PRINT("sys_set_tid_address ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "set_tid_address", int *, tidptr);
}
PRE(sys_fadvise64)
{
- PRINT("sys_fadvise64 ( %ld, %llu, %lu, %ld )",
+ PRINT("sys_fadvise64 ( %ld, %llu, %" FMT_REGWORD "u, %ld )",
SARG1, MERGE64(ARG2,ARG3), ARG4, SARG5);
PRE_REG_READ5(long, "fadvise64",
int, fd, vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset),
PRE(sys_io_setup)
{
- PRINT("sys_io_setup ( %lu, %#lx )", ARG1,ARG2);
+ PRINT("sys_io_setup ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(long, "io_setup",
unsigned, nr_events, vki_aio_context_t *, ctxp);
PRE_MEM_WRITE( "io_setup(ctxp)", ARG2, sizeof(vki_aio_context_t) );
size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
ARG1*sizeof(struct vki_io_event));
- r = *(struct vki_aio_ring **)ARG2;
+ r = *(struct vki_aio_ring **)(Addr)ARG2;
vg_assert(ML_(valid_client_addr)((Addr)r, size, tid, "io_setup"));
ML_(notify_core_and_tool_of_mmap)( (Addr)r, size,
// If we are going to seg fault (due to a bogus ARG1) do it as late as
// possible...
- if (ML_(safe_to_deref)( (void*)ARG1, sizeof(struct vki_aio_ring))) {
- struct vki_aio_ring *r = (struct vki_aio_ring *)ARG1;
+ if (ML_(safe_to_deref)( (void*)(Addr)ARG1, sizeof(struct vki_aio_ring))) {
+ struct vki_aio_ring *r = (struct vki_aio_ring *)(Addr)ARG1;
size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
r->nr*sizeof(struct vki_io_event));
}
PRE(sys_io_getevents)
{
*flags |= SfMayBlock;
- PRINT("sys_io_getevents ( %llu, %lld, %lld, %#lx, %#lx )",
+ PRINT("sys_io_getevents ( %llu, %lld, %lld, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )",
(ULong)ARG1,(Long)ARG2,(Long)ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "io_getevents",
vki_aio_context_t, ctx_id, long, min_nr, long, nr,
if (RES > 0) {
POST_MEM_WRITE( ARG4, sizeof(struct vki_io_event)*RES );
for (i = 0; i < RES; i++) {
- const struct vki_io_event *vev = ((struct vki_io_event *)ARG4) + i;
+ const struct vki_io_event *vev =
+ ((struct vki_io_event *)(Addr)ARG4) + i;
const struct vki_iocb *cb = (struct vki_iocb *)(Addr)vev->obj;
switch (cb->aio_lio_opcode) {
{
Int i, j;
- PRINT("sys_io_submit ( %lu, %ld, %#lx )", ARG1, SARG2, ARG3);
+ PRINT("sys_io_submit ( %" FMT_REGWORD "u, %ld, %#" FMT_REGWORD "x )",
+ ARG1, SARG2, ARG3);
PRE_REG_READ3(long, "io_submit",
vki_aio_context_t, ctx_id, long, nr,
struct iocb **, iocbpp);
PRE_MEM_READ( "io_submit(iocbpp)", ARG3, ARG2*sizeof(struct vki_iocb *) );
if (ARG3 != 0) {
for (i = 0; i < ARG2; i++) {
- struct vki_iocb *cb = ((struct vki_iocb **)ARG3)[i];
+ struct vki_iocb *cb = ((struct vki_iocb **)(Addr)ARG3)[i];
struct vki_iovec *iov;
PRE_MEM_READ( "io_submit(iocb)", (Addr)cb, sizeof(struct vki_iocb) );
PRE(sys_io_cancel)
{
- PRINT("sys_io_cancel ( %llu, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3);
+ PRINT("sys_io_cancel ( %llu, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ (ULong)ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "io_cancel",
vki_aio_context_t, ctx_id, struct iocb *, iocb,
struct io_event *, result);
PRE(sys_mbind)
{
- PRINT("sys_mbind ( %#lx, %lu, %lu, %#lx, %lu, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+ PRINT("sys_mbind ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
+ 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, %lu )", SARG1, ARG2, ARG3);
+ PRINT("sys_set_mempolicy ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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, %lu, %#lx, %lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
+ PRINT("sys_get_mempolicy ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "x )",
+ ARG1, ARG2, ARG3, ARG4, ARG5);
PRE_REG_READ5(long, "get_mempolicy",
int *, policy, unsigned long *, nodemask,
unsigned long, maxnode, unsigned long, addr,
PRE(sys_fanotify_init)
{
- PRINT("sys_fanotify_init ( %lu, %lu )", ARG1,ARG2);
+ PRINT("sys_fanotify_init ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
+ ARG1, ARG2);
PRE_REG_READ2(long, "fanotify_init",
unsigned int, flags, unsigned int, event_f_flags);
}
PRE(sys_fanotify_mark)
{
#if VG_WORDSIZE == 4
- PRINT( "sys_fanotify_mark ( %ld, %lu, %llu, %ld, %#lx(%s))",
- SARG1, ARG2, MERGE64(ARG3,ARG4), SARG5, ARG6, (HChar *)ARG6);
+ PRINT( "sys_fanotify_mark ( %ld, %" FMT_REGWORD "u, %llu, %ld, %#"
+ FMT_REGWORD "x(%s))", SARG1, ARG2, MERGE64(ARG3,ARG4), SARG5, ARG6,
+ (HChar *)(Addr)ARG6);
PRE_REG_READ6(long, "sys_fanotify_mark",
int, fanotify_fd, unsigned int, flags,
__vki_u32, mask0, __vki_u32, mask1,
PRE_MEM_RASCIIZ( "fanotify_mark(path)", ARG6);
#elif VG_WORDSIZE == 8
PRINT( "sys_fanotify_mark ( %ld, %lu, %lu, %ld, %#lx(%s))",
- SARG1, ARG2, ARG3, SARG4, ARG5, (HChar *)ARG5);
+ SARG1, ARG2, ARG3, SARG4, ARG5, (HChar *)(Addr)ARG5);
PRE_REG_READ5(long, "sys_fanotify_mark",
int, fanotify_fd, unsigned int, flags,
__vki_u64, mask,
PRE(sys_inotify_add_watch)
{
- PRINT( "sys_inotify_add_watch ( %ld, %#lx, %lx )", SARG1, ARG2, ARG3);
+ PRINT( "sys_inotify_add_watch ( %ld, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "x )", 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 )", SARG1, ARG2);
+ PRINT( "sys_inotify_rm_watch ( %ld, %" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(long, "inotify_rm_watch", int, fd, int, wd);
}
PRE(sys_mq_open)
{
- PRINT("sys_mq_open( %#lx(%s), %ld, %lu, %#lx )",
- ARG1, (HChar*)ARG1, SARG2, ARG3, ARG4);
+ PRINT("sys_mq_open( %#" FMT_REGWORD "x(%s), %ld, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", ARG1, (HChar*)(Addr)ARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "mq_open",
const char *, name, int, oflag, vki_mode_t, mode,
struct mq_attr *, attr);
PRE_MEM_RASCIIZ( "mq_open(name)", ARG1 );
if ((ARG2 & VKI_O_CREAT) != 0 && ARG4 != 0) {
- const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG4;
+ const struct vki_mq_attr *attr = (struct vki_mq_attr *)(Addr)ARG4;
PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
(Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG1);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)(Addr)ARG1);
}
}
PRE(sys_mq_unlink)
{
- PRINT("sys_mq_unlink ( %#lx(%s) )", ARG1,(char*)ARG1);
+ PRINT("sys_mq_unlink ( %#" FMT_REGWORD "x(%s) )", ARG1,(char*)(Addr)ARG1);
PRE_REG_READ1(long, "mq_unlink", const char *, name);
PRE_MEM_RASCIIZ( "mq_unlink(name)", ARG1 );
}
PRE(sys_mq_timedsend)
{
*flags |= SfMayBlock;
- PRINT("sys_mq_timedsend ( %ld, %#lx, %lu, %lu, %#lx )",
+ PRINT("sys_mq_timedsend ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u, %#" FMT_REGWORD "x )",
SARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(long, "mq_timedsend",
vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,
PRE(sys_mq_timedreceive)
{
*flags |= SfMayBlock;
- PRINT("sys_mq_timedreceive( %ld, %#lx, %lu, %#lx, %#lx )",
+ PRINT("sys_mq_timedreceive( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1,ARG2,ARG3,ARG4,ARG5);
PRE_REG_READ5(ssize_t, "mq_timedreceive",
vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,
PRE(sys_mq_notify)
{
- PRINT("sys_mq_notify( %ld, %#lx )", SARG1, ARG2 );
+ PRINT("sys_mq_notify( %ld, %#" FMT_REGWORD "x )", 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 )", SARG1,ARG2,ARG3 );
+ PRINT("sys_mq_getsetattr( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ SARG1, ARG2, ARG3 );
PRE_REG_READ3(long, "mq_getsetattr",
vki_mqd_t, mqdes, const struct mq_attr *, mqstat,
struct mq_attr *, omqstat);
SET_STATUS_Failure( VKI_EBADF );
} else {
if (ARG2 != 0) {
- const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG2;
+ const struct vki_mq_attr *attr = (struct vki_mq_attr *)(Addr)ARG2;
PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
(Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
}
PRE(sys_clock_settime)
{
- PRINT("sys_clock_settime( %ld, %#lx )", SARG1, ARG2);
+ PRINT("sys_clock_settime( %ld, %#" FMT_REGWORD "x )", 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 )" , SARG1, ARG2);
+ PRINT("sys_clock_gettime( %ld, %#" FMT_REGWORD "x )" , 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 )" , SARG1, ARG2);
+ PRINT("sys_clock_getres( %ld, %#" FMT_REGWORD "x )" , 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 )",
+ PRINT("sys_clock_nanosleep( %ld, %ld, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )",
SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(int32_t, "clock_nanosleep",
vki_clockid_t, clkid, int, flags,
PRE(sys_timer_create)
{
- PRINT("sys_timer_create( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sys_timer_create( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "timer_create",
vki_clockid_t, clockid, struct sigevent *, evp,
vki_timer_t *, timerid);
if (ARG2 != 0) {
- struct vki_sigevent *evp = (struct vki_sigevent *) ARG2;
+ struct vki_sigevent *evp = (struct vki_sigevent *) (Addr)ARG2;
PRE_MEM_READ( "timer_create(evp.sigev_value)", (Addr)&evp->sigev_value,
sizeof(vki_sigval_t) );
PRE_MEM_READ( "timer_create(evp.sigev_signo)", (Addr)&evp->sigev_signo,
PRE(sys_timer_settime)
{
- PRINT("sys_timer_settime( %ld, %ld, %#lx, %#lx )", SARG1,SARG2,ARG3,ARG4);
+ PRINT("sys_timer_settime( %ld, %ld, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", 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( %ld, %#lx )", SARG1, ARG2);
+ PRINT("sys_timer_gettime( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);
PRE_REG_READ2(long, "timer_gettime",
vki_timer_t, timerid, struct itimerspec *, value);
PRE_MEM_WRITE( "timer_gettime(value)", ARG2,
PRE(sys_timer_getoverrun)
{
- PRINT("sys_timer_getoverrun( %#lx )", ARG1);
+ PRINT("sys_timer_getoverrun( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "timer_getoverrun", vki_timer_t, timerid);
}
PRE(sys_timer_delete)
{
- PRINT("sys_timer_delete( %#lx )", ARG1);
+ PRINT("sys_timer_delete( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid);
}
{
if (linux_kernel_2_6_22()) {
/* 2.6.22 kernel: timerfd system call. */
- PRINT("sys_timerfd ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
+ PRINT("sys_timerfd ( %ld, %ld, %#" FMT_REGWORD "x )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "sys_timerfd",
int, fd, int, clockid, const struct itimerspec *, tmr);
PRE_MEM_READ("timerfd(tmr)", ARG3,
PRE(sys_timerfd_gettime)
{
- PRINT("sys_timerfd_gettime ( %ld, %#lx )", SARG1, ARG2);
+ PRINT("sys_timerfd_gettime ( %ld, %#" FMT_REGWORD "x )", 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 )",
- SARG1, SARG2, ARG3, ARG4);
+ PRINT("sys_timerfd_settime ( %ld, %ld, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )", SARG1, SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "timerfd_settime",
int, ufd,
int, flags,
PRE(sys_capget)
{
- PRINT("sys_capget ( %#lx, %#lx )", ARG1, ARG2 );
+ PRINT("sys_capget ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2 );
PRE_REG_READ2(long, "capget",
vki_cap_user_header_t, header, vki_cap_user_data_t, data);
PRE_MEM_READ( "capget(header)", ARG1,
PRE(sys_capset)
{
- PRINT("sys_capset ( %#lx, %#lx )", ARG1, ARG2 );
+ PRINT("sys_capset ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2 );
PRE_REG_READ2(long, "capset",
vki_cap_user_header_t, header,
const vki_cap_user_data_t, data);
PRE(sys_setuid16)
{
- PRINT("sys_setuid16 ( %lu )", ARG1);
+ PRINT("sys_setuid16 ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setuid16", vki_old_uid_t, uid);
}
PRE(sys_setgid16)
{
- PRINT("sys_setgid16 ( %lu )", ARG1);
+ PRINT("sys_setgid16 ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "setgid16", vki_old_gid_t, gid);
}
PRE(sys_setreuid16)
{
- PRINT("setreuid16 ( 0x%lx, 0x%lx )", ARG1, ARG2);
+ PRINT("setreuid16 ( 0x%" FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(long, "setreuid16", vki_old_uid_t, ruid, vki_old_uid_t, euid);
}
PRE(sys_setregid16)
{
- PRINT("sys_setregid16 ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_setregid16 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", 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 )", SARG1, ARG2);
+ PRINT("sys_getgroups16 ( %ld, %#" FMT_REGWORD "x )", 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_setgroups16)
{
- PRINT("sys_setgroups16 ( %llu, %#lx )", (ULong)ARG1, ARG2);
+ PRINT("sys_setgroups16 ( %llu, %#" FMT_REGWORD "x )", (ULong)ARG1, ARG2);
PRE_REG_READ2(long, "setgroups16", int, size, vki_old_gid_t *, list);
if (ARG1 > 0)
PRE_MEM_READ( "setgroups16(list)", ARG2, ARG1 * sizeof(vki_old_gid_t) );
PRE(sys_chown16)
{
- PRINT("sys_chown16 ( %#lx, 0x%lx, 0x%lx )", ARG1,ARG2,ARG3);
+ PRINT("sys_chown16 ( %#" FMT_REGWORD "x, 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "chown16",
const char *, path,
vki_old_uid_t, owner, vki_old_gid_t, group);
PRE(sys_fchown16)
{
- PRINT("sys_fchown16 ( %lu, %lu, %lu )", ARG1,ARG2,ARG3);
+ PRINT("sys_fchown16 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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, %lu, %ld )",
- ARG1, ARG2, ARG3, ARG4, SARG5);
+ PRINT("sys_setxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u, %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, %lu, %ld )",
+ PRINT("sys_lsetxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u, %ld )",
ARG1, ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "lsetxattr",
char *, path, char *, name,
PRE(sys_fsetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fsetxattr ( %ld, %#lx, %#lx, %lu, %ld )",
+ PRINT("sys_fsetxattr ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u, %ld )",
SARG1, ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "fsetxattr",
int, fd, char *, name, void *, value,
PRE(sys_getxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_getxattr ( %#lx, %#lx, %#lx, %llu )", ARG1,ARG2,ARG3, (ULong)ARG4);
+ PRINT("sys_getxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %llu )", ARG1, ARG2, ARG3, (ULong)ARG4);
PRE_REG_READ4(ssize_t, "getxattr",
char *, path, char *, name, void *, value, vki_size_t, size);
PRE_MEM_RASCIIZ( "getxattr(path)", ARG1 );
PRE(sys_lgetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_lgetxattr ( %#lx, %#lx, %#lx, %llu )", ARG1,ARG2,ARG3, (ULong)ARG4);
+ PRINT("sys_lgetxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %llu )", ARG1, ARG2, ARG3, (ULong)ARG4);
PRE_REG_READ4(ssize_t, "lgetxattr",
char *, path, char *, name, void *, value, vki_size_t, size);
PRE_MEM_RASCIIZ( "lgetxattr(path)", ARG1 );
PRE(sys_fgetxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fgetxattr ( %ld, %#lx, %#lx, %lu )", SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_fgetxattr ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", 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_listxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_listxattr ( %#lx, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_listxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %llu )",
+ ARG1, ARG2, (ULong)ARG3);
PRE_REG_READ3(ssize_t, "listxattr",
char *, path, char *, list, vki_size_t, size);
PRE_MEM_RASCIIZ( "listxattr(path)", ARG1 );
PRE(sys_llistxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_llistxattr ( %#lx, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
+ PRINT("sys_llistxattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %llu )",
+ ARG1, ARG2, (ULong)ARG3);
PRE_REG_READ3(ssize_t, "llistxattr",
char *, path, char *, list, vki_size_t, size);
PRE_MEM_RASCIIZ( "llistxattr(path)", ARG1 );
PRE(sys_flistxattr)
{
*flags |= SfMayBlock;
- PRINT("sys_flistxattr ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
+ PRINT("sys_flistxattr ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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_removexattr)
{
*flags |= SfMayBlock;
- PRINT("sys_removexattr ( %#lx, %#lx )", ARG1, ARG2);
+ PRINT("sys_removexattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ ARG1, ARG2);
PRE_REG_READ2(long, "removexattr", char *, path, char *, name);
PRE_MEM_RASCIIZ( "removexattr(path)", ARG1 );
PRE_MEM_RASCIIZ( "removexattr(name)", ARG2 );
PRE(sys_lremovexattr)
{
*flags |= SfMayBlock;
- PRINT("sys_lremovexattr ( %#lx, %#lx )", ARG1, ARG2);
+ PRINT("sys_lremovexattr ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ ARG1, ARG2);
PRE_REG_READ2(long, "lremovexattr", char *, path, char *, name);
PRE_MEM_RASCIIZ( "lremovexattr(path)", ARG1 );
PRE_MEM_RASCIIZ( "lremovexattr(name)", ARG2 );
PRE(sys_fremovexattr)
{
*flags |= SfMayBlock;
- PRINT("sys_fremovexattr ( %ld, %#lx )", SARG1, ARG2);
+ PRINT("sys_fremovexattr ( %ld, %#" FMT_REGWORD "x )", 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 )", SARG1, ARG2 );
+ PRINT("sched_setparam ( %ld, %#" FMT_REGWORD "x )", 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 )", SARG1, ARG2 );
+ PRINT("sched_getparam ( %ld, %#" FMT_REGWORD "x )", 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_setscheduler)
{
- PRINT("sys_sched_setscheduler ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
+ PRINT("sys_sched_setscheduler ( %ld, %ld, %#" FMT_REGWORD "x )",
+ 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_rr_get_interval)
{
- PRINT("sys_sched_rr_get_interval ( %ld, %#lx )", SARG1, ARG2);
+ PRINT("sys_sched_rr_get_interval ( %ld, %#" FMT_REGWORD "x )", 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, %lu, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sched_setaffinity ( %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
+ 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, %lu, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sched_getaffinity ( %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
+ 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 ( %#lx )", ARG1);
+ PRINT("sys_unshare ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "unshare", unsigned long, flags);
}
// AMD64.
PRE(sys_pipe)
{
- PRINT("sys_pipe ( %#lx )", ARG1);
+ PRINT("sys_pipe ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "pipe", int *, filedes);
PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) );
}
POST(sys_pipe)
{
- Int *p = (Int *)ARG1;
+ Int *p = (Int *)(Addr)ARG1;
if (!ML_(fd_allowed)(p[0], "pipe", tid, True) ||
!ML_(fd_allowed)(p[1], "pipe", tid, True)) {
VG_(close)(p[0]);
duplicated code, hence: */
PRE(sys_pipe2)
{
- PRINT("sys_pipe2 ( %#lx, %#lx )", ARG1, ARG2);
+ PRINT("sys_pipe2 ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(int, "pipe", int *, filedes, long, flags);
PRE_MEM_WRITE( "pipe2(filedes)", ARG1, 2*sizeof(int) );
}
POST(sys_pipe2)
{
- Int *p = (Int *)ARG1;
+ Int *p = (Int *)(Addr)ARG1;
if (!ML_(fd_allowed)(p[0], "pipe2", tid, True) ||
!ML_(fd_allowed)(p[1], "pipe2", tid, True)) {
VG_(close)(p[0]);
PRE(sys_dup3)
{
- PRINT("sys_dup3 ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_dup3 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", 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_quotactl)
{
- PRINT("sys_quotactl (0x%lx, %#lx, 0x%lx, 0x%lx )", ARG1,ARG2,ARG3, ARG4);
+ PRINT("sys_quotactl (0x%" FMT_REGWORD "x, %#" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x, 0x%" FMT_REGWORD "x )", ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "quotactl",
unsigned int, cmd, const char *, special, vki_qid_t, id,
void *, addr);
PRE(sys_waitid)
{
*flags |= SfMayBlock;
- PRINT("sys_waitid( %ld, %ld, %#lx, %ld, %#lx )",
+ PRINT("sys_waitid( %ld, %ld, %#" FMT_REGWORD "x, %ld, %#" FMT_REGWORD "x )",
SARG1, SARG2, ARG3, SARG4, ARG5);
PRE_REG_READ5(int32_t, "sys_waitid",
int, which, vki_pid_t, pid, struct vki_siginfo *, infop,
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_sync_file_range ( %ld, %lld, %lld, %#lx )",
+ PRINT("sys_sync_file_range ( %ld, %lld, %lld, %#" FMT_REGWORD "x )",
SARG1, (Long)MERGE64(ARG2,ARG3), (Long)MERGE64(ARG4,ARG5),ARG6);
PRE_REG_READ6(long, "sync_file_range",
int, fd,
{
*flags |= SfMayBlock;
#if VG_WORDSIZE == 4
- PRINT("sys_sync_file_range2 ( %ld, %lu, %lld, %lld )",
+ PRINT("sys_sync_file_range2 ( %ld, %" FMT_REGWORD "u, %lld, %lld )",
SARG1, ARG2, (Long)MERGE64(ARG3,ARG4), (Long)MERGE64(ARG5,ARG6));
PRE_REG_READ6(long, "sync_file_range2",
int, fd, unsigned int, flags,
PRE(sys_stime)
{
- PRINT("sys_stime ( %#lx )", ARG1);
+ PRINT("sys_stime ( %#" FMT_REGWORD "x )", ARG1);
PRE_REG_READ1(int, "stime", vki_time_t*, t);
PRE_MEM_READ( "stime(t)", ARG1, sizeof(vki_time_t) );
}
PRE(sys_perf_event_open)
{
struct vki_perf_event_attr *attr;
- PRINT("sys_perf_event_open ( %#lx, %ld, %ld, %ld, %#lx )",
- ARG1, SARG2, SARG3, SARG4, ARG5);
+ PRINT("sys_perf_event_open ( %#" FMT_REGWORD "x, %ld, %ld, %ld, %#"
+ FMT_REGWORD "x )", 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,
unsigned long, flags);
- attr = (struct vki_perf_event_attr *)ARG1;
+ attr = (struct vki_perf_event_attr *)(Addr)ARG1;
PRE_MEM_READ( "perf_event_open(attr->size)",
(Addr)&attr->size, sizeof(attr->size) );
PRE_MEM_READ( "perf_event_open(attr)",
PRE(sys_getcpu)
{
- PRINT("sys_getcpu ( %#lx, %#lx, %#lx )" , ARG1,ARG2,ARG3);
+ PRINT("sys_getcpu ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x )" , ARG1, ARG2, ARG3);
PRE_REG_READ3(int, "getcpu",
unsigned *, cpu, unsigned *, node, struct vki_getcpu_cache *, tcache);
if (ARG1 != 0)
PRE(sys_move_pages)
{
- PRINT("sys_move_pages ( %ld, %lu, %#lx, %#lx, %#lx, %#lx )",
+ PRINT("sys_move_pages ( %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(int, "move_pages",
vki_pid_t, pid, unsigned long, nr_pages, const void **, pages,
PRE(sys_getrandom)
{
- PRINT("sys_getrandom ( %#lx, %lu, %lu )" , ARG1, ARG2, ARG3);
+ PRINT("sys_getrandom ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )" , 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, %lu )" , ARG1, ARG2);
+ PRINT("sys_memfd_create ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )" ,
+ 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 ( %lu )", ARG1);
+ PRINT("sys_syncfs ( %" FMT_REGWORD "u )", ARG1);
PRE_REG_READ1(long, "syncfs", unsigned int, fd);
}
PRE(sys_utime)
{
*flags |= SfMayBlock;
- PRINT("sys_utime ( %#lx, %#lx )", ARG1,ARG2);
+ PRINT("sys_utime ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )", ARG1,ARG2);
PRE_REG_READ2(long, "utime", char *, filename, struct utimbuf *, buf);
PRE_MEM_RASCIIZ( "utime(filename)", ARG1 );
if (ARG2 != 0)
PRE(sys_lseek)
{
- PRINT("sys_lseek ( %lu, %ld, %lu )", ARG1, SARG2, ARG3);
+ PRINT("sys_lseek ( %" FMT_REGWORD "u, %ld, %" FMT_REGWORD "u )",
+ 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, %lu )",
+ PRINT("sys_readahead ( %ld, %lld, %" FMT_REGWORD "u )",
SARG1, (Long)MERGE64(ARG2,ARG3), ARG4);
PRE_REG_READ4(vki_off_t, "readahead",
int, fd, unsigned, MERGE64_FIRST(offset),
PRE(sys_sigpending)
{
- PRINT( "sys_sigpending ( %#lx )", ARG1 );
+ PRINT( "sys_sigpending ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ1(long, "sigpending", vki_old_sigset_t *, set);
PRE_MEM_WRITE( "sigpending(set)", ARG1, sizeof(vki_old_sigset_t));
}
// Nb: We must convert the smaller vki_old_sigset_t params into bigger
// vki_sigset_t params.
- set = (vki_old_sigset_t*)ARG2;
- oldset = (vki_old_sigset_t*)ARG3;
+ set = (vki_old_sigset_t*)(Addr)ARG2;
+ oldset = (vki_old_sigset_t*)(Addr)ARG3;
VG_(memset)(&bigger_set, 0, sizeof(vki_sigset_t));
VG_(memset)(&bigger_oldset, 0, sizeof(vki_sigset_t));
newp = oldp = NULL;
if (ARG2 != 0) {
- struct vki_old_sigaction *sa = (struct vki_old_sigaction *)ARG2;
+ struct vki_old_sigaction *sa = (struct vki_old_sigaction *)(Addr)ARG2;
PRE_MEM_READ( "sigaction(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
PRE_MEM_READ( "sigaction(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
PRE_MEM_READ( "sigaction(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
aren't accessible then sigaction returns EFAULT and we cannot
use either struct for our own bookkeeping. Just fail early. */
if (ARG2 != 0
- && ! ML_(safe_to_deref)((void *)ARG2,
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG2,
sizeof(struct vki_old_sigaction))) {
VG_(umsg)("Warning: bad act handler address %p in sigaction()\n",
- (void *)ARG2);
+ (void *)(Addr)ARG2);
SET_STATUS_Failure ( VKI_EFAULT );
} else if ((ARG3 != 0
- && ! ML_(safe_to_deref)((void *)ARG3,
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG3,
sizeof(struct vki_old_sigaction)))) {
VG_(umsg)("Warning: bad oldact handler address %p in sigaction()\n",
- (void *)ARG3);
+ (void *)(Addr)ARG3);
SET_STATUS_Failure ( VKI_EFAULT );
} else {
if (ARG2 != 0) {
- struct vki_old_sigaction *oldnew = (struct vki_old_sigaction *)ARG2;
+ struct vki_old_sigaction *oldnew =
+ (struct vki_old_sigaction *)(Addr)ARG2;
new.ksa_handler = oldnew->ksa_handler;
new.sa_flags = oldnew->sa_flags;
SET_STATUS_from_SysRes( VG_(do_sys_sigaction)(ARG1, newp, oldp) );
if (ARG3 != 0 && SUCCESS && RES == 0) {
- struct vki_old_sigaction *oldold = (struct vki_old_sigaction *)ARG3;
+ struct vki_old_sigaction *oldold =
+ (struct vki_old_sigaction *)(Addr)ARG3;
oldold->ksa_handler = oldp->ksa_handler;
oldold->sa_flags = oldp->sa_flags;
PRE(sys_signalfd)
{
- PRINT("sys_signalfd ( %d, %#lx, %llu )", (Int)ARG1,ARG2,(ULong)ARG3);
+ PRINT("sys_signalfd ( %d, %#" FMT_REGWORD "x, %llu )", (Int)ARG1, ARG2,
+ (ULong)ARG3);
PRE_REG_READ3(long, "sys_signalfd",
int, fd, vki_sigset_t *, sigmask, vki_size_t, sigsetsize);
PRE_MEM_READ( "signalfd(sigmask)", ARG2, sizeof(vki_sigset_t) );
PRE(sys_signalfd4)
{
- PRINT("sys_signalfd4 ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
+ PRINT("sys_signalfd4 ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %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, %lu )", SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_rt_sigaction ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigaction",
int, signum, const struct sigaction *, act,
struct sigaction *, oldact, vki_size_t, sigsetsize);
if (ARG2 != 0) {
- vki_sigaction_toK_t *sa = (vki_sigaction_toK_t *)ARG2;
+ vki_sigaction_toK_t *sa = (vki_sigaction_toK_t *)(Addr)ARG2;
PRE_MEM_READ( "rt_sigaction(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
PRE_MEM_READ( "rt_sigaction(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
PRE_MEM_READ( "rt_sigaction(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
aren't accessible then sigaction returns EFAULT and we cannot
use either struct for our own bookkeeping. Just fail early. */
if (ARG2 != 0
- && ! ML_(safe_to_deref)((void *)ARG2,
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG2,
sizeof(vki_sigaction_toK_t))) {
VG_(umsg)("Warning: bad act handler address %p in rt_sigaction()\n",
- (void *)ARG2);
+ (void *)(Addr)ARG2);
SET_STATUS_Failure ( VKI_EFAULT );
} else if ((ARG3 != 0
- && ! ML_(safe_to_deref)((void *)ARG3,
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG3,
sizeof(vki_sigaction_fromK_t)))) {
VG_(umsg)("Warning: bad oldact handler address %p in rt_sigaction()\n",
- (void *)ARG3);
+ (void *)(Addr)ARG3);
SET_STATUS_Failure ( VKI_EFAULT );
} else {
// VG_(do_sys_rt_sigaction)() --njn
SET_STATUS_from_SysRes(
- VG_(do_sys_sigaction)(ARG1, (const vki_sigaction_toK_t *)ARG2,
- (vki_sigaction_fromK_t *)ARG3)
+ VG_(do_sys_sigaction)(ARG1, (const vki_sigaction_toK_t *)(Addr)ARG2,
+ (vki_sigaction_fromK_t *)(Addr)ARG3)
);
}
}
PRE(sys_rt_sigprocmask)
{
- PRINT("sys_rt_sigprocmask ( %ld, %#lx, %#lx, %lu )",
- SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_rt_sigprocmask ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigprocmask",
int, how, vki_sigset_t *, set, vki_sigset_t *, oldset,
vki_size_t, sigsetsize);
if (sizeof(vki_sigset_t) != ARG4)
SET_STATUS_Failure( VKI_EINVAL );
else if (ARG2 != 0
- && ! ML_(safe_to_deref)((void *)ARG2, sizeof(vki_sigset_t))) {
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG2, sizeof(vki_sigset_t))) {
VG_(dmsg)("Warning: Bad set handler address %p in sigprocmask\n",
- (void *)ARG2);
+ (void *)(Addr)ARG2);
SET_STATUS_Failure ( VKI_EFAULT );
}
else if (ARG3 != 0
- && ! ML_(safe_to_deref)((void *)ARG3, sizeof(vki_sigset_t))) {
+ && ! ML_(safe_to_deref)((void *)(Addr)ARG3, sizeof(vki_sigset_t))) {
VG_(dmsg)("Warning: Bad oldset address %p in sigprocmask\n",
- (void *)ARG3);
+ (void *)(Addr)ARG3);
SET_STATUS_Failure ( VKI_EFAULT );
}
else {
SET_STATUS_from_SysRes(
VG_(do_sys_sigprocmask) ( tid, ARG1 /*how*/,
- (vki_sigset_t*) ARG2,
- (vki_sigset_t*) ARG3 )
+ (vki_sigset_t*) (Addr)ARG2,
+ (vki_sigset_t*) (Addr)ARG3 )
);
}
PRE(sys_rt_sigpending)
{
- PRINT( "sys_rt_sigpending ( %#lx )", ARG1 );
+ PRINT( "sys_rt_sigpending ( %#" FMT_REGWORD "x )", ARG1 );
PRE_REG_READ2(long, "rt_sigpending",
vki_sigset_t *, set, vki_size_t, sigsetsize);
PRE_MEM_WRITE( "rt_sigpending(set)", ARG1, sizeof(vki_sigset_t));
PRE(sys_rt_sigtimedwait)
{
*flags |= SfMayBlock;
- PRINT("sys_rt_sigtimedwait ( %#lx, %#lx, %#lx, %lu )",
+ PRINT("sys_rt_sigtimedwait ( %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u )",
ARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "rt_sigtimedwait",
const vki_sigset_t *, set, vki_siginfo_t *, info,
PRE(sys_rt_sigqueueinfo)
{
- PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#lx)", SARG1, SARG2, ARG3);
+ PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#" FMT_REGWORD "x)",
+ 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)",
+ PRINT("sys_rt_tgsigqueueinfo(%ld, %ld, %ld, %#" FMT_REGWORD "x)",
SARG1, SARG2, SARG3, ARG4);
PRE_REG_READ4(long, "rt_tgsigqueueinfo",
int, tgid, int, pid, int, sig, vki_siginfo_t *, uinfo);
return EINVAL if it isn't.
*/
*flags |= SfMayBlock;
- PRINT("sys_rt_sigsuspend ( %#lx, %lu )", ARG1, ARG2 );
+ PRINT("sys_rt_sigsuspend ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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) );
- if (ML_(safe_to_deref)((vki_sigset_t *) ARG1, sizeof(vki_sigset_t))) {
- VG_(sigdelset)((vki_sigset_t *) ARG1, VG_SIGVGKILL);
+ if (ML_(safe_to_deref)((vki_sigset_t *) (Addr)ARG1, sizeof(vki_sigset_t))) {
+ VG_(sigdelset)((vki_sigset_t *) (Addr)ARG1, VG_SIGVGKILL);
/* We cannot mask VG_SIGVGKILL, as otherwise this thread would not
be killable by VG_(nuke_all_threads_except).
We thus silently ignore the user request to mask this signal.
Addr msgp;
Word msgtyp;
- msgp = deref_Addr( tid, (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
+ msgp = deref_Addr( tid, (Addr) (&((struct vki_ipc_kludge *)(Addr)ARG5)->msgp),
"msgrcv(msgp)" );
msgtyp = deref_Addr( tid,
- (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
+ (Addr) (&((struct vki_ipc_kludge *)(Addr)ARG5)->msgtyp),
"msgrcv(msgp)" );
ML_(linux_PRE_sys_msgrcv)( tid, ARG2, msgp, ARG3, msgtyp, ARG4 );
Word msgtyp;
msgp = deref_Addr( tid,
- (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgp),
+ (Addr) (&((struct vki_ipc_kludge *)(Addr)ARG5)->msgp),
"msgrcv(msgp)" );
msgtyp = deref_Addr( tid,
- (Addr) (&((struct vki_ipc_kludge *)ARG5)->msgtyp),
+ (Addr) (&((struct vki_ipc_kludge *)(Addr)ARG5)->msgtyp),
"msgrcv(msgp)" );
ML_(linux_POST_sys_msgrcv)( tid, RES, ARG2, msgp, ARG3, msgtyp, ARG4 );
PRE(sys_semop)
{
*flags |= SfMayBlock;
- PRINT("sys_semop ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
+ PRINT("sys_semop ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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 )", SARG1, SARG2, SARG3, ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#" FMT_REGWORD "x )", 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 )", SARG1, SARG2, SARG3, ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#" FMT_REGWORD "x )", 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 )", SARG1, SARG2, SARG3, ARG4);
+ PRINT("sys_semctl ( %ld, %ld, %ld, %#" FMT_REGWORD "x )", SARG1, SARG2,
+ SARG3, ARG4);
PRE_REG_READ4(long, "semctl",
int, semid, int, semnum, int, cmd, unsigned short *, arg);
break;
PRE(sys_semtimedop)
{
*flags |= SfMayBlock;
- PRINT("sys_semtimedop ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_semtimedop ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "semtimedop",
int, semid, struct sembuf *, sops, unsigned, nsoops,
struct timespec *, timeout);
PRE(sys_msgsnd)
{
- PRINT("sys_msgsnd ( %ld, %#lx, %lu, %ld )", SARG1, ARG2, ARG3, SARG4);
+ PRINT("sys_msgsnd ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %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, %lu, %ld, %ld )",
+ PRINT("sys_msgrcv ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %ld, %ld )",
SARG1, ARG2, ARG3, SARG4, SARG5);
PRE_REG_READ5(long, "msgrcv",
int, msqid, struct msgbuf *, msgp, vki_size_t, msgsz,
PRE(sys_msgctl)
{
- PRINT("sys_msgctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
+ PRINT("sys_msgctl ( %ld, %ld, %#" FMT_REGWORD "x )", 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, %lu, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_shmget ( %ld, %" FMT_REGWORD "u, %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(sys_shmat)
{
UWord arg2tmp;
- PRINT("sys_shmat ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_shmat ( %ld, %#" FMT_REGWORD "x, %ld )", SARG1, ARG2, SARG3);
PRE_REG_READ3(long, "shmat",
int, shmid, const void *, shmaddr, int, shmflg);
#if defined(VGP_arm_linux)
PRE(sys_shmdt)
{
- PRINT("sys_shmdt ( %#lx )",ARG1);
+ PRINT("sys_shmdt ( %#" FMT_REGWORD "x )",ARG1);
PRE_REG_READ1(long, "shmdt", const void *, shmaddr);
if (!ML_(generic_PRE_sys_shmdt)(tid, ARG1))
SET_STATUS_Failure( VKI_EINVAL );
PRE(sys_shmctl)
{
- PRINT("sys_shmctl ( %ld, %ld, %#lx )", SARG1, SARG2, ARG3);
+ PRINT("sys_shmctl ( %ld, %ld, %#" FMT_REGWORD "x )", SARG1, SARG2, ARG3);
PRE_REG_READ3(long, "shmctl",
int, shmid, int, cmd, struct shmid_ds *, buf);
#ifdef VGP_amd64_linux
#ifdef __NR_socketcall
PRE(sys_socketcall)
{
-# define ARG2_0 (((UWord*)ARG2)[0])
-# define ARG2_1 (((UWord*)ARG2)[1])
-# define ARG2_2 (((UWord*)ARG2)[2])
-# define ARG2_3 (((UWord*)ARG2)[3])
-# define ARG2_4 (((UWord*)ARG2)[4])
-# define ARG2_5 (((UWord*)ARG2)[5])
+# define ARG2_0 (((UWord*)(Addr)ARG2)[0])
+# define ARG2_1 (((UWord*)(Addr)ARG2)[1])
+# define ARG2_2 (((UWord*)(Addr)ARG2)[2])
+# define ARG2_3 (((UWord*)(Addr)ARG2)[3])
+# define ARG2_4 (((UWord*)(Addr)ARG2)[4])
+# define ARG2_5 (((UWord*)(Addr)ARG2)[5])
// call PRE_MEM_READ and check for EFAULT result.
#define PRE_MEM_READ_ef(msg, arg, size) \
case VKI_SYS_SENDMSG:
/* int sendmsg(int s, const struct msghdr *msg, int flags); */
PRE_MEM_READ_ef( "socketcall.sendmsg(args)", ARG2, 3*sizeof(Addr) );
- ML_(generic_PRE_sys_sendmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 );
+ ML_(generic_PRE_sys_sendmsg)( tid, "msg",
+ (struct vki_msghdr *)(Addr)ARG2_1 );
break;
case VKI_SYS_RECVMSG:
/* int recvmsg(int s, struct msghdr *msg, int flags); */
PRE_MEM_READ_ef("socketcall.recvmsg(args)", ARG2, 3*sizeof(Addr) );
- ML_(generic_PRE_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1 );
+ ML_(generic_PRE_sys_recvmsg)( tid, "msg",
+ (struct vki_msghdr *)(Addr)ARG2_1 );
break;
case VKI_SYS_RECVMMSG:
POST(sys_socketcall)
{
-# define ARG2_0 (((UWord*)ARG2)[0])
-# define ARG2_1 (((UWord*)ARG2)[1])
-# define ARG2_2 (((UWord*)ARG2)[2])
-# define ARG2_3 (((UWord*)ARG2)[3])
-# define ARG2_4 (((UWord*)ARG2)[4])
-# define ARG2_5 (((UWord*)ARG2)[5])
+# define ARG2_0 (((UWord*)(Addr)ARG2)[0])
+# define ARG2_1 (((UWord*)(Addr)ARG2)[1])
+# define ARG2_2 (((UWord*)(Addr)ARG2)[2])
+# define ARG2_3 (((UWord*)(Addr)ARG2)[3])
+# define ARG2_4 (((UWord*)(Addr)ARG2)[4])
+# define ARG2_5 (((UWord*)(Addr)ARG2)[5])
SysRes r;
vg_assert(SUCCESS);
break;
case VKI_SYS_RECVMSG:
- ML_(generic_POST_sys_recvmsg)( tid, "msg", (struct vki_msghdr *)ARG2_1, RES );
+ ML_(generic_POST_sys_recvmsg)( tid, "msg",
+ (struct vki_msghdr *)(Addr)ARG2_1, RES );
break;
case VKI_SYS_RECVMMSG:
PRE(sys_setsockopt)
{
- PRINT("sys_setsockopt ( %ld, %ld, %ld, %#lx, %lu )",
- SARG1, SARG2, SARG3, ARG4, ARG5);
+ PRINT("sys_setsockopt ( %ld, %ld, %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u )", SARG1, SARG2, SARG3, ARG4, ARG5);
PRE_REG_READ5(long, "setsockopt",
int, s, int, level, int, optname,
const void *, optval, unsigned, optlen); // socklen_t
PRE(sys_getsockopt)
{
- PRINT("sys_getsockopt ( %ld, %ld, %ld, %#lx, %ld )",
+ PRINT("sys_getsockopt ( %ld, %ld, %ld, %#" FMT_REGWORD "x, %ld )",
SARG1, SARG2, SARG3, ARG4, SARG5);
PRE_REG_READ5(long, "getsockopt",
int, s, int, level, int, optname,
PRE(sys_connect)
{
*flags |= SfMayBlock;
- PRINT("sys_connect ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_connect ( %ld, %#" FMT_REGWORD "x, %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, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sys_accept ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "accept",
int, s, struct sockaddr *, addr, int *, addrlen);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
PRE(sys_accept4)
{
*flags |= SfMayBlock;
- PRINT("sys_accept4 ( %ld, %#lx, %#lx, %ld )", SARG1, ARG2, ARG3, SARG4);
+ PRINT("sys_accept4 ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %ld )",
+ SARG1, ARG2, ARG3, SARG4);
PRE_REG_READ4(long, "accept4",
int, s, struct sockaddr *, addr, int *, addrlen, int, flags);
ML_(generic_PRE_sys_accept)(tid, ARG1,ARG2,ARG3);
PRE(sys_send)
{
*flags |= SfMayBlock;
- PRINT("sys_send ( %ld, %#lx, %lu, %#lx )", SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_send ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "send",
int, s, const void *, msg, vki_size_t, len,
int, flags);
PRE(sys_sendto)
{
*flags |= SfMayBlock;
- PRINT("sys_sendto ( %ld, %#lx, %lu, %lu, %#lx, %ld )",
+ PRINT("sys_sendto ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u, %#" FMT_REGWORD "x, %ld )",
SARG1, ARG2, ARG3, ARG4, ARG5, SARG6);
PRE_REG_READ6(long, "sendto",
int, s, const void *, msg, vki_size_t, len,
PRE (sys_recv)
{
*flags |= SfMayBlock;
- PRINT ("sys_recv ( %ld, %#lx, %lu, %lu )", SARG1, ARG2, ARG3, ARG4);
+ PRINT ("sys_recv ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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, %lu, %lu, %#lx, %#lx )",
+ PRINT("sys_recvfrom ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(long, "recvfrom",
int, s, void *, buf, vki_size_t, len, unsigned int, flags,
PRE(sys_sendmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_sendmsg ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
+ PRINT("sys_sendmsg ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ SARG1, ARG2, ARG3);
PRE_REG_READ3(long, "sendmsg",
int, s, const struct msghdr *, msg, unsigned int, flags);
- ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr *)ARG2);
+ ML_(generic_PRE_sys_sendmsg)(tid, "msg", (struct vki_msghdr *)(Addr)ARG2);
}
PRE(sys_recvmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_recvmsg ( %ld, %#lx, %lu )", SARG1, ARG2, ARG3);
+ PRINT("sys_recvmsg ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",
+ 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);
+ ML_(generic_PRE_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)(Addr)ARG2);
}
POST(sys_recvmsg)
{
- ML_(generic_POST_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)ARG2, RES);
+ ML_(generic_POST_sys_recvmsg)(tid, "msg", (struct vki_msghdr *)(Addr)ARG2,
+ RES);
}
PRE(sys_shutdown)
PRE(sys_bind)
{
- PRINT("sys_bind ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_bind ( %ld, %#" FMT_REGWORD "x, %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_getsockname)
{
- PRINT("sys_getsockname ( %ld, %#lx, %#lx )", SARG1, ARG2, ARG3);
+ PRINT("sys_getsockname ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ 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 )", SARG1, ARG2, ARG3);
+ PRINT("sys_getpeername ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",
+ 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 )", SARG1, SARG2, SARG3, ARG4);
+ PRINT("sys_socketpair ( %ld, %ld, %ld, %#" FMT_REGWORD "x )", 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 )",
- SARG1, ARG2, (HChar*)ARG2, SARG3, SARG4);
+ PRINT("sys_openat ( %ld, %#" FMT_REGWORD "x(%s), %ld, %ld )",
+ SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, SARG3);
+ PRINT("sys_openat ( %ld, %#" FMT_REGWORD "x(%s), %ld )",
+ SARG1, ARG2, (HChar*)(Addr)ARG2, SARG3);
PRE_REG_READ3(long, "openat",
int, dfd, const char *, filename, int, flags);
}
/* For absolute filenames, dfd is ignored. If dfd is AT_FDCWD,
filename is relative to cwd. When comparing dfd against AT_FDCWD,
be sure only to compare the bottom 32 bits. */
- if (ML_(safe_to_deref)( (void*)ARG2, 1 )
- && *(Char *)ARG2 != '/'
+ if (ML_(safe_to_deref)( (void*)(Addr)ARG2, 1 )
+ && *(Char *)(Addr)ARG2 != '/'
&& ((Int)ARG1) != ((Int)VKI_AT_FDCWD)
&& !ML_(fd_allowed)(ARG1, "openat", tid, False))
SET_STATUS_Failure( VKI_EBADF );
cloned fd back to the start. */
VG_(sprintf)(name, "/proc/%d/cmdline", VG_(getpid)());
- if (ML_(safe_to_deref)( (void*)ARG2, 1 )
- && (VG_(strcmp)((HChar *)ARG2, name) == 0
- || VG_(strcmp)((HChar *)ARG2, "/proc/self/cmdline") == 0)) {
+ if (ML_(safe_to_deref)( (void*)(Addr)ARG2, 1 )
+ && (VG_(strcmp)((HChar *)(Addr)ARG2, name) == 0
+ || VG_(strcmp)((HChar *)(Addr)ARG2, "/proc/self/cmdline") == 0)) {
sres = VG_(dup)( VG_(cl_cmdline_fd) );
SET_STATUS_from_SysRes( sres );
if (!sr_isError(sres)) {
/* Do the same for /proc/self/auxv or /proc/<pid>/auxv case. */
VG_(sprintf)(name, "/proc/%d/auxv", VG_(getpid)());
- if (ML_(safe_to_deref)( (void*)ARG2, 1 )
- && (VG_(strcmp)((HChar *)ARG2, name) == 0
- || VG_(strcmp)((HChar *)ARG2, "/proc/self/auxv") == 0)) {
+ if (ML_(safe_to_deref)( (void*)(Addr)ARG2, 1 )
+ && (VG_(strcmp)((HChar *)(Addr)ARG2, name) == 0
+ || VG_(strcmp)((HChar *)(Addr)ARG2, "/proc/self/auxv") == 0)) {
sres = VG_(dup)( VG_(cl_auxv_fd) );
SET_STATUS_from_SysRes( sres );
if (!sr_isError(sres)) {
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG2);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)(Addr)ARG2);
}
}
PRE(sys_mkdirat)
{
*flags |= SfMayBlock;
- PRINT("sys_mkdirat ( %ld, %#lx(%s), %ld )",
- SARG1, ARG2, (HChar*)ARG2, SARG3);
+ PRINT("sys_mkdirat ( %ld, %#" FMT_REGWORD "x(%s), %ld )",
+ SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4 );
+ PRINT("sys_mknodat ( %ld, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
+ PRINT("sys_fchownat ( %ld, %#" FMT_REGWORD "x(%s), 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3);
+ PRINT("sys_futimesat ( %ld, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",
+ SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
+ PRINT("sys_utimensat ( %ld, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3);
+ PRINT("sys_newfstatat ( %ld, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x )",
+ SARG1, ARG2, (HChar*)(Addr)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) )", SARG1, ARG2, (HChar*)ARG2);
+ PRINT("sys_unlinkat ( %ld, %#" FMT_REGWORD "x(%s) )", SARG1, ARG2,
+ (HChar*)(Addr)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) )",
- SARG1, ARG2, (HChar*)ARG2, SARG3, ARG4, (HChar*)ARG4);
+ PRINT("sys_renameat ( %ld, %#" FMT_REGWORD "x(%s), %ld, %#"
+ FMT_REGWORD "x(%s) )", SARG1, ARG2, (HChar*)(Addr)ARG2, SARG3,
+ ARG4, (HChar*)(Addr)ARG4);
PRE_REG_READ4(long, "renameat",
int, olddfd, const char *, oldpath,
int, newdfd, const char *, newpath);
PRE(sys_renameat2)
{
- PRINT("sys_renameat2 ( %ld, %#lx(%s), %ld, %#lx(%s), %lu )",
- SARG1, ARG2, (HChar*)ARG2, SARG3, ARG4, (HChar*)ARG4, ARG5);
+ PRINT("sys_renameat2 ( %ld, %#" FMT_REGWORD "x(%s), %ld, %#" FMT_REGWORD
+ "x(%s), %" FMT_REGWORD "u )", SARG1, ARG2, (HChar*)(Addr)ARG2, SARG3,
+ ARG4, (HChar*)(Addr)ARG4, ARG5);
PRE_REG_READ5(long, "renameat2",
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 )",
- SARG1, ARG2, (HChar*)ARG2, SARG3, ARG4, (HChar*)ARG4, SARG5);
+ PRINT("sys_linkat ( %ld, %#" FMT_REGWORD "x(%s), %ld, %#" FMT_REGWORD
+ "x(%s), %ld )", SARG1, ARG2, (HChar*)(Addr)ARG2, SARG3, ARG4,
+ (HChar*)(Addr)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, (HChar*)ARG1, SARG2, ARG3, (HChar*)ARG3);
+ PRINT("sys_symlinkat ( %#" FMT_REGWORD "x(%s), %ld, %#" FMT_REGWORD
+ "x(%s) )", ARG1, (HChar*)(Addr)ARG1, SARG2, ARG3, (HChar*)(Addr)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, %lu )",
- SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4);
+ PRINT("sys_readlinkat ( %ld, %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", SARG1, ARG2, (HChar*)(Addr)ARG2, ARG3, ARG4);
PRE_REG_READ4(long, "readlinkat",
int, dfd, const char *, path, char *, buf, vki_size_t, bufsiz);
PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
* /proc/<pid>/exe.
*/
VG_(sprintf)(name, "/proc/%d/exe", VG_(getpid)());
- if (ML_(safe_to_deref)((void*)ARG2, 1)
- && (VG_(strcmp)((HChar *)ARG2, name) == 0
- || VG_(strcmp)((HChar *)ARG2, "/proc/self/exe") == 0)) {
+ if (ML_(safe_to_deref)((void*)(Addr)ARG2, 1)
+ && (VG_(strcmp)((HChar *)(Addr)ARG2, name) == 0
+ || VG_(strcmp)((HChar *)(Addr)ARG2, "/proc/self/exe") == 0)) {
VG_(sprintf)(name, "/proc/self/fd/%d", VG_(cl_exec_fd));
SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, (UWord)name,
ARG3, ARG4));
PRE(sys_fchmodat)
{
- PRINT("sys_fchmodat ( %ld, %#lx(%s), %lu )",
- SARG1, ARG2, (HChar*)ARG2, ARG3);
+ PRINT("sys_fchmodat ( %ld, %#" FMT_REGWORD "x(%s), %" FMT_REGWORD "u )",
+ SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, SARG3);
+ PRINT("sys_faccessat ( %ld, %#" FMT_REGWORD "x(%s), %ld )",
+ SARG1, ARG2, (HChar*)(Addr)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 )",
- SARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, SARG5);
+ PRINT("sys_name_to_handle_at ( %ld, %#" FMT_REGWORD "x(%s), %#"
+ FMT_REGWORD "x, %#" FMT_REGWORD "x, %ld )", SARG1, ARG2,
+ (HChar*)(Addr)ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(int, "name_to_handle_at",
int, dfd, const char *, name,
struct vki_file_handle *, handle,
int *, mnt_id, int, flag);
PRE_MEM_RASCIIZ( "name_to_handle_at(name)", ARG2 );
- if (ML_(safe_to_deref)( (void*)ARG3, sizeof(struct vki_file_handle))) {
- struct vki_file_handle *fh = (struct vki_file_handle *)ARG3;
+ if (ML_(safe_to_deref)( (void*)(Addr)ARG3, sizeof(struct vki_file_handle))) {
+ struct vki_file_handle *fh = (struct vki_file_handle *)(Addr)ARG3;
PRE_MEM_READ( "name_to_handle_at(handle)", (Addr)&fh->handle_bytes, sizeof(fh->handle_bytes) );
PRE_MEM_WRITE( "name_to_handle_at(handle)", (Addr)fh, sizeof(struct vki_file_handle) + fh->handle_bytes );
}
POST(sys_name_to_handle_at)
{
- struct vki_file_handle *fh = (struct vki_file_handle *)ARG3;
+ struct vki_file_handle *fh = (struct vki_file_handle *)(Addr)ARG3;
POST_MEM_WRITE( ARG3, sizeof(struct vki_file_handle) + fh->handle_bytes );
POST_MEM_WRITE( ARG4, sizeof(int) );
}
PRE(sys_open_by_handle_at)
{
*flags |= SfMayBlock;
- PRINT("sys_open_by_handle_at ( %ld, %#lx, %ld )", SARG1, ARG2, SARG3);
+ PRINT("sys_open_by_handle_at ( %ld, %#" FMT_REGWORD "x, %ld )", SARG1,
+ ARG2, SARG3);
PRE_REG_READ3(int, "open_by_handle_at",
int, mountdirfd,
struct vki_file_handle *, handle,
int, flags);
- PRE_MEM_READ( "open_by_handle_at(handle)", ARG2, sizeof(struct vki_file_handle) + ((struct vki_file_handle*)ARG2)->handle_bytes );
+ PRE_MEM_READ( "open_by_handle_at(handle)", ARG2,
+ sizeof(struct vki_file_handle) +
+ ((struct vki_file_handle*)(Addr)ARG2)->handle_bytes);
}
POST(sys_open_by_handle_at)
SET_STATUS_Failure( VKI_EMFILE );
} else {
if (VG_(clo_track_fds))
- ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)ARG2);
+ ML_(record_fd_open_with_given_name)(tid, RES, (HChar*)(Addr)ARG2);
}
}
#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 ( %lu, %#lx, %lu, %lld )",
+ PRINT("sys_preadv ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u, %lld )",
ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5));
PRE_REG_READ5(ssize_t, "preadv",
unsigned long, fd, const struct iovec *, vector,
if (ARG2 != 0) {
/* ToDo: don't do any of the following if the vector is invalid */
- vec = (struct vki_iovec *)ARG2;
+ vec = (struct vki_iovec *)(Addr)ARG2;
for (i = 0; i < (Int)ARG3; i++)
PRE_MEM_WRITE( "preadv(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
vg_assert(SUCCESS);
if (RES > 0) {
Int i;
- struct vki_iovec * vec = (struct vki_iovec *)ARG2;
+ struct vki_iovec * vec = (struct vki_iovec *)(Addr)ARG2;
Int remains = RES;
/* RES holds the number of bytes read. */
#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 ( %lu, %#lx, %lu, %lld )",
- ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5));
+ PRINT("sys_pwritev ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u, %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,
ARG2, ARG3 * sizeof(struct vki_iovec) );
if (ARG2 != 0) {
/* ToDo: don't do any of the following if the vector is invalid */
- vec = (struct vki_iovec *)ARG2;
+ vec = (struct vki_iovec *)(Addr)ARG2;
for (i = 0; i < (Int)ARG3; i++)
PRE_MEM_READ( "pwritev(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
PRE(sys_process_vm_readv)
{
- PRINT("sys_process_vm_readv ( %ld, %#lx, %lu, %#lx, %lu, %lu )",
+ PRINT("sys_process_vm_readv ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(ssize_t, "process_vm_readv",
vki_pid_t, pid,
PRE_MEM_READ( "process_vm_readv(rvec)",
ARG4, ARG5 * sizeof(struct vki_iovec) );
if (ARG2 != 0
- && ML_(safe_to_deref) ((void *)ARG2, sizeof(struct vki_iovec) * ARG3)) {
- const struct vki_iovec *vec = (const struct vki_iovec *)ARG2;
+ && ML_(safe_to_deref) ((void *)(Addr)ARG2,
+ sizeof(struct vki_iovec) * ARG3)) {
+ const struct vki_iovec *vec = (const struct vki_iovec *)(Addr)ARG2;
UInt i;
for (i = 0; i < ARG3; i++)
PRE_MEM_WRITE( "process_vm_readv(lvec[...])",
POST(sys_process_vm_readv)
{
- const struct vki_iovec *vec = (const struct vki_iovec *)ARG2;
+ const struct vki_iovec *vec = (const struct vki_iovec *)(Addr)ARG2;
UInt remains = RES;
UInt i;
for (i = 0; i < ARG3; i++) {
PRE(sys_process_vm_writev)
{
- PRINT("sys_process_vm_writev ( %ld, %#lx, %lu, %#lx, %lu, %lu )",
+ PRINT("sys_process_vm_writev ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(ssize_t, "process_vm_writev",
vki_pid_t, pid,
PRE_MEM_READ( "process_vm_writev(rvec)",
ARG4, ARG5 * sizeof(struct vki_iovec) );
if (ARG2 != 0
- && ML_(safe_to_deref) ((void *)ARG2, sizeof(struct vki_iovec) * ARG3)) {
- const struct vki_iovec *vec = (const struct vki_iovec *)ARG2;
+ && ML_(safe_to_deref) ((void *)(Addr)ARG2,
+ sizeof(struct vki_iovec) * ARG3)) {
+ const struct vki_iovec *vec = (const struct vki_iovec *)(Addr)ARG2;
UInt i;
for (i = 0; i < ARG3; i++)
PRE_MEM_READ( "process_vm_writev(lvec[...])",
PRE(sys_sendmmsg)
{
*flags |= SfMayBlock;
- PRINT("sys_sendmmsg ( %ld, %#lx, %ld, %ld )", SARG1, ARG2, SARG3, SARG4);
+ PRINT("sys_sendmmsg ( %ld, %#" FMT_REGWORD "x, %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 )",
+ PRINT("sys_recvmmsg ( %ld, %#" FMT_REGWORD "x, %ld, %ld, %#"
+ FMT_REGWORD "x )",
SARG1, ARG2, SARG3, SARG4, ARG5);
PRE_REG_READ5(long, "recvmmsg",
int, s, struct mmsghdr *, mmsg, int, vlen,
PRE(sys_request_key)
{
- PRINT("sys_request_key ( %#lx(%s), %#lx(%s), %#lx(%s), %ld )",
- ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3, (HChar*)ARG3, SARG4);
+ PRINT("sys_request_key ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s), %#"
+ FMT_REGWORD "x(%s), %ld )", ARG1, (HChar*)(Addr)ARG1, ARG2,
+ (HChar*)(Addr)ARG2, ARG3, (HChar*)(Addr)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, %lu, %ld )",
- ARG1, (HChar*)ARG1, ARG2, (HChar*)ARG2, ARG3, ARG4, SARG5);
+ PRINT("sys_add_key ( %#" FMT_REGWORD "x(%s), %#" FMT_REGWORD "x(%s), %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u, %ld )", ARG1, (HChar*)(Addr)ARG1,
+ ARG2, (HChar*)(Addr)ARG2, ARG3, ARG4, SARG5);
PRE_REG_READ5(long, "add_key",
const char *, type, const char *, description,
const void *, payload, vki_size_t, plen,
int, option, vki_key_serial_t, id, int, create);
break;
case VKI_KEYCTL_JOIN_SESSION_KEYRING:
- PRINT("sys_keyctl ( KEYCTL_JOIN_SESSION_KEYRING, %#lx(%s) )", ARG2,(char*)ARG2);
+ PRINT("sys_keyctl ( KEYCTL_JOIN_SESSION_KEYRING, %#" FMT_REGWORD
+ "x(%s) )", ARG2,(char*)(Addr)ARG2);
PRE_REG_READ2(long, "keyctl(KEYCTL_JOIN_SESSION_KEYRING)",
int, option, const char *, name);
if (ARG2 != (UWord)NULL)
PRE_MEM_RASCIIZ("keyctl(KEYCTL_JOIN_SESSION_KEYRING, name)", ARG2);
break;
case VKI_KEYCTL_UPDATE:
- PRINT("sys_keyctl ( KEYCTL_UPDATE, %ld, %#lx, %lu )", SARG2, ARG3, ARG4);
+ PRINT("sys_keyctl ( KEYCTL_UPDATE, %ld, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_UPDATE)",
int, option, vki_key_serial_t, key,
const void *, payload, vki_size_t, plen);
int, option, vki_key_serial_t, id);
break;
case VKI_KEYCTL_CHOWN:
- PRINT("sys_keyctl ( KEYCTL_CHOWN, %ld, %lu, %lu )", SARG2, ARG3, ARG4);
+ PRINT("sys_keyctl ( KEYCTL_CHOWN, %ld, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", 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, %lu )", SARG2, ARG3);
+ PRINT("sys_keyctl ( KEYCTL_SETPERM, %ld, %" FMT_REGWORD "u )",
+ 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, %lu )", SARG2, ARG3, ARG4);
+ PRINT("sys_keyctl ( KEYCTL_DESCRIBE, %ld, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u )", SARG2, ARG3, ARG4);
PRE_REG_READ4(long, "keyctl(KEYCTL_DESCRIBE)",
int, option, vki_key_serial_t, id,
char *, buffer, vki_size_t, buflen);
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 )",
- SARG2, ARG3, (HChar*)ARG3, ARG4, (HChar*)ARG4, SARG5);
+ PRINT("sys_keyctl ( KEYCTL_SEARCH, %ld, %#" FMT_REGWORD "x(%s), %#"
+ FMT_REGWORD "x(%s), %ld )", SARG2, ARG3, (HChar*)(Addr)ARG3,
+ ARG4, (HChar*)(Addr)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, %lu )", SARG2, ARG3, ARG4);
+ PRINT("sys_keyctl ( KEYCTL_READ, %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD
+ "u )", 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, %lu, %ld )",
- SARG2, ARG3, ARG4, SARG5);
+ PRINT("sys_keyctl ( KEYCTL_INSTANTIATE, %ld, %#" FMT_REGWORD "x, %"
+ FMT_REGWORD "u, %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 )", SARG2, ARG3, SARG4);
+ PRINT("sys_keyctl ( KEYCTL_NEGATE, %ld, %" FMT_REGWORD "u, %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);
int, option, int, reqkey_defl);
break;
case VKI_KEYCTL_SET_TIMEOUT:
- PRINT("sys_keyctl ( KEYCTL_SET_TIMEOUT, %ld, %lu )", SARG2, ARG3);
+ PRINT("sys_keyctl ( KEYCTL_SET_TIMEOUT, %ld, %" FMT_REGWORD "u )",
+ SARG2, ARG3);
PRE_REG_READ3(long, "keyctl(KEYCTL_SET_TIMEOUT)",
int, option, vki_key_serial_t, key, unsigned, timeout);
break;
PRE(sys_init_module)
{
*flags |= SfMayBlock;
- PRINT("sys_init_module ( %#lx, %lu, %#lx(\"%s\") )",
- ARG1, ARG2, ARG3, (HChar*)ARG3);
+ PRINT("sys_init_module ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#"
+ FMT_REGWORD "x(\"%s\") )", ARG1, ARG2, ARG3, (HChar*)(Addr)ARG3);
PRE_REG_READ3(long, "init_module",
void *, umod, unsigned long, len, const char *, uargs);
PRE_MEM_READ( "init_module(umod)", ARG1, ARG2 );
{
*flags |= SfMayBlock;
- PRINT("sys_finit_module ( %lx, %#lx(\"%s\"), %lx )",
- ARG1, ARG2, (HChar*)ARG2, ARG3);
+ PRINT("sys_finit_module ( %" FMT_REGWORD "x, %#" FMT_REGWORD "x(\"%s\"), %"
+ FMT_REGWORD "x )", ARG1, ARG2, (HChar*)(Addr)ARG2, ARG3);
PRE_REG_READ3(long, "finit_module",
int, fd, const char *, params, int, flags);
PRE_MEM_RASCIIZ("finit_module(params)", ARG2);
PRE(sys_delete_module)
{
*flags |= SfMayBlock;
- PRINT("sys_delete_module ( %#lx(\"%s\"), 0x%lx )", ARG1, (HChar*)ARG1, ARG2);
+ PRINT("sys_delete_module ( %#" FMT_REGWORD "x(\"%s\"), 0x%" FMT_REGWORD
+ "x )", ARG1, (HChar*)(Addr)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, %lu, %#lx )",
+ PRINT("sys_splice ( %ld, %#" FMT_REGWORD "x, %ld, %#"
+ FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
SARG1, ARG2, SARG3, ARG4, ARG5, ARG6);
PRE_REG_READ6(vki_ssize_t, "splice",
int, fd_in, vki_loff_t *, off_in,
PRE(sys_tee)
{
*flags |= SfMayBlock;
- PRINT("sys_tree ( %ld, %ld, %lu, %#lx )", SARG1, SARG2, ARG3, ARG4);
+ PRINT("sys_tree ( %ld, %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",
+ 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, %lu, %lu )", SARG1, ARG2, ARG3, ARG4);
+ PRINT("sys_vmsplice ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", SARG1, ARG2, ARG3, ARG4);
PRE_REG_READ4(vki_ssize_t, "splice",
int, fd, struct vki_iovec *, iov,
unsigned long, nr_segs, unsigned int, flags);
} else {
const struct vki_iovec *iov;
PRE_MEM_READ( "vmsplice(iov)", ARG2, sizeof(struct vki_iovec) * ARG3 );
- for (iov = (struct vki_iovec *)ARG2;
- iov < (struct vki_iovec *)ARG2 + ARG3; iov++)
+ for (iov = (struct vki_iovec *)(Addr)ARG2;
+ iov < (struct vki_iovec *)(Addr)ARG2 + ARG3; iov++)
{
if (ML_(safe_to_deref) (iov, sizeof(struct vki_iovec))) {
if ((fdfl & VKI_O_ACCMODE) == VKI_O_RDONLY)
if ((fdfl & VKI_O_ACCMODE) == VKI_O_RDONLY)
{
const struct vki_iovec *iov;
- for (iov = (struct vki_iovec *)ARG2;
- iov < (struct vki_iovec *)ARG2 + ARG3; iov++)
+ for (iov = (struct vki_iovec *)(Addr)ARG2;
+ iov < (struct vki_iovec *)(Addr)ARG2 + ARG3; iov++)
{
POST_MEM_WRITE( (Addr)iov->iov_base, iov->iov_len );
}
case VKI_F_GETSIG:
case VKI_F_GETLEASE:
case VKI_F_GETPIPE_SZ:
- PRINT("sys_fcntl ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_fcntl ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", 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'] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[ARG3=='arg'] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", 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'] ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_flock *, lock);
{
- struct vki_flock *lock = (struct vki_flock *) ARG3;
+ struct vki_flock *lock = (struct vki_flock *) (Addr)ARG3;
PRE_FIELD_READ("fcntl(lock->l_type)", lock->l_type);
PRE_FIELD_READ("fcntl(lock->l_whence)", lock->l_whence);
PRE_FIELD_READ("fcntl(lock->l_start)", lock->l_start);
case VKI_F_GETLK64:
case VKI_F_SETLK64:
case VKI_F_SETLKW64:
- PRINT("sys_fcntl[ARG3=='lock'] ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[ARG3=='lock'] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct flock64 *, lock);
{
- struct vki_flock64 *lock = (struct vki_flock64 *) ARG3;
+ struct vki_flock64 *lock = (struct vki_flock64 *) (Addr)ARG3;
PRE_FIELD_READ("fcntl(lock->l_type)", lock->l_type);
PRE_FIELD_READ("fcntl(lock->l_whence)", lock->l_whence);
PRE_FIELD_READ("fcntl(lock->l_start)", lock->l_start);
# endif
case VKI_F_SETOWN_EX:
- PRINT("sys_fcntl[F_SETOWN_EX] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[F_SETOWN_EX] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", 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] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[F_GETOWN_EX] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", 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] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
- VG_(umsg)("Warning: unimplemented fcntl command: %lu\n", ARG2);
+ PRINT("sys_fcntl[UNKNOWN] ( %" FMT_REGWORD "u, %" FMT_REGWORD "u, %"
+ FMT_REGWORD "u )", ARG1, ARG2, ARG3);
+ VG_(umsg)("Warning: unimplemented fcntl command: %" FMT_REGWORD "u\n",
+ ARG2);
SET_STATUS_Failure( VKI_EINVAL );
break;
}
} else if (ARG2 == VKI_F_GETOWN_EX) {
POST_MEM_WRITE(ARG3, sizeof(struct vki_f_owner_ex));
} else if (ARG2 == VKI_F_GETLK || ARG2 == VKI_F_OFD_GETLK) {
- struct vki_flock *lock = (struct vki_flock *) ARG3;
+ struct vki_flock *lock = (struct vki_flock *) (Addr)ARG3;
POST_FIELD_WRITE(lock->l_pid);
# if defined(VGP_x86_linux) || defined(VGP_mips64_linux)
} else if (ARG2 == VKI_F_GETLK64) {
- struct vki_flock64 *lock = (struct vki_flock64 *) ARG3;
+ struct vki_flock64 *lock = (struct vki_flock64 *) (Addr)ARG3;
PRE_FIELD_WRITE("fcntl(lock->l_pid)", lock->l_pid);
# endif
}
case VKI_F_GETSIG:
case VKI_F_SETSIG:
case VKI_F_GETLEASE:
- PRINT("sys_fcntl64 ( %lu, %lu )", ARG1, ARG2);
+ PRINT("sys_fcntl64 ( %" FMT_REGWORD "u, %" FMT_REGWORD "u )", 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'] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl64[ARG3=='arg'] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", 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'] ( %lu, %lu, %#lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl64[ARG3=='lock'] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %#" FMT_REGWORD "x )", 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] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[F_SETOWN_EX] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", 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] ( %lu, %lu, %lu )", ARG1, ARG2, ARG3);
+ PRINT("sys_fcntl[F_GETOWN_EX] ( %" FMT_REGWORD "u, %" FMT_REGWORD
+ "u, %" FMT_REGWORD "u )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "fcntl",
unsigned int, fd, unsigned int, cmd,
struct vki_f_owner_ex *, arg);
/* DVB */
case VKI_DMX_STOP:
- PRINT("sys_ioctl ( %lu, 0x%lx )", ARG1, ARG2);
+ PRINT("sys_ioctl ( %" FMT_REGWORD "u, 0x%" FMT_REGWORD "x )", ARG1, ARG2);
PRE_REG_READ2(long, "ioctl",
unsigned int, fd, unsigned int, request);
return;
default:
- PRINT("sys_ioctl ( %lu, 0x%lx, 0x%lx )", ARG1, ARG2, ARG3);
+ PRINT("sys_ioctl ( %" FMT_REGWORD "u, 0x%" FMT_REGWORD "x, 0x%"
+ FMT_REGWORD "x )", ARG1, ARG2, ARG3);
PRE_REG_READ3(long, "ioctl",
unsigned int, fd, unsigned int, request, unsigned long, arg);
break;
case VKI_ION_IOC_ALLOC: {
struct vki_ion_allocation_data* data
- = (struct vki_ion_allocation_data*)ARG3;
+ = (struct vki_ion_allocation_data*)(Addr)ARG3;
PRE_FIELD_READ ("ioctl(ION_IOC_ALLOC).len", data->len);
PRE_FIELD_READ ("ioctl(ION_IOC_ALLOC).align", data->align);
PRE_FIELD_READ ("ioctl(ION_IOC_ALLOC).heap_id_mask", data->heap_id_mask);
break;
}
case VKI_ION_IOC_MAP: {
- struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)ARG3;
+ struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)(Addr)ARG3;
PRE_FIELD_READ ("ioctl(ION_IOC_MAP).handle", data->handle);
PRE_FIELD_WRITE("ioctl(ION_IOC_MAP).fd", data->fd);
break;
}
case VKI_ION_IOC_IMPORT: {
- struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)ARG3;
+ struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)(Addr)ARG3;
PRE_FIELD_READ ("ioctl(ION_IOC_IMPORT).fd", data->fd);
PRE_FIELD_WRITE("ioctl(ION_IOC_IMPORT).handle", data->handle);
break;
}
case VKI_SYNC_IOC_MERGE: {
- struct vki_sync_merge_data* data = (struct vki_sync_merge_data*)ARG3;
+ struct vki_sync_merge_data* data =
+ (struct vki_sync_merge_data*)(Addr)ARG3;
PRE_FIELD_READ ("ioctl(SYNC_IOC_MERGE).fd2", data->fd2);
PRE_MEM_RASCIIZ("ioctl(SYNC_IOC_MERGE).name", (Addr)(&data->name[0]));
PRE_FIELD_WRITE("ioctl(SYNC_IOC_MERGE).fence", data->fence);
break;
case VKI_TIOCLINUX:
PRE_MEM_READ( "ioctl(TIOCLINUX)", ARG3, sizeof(char *) );
- if (*(char *)ARG3 == 11) {
+ if (*(char *)(Addr)ARG3 == 11) {
PRE_MEM_READ( "ioctl(TIOCLINUX, 11)", ARG3, 2 * sizeof(char *) );
}
break;
case VKI_SG_IO:
PRE_MEM_READ( "ioctl(SG_IO)", ARG3, sizeof(vki_sg_io_hdr_t) );
{
- vki_sg_io_hdr_t *sgio = (vki_sg_io_hdr_t*)ARG3;
+ vki_sg_io_hdr_t *sgio = (vki_sg_io_hdr_t*)(Addr)ARG3;
PRE_MEM_READ( "ioctl(SG_IO)", (Addr)sgio->cmdp, sgio->cmd_len );
if ( sgio->dxfer_direction == VKI_SG_DXFER_TO_DEV ||
sgio->dxfer_direction == VKI_SG_DXFER_TO_FROM_DEV ) {
break;
case VKI_IIOCNETGPN:
PRE_MEM_READ( "ioctl(IIOCNETGPN)",
- (Addr)&((vki_isdn_net_ioctl_phone *)ARG3)->name,
- sizeof(((vki_isdn_net_ioctl_phone *)ARG3)->name) );
+ (Addr)&((vki_isdn_net_ioctl_phone *)(Addr)ARG3)->name,
+ sizeof(((vki_isdn_net_ioctl_phone *)(Addr)ARG3)->name) );
PRE_MEM_WRITE( "ioctl(IIOCNETGPN)", ARG3,
sizeof(vki_isdn_net_ioctl_phone) );
break;
/* These all use struct ifreq AFAIK */
case VKI_SIOCGIFINDEX: /* get iface index */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFINDEX)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFINDEX)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFFLAGS: /* get flags */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFFLAGS)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFFLAGS)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFHWADDR: /* Get hardware address */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFHWADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFHWADDR)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMTU: /* get MTU size */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMTU)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFMTU)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFADDR: /* get PA address */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFADDR)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFNETMASK: /* get network PA mask */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFNETMASK)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFNETMASK)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMETRIC: /* get metric */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMETRIC)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFMETRIC)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMAP: /* Get device parameters */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMAP)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFMAP)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFTXQLEN: /* Get the tx queue length */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFTXQLEN)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFTXQLEN)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFDSTADDR: /* get remote PA address */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFDSTADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFDSTADDR)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFBRDADDR: /* get broadcast PA address */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFBRDADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFBRDADDR)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFNAME: /* get iface name */
PRE_MEM_READ( "ioctl(SIOCGIFNAME)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_ifindex,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_ifindex) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_ifindex,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_ifindex));
PRE_MEM_WRITE( "ioctl(SIOCGIFNAME)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCETHTOOL: { /* ethtool(8) interface */
- struct vki_ifreq *ir = (struct vki_ifreq *)ARG3;
+ struct vki_ifreq *ir = (struct vki_ifreq *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(SIOCETHTOOL)", (Addr)ir, sizeof(struct vki_ifreq) );
PRE_MEM_RASCIIZ( "ioctl(SIOCETHTOOL)", (Addr)ir->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCETHTOOL)", (Addr)ir->vki_ifr_data, sizeof(vki_u32) );
}
case VKI_SIOCGMIIPHY: /* get hardware entry */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIPHY)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_WRITE( "ioctl(SIOCGIFMIIPHY)", ARG3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGMIIREG: /* get hardware entry registers */
PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIREG)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id));
PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->reg_num,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->reg_num));
PRE_MEM_WRITE( "ioctl(SIOCGIFMIIREG)", ARG3,
sizeof(struct vki_ifreq));
break;
POST_MEM_WRITE(ARG3, sizeof(struct ifconf));
*/
PRE_MEM_READ( "ioctl(SIOCGIFCONF)",
- (Addr)&((struct vki_ifconf *)ARG3)->ifc_len,
- sizeof(((struct vki_ifconf *)ARG3)->ifc_len));
+ (Addr)&((struct vki_ifconf *)(Addr)ARG3)->ifc_len,
+ sizeof(((struct vki_ifconf *)(Addr)ARG3)->ifc_len));
PRE_MEM_READ( "ioctl(SIOCGIFCONF)",
- (Addr)&((struct vki_ifconf *)ARG3)->vki_ifc_buf,
- sizeof(((struct vki_ifconf *)ARG3)->vki_ifc_buf));
+ (Addr)&((struct vki_ifconf *)(Addr)ARG3)->vki_ifc_buf,
+ sizeof(((struct vki_ifconf *)(Addr)ARG3)->vki_ifc_buf));
if ( ARG3 ) {
// TODO len must be readable and writable
// buf pointer only needs to be readable
- struct vki_ifconf *ifc = (struct vki_ifconf *) ARG3;
+ struct vki_ifconf *ifc = (struct vki_ifconf *) (Addr)ARG3;
PRE_MEM_WRITE( "ioctl(SIOCGIFCONF).ifc_buf",
(Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
}
case VKI_SIOCSIFFLAGS: /* set flags */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFFLAGS)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags) );
break;
case VKI_SIOCSIFMAP: /* Set device parameters */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMAP)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFMAP)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_map,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_map) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_map,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_map) );
break;
case VKI_SIOCSHWTSTAMP: /* Set hardware time stamping */
PRE_MEM_RASCIIZ( "ioctl(SIOCSHWTSTAMP)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSHWTSTAMP)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_data,
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data,
sizeof(struct vki_hwtstamp_config) );
break;
case VKI_SIOCSIFTXQLEN: /* Set the tx queue length */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFTXQLEN)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFTXQLEN)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_qlen,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_qlen) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_qlen,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_qlen) );
break;
case VKI_SIOCSIFADDR: /* set PA address */
case VKI_SIOCSIFDSTADDR: /* set remote PA address */
case VKI_SIOCSIFBRDADDR: /* set broadcast PA address */
case VKI_SIOCSIFNETMASK: /* set network PA mask */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIF*ADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIF*ADDR)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_addr,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_addr) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_addr,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_addr) );
break;
case VKI_SIOCSIFMETRIC: /* set metric */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMETRIC)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFMETRIC)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_metric,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_metric) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_metric,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_metric) );
break;
case VKI_SIOCSIFMTU: /* set MTU size */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMTU)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFMTU)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_mtu,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_mtu) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_mtu,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_mtu) );
break;
case VKI_SIOCSIFHWADDR: /* set hardware address */
PRE_MEM_RASCIIZ( "ioctl(SIOCSIFHWADDR)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSIFHWADDR)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_hwaddr,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_hwaddr) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_hwaddr,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_hwaddr) );
break;
case VKI_SIOCSMIIREG: /* set hardware entry registers */
PRE_MEM_RASCIIZ( "ioctl(SIOCSMIIREG)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id));
PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->reg_num,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->reg_num));
PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_in,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_in) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->val_in,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->val_in));
break;
/* Routing table calls. */
case VKI_SIOCADDRT: /* add routing table entry */
break;
case VKI_TUNSETIFF:
PRE_MEM_RASCIIZ( "ioctl(TUNSETIFF)",
- (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
+ (Addr)((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name );
PRE_MEM_READ( "ioctl(TUNSETIFF)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags) );
PRE_MEM_WRITE( "ioctl(TUNSETIFF)", ARG3, sizeof(struct vki_ifreq) );
break;
case VKI_TUNSETPERSIST:
break;
case VKI_TUNSETQUEUE:
PRE_MEM_READ( "ioctl(TUNSETQUEUE)",
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags) );
break;
case VKI_TUNSETIFINDEX:
PRE_MEM_READ( "ioctl(TUNSETIFINDEX)", ARG3, sizeof(unsigned int));
PRE_MEM_WRITE( "ioctl(SNDRV_CTL_IOCTL_CARD_INFO)", (Addr)ARG3, sizeof(struct vki_snd_ctl_card_info) );
break;
case VKI_SNDRV_CTL_IOCTL_ELEM_LIST: {
- struct vki_snd_ctl_elem_list *data = (struct vki_snd_ctl_elem_list *)ARG3;
+ struct vki_snd_ctl_elem_list *data =
+ (struct vki_snd_ctl_elem_list *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_ELEM_LIST)", (Addr)&data->offset, sizeof(data->offset) );
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_ELEM_LIST)", (Addr)&data->space, sizeof(data->space) );
PRE_MEM_WRITE( "ioctl(SNDRV_CTL_IOCTL_ELEM_LIST)", (Addr)&data->used, sizeof(data->used) );
break;
}
case VKI_SNDRV_CTL_IOCTL_TLV_READ: {
- struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)ARG3;
+ struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_TLV_READ)", (Addr)&data->numid, sizeof(data->numid) );
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_TLV_READ)", (Addr)&data->length, sizeof(data->length) );
PRE_MEM_WRITE( "ioctl(SNDRV_CTL_IOCTL_TLV_READ)", (Addr)data->tlv, data->length );
}
case VKI_SNDRV_CTL_IOCTL_TLV_WRITE:
case VKI_SNDRV_CTL_IOCTL_TLV_COMMAND: {
- struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)ARG3;
+ struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_TLV_WRITE)", (Addr)&data->numid, sizeof(data->numid) );
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_TLV_WRITE)", (Addr)&data->length, sizeof(data->length) );
PRE_MEM_READ( "ioctl(SNDRV_CTL_IOCTL_TLV_WRITE)", (Addr)data->tlv, data->length );
break;
case VKI_CDROMSUBCHNL:
PRE_MEM_READ( "ioctl(CDROMSUBCHNL (cdsc_format, char))",
- (Addr) &(((struct vki_cdrom_subchnl*) ARG3)->cdsc_format),
- sizeof(((struct vki_cdrom_subchnl*) ARG3)->cdsc_format));
+ (Addr) &(((struct vki_cdrom_subchnl*) (Addr)ARG3)->cdsc_format),
+ sizeof(((struct vki_cdrom_subchnl*) (Addr)ARG3)->cdsc_format));
PRE_MEM_WRITE( "ioctl(CDROMSUBCHNL)", ARG3,
sizeof(struct vki_cdrom_subchnl));
break;
break;
case VKI_CDROMREADTOCENTRY:
PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_format, char))",
- (Addr) &(((struct vki_cdrom_tocentry*) ARG3)->cdte_format),
- sizeof(((struct vki_cdrom_tocentry*) ARG3)->cdte_format));
+ (Addr) &(((struct vki_cdrom_tocentry*) (Addr)ARG3)->cdte_format),
+ sizeof(((struct vki_cdrom_tocentry*) (Addr)ARG3)->cdte_format));
PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_track, char))",
- (Addr) &(((struct vki_cdrom_tocentry*) ARG3)->cdte_track),
- sizeof(((struct vki_cdrom_tocentry*) ARG3)->cdte_track));
+ (Addr) &(((struct vki_cdrom_tocentry*) (Addr)ARG3)->cdte_track),
+ sizeof(((struct vki_cdrom_tocentry*) (Addr)ARG3)->cdte_track));
PRE_MEM_WRITE( "ioctl(CDROMREADTOCENTRY)", ARG3,
sizeof(struct vki_cdrom_tocentry));
break;
sizeof (struct vki_cdrom_read_audio));
if ( ARG3 ) {
/* ToDo: don't do any of the following if the structure is invalid */
- struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) ARG3;
+ struct vki_cdrom_read_audio *cra =
+ (struct vki_cdrom_read_audio *) (Addr)ARG3;
PRE_MEM_WRITE( "ioctl(CDROMREADAUDIO).buf",
(Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
}
PRE_MEM_READ( "ioctl(GIO_FONTX)", ARG3, sizeof(struct vki_consolefontdesc) );
if ( ARG3 ) {
/* ToDo: don't do any of the following if the structure is invalid */
- struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)ARG3;
+ struct vki_consolefontdesc *cfd =
+ (struct vki_consolefontdesc *)(Addr)ARG3;
PRE_MEM_WRITE( "ioctl(GIO_FONTX).chardata", (Addr)cfd->chardata,
32 * cfd->charcount );
}
PRE_MEM_READ( "ioctl(PIO_FONTX)", ARG3, sizeof(struct vki_consolefontdesc) );
if ( ARG3 ) {
/* ToDo: don't do any of the following if the structure is invalid */
- struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)ARG3;
+ struct vki_consolefontdesc *cfd =
+ (struct vki_consolefontdesc *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(PIO_FONTX).chardata", (Addr)cfd->chardata,
32 * cfd->charcount );
}
case VKI_GIO_UNIMAP:
if ( ARG3 ) {
- struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
+ struct vki_unimapdesc *desc = (struct vki_unimapdesc *) (Addr)ARG3;
PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
sizeof(unsigned short));
PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
break;
case VKI_PIO_UNIMAP:
if ( ARG3 ) {
- struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
+ struct vki_unimapdesc *desc = (struct vki_unimapdesc *) (Addr)ARG3;
PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
sizeof(unsigned short) );
PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
case VKI_KDGKBENT:
PRE_MEM_READ( "ioctl(KDGKBENT).kb_table",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_table,
- sizeof(((struct vki_kbentry *)ARG3)->kb_table) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_table,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_table) );
PRE_MEM_READ( "ioctl(KDGKBENT).kb_index",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_index,
- sizeof(((struct vki_kbentry *)ARG3)->kb_index) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_index,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_index) );
PRE_MEM_WRITE( "ioctl(KDGKBENT).kb_value",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
- sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_value,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_value) );
break;
case VKI_KDSKBENT:
PRE_MEM_READ( "ioctl(KDSKBENT).kb_table",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_table,
- sizeof(((struct vki_kbentry *)ARG3)->kb_table) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_table,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_table) );
PRE_MEM_READ( "ioctl(KDSKBENT).kb_index",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_index,
- sizeof(((struct vki_kbentry *)ARG3)->kb_index) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_index,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_index) );
PRE_MEM_READ( "ioctl(KDSKBENT).kb_value",
- (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
- sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
+ (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_value,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_value) );
break;
case VKI_KDGKBSENT:
PRE_MEM_READ( "ioctl(KDGKBSENT).kb_func",
- (Addr)&((struct vki_kbsentry *)ARG3)->kb_func,
- sizeof(((struct vki_kbsentry *)ARG3)->kb_func) );
+ (Addr)&((struct vki_kbsentry *)(Addr)ARG3)->kb_func,
+ sizeof(((struct vki_kbsentry *)(Addr)ARG3)->kb_func) );
PRE_MEM_WRITE( "ioctl(KDGKSENT).kb_string",
- (Addr)((struct vki_kbsentry *)ARG3)->kb_string,
- sizeof(((struct vki_kbsentry *)ARG3)->kb_string) );
+ (Addr)((struct vki_kbsentry *)(Addr)ARG3)->kb_string,
+ sizeof(((struct vki_kbsentry *)(Addr)ARG3)->kb_string) );
break;
case VKI_KDSKBSENT:
PRE_MEM_READ( "ioctl(KDSKBSENT).kb_func",
- (Addr)&((struct vki_kbsentry *)ARG3)->kb_func,
- sizeof(((struct vki_kbsentry *)ARG3)->kb_func) );
+ (Addr)&((struct vki_kbsentry *)(Addr)ARG3)->kb_func,
+ sizeof(((struct vki_kbsentry *)(Addr)ARG3)->kb_func) );
PRE_MEM_RASCIIZ( "ioctl(KDSKBSENT).kb_string",
- (Addr)((struct vki_kbsentry *)ARG3)->kb_string );
+ (Addr)((struct vki_kbsentry *)(Addr)ARG3)->kb_string );
break;
case VKI_KDGKBDIACR:
case VKI_KDGETKEYCODE:
PRE_MEM_READ( "ioctl(KDGETKEYCODE).scancode",
- (Addr)&((struct vki_kbkeycode *)ARG3)->scancode,
- sizeof(((struct vki_kbkeycode *)ARG3)->scancode) );
+ (Addr)&((struct vki_kbkeycode *)(Addr)ARG3)->scancode,
+ sizeof(((struct vki_kbkeycode *)(Addr)ARG3)->scancode) );
PRE_MEM_WRITE( "ioctl(KDGETKEYCODE).keycode",
- (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
- sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
+ (Addr)((struct vki_kbkeycode *)(Addr)ARG3)->keycode,
+ sizeof(((struct vki_kbkeycode *)(Addr)ARG3)->keycode) );
break;
case VKI_KDSETKEYCODE:
PRE_MEM_READ( "ioctl(KDSETKEYCODE).scancode",
- (Addr)&((struct vki_kbkeycode *)ARG3)->scancode,
- sizeof(((struct vki_kbkeycode *)ARG3)->scancode) );
+ (Addr)&((struct vki_kbkeycode *)(Addr)ARG3)->scancode,
+ sizeof(((struct vki_kbkeycode *)(Addr)ARG3)->scancode) );
PRE_MEM_READ( "ioctl(KDSETKEYCODE).keycode",
- (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
- sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
+ (Addr)((struct vki_kbkeycode *)(Addr)ARG3)->keycode,
+ sizeof(((struct vki_kbkeycode *)(Addr)ARG3)->keycode) );
break;
case VKI_KDSIGACCEPT:
case VKI_KDFONTOP:
if ( ARG3 ) {
- struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
+ struct vki_console_font_op *op =
+ (struct vki_console_font_op *) (Addr)ARG3;
PRE_MEM_READ( "ioctl(KDFONTOP)", (Addr)op,
sizeof(struct vki_console_font_op) );
switch ( op->op ) {
break;
case VKI_VT_GETSTATE:
PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_active",
- (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
- sizeof(((struct vki_vt_stat*) ARG3)->v_active));
+ (Addr) &(((struct vki_vt_stat*) (Addr)ARG3)->v_active),
+ sizeof(((struct vki_vt_stat*) (Addr)ARG3)->v_active));
PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_state",
- (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
- sizeof(((struct vki_vt_stat*) ARG3)->v_state));
+ (Addr) &(((struct vki_vt_stat*) (Addr)ARG3)->v_state),
+ sizeof(((struct vki_vt_stat*) (Addr)ARG3)->v_state));
break;
case VKI_VT_RELDISP:
case VKI_VT_ACTIVATE:
case VKI_USBDEVFS_CONTROL:
if ( ARG3 ) {
- struct vki_usbdevfs_ctrltransfer *vkuc = (struct vki_usbdevfs_ctrltransfer *)ARG3;
+ struct vki_usbdevfs_ctrltransfer *vkuc =
+ (struct vki_usbdevfs_ctrltransfer *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).bRequestType", (Addr)&vkuc->bRequestType, sizeof(vkuc->bRequestType));
PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).bRequest", (Addr)&vkuc->bRequest, sizeof(vkuc->bRequest));
PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).wValue", (Addr)&vkuc->wValue, sizeof(vkuc->wValue));
break;
case VKI_USBDEVFS_BULK:
if ( ARG3 ) {
- struct vki_usbdevfs_bulktransfer *vkub = (struct vki_usbdevfs_bulktransfer *)ARG3;
+ struct vki_usbdevfs_bulktransfer *vkub =
+ (struct vki_usbdevfs_bulktransfer *)(Addr)ARG3;
PRE_MEM_READ( "ioctl(USBDEVFS_BULK)", ARG3, sizeof(struct vki_usbdevfs_bulktransfer));
if (vkub->ep & 0x80)
PRE_MEM_WRITE( "ioctl(USBDEVFS_BULK).data", (Addr)vkub->data, vkub->len);
break;
case VKI_USBDEVFS_GETDRIVER:
if ( ARG3 ) {
- struct vki_usbdevfs_getdriver *vkugd = (struct vki_usbdevfs_getdriver *) ARG3;
+ struct vki_usbdevfs_getdriver *vkugd =
+ (struct vki_usbdevfs_getdriver *) (Addr)ARG3;
PRE_MEM_WRITE( "ioctl(USBDEVFS_GETDRIVER)", (Addr)&vkugd->driver, sizeof(vkugd->driver));
}
break;
case VKI_USBDEVFS_SUBMITURB:
if ( ARG3 ) {
- struct vki_usbdevfs_urb *vkuu = (struct vki_usbdevfs_urb *)ARG3;
+ struct vki_usbdevfs_urb *vkuu = (struct vki_usbdevfs_urb *)(Addr)ARG3;
/* Not the whole struct needs to be initialized */
PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).endpoint", (Addr)&vkuu->endpoint, sizeof(vkuu->endpoint));
break;
case VKI_USBDEVFS_IOCTL:
if ( ARG3 ) {
- struct vki_usbdevfs_ioctl *vkui = (struct vki_usbdevfs_ioctl *)ARG3;
+ struct vki_usbdevfs_ioctl *vkui =
+ (struct vki_usbdevfs_ioctl *)(Addr)ARG3;
UInt dir2, size2;
PRE_MEM_READ("ioctl(USBDEVFS_IOCTL)", (Addr)vkui, sizeof(struct vki_usbdevfs_ioctl));
dir2 = _VKI_IOC_DIR(vkui->ioctl_code);
break;
case VKI_I2C_RDWR:
if ( ARG3 ) {
- struct vki_i2c_rdwr_ioctl_data *vkui = (struct vki_i2c_rdwr_ioctl_data *)ARG3;
+ struct vki_i2c_rdwr_ioctl_data *vkui =
+ (struct vki_i2c_rdwr_ioctl_data *)(Addr)ARG3;
UInt i;
PRE_MEM_READ("ioctl(I2C_RDWR)", (Addr)vkui, sizeof(struct vki_i2c_rdwr_ioctl_data));
for (i=0; i < vkui->nmsgs; i++) {
case VKI_I2C_SMBUS:
if ( ARG3 ) {
struct vki_i2c_smbus_ioctl_data *vkis
- = (struct vki_i2c_smbus_ioctl_data *) ARG3;
+ = (struct vki_i2c_smbus_ioctl_data *) (Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_I2C_SMBUS).i2c_smbus_ioctl_data.read_write",
(Addr)&vkis->read_write, sizeof(vkis->read_write));
PRE_MEM_READ("ioctl(VKI_I2C_SMBUS).i2c_smbus_ioctl_data.size",
case VKI_SIOCGIWNAME:
if (ARG3) {
PRE_MEM_WRITE("ioctl(SIOCGIWNAME)",
- (Addr)((struct vki_iwreq *)ARG3)->u.name,
- sizeof(((struct vki_iwreq *)ARG3)->u.name));
+ (Addr)((struct vki_iwreq *)(Addr)ARG3)->u.name,
+ sizeof(((struct vki_iwreq *)(Addr)ARG3)->u.name));
}
break;
case VKI_SIOCGIWNWID:
if (ARG3) {
PRE_MEM_WRITE("ioctl(SIOCGIW[NWID|SENS|RATE|RTS|FRAG|TXPOW|"
"RETRY|PARAM|AUTH])",
- (Addr)&((struct vki_iwreq *)ARG3)->u.nwid,
+ (Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.nwid,
sizeof(struct vki_iw_param));
}
break;
case VKI_SIOCGIWFREQ:
if (ARG3) {
PRE_MEM_WRITE("ioctl(SIOCGIWFREQ",
- (Addr)&((struct vki_iwreq *)ARG3)->u.freq,
+ (Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.freq,
sizeof(struct vki_iw_freq));
}
break;
case VKI_SIOCGIWMODE:
if (ARG3) {
PRE_MEM_WRITE("ioctl(SIOCGIWMODE",
- (Addr)&((struct vki_iwreq *)ARG3)->u.mode,
+ (Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.mode,
sizeof(__vki_u32));
}
break;
case VKI_SIOCGIWENCODEEXT:
if (ARG3) {
struct vki_iw_point* point;
- point = &((struct vki_iwreq *)ARG3)->u.data;
+ point = &((struct vki_iwreq *)(Addr)ARG3)->u.data;
PRE_MEM_WRITE("ioctl(SIOCGIW[RANGE|PRIV|STATS|SPY|THRSPY|"
"APLIST|SCAN|ESSID|NICKN|ENCODE|GENIE|ENCODEEXT])",
(Addr)point->pointer, point->length);
case VKI_SIOCGIWAP:
if (ARG3) {
PRE_MEM_WRITE("ioctl(SIOCGIWAP)",
- (Addr)&((struct vki_iwreq *)ARG3)->u.ap_addr,
+ (Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.ap_addr,
sizeof(struct vki_sockaddr));
}
break;
case VKI_BINDER_WRITE_READ:
if (ARG3) {
struct vki_binder_write_read* bwr
- = (struct vki_binder_write_read*)ARG3;
+ = (struct vki_binder_write_read*)(Addr)ARG3;
PRE_FIELD_READ("ioctl(BINDER_WRITE_READ).write_buffer",
bwr->write_buffer);
break;
case VKI_BINDER_VERSION:
if (ARG3) {
- struct vki_binder_version* bv = (struct vki_binder_version*)ARG3;
+ struct vki_binder_version* bv =
+ (struct vki_binder_version*)(Addr)ARG3;
PRE_FIELD_WRITE("ioctl(BINDER_VERSION)", bv->protocol_version);
}
break;
case VKI_HCIGETDEVLIST:
if (ARG3) {
- struct vki_hci_dev_list_req* dlr = (struct vki_hci_dev_list_req*)ARG3;
+ struct vki_hci_dev_list_req* dlr =
+ (struct vki_hci_dev_list_req*)(Addr)ARG3;
PRE_MEM_READ("ioctl(HCIGETDEVLIST)",
(Addr)ARG3, sizeof(struct vki_hci_dev_list_req));
PRE_MEM_WRITE("ioctl(HCIGETDEVLIST)",
case VKI_HCIINQUIRY:
if (ARG3) {
- struct vki_hci_inquiry_req* ir = (struct vki_hci_inquiry_req*)ARG3;
+ struct vki_hci_inquiry_req* ir =
+ (struct vki_hci_inquiry_req*)(Addr)ARG3;
PRE_MEM_READ("ioctl(HCIINQUIRY)",
(Addr)ARG3, sizeof(struct vki_hci_inquiry_req));
PRE_MEM_WRITE("ioctl(HCIINQUIRY)",
case VKI_DRM_IOCTL_VERSION:
if (ARG3) {
- struct vki_drm_version* data = (struct vki_drm_version *)ARG3;
+ struct vki_drm_version* data = (struct vki_drm_version *)(Addr)ARG3;
struct vg_drm_version_info* info;
PRE_MEM_WRITE("ioctl(DRM_VERSION).version_major", (Addr)&data->version_major, sizeof(data->version_major));
PRE_MEM_WRITE("ioctl(DRM_VERSION).version_minor", (Addr)&data->version_minor, sizeof(data->version_minor));
break;
case VKI_DRM_IOCTL_GET_UNIQUE:
if (ARG3) {
- struct vki_drm_unique *data = (struct vki_drm_unique *)ARG3;
+ struct vki_drm_unique *data = (struct vki_drm_unique *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_GET_UNIQUE).unique_len", (Addr)&data->unique_len, sizeof(data->unique_len));
PRE_MEM_READ("ioctl(DRM_GET_UNIQUE).unique", (Addr)&data->unique, sizeof(data->unique));
PRE_MEM_WRITE("ioctl(DRM_GET_UNIQUE).unique", (Addr)data->unique, data->unique_len);
break;
case VKI_DRM_IOCTL_GET_MAGIC:
if (ARG3) {
- struct vki_drm_auth *data = (struct vki_drm_auth *)ARG3;
+ struct vki_drm_auth *data = (struct vki_drm_auth *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(DRM_GET_MAGIC).magic", (Addr)&data->magic, sizeof(data->magic));
}
break;
case VKI_DRM_IOCTL_WAIT_VBLANK:
if (ARG3) {
- union vki_drm_wait_vblank *data = (union vki_drm_wait_vblank *)ARG3;
+ union vki_drm_wait_vblank *data =
+ (union vki_drm_wait_vblank *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_WAIT_VBLANK).request.type", (Addr)&data->request.type, sizeof(data->request.type));
PRE_MEM_READ("ioctl(DRM_WAIT_VBLANK).request.sequence", (Addr)&data->request.sequence, sizeof(data->request.sequence));
/* XXX: It seems request.signal isn't used */
break;
case VKI_DRM_IOCTL_GEM_CLOSE:
if (ARG3) {
- struct vki_drm_gem_close *data = (struct vki_drm_gem_close *)ARG3;
+ struct vki_drm_gem_close *data =
+ (struct vki_drm_gem_close *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_GEM_CLOSE).handle", (Addr)&data->handle, sizeof(data->handle));
}
break;
case VKI_DRM_IOCTL_GEM_FLINK:
if (ARG3) {
- struct vki_drm_gem_flink *data = (struct vki_drm_gem_flink *)ARG3;
+ struct vki_drm_gem_flink *data =
+ (struct vki_drm_gem_flink *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_GEM_FLINK).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_WRITE("ioctl(DRM_GEM_FLINK).name", (Addr)&data->name, sizeof(data->name));
}
break;
case VKI_DRM_IOCTL_GEM_OPEN:
if (ARG3) {
- struct vki_drm_gem_open *data = (struct vki_drm_gem_open *)ARG3;
+ struct vki_drm_gem_open *data = (struct vki_drm_gem_open *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_GEM_OPEN).name", (Addr)&data->name, sizeof(data->name));
PRE_MEM_WRITE("ioctl(DRM_GEM_OPEN).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_WRITE("ioctl(DRM_GEM_OPEN).size", (Addr)&data->size, sizeof(data->size));
break;
case VKI_DRM_IOCTL_I915_GETPARAM:
if (ARG3) {
- vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t *)ARG3;
+ vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GETPARAM).param", (Addr)&data->param, sizeof(data->param));
PRE_MEM_WRITE("ioctl(DRM_I915_GETPARAM).value", (Addr)data->value, sizeof(int));
}
break;
case VKI_DRM_IOCTL_I915_GEM_BUSY:
if (ARG3) {
- struct vki_drm_i915_gem_busy *data = (struct vki_drm_i915_gem_busy *)ARG3;
+ struct vki_drm_i915_gem_busy *data =
+ (struct vki_drm_i915_gem_busy *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_BUSY).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_BUSY).busy", (Addr)&data->busy, sizeof(data->busy));
}
break;
case VKI_DRM_IOCTL_I915_GEM_CREATE:
if (ARG3) {
- struct vki_drm_i915_gem_create *data = (struct vki_drm_i915_gem_create *)ARG3;
+ struct vki_drm_i915_gem_create *data =
+ (struct vki_drm_i915_gem_create *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_CREATE).size", (Addr)&data->size, sizeof(data->size));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_CREATE).handle", (Addr)&data->handle, sizeof(data->handle));
}
break;
case VKI_DRM_IOCTL_I915_GEM_PREAD:
if (ARG3) {
- struct vki_drm_i915_gem_pread *data = (struct vki_drm_i915_gem_pread *)ARG3;
+ struct vki_drm_i915_gem_pread *data =
+ (struct vki_drm_i915_gem_pread *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_PREAD).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_READ("ioctl(DRM_I915_GEM_PREAD).offset", (Addr)&data->offset, sizeof(data->offset));
PRE_MEM_READ("ioctl(DRM_I915_GEM_PREAD).size", (Addr)&data->size, sizeof(data->size));
break;
case VKI_DRM_IOCTL_I915_GEM_PWRITE:
if (ARG3) {
- struct vki_drm_i915_gem_pwrite *data = (struct vki_drm_i915_gem_pwrite *)ARG3;
+ struct vki_drm_i915_gem_pwrite *data =
+ (struct vki_drm_i915_gem_pwrite *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_PWRITE).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_READ("ioctl(DRM_I915_GEM_PWRITE).offset", (Addr)&data->offset, sizeof(data->offset));
PRE_MEM_READ("ioctl(DRM_I915_GEM_PWRITE).size", (Addr)&data->size, sizeof(data->size));
break;
case VKI_DRM_IOCTL_I915_GEM_MMAP_GTT:
if (ARG3) {
- struct vki_drm_i915_gem_mmap_gtt *data = (struct vki_drm_i915_gem_mmap_gtt *)ARG3;
+ struct vki_drm_i915_gem_mmap_gtt *data =
+ (struct vki_drm_i915_gem_mmap_gtt *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_MMAP_GTT).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_MMAP_GTT).offset", (Addr)&data->offset, sizeof(data->offset));
}
break;
case VKI_DRM_IOCTL_I915_GEM_SET_DOMAIN:
if (ARG3) {
- struct vki_drm_i915_gem_set_domain *data = (struct vki_drm_i915_gem_set_domain *)ARG3;
+ struct vki_drm_i915_gem_set_domain *data =
+ (struct vki_drm_i915_gem_set_domain *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_DOMAIN).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_DOMAIN).read_domains", (Addr)&data->read_domains, sizeof(data->read_domains));
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_DOMAIN).write_domain", (Addr)&data->write_domain, sizeof(data->write_domain));
break;
case VKI_DRM_IOCTL_I915_GEM_SET_TILING:
if (ARG3) {
- struct vki_drm_i915_gem_set_tiling *data = (struct vki_drm_i915_gem_set_tiling *)ARG3;
+ struct vki_drm_i915_gem_set_tiling *data =
+ (struct vki_drm_i915_gem_set_tiling *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_TILING).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_TILING).tiling_mode", (Addr)&data->tiling_mode, sizeof(data->tiling_mode));
PRE_MEM_READ("ioctl(DRM_I915_GEM_SET_TILING).stride", (Addr)&data->stride, sizeof(data->stride));
break;
case VKI_DRM_IOCTL_I915_GEM_GET_TILING:
if (ARG3) {
- struct vki_drm_i915_gem_get_tiling *data = (struct vki_drm_i915_gem_get_tiling *)ARG3;
+ struct vki_drm_i915_gem_get_tiling *data =
+ (struct vki_drm_i915_gem_get_tiling *)(Addr)ARG3;
PRE_MEM_READ("ioctl(DRM_I915_GEM_GET_TILING).handle", (Addr)&data->handle, sizeof(data->handle));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_GET_TILING).tiling_mode", (Addr)&data->tiling_mode, sizeof(data->tiling_mode));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_GET_TILING).swizzle_mode", (Addr)&data->swizzle_mode, sizeof(data->swizzle_mode));
break;
case VKI_DRM_IOCTL_I915_GEM_GET_APERTURE:
if (ARG3) {
- struct vki_drm_i915_gem_get_aperture *data = (struct vki_drm_i915_gem_get_aperture *)ARG3;
+ struct vki_drm_i915_gem_get_aperture *data =
+ (struct vki_drm_i915_gem_get_aperture *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_GET_APERTURE).aper_size", (Addr)&data->aper_size, sizeof(data->aper_size));
PRE_MEM_WRITE("ioctl(DRM_I915_GEM_GET_APERTURE).aper_available_size", (Addr)&data->aper_available_size, sizeof(data->aper_available_size));
}
case VKI_KVM_S390_MEM_OP: {
struct vki_kvm_s390_mem_op *args =
- (struct vki_kvm_s390_mem_op *)(ARG3);
+ (struct vki_kvm_s390_mem_op *)(Addr)(ARG3);
PRE_MEM_READ("ioctl(KVM_S390_MEM_OP)", ARG3,
sizeof(struct vki_kvm_s390_mem_op));
if (args->flags & VKI_KVM_S390_MEMOP_F_CHECK_ONLY)
case VKI_XEN_IOCTL_PRIVCMD_HYPERCALL: {
SyscallArgs harrghs;
struct vki_xen_privcmd_hypercall *args =
- (struct vki_xen_privcmd_hypercall *)(ARG3);
+ (struct vki_xen_privcmd_hypercall *)(Addr)(ARG3);
if (!args)
break;
case VKI_XEN_IOCTL_PRIVCMD_MMAP: {
struct vki_xen_privcmd_mmap *args =
- (struct vki_xen_privcmd_mmap *)(ARG3);
+ (struct vki_xen_privcmd_mmap *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP(num)",
(Addr)&args->num, sizeof(args->num));
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAP(dom)",
}
case VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH: {
struct vki_xen_privcmd_mmapbatch *args =
- (struct vki_xen_privcmd_mmapbatch *)(ARG3);
+ (struct vki_xen_privcmd_mmapbatch *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH(num)",
(Addr)&args->num, sizeof(args->num));
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH(dom)",
}
case VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2: {
struct vki_xen_privcmd_mmapbatch_v2 *args =
- (struct vki_xen_privcmd_mmapbatch_v2 *)(ARG3);
+ (struct vki_xen_privcmd_mmapbatch_v2 *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2(num)",
(Addr)&args->num, sizeof(args->num));
PRE_MEM_READ("VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2(dom)",
case VKI_XEN_IOCTL_EVTCHN_BIND_VIRQ: {
struct vki_xen_ioctl_evtchn_bind_virq *args =
- (struct vki_xen_ioctl_evtchn_bind_virq *)(ARG3);
+ (struct vki_xen_ioctl_evtchn_bind_virq *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_BIND_VIRQ(virq)",
(Addr)&args->virq, sizeof(args->virq));
}
break;
case VKI_XEN_IOCTL_EVTCHN_BIND_INTERDOMAIN: {
struct vki_xen_ioctl_evtchn_bind_interdomain *args =
- (struct vki_xen_ioctl_evtchn_bind_interdomain *)(ARG3);
+ (struct vki_xen_ioctl_evtchn_bind_interdomain *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_BIND_INTERDOMAIN(remote_domain)",
(Addr)&args->remote_domain, sizeof(args->remote_domain));
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_BIND_INTERDOMAIN(remote_port)",
break;
case VKI_XEN_IOCTL_EVTCHN_BIND_UNBOUND_PORT: {
struct vki_xen_ioctl_evtchn_bind_unbound_port *args =
- (struct vki_xen_ioctl_evtchn_bind_unbound_port *)(ARG3);
+ (struct vki_xen_ioctl_evtchn_bind_unbound_port *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_BIND_UNBOUND_PORT(remote_domain)",
(Addr)&args->remote_domain, sizeof(args->remote_domain));
}
break;
case VKI_XEN_IOCTL_EVTCHN_UNBIND: {
struct vki_xen_ioctl_evtchn_unbind *args =
- (struct vki_xen_ioctl_evtchn_unbind *)(ARG3);
+ (struct vki_xen_ioctl_evtchn_unbind *)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_UNBIND(port)",
(Addr)&args->port, sizeof(args->port));
}
break;
case VKI_XEN_IOCTL_EVTCHN_NOTIFY: {
struct vki_xen_ioctl_evtchn_notify *args =
- (struct vki_xen_ioctl_evtchn_notify*)(ARG3);
+ (struct vki_xen_ioctl_evtchn_notify*)(Addr)(ARG3);
PRE_MEM_READ("VKI_XEN_IOCTL_EVTCHN_notify(port)",
(Addr)&args->port, sizeof(args->port));
}
/* Lustre */
case VKI_OBD_IOC_FID2PATH: {
- struct vki_getinfo_fid2path *gf = (struct vki_getinfo_fid2path *)ARG3;
+ struct vki_getinfo_fid2path *gf =
+ (struct vki_getinfo_fid2path *)(Addr)ARG3;
PRE_MEM_READ("VKI_OBD_IOC_FID2PATH(args)", ARG3, sizeof(struct vki_getinfo_fid2path));
PRE_FIELD_WRITE("VKI_OBD_IOC_FID2PATH(args).gf_recno", gf->gf_recno);
PRE_FIELD_WRITE("VKI_OBD_IOC_FID2PATH(args).gf_linkno", gf->gf_linkno);
break;
case VKI_LL_IOC_GETPARENT: {
- struct vki_getparent *gp = (struct vki_getparent *)ARG3;
+ struct vki_getparent *gp = (struct vki_getparent *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_LL_IOC_GETPARENT).gp_linkno", gp->gp_linkno);
PRE_FIELD_READ("ioctl(VKI_LL_IOC_GETPARENT).gp_name_size", gp->gp_name_size);
PRE_FIELD_WRITE("ioctl(VKI_LL_IOC_GETPARENT).gp_fid", gp->gp_fid);
/* V4L2 */
case VKI_V4L2_QUERYCAP: {
- struct vki_v4l2_capability *data = (struct vki_v4l2_capability *)ARG3;
+ struct vki_v4l2_capability *data =
+ (struct vki_v4l2_capability *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYCAP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUM_FMT: {
- struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)ARG3;
+ struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FMT).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FMT).type", data->type);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_ENUM_FMT).flags", data->flags);
break;
}
case VKI_V4L2_G_FMT: {
- struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3;
+ struct vki_v4l2_format *data = (struct vki_v4l2_format *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_FMT).type", data->type);
switch (data->type) {
case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE:
break;
}
case VKI_V4L2_S_FMT: {
- struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3;
+ struct vki_v4l2_format *data = (struct vki_v4l2_format *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_FMT).type", data->type);
switch (data->type) {
case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE:
break;
}
case VKI_V4L2_TRY_FMT: {
- struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3;
+ struct vki_v4l2_format *data = (struct vki_v4l2_format *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_FMT).type", data->type);
switch (data->type) {
case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE:
break;
}
case VKI_V4L2_REQBUFS: {
- struct vki_v4l2_requestbuffers *data = (struct vki_v4l2_requestbuffers *)ARG3;
+ struct vki_v4l2_requestbuffers *data =
+ (struct vki_v4l2_requestbuffers *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_REQBUFS)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_QUERYBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYBUF).reserved", data->reserved);
break;
}
case VKI_V4L2_G_FBUF: {
- struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3;
+ struct vki_v4l2_framebuffer *data =
+ (struct vki_v4l2_framebuffer *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_FBUF)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_FBUF: {
- struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3;
+ struct vki_v4l2_framebuffer *data =
+ (struct vki_v4l2_framebuffer *)(Addr)ARG3;
PRE_FIELD_WRITE("ioctl(VKI_V4L2_S_FBUF).capability", data->capability);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_FBUF).flags", data->flags);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_FBUF).base", data->base);
break;
}
case VKI_V4L2_OVERLAY: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_OVERLAY)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_QBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT ||
break;
}
case VKI_V4L2_EXPBUF: {
- struct vki_v4l2_exportbuffer *data = (struct vki_v4l2_exportbuffer *)ARG3;
+ struct vki_v4l2_exportbuffer *data =
+ (struct vki_v4l2_exportbuffer *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_EXPBUF).plane", data->plane);
break;
}
case VKI_V4L2_DQBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).type", data->type);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_DQBUF).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_DQBUF).memory", data->memory);
break;
}
case VKI_V4L2_STREAMON: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_STREAMON)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_STREAMOFF: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_STREAMOFF)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_PARM: {
- struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3;
+ struct vki_v4l2_streamparm *data =
+ (struct vki_v4l2_streamparm *)(Addr)ARG3;
int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT ||
break;
}
case VKI_V4L2_S_PARM: {
- struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3;
+ struct vki_v4l2_streamparm *data =
+ (struct vki_v4l2_streamparm *)(Addr)ARG3;
int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT ||
break;
}
case VKI_V4L2_G_STD: {
- vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3;
+ vki_v4l2_std_id *data = (vki_v4l2_std_id *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_STD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_STD: {
- vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3;
+ vki_v4l2_std_id *data = (vki_v4l2_std_id *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_STD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMSTD: {
- struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)ARG3;
+ struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMSTD).index", data->index);
PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMSTD)", (Addr)&data->id, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_ENUMINPUT: {
- struct vki_v4l2_input *data = (struct vki_v4l2_input *)ARG3;
+ struct vki_v4l2_input *data = (struct vki_v4l2_input *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMINPUT).index", data->index);
PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMINPUT)", (Addr)data->name, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_G_CTRL: {
- struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3;
+ struct vki_v4l2_control *data = (struct vki_v4l2_control *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_CTRL).id", data->id);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_CTRL).value", data->value);
break;
}
case VKI_V4L2_S_CTRL: {
- struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3;
+ struct vki_v4l2_control *data = (struct vki_v4l2_control *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_CTRL)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_TUNER: {
- struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3;
+ struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_TUNER).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_TUNER).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_TUNER)", (Addr)data->name,
break;
}
case VKI_V4L2_S_TUNER: {
- struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3;
+ struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).audmode", data->audmode);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_TUNER).reserved", data->reserved);
break;
}
case VKI_V4L2_G_AUDIO: {
- struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3;
+ struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_AUDIO)", (Addr)data,
sizeof(*data) - sizeof(data->reserved));
PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDIO).reserved", data->reserved);
break;
}
case VKI_V4L2_S_AUDIO: {
- struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3;
+ struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).mode", data->mode);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDIO).reserved", data->reserved);
break;
}
case VKI_V4L2_QUERYCTRL: {
- struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)ARG3;
+ struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYCTRL).id", data->id);
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYCTRL)", (Addr)&data->type,
sizeof(*data) - sizeof(data->id));
break;
}
case VKI_V4L2_QUERYMENU: {
- struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)ARG3;
+ struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYMENU).id", data->id);
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERYMENU).index", data->index);
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYMENU)", (Addr)data->name,
break;
}
case VKI_V4L2_G_INPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_INPUT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_INPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_INPUT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_EDID: {
- struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3;
+ struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_G_EDID)", (Addr)data, sizeof(*data));
if (data->blocks && data->edid)
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_EDID)", (Addr)data->edid, data->blocks * 128);
break;
}
case VKI_V4L2_S_EDID: {
- struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3;
+ struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_EDID)", (Addr)data, sizeof(*data));
if (data->blocks && data->edid)
PRE_MEM_READ("ioctl(VKI_V4L2_S_EDID)", (Addr)data->edid, data->blocks * 128);
break;
}
case VKI_V4L2_G_OUTPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_OUTPUT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_OUTPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_OUTPUT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMOUTPUT: {
- struct vki_v4l2_output *data = (struct vki_v4l2_output *)ARG3;
+ struct vki_v4l2_output *data = (struct vki_v4l2_output *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMOUTPUT).index", data->index);
PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMOUTPUT)", (Addr)data->name, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_G_AUDOUT: {
- struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3;
+ struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_AUDOUT)", (Addr)data,
sizeof(*data) - sizeof(data->reserved));
PRE_FIELD_READ("ioctl(VKI_V4L2_G_AUDOUT).reserved", data->reserved);
break;
}
case VKI_V4L2_S_AUDOUT: {
- struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3;
+ struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).reserved", data->reserved);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_AUDOUT).mode", data->mode);
break;
}
case VKI_V4L2_G_MODULATOR: {
- struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3;
+ struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_MODULATOR).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_MODULATOR).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_MODULATOR)", (Addr)data->name,
break;
}
case VKI_V4L2_S_MODULATOR: {
- struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3;
+ struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).txsubchans", data->txsubchans);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_MODULATOR).reserved", data->reserved);
break;
}
case VKI_V4L2_G_FREQUENCY: {
- struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3;
+ struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_FREQUENCY).tuner", data->tuner);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_FREQUENCY).reserved", data->reserved);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_FREQUENCY).type", data->type);
break;
}
case VKI_V4L2_S_FREQUENCY: {
- struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3;
+ struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_FREQUENCY)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_CROPCAP: {
- struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)ARG3;
+ struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_CROPCAP)", data->type);
PRE_MEM_WRITE("ioctl(VKI_V4L2_CROPCAP)", (Addr)&data->bounds, sizeof(*data) - sizeof(data->type));
break;
}
case VKI_V4L2_G_CROP: {
- struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3;
+ struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_CROP).type", data->type);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_G_CROP).c", data->c);
break;
}
case VKI_V4L2_S_CROP: {
- struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3;
+ struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_CROP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_JPEGCOMP: {
- struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3;
+ struct vki_v4l2_jpegcompression *data =
+ (struct vki_v4l2_jpegcompression *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_JPEGCOMP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_JPEGCOMP: {
- struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3;
+ struct vki_v4l2_jpegcompression *data =
+ (struct vki_v4l2_jpegcompression *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_JPEGCOMP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_QUERYSTD: {
- vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3;
+ vki_v4l2_std_id *data = (vki_v4l2_std_id *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERYSTD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMAUDIO: {
- struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3;
+ struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDIO).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDIO).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMAUDIO)", (Addr)data->name,
break;
}
case VKI_V4L2_ENUMAUDOUT: {
- struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3;
+ struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDOUT).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUMAUDOUT).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_ENUMAUDOUT)", (Addr)data->name,
break;
}
case VKI_V4L2_G_PRIORITY: {
- __vki_u32 *data = (__vki_u32 *)ARG3;
+ __vki_u32 *data = (__vki_u32 *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_PRIORITY)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_PRIORITY: {
- __vki_u32 *data = (__vki_u32 *)ARG3;
+ __vki_u32 *data = (__vki_u32 *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_PRIORITY)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_SLICED_VBI_CAP: {
- struct vki_v4l2_sliced_vbi_cap *data = (struct vki_v4l2_sliced_vbi_cap *)ARG3;
+ struct vki_v4l2_sliced_vbi_cap *data =
+ (struct vki_v4l2_sliced_vbi_cap *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_SLICED_VBI_CAP).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_SLICED_VBI_CAP).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_SLICED_VBI_CAP)", (Addr)data,
break;
}
case VKI_V4L2_G_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).ctrl_class", data->ctrl_class);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_EXT_CTRLS).count", data->count);
if (data->count) {
break;
}
case VKI_V4L2_S_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).ctrl_class", data->ctrl_class);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_EXT_CTRLS).count", data->count);
if (data->count) {
break;
}
case VKI_V4L2_TRY_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).ctrl_class", data->ctrl_class);
PRE_FIELD_READ("ioctl(VKI_V4L2_TRY_EXT_CTRLS).count", data->count);
if (data->count) {
break;
}
case VKI_V4L2_ENUM_FRAMESIZES: {
- struct vki_v4l2_frmsizeenum *data = (struct vki_v4l2_frmsizeenum *)ARG3;
+ struct vki_v4l2_frmsizeenum *data =
+ (struct vki_v4l2_frmsizeenum *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).pixel_format", data->pixel_format);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMESIZES).reserved", data->reserved);
break;
}
case VKI_V4L2_ENUM_FRAMEINTERVALS: {
- struct vki_v4l2_frmivalenum *data = (struct vki_v4l2_frmivalenum *)ARG3;
+ struct vki_v4l2_frmivalenum *data =
+ (struct vki_v4l2_frmivalenum *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).pixel_format", data->pixel_format);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FRAMEINTERVALS).width", data->width);
break;
}
case VKI_V4L2_G_ENC_INDEX: {
- struct vki_v4l2_enc_idx *data = (struct vki_v4l2_enc_idx *)ARG3;
+ struct vki_v4l2_enc_idx *data = (struct vki_v4l2_enc_idx *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_ENC_INDEX)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENCODER_CMD: {
- struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3;
+ struct vki_v4l2_encoder_cmd *data =
+ (struct vki_v4l2_encoder_cmd *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_ENCODER_CMD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_TRY_ENCODER_CMD: {
- struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3;
+ struct vki_v4l2_encoder_cmd *data =
+ (struct vki_v4l2_encoder_cmd *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_TRY_ENCODER_CMD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DBG_S_REGISTER: {
- struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3;
+ struct vki_v4l2_dbg_register *data =
+ (struct vki_v4l2_dbg_register *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).match.type", data->match.type);
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).match.addr", data->match.addr);
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_S_REGISTER).reg", data->reg);
break;
}
case VKI_V4L2_DBG_G_REGISTER: {
- struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3;
+ struct vki_v4l2_dbg_register *data =
+ (struct vki_v4l2_dbg_register *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).match.type", data->match.type);
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).match.addr", data->match.addr);
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_REGISTER).reg", data->reg);
break;
}
case VKI_V4L2_S_HW_FREQ_SEEK: {
- struct vki_v4l2_hw_freq_seek *data = (struct vki_v4l2_hw_freq_seek *)ARG3;
+ struct vki_v4l2_hw_freq_seek *data =
+ (struct vki_v4l2_hw_freq_seek *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_HW_FREQ_SEEK)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_DV_TIMINGS: {
- struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3;
+ struct vki_v4l2_dv_timings *data =
+ (struct vki_v4l2_dv_timings *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_S_DV_TIMINGS).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_S_DV_TIMINGS).bt", data->bt);
break;
}
case VKI_V4L2_G_DV_TIMINGS: {
- struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3;
+ struct vki_v4l2_dv_timings *data =
+ (struct vki_v4l2_dv_timings *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_G_DV_TIMINGS)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DQEVENT: {
- struct vki_v4l2_event *data = (struct vki_v4l2_event *)ARG3;
+ struct vki_v4l2_event *data = (struct vki_v4l2_event *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_DQEVENT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_SUBSCRIBE_EVENT: {
- struct vki_v4l2_event_subscription *data = (struct vki_v4l2_event_subscription *)ARG3;
+ struct vki_v4l2_event_subscription *data =
+ (struct vki_v4l2_event_subscription *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_SUBSCRIBE_EVENT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_UNSUBSCRIBE_EVENT: {
- struct vki_v4l2_event_subscription *data = (struct vki_v4l2_event_subscription *)ARG3;
+ struct vki_v4l2_event_subscription *data =
+ (struct vki_v4l2_event_subscription *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_UNSUBSCRIBE_EVENT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_CREATE_BUFS: {
- struct vki_v4l2_create_buffers *data = (struct vki_v4l2_create_buffers *)ARG3;
+ struct vki_v4l2_create_buffers *data =
+ (struct vki_v4l2_create_buffers *)(Addr)ARG3;
struct vki_v4l2_format *fmt = &data->format;
PRE_FIELD_WRITE("ioctl(VKI_V4L2_CREATE_BUFS).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_CREATE_BUFS).count", data->count);
break;
}
case VKI_V4L2_PREPARE_BUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_PREPARE_BUF).memory", data->memory);
break;
}
case VKI_V4L2_G_SELECTION: {
- struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3;
+ struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).target", data->target);
PRE_FIELD_READ("ioctl(VKI_V4L2_G_SELECTION).flags", data->flags);
break;
}
case VKI_V4L2_S_SELECTION: {
- struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3;
+ struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_S_SELECTION)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DECODER_CMD: {
- struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3;
+ struct vki_v4l2_decoder_cmd *data =
+ (struct vki_v4l2_decoder_cmd *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_DECODER_CMD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_TRY_DECODER_CMD: {
- struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3;
+ struct vki_v4l2_decoder_cmd *data =
+ (struct vki_v4l2_decoder_cmd *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_TRY_DECODER_CMD)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUM_DV_TIMINGS: {
- struct vki_v4l2_enum_dv_timings *data = (struct vki_v4l2_enum_dv_timings *)ARG3;
+ struct vki_v4l2_enum_dv_timings *data =
+ (struct vki_v4l2_enum_dv_timings *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_DV_TIMINGS).reserved", data->reserved);
break;
}
case VKI_V4L2_QUERY_DV_TIMINGS: {
- struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3;
+ struct vki_v4l2_dv_timings *data =
+ (struct vki_v4l2_dv_timings *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERY_DV_TIMINGS)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DV_TIMINGS_CAP: {
- struct vki_v4l2_dv_timings_cap *data = (struct vki_v4l2_dv_timings_cap *)ARG3;
+ struct vki_v4l2_dv_timings_cap *data =
+ (struct vki_v4l2_dv_timings_cap *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_V4L2_DV_TIMINGS_CAP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUM_FREQ_BANDS: {
- struct vki_v4l2_frequency_band *data = (struct vki_v4l2_frequency_band *)ARG3;
+ struct vki_v4l2_frequency_band *data =
+ (struct vki_v4l2_frequency_band *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).tuner", data->tuner);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).type", data->type);
PRE_FIELD_READ("ioctl(VKI_V4L2_ENUM_FREQ_BANDS).index", data->index);
break;
}
case VKI_V4L2_DBG_G_CHIP_INFO: {
- struct vki_v4l2_dbg_chip_info *data = (struct vki_v4l2_dbg_chip_info *)ARG3;
+ struct vki_v4l2_dbg_chip_info *data =
+ (struct vki_v4l2_dbg_chip_info *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).match.type", data->match.type);
PRE_FIELD_READ("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).match.addr", data->match.addr);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_DBG_G_CHIP_INFO).name", data->name);
break;
}
case VKI_V4L2_QUERY_EXT_CTRL: {
- struct vki_v4l2_query_ext_ctrl *data = (struct vki_v4l2_query_ext_ctrl *)ARG3;
+ struct vki_v4l2_query_ext_ctrl *data =
+ (struct vki_v4l2_query_ext_ctrl *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERY_EXT_CTRL).id", data->id);
PRE_FIELD_READ("ioctl(VKI_V4L2_QUERY_EXT_CTRL).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_V4L2_QUERY_EXT_CTRL)", (Addr)&data->type,
break;
}
case VKI_V4L2_SUBDEV_G_FMT: {
- struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3;
+ struct vki_v4l2_subdev_format *data =
+ (struct vki_v4l2_subdev_format *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).which", data->which);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FMT).reserved", data->reserved);
break;
}
case VKI_V4L2_SUBDEV_S_FMT: {
- struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3;
+ struct vki_v4l2_subdev_format *data =
+ (struct vki_v4l2_subdev_format *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_FMT)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_SUBDEV_G_FRAME_INTERVAL: {
- struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3;
+ struct vki_v4l2_subdev_frame_interval *data =
+ (struct vki_v4l2_subdev_frame_interval *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).reserved", data->reserved);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_G_FRAME_SIZE).interval", data->interval);
break;
}
case VKI_V4L2_SUBDEV_S_FRAME_INTERVAL: {
- struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3;
+ struct vki_v4l2_subdev_frame_interval *data =
+ (struct vki_v4l2_subdev_frame_interval *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_FRAME_INTERVAL)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_SUBDEV_ENUM_MBUS_CODE: {
- struct vki_v4l2_subdev_mbus_code_enum *data = (struct vki_v4l2_subdev_mbus_code_enum *)ARG3;
+ struct vki_v4l2_subdev_mbus_code_enum *data =
+ (struct vki_v4l2_subdev_mbus_code_enum *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).pad", data->pad);
PRE_FIELD_WRITE("ioctl(VKI_V4L2_SUBDEV_ENUM_MBUS_CODE).code", data->code);
break;
}
case VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE: {
- struct vki_v4l2_subdev_frame_size_enum *data = (struct vki_v4l2_subdev_frame_size_enum *)ARG3;
+ struct vki_v4l2_subdev_frame_size_enum *data =
+ (struct vki_v4l2_subdev_frame_size_enum *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE).code", data->code);
break;
}
case VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL: {
- struct vki_v4l2_subdev_frame_interval_enum *data = (struct vki_v4l2_subdev_frame_interval_enum *)ARG3;
+ struct vki_v4l2_subdev_frame_interval_enum *data =
+ (struct vki_v4l2_subdev_frame_interval_enum *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).index", data->index);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL).code", data->code);
break;
}
case VKI_V4L2_SUBDEV_G_CROP: {
- struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3;
+ struct vki_v4l2_subdev_crop *data =
+ (struct vki_v4l2_subdev_crop *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).which", data->which);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_CROP).reserved", data->reserved);
break;
}
case VKI_V4L2_SUBDEV_S_CROP: {
- struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3;
+ struct vki_v4l2_subdev_crop *data =
+ (struct vki_v4l2_subdev_crop *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_CROP)", (Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_SUBDEV_G_SELECTION: {
- struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3;
+ struct vki_v4l2_subdev_selection *data =
+ (struct vki_v4l2_subdev_selection *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).pad", data->pad);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).which", data->which);
PRE_FIELD_READ("ioctl(VKI_V4L2_SUBDEV_G_SELECTION).target", data->target);
break;
}
case VKI_V4L2_SUBDEV_S_SELECTION: {
- struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3;
+ struct vki_v4l2_subdev_selection *data =
+ (struct vki_v4l2_subdev_selection *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_V4L2_SUBDEV_S_SELECTION)", (Addr)data, sizeof(*data));
break;
}
case VKI_MEDIA_IOC_DEVICE_INFO: {
- struct vki_media_device_info *data = (struct vki_media_device_info *)ARG3;
+ struct vki_media_device_info *data =
+ (struct vki_media_device_info *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_MEDIA_IOC_DEVICE_INFO).reserved", data->reserved);
PRE_MEM_WRITE("ioctl(VKI_MEDIA_IOC_DEVICE_INFO)",
(Addr)data, sizeof(*data) - sizeof(data->reserved));
break;
}
case VKI_MEDIA_IOC_ENUM_ENTITIES: {
- struct vki_media_entity_desc *data = (struct vki_media_entity_desc *)ARG3;
+ struct vki_media_entity_desc *data =
+ (struct vki_media_entity_desc *)(Addr)ARG3;
PRE_FIELD_READ("ioctl(VKI_MEDIA_IOC_ENUM_ENTITIES).id", data->id);
PRE_MEM_WRITE("ioctl(VKI_MEDIA_IOC_ENUM_ENTITIES)",
(Addr)data->name, sizeof(*data) - sizeof(data->id));
break;
}
case VKI_MEDIA_IOC_ENUM_LINKS: {
- struct vki_media_links_enum *data = (struct vki_media_links_enum *)ARG3;
+ struct vki_media_links_enum *data =
+ (struct vki_media_links_enum *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_MEDIA_IOC_ENUM_LINKS)", (Addr)data, sizeof(*data));
break;
}
case VKI_MEDIA_IOC_SETUP_LINK: {
- struct vki_media_link_desc *data = (struct vki_media_link_desc *)ARG3;
+ struct vki_media_link_desc *data =
+ (struct vki_media_link_desc *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_MEDIA_IOC_SETUP_LINK)", (Addr)data, sizeof(*data));
break;
}
/* Serial */
case VKI_TIOCGSERIAL: {
- struct vki_serial_struct *data = (struct vki_serial_struct *)ARG3;
+ struct vki_serial_struct *data = (struct vki_serial_struct *)(Addr)ARG3;
PRE_MEM_WRITE("ioctl(VKI_TIOCGSERIAL)", (Addr)data, sizeof(*data));
break;
}
case VKI_TIOCSSERIAL: {
- struct vki_serial_struct *data = (struct vki_serial_struct *)ARG3;
+ struct vki_serial_struct *data = (struct vki_serial_struct *)(Addr)ARG3;
PRE_MEM_READ("ioctl(VKI_TIOCSSERIAL)", (Addr)data, sizeof(*data));
break;
}
} else {
/* be a bit more sophisticated */
POST_MEM_WRITE(ARG3, 28);
- UInt* word = (UInt*)ARG3;
+ UInt* word = (UInt*)(Addr)ARG3;
if (word && word[2] && word[3] < 0x200/*stay sane*/)
POST_MEM_WRITE(word[2], word[3]); // "ptr1"
if (word && word[4] && word[5] < 0x200/*stay sane*/)
that writable areas are addressable. */
case VKI_ION_IOC_ALLOC: {
struct vki_ion_allocation_data* data
- = (struct vki_ion_allocation_data*)ARG3;
+ = (struct vki_ion_allocation_data*)(Addr)ARG3;
POST_FIELD_WRITE(data->handle);
break;
}
case VKI_ION_IOC_MAP: {
- struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)ARG3;
+ struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)(Addr)ARG3;
POST_FIELD_WRITE(data->fd);
break;
}
case VKI_ION_IOC_SHARE:
break;
case VKI_ION_IOC_IMPORT: {
- struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)ARG3;
+ struct vki_ion_fd_data* data = (struct vki_ion_fd_data*)(Addr)ARG3;
POST_FIELD_WRITE(data->handle);
break;
}
break;
case VKI_SYNC_IOC_MERGE: {
- struct vki_sync_merge_data* data = (struct vki_sync_merge_data*)ARG3;
+ struct vki_sync_merge_data* data =
+ (struct vki_sync_merge_data*)(Addr)ARG3;
POST_FIELD_WRITE(data->fence);
break;
}
break;
case VKI_SG_IO:
{
- vki_sg_io_hdr_t *sgio = (vki_sg_io_hdr_t*)ARG3;
+ vki_sg_io_hdr_t *sgio = (vki_sg_io_hdr_t*)(Addr)ARG3;
if ( sgio->sbp ) {
POST_MEM_WRITE( (Addr)sgio->sbp, sgio->sb_len_wr );
}
/* These all use struct ifreq AFAIK */
case VKI_SIOCGIFINDEX: /* get iface index */
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_ifindex,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_ifindex) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_ifindex,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_ifindex));
break;
case VKI_SIOCGIFFLAGS: /* get flags */
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags));
break;
case VKI_SIOCGIFHWADDR: /* Get hardware address */
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_hwaddr,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_hwaddr) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_hwaddr,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_hwaddr));
break;
case VKI_SIOCGIFMTU: /* get MTU size */
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_mtu,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_mtu) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_mtu,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_mtu) );
break;
case VKI_SIOCGIFADDR: /* get PA address */
case VKI_SIOCGIFDSTADDR: /* get remote PA address */
case VKI_SIOCGIFBRDADDR: /* get broadcast PA address */
case VKI_SIOCGIFNETMASK: /* get network PA mask */
POST_MEM_WRITE(
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_addr,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_addr) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_addr,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_addr) );
break;
case VKI_SIOCGIFMETRIC: /* get metric */
POST_MEM_WRITE(
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_metric,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_metric) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_metric,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_metric) );
break;
case VKI_SIOCGIFMAP: /* Get device parameters */
POST_MEM_WRITE(
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_map,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_map) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_map,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_map) );
break;
break;
case VKI_SIOCGIFTXQLEN: /* Get the tx queue length */
POST_MEM_WRITE(
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_qlen,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_qlen) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_qlen,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_qlen) );
break;
case VKI_SIOCGIFNAME: /* get iface name */
POST_MEM_WRITE(
- (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_name,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_name) );
+ (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name) );
break;
case VKI_SIOCETHTOOL: { /* ethtool(8) interface */
- struct vki_ifreq *ir = (struct vki_ifreq *)ARG3;
+ struct vki_ifreq *ir = (struct vki_ifreq *)(Addr)ARG3;
switch ( *(vki_u32 *)ir->vki_ifr_data ) {
case VKI_ETHTOOL_GSET:
POST_MEM_WRITE( (Addr)ir->vki_ifr_data, sizeof(struct vki_ethtool_cmd));
}
case VKI_SIOCGMIIPHY: /* get hardware entry */
POST_MEM_WRITE(
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->phy_id));
break;
case VKI_SIOCGMIIREG: /* get hardware entry registers */
POST_MEM_WRITE(
- (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_out,
- sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_out) );
+ (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->val_out,
+ sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_data)->val_out));
break;
/* tun/tap related ioctls */
case VKI_TUNSETIFF:
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_name,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_name) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name) );
break;
case VKI_TUNGETFEATURES:
POST_MEM_WRITE( ARG3, sizeof(unsigned int) );
break;
case VKI_TUNGETIFF:
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_name,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_name) );
- POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
- sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_name) );
+ POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags,
+ sizeof(((struct vki_ifreq *)(Addr)ARG3)->vki_ifr_flags) );
break;
case VKI_TUNGETSNDBUF:
POST_MEM_WRITE( ARG3, sizeof(int) );
POST_MEM_WRITE(ARG3, sizeof(struct ifconf));
*/
if (RES == 0 && ARG3 ) {
- struct vki_ifconf *ifc = (struct vki_ifconf *) ARG3;
+ struct vki_ifconf *ifc = (struct vki_ifconf *) (Addr)ARG3;
if (ifc->vki_ifc_buf != NULL)
POST_MEM_WRITE( (Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
}
POST_MEM_WRITE( (Addr)ARG3, sizeof(struct vki_snd_ctl_card_info) );
break;
case VKI_SNDRV_CTL_IOCTL_ELEM_LIST: {
- struct vki_snd_ctl_elem_list *data = (struct vki_snd_ctl_elem_list *)ARG3;
+ struct vki_snd_ctl_elem_list *data =
+ (struct vki_snd_ctl_elem_list *)(Addr)ARG3;
POST_MEM_WRITE( (Addr)&data->used, sizeof(data->used) );
POST_MEM_WRITE( (Addr)&data->count, sizeof(data->count) );
if (data->pids) {
break;
}
case VKI_SNDRV_CTL_IOCTL_TLV_READ: {
- struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)ARG3;
+ struct vki_snd_ctl_tlv *data = (struct vki_snd_ctl_tlv *)(Addr)ARG3;
POST_MEM_WRITE( (Addr)data->tlv, data->length );
break;
}
POST_MEM_WRITE(ARG3, sizeof(vki_uint));
break;
case VKI_BLKREPORTZONE: {
- const struct vki_blk_zone_report *zr = (void *)ARG3;
+ const struct vki_blk_zone_report *zr = (void *)(Addr)ARG3;
POST_MEM_WRITE(ARG3, sizeof(*zr) + zr->nr_zones * sizeof(zr->zones[0]));
break;
break;
case VKI_CDROMREADAUDIO:
{
- struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) ARG3;
+ struct vki_cdrom_read_audio *cra =
+ (struct vki_cdrom_read_audio *) (Addr)ARG3;
POST_MEM_WRITE( (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
break;
}
break;
case VKI_GIO_FONTX:
- POST_MEM_WRITE( (Addr)((struct vki_consolefontdesc *)ARG3)->chardata,
- 32 * ((struct vki_consolefontdesc *)ARG3)->charcount );
+ POST_MEM_WRITE((Addr)((struct vki_consolefontdesc *)(Addr)ARG3)->chardata,
+ 32 * ((struct vki_consolefontdesc *)(Addr)ARG3)->charcount);
break;
case VKI_PIO_FONTX:
break;
case VKI_GIO_UNIMAP:
if ( ARG3 ) {
- struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
+ struct vki_unimapdesc *desc = (struct vki_unimapdesc *) (Addr)ARG3;
POST_MEM_WRITE( (Addr)&desc->entry_ct, sizeof(desc->entry_ct));
POST_MEM_WRITE( (Addr)desc->entries,
desc->entry_ct * sizeof(struct vki_unipair) );
break;
case VKI_KDGKBENT:
- POST_MEM_WRITE( (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
- sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
+ POST_MEM_WRITE( (Addr)&((struct vki_kbentry *)(Addr)ARG3)->kb_value,
+ sizeof(((struct vki_kbentry *)(Addr)ARG3)->kb_value) );
break;
case VKI_KDSKBENT:
break;
case VKI_KDGKBSENT:
- POST_MEM_WRITE( (Addr)((struct vki_kbsentry *)ARG3)->kb_string,
- sizeof(((struct vki_kbsentry *)ARG3)->kb_string) );
+ POST_MEM_WRITE( (Addr)((struct vki_kbsentry *)(Addr)ARG3)->kb_string,
+ sizeof(((struct vki_kbsentry *)(Addr)ARG3)->kb_string) );
break;
case VKI_KDSKBSENT:
break;
break;
case VKI_KDGETKEYCODE:
- POST_MEM_WRITE( (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
- sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
+ POST_MEM_WRITE( (Addr)((struct vki_kbkeycode *)(Addr)ARG3)->keycode,
+ sizeof(((struct vki_kbkeycode *)(Addr)ARG3)->keycode) );
break;
case VKI_KDSETKEYCODE:
break;
case VKI_KDFONTOP:
if ( ARG3 ) {
- struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
+ struct vki_console_font_op *op =
+ (struct vki_console_font_op *) (Addr)ARG3;
switch ( op->op ) {
case VKI_KD_FONT_OP_SET:
break;
case VKI_VT_SETMODE:
break;
case VKI_VT_GETSTATE:
- POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
- sizeof(((struct vki_vt_stat*) ARG3)->v_active) );
- POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
- sizeof(((struct vki_vt_stat*) ARG3)->v_state) );
+ POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) (Addr)ARG3)->v_active),
+ sizeof(((struct vki_vt_stat*) (Addr)ARG3)->v_active) );
+ POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) (Addr)ARG3)->v_state),
+ sizeof(((struct vki_vt_stat*) (Addr)ARG3)->v_state) );
break;
case VKI_VT_RELDISP:
case VKI_VT_ACTIVATE:
case VKI_USBDEVFS_CONTROL:
if ( ARG3 ) {
- struct vki_usbdevfs_ctrltransfer *vkuc = (struct vki_usbdevfs_ctrltransfer *)ARG3;
+ struct vki_usbdevfs_ctrltransfer *vkuc =
+ (struct vki_usbdevfs_ctrltransfer *)(Addr)ARG3;
if (vkuc->bRequestType & 0x80)
POST_MEM_WRITE((Addr)vkuc->data, RES);
}
break;
case VKI_USBDEVFS_BULK:
if ( ARG3 ) {
- struct vki_usbdevfs_bulktransfer *vkub = (struct vki_usbdevfs_bulktransfer *)ARG3;
+ struct vki_usbdevfs_bulktransfer *vkub =
+ (struct vki_usbdevfs_bulktransfer *)(Addr)ARG3;
if (vkub->ep & 0x80)
POST_MEM_WRITE((Addr)vkub->data, RES);
}
break;
case VKI_USBDEVFS_GETDRIVER:
if ( ARG3 ) {
- struct vki_usbdevfs_getdriver *vkugd = (struct vki_usbdevfs_getdriver *)ARG3;
+ struct vki_usbdevfs_getdriver *vkugd =
+ (struct vki_usbdevfs_getdriver *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&vkugd->driver, sizeof(vkugd->driver));
}
break;
case VKI_USBDEVFS_REAPURB:
case VKI_USBDEVFS_REAPURBNDELAY:
if ( ARG3 ) {
- struct vki_usbdevfs_urb **vkuu = (struct vki_usbdevfs_urb**)ARG3;
+ struct vki_usbdevfs_urb **vkuu = (struct vki_usbdevfs_urb**)(Addr)ARG3;
POST_MEM_WRITE((Addr)vkuu, sizeof(*vkuu));
if (!*vkuu)
break;
break;
case VKI_USBDEVFS_IOCTL:
if ( ARG3 ) {
- struct vki_usbdevfs_ioctl *vkui = (struct vki_usbdevfs_ioctl *)ARG3;
+ struct vki_usbdevfs_ioctl *vkui =
+ (struct vki_usbdevfs_ioctl *)(Addr)ARG3;
UInt dir2, size2;
dir2 = _VKI_IOC_DIR(vkui->ioctl_code);
size2 = _VKI_IOC_SIZE(vkui->ioctl_code);
break;
case VKI_I2C_RDWR:
if ( ARG3 ) {
- struct vki_i2c_rdwr_ioctl_data *vkui = (struct vki_i2c_rdwr_ioctl_data *)ARG3;
+ struct vki_i2c_rdwr_ioctl_data *vkui =
+ (struct vki_i2c_rdwr_ioctl_data *)(Addr)ARG3;
UInt i;
for (i=0; i < vkui->nmsgs; i++) {
struct vki_i2c_msg *msg = vkui->msgs + i;
case VKI_I2C_SMBUS:
if ( ARG3 ) {
struct vki_i2c_smbus_ioctl_data *vkis
- = (struct vki_i2c_smbus_ioctl_data *) ARG3;
+ = (struct vki_i2c_smbus_ioctl_data *) (Addr)ARG3;
/* i2c_smbus_write_quick hides its value in read_write, so
this variable can have a different meaning */
if ((vkis->read_write == VKI_I2C_SMBUS_READ)
break;
case VKI_SIOCGIWNAME:
if (ARG3) {
- POST_MEM_WRITE((Addr)((struct vki_iwreq *)ARG3)->u.name,
- sizeof(((struct vki_iwreq *)ARG3)->u.name));
+ POST_MEM_WRITE((Addr)((struct vki_iwreq *)(Addr)ARG3)->u.name,
+ sizeof(((struct vki_iwreq *)(Addr)ARG3)->u.name));
}
break;
case VKI_SIOCGIWNWID:
case VKI_SIOCGIWPOWER:
case VKI_SIOCGIWAUTH:
if (ARG3) {
- POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.param,
+ POST_MEM_WRITE((Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.param,
sizeof(struct vki_iw_param));
}
break;
case VKI_SIOCGIWFREQ:
if (ARG3) {
- POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.freq,
+ POST_MEM_WRITE((Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.freq,
sizeof(struct vki_iw_freq));
}
break;
case VKI_SIOCGIWMODE:
if (ARG3) {
- POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.mode,
+ POST_MEM_WRITE((Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.mode,
sizeof(__vki_u32));
}
break;
case VKI_SIOCGIWENCODEEXT:
if (ARG3) {
struct vki_iw_point* point;
- point = &((struct vki_iwreq *)ARG3)->u.data;
+ point = &((struct vki_iwreq *)(Addr)ARG3)->u.data;
POST_MEM_WRITE((Addr)point->pointer, point->length);
}
break;
case VKI_SIOCGIWAP:
if (ARG3) {
- POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.ap_addr,
+ POST_MEM_WRITE((Addr)&((struct vki_iwreq *)(Addr)ARG3)->u.ap_addr,
sizeof(struct vki_sockaddr));
}
break;
case VKI_BINDER_WRITE_READ:
if (ARG3) {
struct vki_binder_write_read* bwr
- = (struct vki_binder_write_read*)ARG3;
+ = (struct vki_binder_write_read*)(Addr)ARG3;
POST_FIELD_WRITE(bwr->write_consumed);
POST_FIELD_WRITE(bwr->read_consumed);
break;
case VKI_BINDER_VERSION:
if (ARG3) {
- struct vki_binder_version* bv = (struct vki_binder_version*)ARG3;
+ struct vki_binder_version* bv =
+ (struct vki_binder_version*)(Addr)ARG3;
POST_FIELD_WRITE(bv->protocol_version);
}
break;
case VKI_HCIGETDEVLIST:
if (ARG3) {
- struct vki_hci_dev_list_req* dlr = (struct vki_hci_dev_list_req*)ARG3;
+ struct vki_hci_dev_list_req* dlr =
+ (struct vki_hci_dev_list_req*)(Addr)ARG3;
POST_MEM_WRITE((Addr)ARG3 + sizeof(struct vki_hci_dev_list_req),
dlr->dev_num * sizeof(struct vki_hci_dev_req));
}
case VKI_HCIINQUIRY:
if (ARG3) {
- struct vki_hci_inquiry_req* ir = (struct vki_hci_inquiry_req*)ARG3;
+ struct vki_hci_inquiry_req* ir =
+ (struct vki_hci_inquiry_req*)(Addr)ARG3;
POST_MEM_WRITE((Addr)ARG3 + sizeof(struct vki_hci_inquiry_req),
ir->num_rsp * sizeof(struct vki_inquiry_info));
}
case VKI_DRM_IOCTL_VERSION:
if (ARG3) {
- struct vki_drm_version* data = (struct vki_drm_version *)ARG3;
+ struct vki_drm_version* data = (struct vki_drm_version *)(Addr)ARG3;
struct vg_drm_version_info* info = container_of(data, struct vg_drm_version_info, data);
const vki_size_t orig_name_len = info->orig->name_len;
const vki_size_t orig_date_len = info->orig->date_len;
break;
case VKI_DRM_IOCTL_GET_UNIQUE:
if (ARG3) {
- struct vki_drm_unique *data = (struct vki_drm_unique *)ARG3;
+ struct vki_drm_unique *data = (struct vki_drm_unique *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->unique, sizeof(data->unique_len));
}
break;
case VKI_DRM_IOCTL_GET_MAGIC:
if (ARG3) {
- struct vki_drm_auth *data = (struct vki_drm_auth *)ARG3;
+ struct vki_drm_auth *data = (struct vki_drm_auth *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->magic, sizeof(data->magic));
}
break;
case VKI_DRM_IOCTL_WAIT_VBLANK:
if (ARG3) {
- union vki_drm_wait_vblank *data = (union vki_drm_wait_vblank *)ARG3;
+ union vki_drm_wait_vblank *data =
+ (union vki_drm_wait_vblank *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->reply, sizeof(data->reply));
}
break;
case VKI_DRM_IOCTL_GEM_FLINK:
if (ARG3) {
- struct vki_drm_gem_flink *data = (struct vki_drm_gem_flink *)ARG3;
+ struct vki_drm_gem_flink *data =
+ (struct vki_drm_gem_flink *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->name, sizeof(data->name));
}
break;
case VKI_DRM_IOCTL_GEM_OPEN:
if (ARG3) {
- struct vki_drm_gem_open *data = (struct vki_drm_gem_open *)ARG3;
+ struct vki_drm_gem_open *data = (struct vki_drm_gem_open *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->handle, sizeof(data->handle));
POST_MEM_WRITE((Addr)&data->size, sizeof(data->size));
}
break;
case VKI_DRM_IOCTL_I915_GETPARAM:
if (ARG3) {
- vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t *)ARG3;
+ vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->value, sizeof(int));
}
break;
case VKI_DRM_IOCTL_I915_GEM_BUSY:
if (ARG3) {
- struct vki_drm_i915_gem_busy *data = (struct vki_drm_i915_gem_busy *)ARG3;
+ struct vki_drm_i915_gem_busy *data =
+ (struct vki_drm_i915_gem_busy *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->busy, sizeof(data->busy));
}
break;
case VKI_DRM_IOCTL_I915_GEM_CREATE:
if (ARG3) {
- struct vki_drm_i915_gem_create *data = (struct vki_drm_i915_gem_create *)ARG3;
+ struct vki_drm_i915_gem_create *data =
+ (struct vki_drm_i915_gem_create *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->handle, sizeof(data->handle));
}
break;
case VKI_DRM_IOCTL_I915_GEM_PREAD:
if (ARG3) {
- struct vki_drm_i915_gem_pread *data = (struct vki_drm_i915_gem_pread *)ARG3;
+ struct vki_drm_i915_gem_pread *data =
+ (struct vki_drm_i915_gem_pread *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->data_ptr, data->size);
}
break;
case VKI_DRM_IOCTL_I915_GEM_MMAP_GTT:
if (ARG3) {
- struct vki_drm_i915_gem_mmap_gtt *data = (struct vki_drm_i915_gem_mmap_gtt *)ARG3;
+ struct vki_drm_i915_gem_mmap_gtt *data =
+ (struct vki_drm_i915_gem_mmap_gtt *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->offset, sizeof(data->offset));
}
break;
case VKI_DRM_IOCTL_I915_GEM_SET_TILING:
if (ARG3) {
- struct vki_drm_i915_gem_set_tiling *data = (struct vki_drm_i915_gem_set_tiling *)ARG3;
+ struct vki_drm_i915_gem_set_tiling *data =
+ (struct vki_drm_i915_gem_set_tiling *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->tiling_mode, sizeof(data->tiling_mode));
POST_MEM_WRITE((Addr)&data->stride, sizeof(data->stride));
POST_MEM_WRITE((Addr)&data->swizzle_mode, sizeof(data->swizzle_mode));
break;
case VKI_DRM_IOCTL_I915_GEM_GET_TILING:
if (ARG3) {
- struct vki_drm_i915_gem_get_tiling *data = (struct vki_drm_i915_gem_get_tiling *)ARG3;
+ struct vki_drm_i915_gem_get_tiling *data =
+ (struct vki_drm_i915_gem_get_tiling *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->tiling_mode, sizeof(data->tiling_mode));
POST_MEM_WRITE((Addr)&data->swizzle_mode, sizeof(data->swizzle_mode));
}
break;
case VKI_DRM_IOCTL_I915_GEM_GET_APERTURE:
if (ARG3) {
- struct vki_drm_i915_gem_get_aperture *data = (struct vki_drm_i915_gem_get_aperture *)ARG3;
+ struct vki_drm_i915_gem_get_aperture *data =
+ (struct vki_drm_i915_gem_get_aperture *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->aper_size, sizeof(data->aper_size));
POST_MEM_WRITE((Addr)&data->aper_available_size, sizeof(data->aper_available_size));
}
case VKI_KVM_S390_MEM_OP: {
struct vki_kvm_s390_mem_op *args =
- (struct vki_kvm_s390_mem_op *)(ARG3);
+ (struct vki_kvm_s390_mem_op *)(Addr)(ARG3);
if (args->flags & VKI_KVM_S390_MEMOP_F_CHECK_ONLY)
break;
if (args->op == VKI_KVM_S390_MEMOP_LOGICAL_READ)
case VKI_XEN_IOCTL_PRIVCMD_HYPERCALL: {
SyscallArgs harrghs;
struct vki_xen_privcmd_hypercall *args =
- (struct vki_xen_privcmd_hypercall *)(ARG3);
+ (struct vki_xen_privcmd_hypercall *)(Addr)(ARG3);
if (!args)
break;
break;
case VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH: {
struct vki_xen_privcmd_mmapbatch *args =
- (struct vki_xen_privcmd_mmapbatch *)(ARG3);
+ (struct vki_xen_privcmd_mmapbatch *)(Addr)(ARG3);
POST_MEM_WRITE((Addr)args->arr, sizeof(*(args->arr)) * args->num);
}
break;
case VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2: {
struct vki_xen_privcmd_mmapbatch_v2 *args =
- (struct vki_xen_privcmd_mmapbatch_v2 *)(ARG3);
+ (struct vki_xen_privcmd_mmapbatch_v2 *)(Addr)(ARG3);
POST_MEM_WRITE((Addr)args->err, sizeof(*(args->err)) * args->num);
}
break;
/* Lustre */
case VKI_OBD_IOC_FID2PATH: {
- struct vki_getinfo_fid2path *args = (void *)(ARG3);
+ struct vki_getinfo_fid2path *args = (void *)(Addr)(ARG3);
POST_FIELD_WRITE(args->gf_recno);
POST_FIELD_WRITE(args->gf_linkno);
POST_MEM_WRITE((Addr)args->gf_path, VG_(strlen)(args->gf_path)+1);
break;
case VKI_LL_IOC_GETPARENT: {
- struct vki_getparent *gp = (struct vki_getparent *)ARG3;
+ struct vki_getparent *gp = (struct vki_getparent *)(Addr)ARG3;
POST_FIELD_WRITE(gp->gp_fid);
POST_MEM_WRITE((Addr)gp->gp_name, VG_(strlen)(gp->gp_name)+1);
break;
case VKI_V4L2_PREPARE_BUF:
break;
case VKI_V4L2_QUERYCAP: {
- struct vki_v4l2_capability *data = (struct vki_v4l2_capability *)ARG3;
+ struct vki_v4l2_capability *data =
+ (struct vki_v4l2_capability *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUM_FMT: {
- struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)ARG3;
+ struct vki_v4l2_fmtdesc *data = (struct vki_v4l2_fmtdesc *)(Addr)ARG3;
POST_FIELD_WRITE(data->flags);
POST_FIELD_WRITE(data->description);
POST_FIELD_WRITE(data->pixelformat);
break;
}
case VKI_V4L2_G_FMT: {
- struct vki_v4l2_format *data = (struct vki_v4l2_format *)ARG3;
+ struct vki_v4l2_format *data = (struct vki_v4l2_format *)(Addr)ARG3;
switch (data->type) {
case VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE:
case VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT:
break;
}
case VKI_V4L2_QUERYBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
unsigned i;
break;
}
case VKI_V4L2_G_FBUF: {
- struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3;
+ struct vki_v4l2_framebuffer *data =
+ (struct vki_v4l2_framebuffer *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_S_FBUF: {
- struct vki_v4l2_framebuffer *data = (struct vki_v4l2_framebuffer *)ARG3;
+ struct vki_v4l2_framebuffer *data =
+ (struct vki_v4l2_framebuffer *)(Addr)ARG3;
POST_FIELD_WRITE(data->capability);
POST_FIELD_WRITE(data->flags);
POST_FIELD_WRITE(data->fmt);
break;
}
case VKI_V4L2_QBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)(Addr)ARG3;
if (data->type == VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
break;
}
case VKI_V4L2_EXPBUF: {
- struct vki_v4l2_exportbuffer *data = (struct vki_v4l2_exportbuffer *)ARG3;
+ struct vki_v4l2_exportbuffer *data =
+ (struct vki_v4l2_exportbuffer *)(Addr)ARG3;
POST_FIELD_WRITE(data->fd);
break;
}
case VKI_V4L2_DQBUF: {
- struct vki_v4l2_buffer *data = (struct vki_v4l2_buffer *)ARG3;
+ struct vki_v4l2_buffer *data =
+ (struct vki_v4l2_buffer *)(Addr)ARG3;
POST_FIELD_WRITE(data->index);
POST_FIELD_WRITE(data->bytesused);
POST_FIELD_WRITE(data->field);
break;
}
case VKI_V4L2_G_PARM: {
- struct vki_v4l2_streamparm *data = (struct vki_v4l2_streamparm *)ARG3;
+ struct vki_v4l2_streamparm *data =
+ (struct vki_v4l2_streamparm *)(Addr)ARG3;
int is_output = data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT ||
data->type == VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
data->type == VKI_V4L2_BUF_TYPE_VBI_OUTPUT ||
break;
}
case VKI_V4L2_G_STD: {
- vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3;
+ vki_v4l2_std_id *data = (vki_v4l2_std_id *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMSTD: {
- struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)ARG3;
+ struct vki_v4l2_standard *data = (struct vki_v4l2_standard *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->id, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_ENUMINPUT: {
- struct vki_v4l2_input *data = (struct vki_v4l2_input *)ARG3;
+ struct vki_v4l2_input *data = (struct vki_v4l2_input *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_G_CTRL: {
- struct vki_v4l2_control *data = (struct vki_v4l2_control *)ARG3;
+ struct vki_v4l2_control *data = (struct vki_v4l2_control *)(Addr)ARG3;
POST_FIELD_WRITE(data->value);
break;
}
case VKI_V4L2_G_TUNER: {
- struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)ARG3;
+ struct vki_v4l2_tuner *data = (struct vki_v4l2_tuner *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name,
sizeof(*data) - sizeof(data->index) - sizeof(data->reserved));
break;
}
case VKI_V4L2_G_AUDIO: {
- struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3;
+ struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data,
sizeof(*data) - sizeof(data->reserved));
break;
}
case VKI_V4L2_QUERYCTRL: {
- struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)ARG3;
+ struct vki_v4l2_queryctrl *data = (struct vki_v4l2_queryctrl *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->type,
sizeof(*data) - sizeof(data->id));
break;
}
case VKI_V4L2_QUERYMENU: {
- struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)ARG3;
+ struct vki_v4l2_querymenu *data = (struct vki_v4l2_querymenu *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name,
sizeof(*data) - sizeof(data->id) - sizeof(data->index));
break;
}
case VKI_V4L2_G_INPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_EDID: {
- struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)ARG3;
+ struct vki_v4l2_edid *data = (struct vki_v4l2_edid *)(Addr)ARG3;
if (data->blocks && data->edid)
POST_MEM_WRITE((Addr)data->edid, data->blocks * 128);
break;
}
case VKI_V4L2_G_OUTPUT: {
- int *data = (int *)ARG3;
+ int *data = (int *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMOUTPUT: {
- struct vki_v4l2_output *data = (struct vki_v4l2_output *)ARG3;
+ struct vki_v4l2_output *data = (struct vki_v4l2_output *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->index));
break;
}
case VKI_V4L2_G_AUDOUT: {
- struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3;
+ struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data,
sizeof(*data) - sizeof(data->reserved));
break;
}
case VKI_V4L2_G_MODULATOR: {
- struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)ARG3;
+ struct vki_v4l2_modulator *data = (struct vki_v4l2_modulator *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name,
sizeof(*data) - sizeof(data->index) - sizeof(data->reserved));
break;
}
case VKI_V4L2_G_FREQUENCY: {
- struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)ARG3;
+ struct vki_v4l2_frequency *data = (struct vki_v4l2_frequency *)(Addr)ARG3;
POST_FIELD_WRITE(data->type);
POST_FIELD_WRITE(data->frequency);
break;
}
case VKI_V4L2_CROPCAP: {
- struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)ARG3;
+ struct vki_v4l2_cropcap *data = (struct vki_v4l2_cropcap *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->bounds, sizeof(*data) - sizeof(data->type));
break;
}
case VKI_V4L2_G_CROP: {
- struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)ARG3;
+ struct vki_v4l2_crop *data = (struct vki_v4l2_crop *)(Addr)ARG3;
POST_FIELD_WRITE(data->c);
break;
}
case VKI_V4L2_G_JPEGCOMP: {
- struct vki_v4l2_jpegcompression *data = (struct vki_v4l2_jpegcompression *)ARG3;
+ struct vki_v4l2_jpegcompression *data =
+ (struct vki_v4l2_jpegcompression *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_QUERYSTD: {
- vki_v4l2_std_id *data = (vki_v4l2_std_id *)ARG3;
+ vki_v4l2_std_id *data = (vki_v4l2_std_id *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUMAUDIO: {
- struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)ARG3;
+ struct vki_v4l2_audio *data = (struct vki_v4l2_audio *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name,
sizeof(*data) - sizeof(data->index) - sizeof(data->reserved));
break;
}
case VKI_V4L2_ENUMAUDOUT: {
- struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)ARG3;
+ struct vki_v4l2_audioout *data = (struct vki_v4l2_audioout *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name,
sizeof(*data) - sizeof(data->index) - sizeof(data->reserved));
break;
}
case VKI_V4L2_G_PRIORITY: {
- __vki_u32 *data = (__vki_u32 *)ARG3;
+ __vki_u32 *data = (__vki_u32 *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_G_SLICED_VBI_CAP: {
- struct vki_v4l2_sliced_vbi_cap *data = (struct vki_v4l2_sliced_vbi_cap *)ARG3;
+ struct vki_v4l2_sliced_vbi_cap *data =
+ (struct vki_v4l2_sliced_vbi_cap *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data,
sizeof(*data) - sizeof(data->type) - sizeof(data->reserved));
break;
}
case VKI_V4L2_G_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
if (data->count) {
unsigned i;
break;
}
case VKI_V4L2_S_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
POST_FIELD_WRITE(data->error_idx);
break;
}
case VKI_V4L2_TRY_EXT_CTRLS: {
- struct vki_v4l2_ext_controls *data = (struct vki_v4l2_ext_controls *)ARG3;
+ struct vki_v4l2_ext_controls *data =
+ (struct vki_v4l2_ext_controls *)(Addr)ARG3;
POST_FIELD_WRITE(data->error_idx);
break;
}
case VKI_V4L2_ENUM_FRAMESIZES: {
- struct vki_v4l2_frmsizeenum *data = (struct vki_v4l2_frmsizeenum *)ARG3;
+ struct vki_v4l2_frmsizeenum *data =
+ (struct vki_v4l2_frmsizeenum *)(Addr)ARG3;
POST_FIELD_WRITE(data->type);
POST_FIELD_WRITE(data->stepwise);
break;
}
case VKI_V4L2_ENUM_FRAMEINTERVALS: {
- struct vki_v4l2_frmivalenum *data = (struct vki_v4l2_frmivalenum *)ARG3;
+ struct vki_v4l2_frmivalenum *data =
+ (struct vki_v4l2_frmivalenum *)(Addr)ARG3;
POST_FIELD_WRITE(data->type);
POST_FIELD_WRITE(data->stepwise);
break;
}
case VKI_V4L2_G_ENC_INDEX: {
- struct vki_v4l2_enc_idx *data = (struct vki_v4l2_enc_idx *)ARG3;
+ struct vki_v4l2_enc_idx *data = (struct vki_v4l2_enc_idx *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENCODER_CMD: {
- struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3;
+ struct vki_v4l2_encoder_cmd *data =
+ (struct vki_v4l2_encoder_cmd *)(Addr)ARG3;
POST_FIELD_WRITE(data->flags);
break;
}
case VKI_V4L2_TRY_ENCODER_CMD: {
- struct vki_v4l2_encoder_cmd *data = (struct vki_v4l2_encoder_cmd *)ARG3;
+ struct vki_v4l2_encoder_cmd *data =
+ (struct vki_v4l2_encoder_cmd *)(Addr)ARG3;
POST_FIELD_WRITE(data->flags);
break;
}
case VKI_V4L2_DBG_S_REGISTER: {
- struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3;
+ struct vki_v4l2_dbg_register *data =
+ (struct vki_v4l2_dbg_register *)(Addr)ARG3;
POST_FIELD_WRITE(data->size);
break;
}
case VKI_V4L2_DBG_G_REGISTER: {
- struct vki_v4l2_dbg_register *data = (struct vki_v4l2_dbg_register *)ARG3;
+ struct vki_v4l2_dbg_register *data =
+ (struct vki_v4l2_dbg_register *)(Addr)ARG3;
POST_FIELD_WRITE(data->val);
POST_FIELD_WRITE(data->size);
break;
}
case VKI_V4L2_G_DV_TIMINGS: {
- struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3;
+ struct vki_v4l2_dv_timings *data =
+ (struct vki_v4l2_dv_timings *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DQEVENT: {
- struct vki_v4l2_event *data = (struct vki_v4l2_event *)ARG3;
+ struct vki_v4l2_event *data = (struct vki_v4l2_event *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_CREATE_BUFS: {
- struct vki_v4l2_create_buffers *data = (struct vki_v4l2_create_buffers *)ARG3;
+ struct vki_v4l2_create_buffers *data =
+ (struct vki_v4l2_create_buffers *)(Addr)ARG3;
POST_FIELD_WRITE(data->index);
break;
}
case VKI_V4L2_G_SELECTION: {
- struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3;
+ struct vki_v4l2_selection *data =
+ (struct vki_v4l2_selection *)(Addr)ARG3;
POST_FIELD_WRITE(data->r);
break;
}
case VKI_V4L2_S_SELECTION: {
- struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)ARG3;
+ struct vki_v4l2_selection *data = (struct vki_v4l2_selection *)(Addr)ARG3;
POST_FIELD_WRITE(data->r);
break;
}
case VKI_V4L2_DECODER_CMD: {
- struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3;
+ struct vki_v4l2_decoder_cmd *data =
+ (struct vki_v4l2_decoder_cmd *)(Addr)ARG3;
POST_FIELD_WRITE(data->flags);
break;
}
case VKI_V4L2_TRY_DECODER_CMD: {
- struct vki_v4l2_decoder_cmd *data = (struct vki_v4l2_decoder_cmd *)ARG3;
+ struct vki_v4l2_decoder_cmd *data =
+ (struct vki_v4l2_decoder_cmd *)(Addr)ARG3;
POST_FIELD_WRITE(data->flags);
break;
}
case VKI_V4L2_ENUM_DV_TIMINGS: {
- struct vki_v4l2_enum_dv_timings *data = (struct vki_v4l2_enum_dv_timings *)ARG3;
+ struct vki_v4l2_enum_dv_timings *data =
+ (struct vki_v4l2_enum_dv_timings *)(Addr)ARG3;
POST_FIELD_WRITE(data->timings);
break;
}
case VKI_V4L2_QUERY_DV_TIMINGS: {
- struct vki_v4l2_dv_timings *data = (struct vki_v4l2_dv_timings *)ARG3;
+ struct vki_v4l2_dv_timings *data =
+ (struct vki_v4l2_dv_timings *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_DV_TIMINGS_CAP: {
- struct vki_v4l2_dv_timings_cap *data = (struct vki_v4l2_dv_timings_cap *)ARG3;
+ struct vki_v4l2_dv_timings_cap *data =
+ (struct vki_v4l2_dv_timings_cap *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
case VKI_V4L2_ENUM_FREQ_BANDS: {
- struct vki_v4l2_frequency_band *data = (struct vki_v4l2_frequency_band *)ARG3;
+ struct vki_v4l2_frequency_band *data =
+ (struct vki_v4l2_frequency_band *)(Addr)ARG3;
POST_FIELD_WRITE(data->capability);
POST_FIELD_WRITE(data->rangelow);
POST_FIELD_WRITE(data->rangehigh);
break;
}
case VKI_V4L2_DBG_G_CHIP_INFO: {
- struct vki_v4l2_dbg_chip_info *data = (struct vki_v4l2_dbg_chip_info *)ARG3;
+ struct vki_v4l2_dbg_chip_info *data =
+ (struct vki_v4l2_dbg_chip_info *)(Addr)ARG3;
POST_FIELD_WRITE(data->name);
POST_FIELD_WRITE(data->flags);
break;
}
case VKI_V4L2_QUERY_EXT_CTRL: {
- struct vki_v4l2_query_ext_ctrl *data = (struct vki_v4l2_query_ext_ctrl *)ARG3;
+ struct vki_v4l2_query_ext_ctrl *data =
+ (struct vki_v4l2_query_ext_ctrl *)(Addr)ARG3;
POST_MEM_WRITE((Addr)&data->type,
sizeof(*data) - sizeof(data->id) - sizeof(data->reserved));
break;
break;
case VKI_V4L2_SUBDEV_G_FMT: {
- struct vki_v4l2_subdev_format *data = (struct vki_v4l2_subdev_format *)ARG3;
+ struct vki_v4l2_subdev_format *data =
+ (struct vki_v4l2_subdev_format *)(Addr)ARG3;
POST_FIELD_WRITE(data->format);
break;
}
case VKI_V4L2_SUBDEV_G_FRAME_INTERVAL: {
- struct vki_v4l2_subdev_frame_interval *data = (struct vki_v4l2_subdev_frame_interval *)ARG3;
+ struct vki_v4l2_subdev_frame_interval *data =
+ (struct vki_v4l2_subdev_frame_interval *)(Addr)ARG3;
POST_FIELD_WRITE(data->interval);
break;
}
case VKI_V4L2_SUBDEV_ENUM_MBUS_CODE: {
- struct vki_v4l2_subdev_mbus_code_enum *data = (struct vki_v4l2_subdev_mbus_code_enum *)ARG3;
+ struct vki_v4l2_subdev_mbus_code_enum *data =
+ (struct vki_v4l2_subdev_mbus_code_enum *)(Addr)ARG3;
POST_FIELD_WRITE(data->code);
break;
}
case VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE: {
- struct vki_v4l2_subdev_frame_size_enum *data = (struct vki_v4l2_subdev_frame_size_enum *)ARG3;
+ struct vki_v4l2_subdev_frame_size_enum *data =
+ (struct vki_v4l2_subdev_frame_size_enum *)(Addr)ARG3;
POST_FIELD_WRITE(data->min_width);
POST_FIELD_WRITE(data->min_height);
POST_FIELD_WRITE(data->max_width);
break;
}
case VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL: {
- struct vki_v4l2_subdev_frame_interval_enum *data = (struct vki_v4l2_subdev_frame_interval_enum *)ARG3;
+ struct vki_v4l2_subdev_frame_interval_enum *data =
+ (struct vki_v4l2_subdev_frame_interval_enum *)(Addr)ARG3;
POST_FIELD_WRITE(data->interval);
break;
}
case VKI_V4L2_SUBDEV_G_CROP: {
- struct vki_v4l2_subdev_crop *data = (struct vki_v4l2_subdev_crop *)ARG3;
+ struct vki_v4l2_subdev_crop *data =
+ (struct vki_v4l2_subdev_crop *)(Addr)ARG3;
POST_FIELD_WRITE(data->rect);
break;
}
case VKI_V4L2_SUBDEV_G_SELECTION: {
- struct vki_v4l2_subdev_selection *data = (struct vki_v4l2_subdev_selection *)ARG3;
+ struct vki_v4l2_subdev_selection *data =
+ (struct vki_v4l2_subdev_selection *)(Addr)ARG3;
POST_FIELD_WRITE(data->r);
break;
}
case VKI_MEDIA_IOC_DEVICE_INFO: {
- struct vki_media_device_info *data = (struct vki_media_device_info *)ARG3;
+ struct vki_media_device_info *data =
+ (struct vki_media_device_info *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data) - sizeof(data->reserved));
break;
}
case VKI_MEDIA_IOC_ENUM_ENTITIES: {
- struct vki_media_entity_desc *data = (struct vki_media_entity_desc *)ARG3;
+ struct vki_media_entity_desc *data =
+ (struct vki_media_entity_desc *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data->name, sizeof(*data) - sizeof(data->id));
break;
}
/* Serial */
case VKI_TIOCGSERIAL: {
- struct vki_serial_struct *data = (struct vki_serial_struct *)ARG3;
+ struct vki_serial_struct *data = (struct vki_serial_struct *)(Addr)ARG3;
POST_MEM_WRITE((Addr)data, sizeof(*data));
break;
}
PRE(sys_kcmp)
{
- PRINT("kcmp ( %ld, %ld, %ld, %lu, %lu )", SARG1, SARG2, SARG3, ARG4, ARG5);
+ PRINT("kcmp ( %ld, %ld, %ld, %" FMT_REGWORD "u, %" FMT_REGWORD "u )",
+ 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:
projects / thirdparty / valgrind.git / commitdiff
