/*
-#ifdef LINUX
* Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
* Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
* Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
#ifdef O_RSYNC
{ O_RSYNC, "O_RSYNC" },
#endif
-#ifdef O_NDELAY
+#if defined(O_NDELAY) && (O_NDELAY != O_NONBLOCK)
{ O_NDELAY, "O_NDELAY" },
#endif
#ifdef O_PRIV
# endif
# endif
# ifdef O_LARGEFILE
- { O_LARGEFILE, "O_LARGEFILE" },
+ { O_LARGEFILE, "O_LARGEFILE" },
# endif
#endif
#ifdef O_DIRECTORY
- { O_DIRECTORY, "O_DIRECTORY" },
+ { O_DIRECTORY, "O_DIRECTORY" },
#endif
#ifdef O_NOFOLLOW
- { O_NOFOLLOW, "O_NOFOLLOW" },
+ { O_NOFOLLOW, "O_NOFOLLOW" },
#endif
#ifdef O_NOATIME
- { O_NOATIME, "O_NOATIME" },
+ { O_NOATIME, "O_NOATIME" },
#endif
#ifdef O_CLOEXEC
{ O_CLOEXEC, "O_CLOEXEC" },
#endif
-
#ifdef FNDELAY
{ FNDELAY, "FNDELAY" },
#endif
# define AT_FDCWD -100
#endif
+/* The fd is an "int", so when decoding x86 on x86_64, we need to force sign
+ * extension to get the right value. We do this by declaring fd as int here.
+ */
static void
-print_dirfd(long fd)
+print_dirfd(struct tcb *tcp, int fd)
{
if (fd == AT_FDCWD)
- tprintf("AT_FDCWD, ");
- else
- tprintf("%ld, ", fd);
+ tprints("AT_FDCWD, ");
+ else {
+ printfd(tcp, fd);
+ tprints(", ");
+ }
}
#endif
* low bits of the open(2) flags define access mode,
* other bits are real flags.
*/
-void
-tprint_open_modes(struct tcb *tcp, mode_t flags)
-{
- const char *str = xlookup(open_access_modes, flags & 3);
-
- if (str)
- {
- tprintf("%s", str);
+const char *
+sprint_open_modes(mode_t flags)
+{
+ static char outstr[(1 + ARRAY_SIZE(open_mode_flags)) * sizeof("O_LARGEFILE")];
+ char *p;
+ char sep;
+ const char *str;
+ const struct xlat *x;
+
+ sep = ' ';
+ p = stpcpy(outstr, "flags");
+ str = xlookup(open_access_modes, flags & 3);
+ if (str) {
+ *p++ = sep;
+ p = stpcpy(p, str);
flags &= ~3;
if (!flags)
- return;
- tprintf("|");
+ return outstr;
+ sep = '|';
+ }
+
+ for (x = open_mode_flags; x->str; x++) {
+ if ((flags & x->val) == x->val) {
+ *p++ = sep;
+ p = stpcpy(p, x->str);
+ flags &= ~x->val;
+ if (!flags)
+ return outstr;
+ sep = '|';
+ }
}
- printflags(open_mode_flags, flags, "O_???");
+ /* flags is still nonzero */
+ *p++ = sep;
+ sprintf(p, "%#x", flags);
+ return outstr;
+}
+
+void
+tprint_open_modes(mode_t flags)
+{
+ tprints(sprint_open_modes(flags) + sizeof("flags"));
}
static int
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
/* flags */
- tprint_open_modes(tcp, tcp->u_arg[offset + 1]);
+ tprint_open_modes(tcp->u_arg[offset + 1]);
if (tcp->u_arg[offset + 1] & O_CREAT) {
/* mode */
tprintf(", %#lo", tcp->u_arg[offset + 2]);
sys_openat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_open(tcp, 1);
}
#endif
};
int
-solaris_open(tcp)
-struct tcb *tcp;
+solaris_open(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
/* flags */
printflags(openmodessol, tcp->u_arg[1] + 1, "O_???");
if (tcp->u_arg[1] & 0x100) {
#endif
int
-sys_creat(tcp)
-struct tcb *tcp;
+sys_creat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
printflags(access_flags, tcp->u_arg[offset + 1], "?_OK");
}
return 0;
sys_faccessat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_access(tcp, 1);
}
#endif
int
-sys_umask(tcp)
-struct tcb *tcp;
+sys_umask(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%#lo", tcp->u_arg[0]);
#ifndef HAVE_LONG_LONG_OFF_T
#if defined (LINUX_MIPSN32)
int
-sys_lseek(tcp)
-struct tcb *tcp;
+sys_lseek(struct tcb *tcp)
{
long long offset;
int _whence;
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
offset = tcp->ext_arg[1];
_whence = tcp->u_arg[2];
if (_whence == SEEK_SET)
}
#else /* !LINUX_MIPSN32 */
int
-sys_lseek(tcp)
-struct tcb *tcp;
+sys_lseek(struct tcb *tcp)
{
off_t offset;
int _whence;
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
offset = tcp->u_arg[1];
_whence = tcp->u_arg[2];
if (_whence == SEEK_SET)
#ifdef LINUX
int
-sys_llseek (tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- /*
- * This one call takes explicitly two 32-bit arguments hi, lo,
- * rather than one 64-bit argument for which LONG_LONG works
- * appropriate for the native byte order.
- */
- if (tcp->u_arg[4] == SEEK_SET)
- tprintf("%ld, %llu, ", tcp->u_arg[0],
- (((long long int) tcp->u_arg[1]) << 32
- | (unsigned long long) (unsigned) tcp->u_arg[2]));
- else
- tprintf("%ld, %lld, ", tcp->u_arg[0],
- (((long long int) tcp->u_arg[1]) << 32
- | (unsigned long long) (unsigned) tcp->u_arg[2]));
- }
- else {
- long long int off;
- if (syserror(tcp) || umove(tcp, tcp->u_arg[3], &off) < 0)
- tprintf("%#lx, ", tcp->u_arg[3]);
- else
- tprintf("[%llu], ", off);
- printxval(whence, tcp->u_arg[4], "SEEK_???");
- }
- return 0;
+sys_llseek(struct tcb *tcp)
+{
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ /*
+ * This one call takes explicitly two 32-bit arguments hi, lo,
+ * rather than one 64-bit argument for which LONG_LONG works
+ * appropriate for the native byte order.
+ */
+ if (tcp->u_arg[4] == SEEK_SET)
+ tprintf(", %llu, ",
+ ((long long int) tcp->u_arg[1]) << 32 |
+ (unsigned long long) (unsigned) tcp->u_arg[2]);
+ else
+ tprintf(", %lld, ",
+ ((long long int) tcp->u_arg[1]) << 32 |
+ (unsigned long long) (unsigned) tcp->u_arg[2]);
+ }
+ else {
+ long long int off;
+ if (syserror(tcp) || umove(tcp, tcp->u_arg[3], &off) < 0)
+ tprintf("%#lx, ", tcp->u_arg[3]);
+ else
+ tprintf("[%llu], ", off);
+ printxval(whence, tcp->u_arg[4], "SEEK_???");
+ }
+ return 0;
}
int
-sys_readahead (tcp)
-struct tcb *tcp;
+sys_readahead(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, %lld, %ld", tcp->u_arg[0],
-# if defined LINUX_MIPSN32
- tcp->ext_arg[1], tcp->u_arg[2]
-# elif defined IA64 || defined X86_64 || defined ALPHA || defined LINUX_MIPSN64
- (long long int) tcp->u_arg[1], tcp->u_arg[2]
-# else
- LONG_LONG(tcp->u_arg[1], tcp->u_arg[2]), tcp->u_arg[3]
-# endif
- );
- }
- return 0;
+ if (entering(tcp)) {
+ int argn;
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ argn = printllval(tcp, "%lld", 1);
+ tprintf(", %ld", tcp->u_arg[argn]);
+ }
+ return 0;
}
#endif
#if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
int
-sys_lseek64 (tcp)
-struct tcb *tcp;
+sys_lseek64(struct tcb *tcp)
{
if (entering(tcp)) {
- long long offset;
- ALIGN64 (tcp, 1); /* FreeBSD aligns off_t args */
- offset = LONG_LONG(tcp->u_arg [1], tcp->u_arg[2]);
+ int argn;
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
if (tcp->u_arg[3] == SEEK_SET)
- tprintf("%ld, %llu, ", tcp->u_arg[0], offset);
+ argn = printllval(tcp, "%llu, ", 1);
else
- tprintf("%ld, %lld, ", tcp->u_arg[0], offset);
- printxval(whence, tcp->u_arg[3], "SEEK_???");
+ argn = printllval(tcp, "%lld, ", 1);
+ printxval(whence, tcp->u_arg[argn], "SEEK_???");
}
return RVAL_LUDECIMAL;
}
#ifndef HAVE_LONG_LONG_OFF_T
int
-sys_truncate(tcp)
-struct tcb *tcp;
+sys_truncate(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
#if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
int
-sys_truncate64(tcp)
-struct tcb *tcp;
+sys_truncate64(struct tcb *tcp)
{
if (entering(tcp)) {
- ALIGN64 (tcp, 1);
printpath(tcp, tcp->u_arg[0]);
- tprintf(", %llu", LONG_LONG(tcp->u_arg[1],tcp->u_arg[2]));
+ printllval(tcp, ", %llu", 1);
}
return 0;
}
#ifndef HAVE_LONG_LONG_OFF_T
int
-sys_ftruncate(tcp)
-struct tcb *tcp;
+sys_ftruncate(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, %lu", tcp->u_arg[0], tcp->u_arg[1]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprintf(", %lu", tcp->u_arg[1]);
}
return 0;
}
#if _LFS64_LARGEFILE || HAVE_LONG_LONG_OFF_T
int
-sys_ftruncate64(tcp)
-struct tcb *tcp;
+sys_ftruncate64(struct tcb *tcp)
{
if (entering(tcp)) {
- ALIGN64 (tcp, 1);
- tprintf("%ld, %llu", tcp->u_arg[0],
- LONG_LONG(tcp->u_arg[1] ,tcp->u_arg[2]));
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printllval(tcp, "%llu", 1);
}
return 0;
}
};
static const char *
-sprintmode(mode)
-int mode;
+sprintmode(int mode)
{
static char buf[64];
const char *s;
strcpy(buf, "0");
return buf;
}
- if ((tmp = localtime(&t)))
+ tmp = localtime(&t);
+ if (tmp)
snprintf(buf, sizeof buf, "%02d/%02d/%02d-%02d:%02d:%02d",
tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
{
struct solstat statbuf;
- if (!addr) {
- tprintf("NULL");
- return;
- }
- if (syserror(tcp) || !verbose(tcp)) {
- tprintf("%#lx", addr);
- return;
- }
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
if (!abbrev(tcp)) {
tprintf("st_ctime=%s}", sprinttime(statbuf.st_ctime.tv_sec));
}
else
- tprintf("...}");
+ tprints("...}");
}
#if defined (SPARC64)
static void
-printstat_sparc64(tcp, addr)
-struct tcb *tcp;
-long addr;
+printstat_sparc64(struct tcb *tcp, long addr)
{
struct stat_sparc64 statbuf;
- if (!addr) {
- tprintf("NULL");
- return;
- }
- if (syserror(tcp) || !verbose(tcp)) {
- tprintf("%#lx", addr);
- return;
- }
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
#endif /* SPARC64 */
#endif /* LINUXSPARC */
+#if defined LINUX && defined POWERPC64
+struct stat_powerpc32 {
+ unsigned int st_dev;
+ unsigned int st_ino;
+ unsigned int st_mode;
+ unsigned short st_nlink;
+ unsigned int st_uid;
+ unsigned int st_gid;
+ unsigned int st_rdev;
+ unsigned int st_size;
+ unsigned int st_blksize;
+ unsigned int st_blocks;
+ unsigned int st_atime;
+ unsigned int st_atime_nsec;
+ unsigned int st_mtime;
+ unsigned int st_mtime_nsec;
+ unsigned int st_ctime;
+ unsigned int st_ctime_nsec;
+ unsigned int __unused4;
+ unsigned int __unused5;
+};
+
+static void
+printstat_powerpc32(struct tcb *tcp, long addr)
+{
+ struct stat_powerpc32 statbuf;
+
+ if (umove(tcp, addr, &statbuf) < 0) {
+ tprints("{...}");
+ return;
+ }
+
+ if (!abbrev(tcp)) {
+ tprintf("{st_dev=makedev(%u, %u), st_ino=%u, st_mode=%s, ",
+ major(statbuf.st_dev), minor(statbuf.st_dev),
+ statbuf.st_ino,
+ sprintmode(statbuf.st_mode));
+ tprintf("st_nlink=%u, st_uid=%u, st_gid=%u, ",
+ statbuf.st_nlink, statbuf.st_uid, statbuf.st_gid);
+ tprintf("st_blksize=%u, ", statbuf.st_blksize);
+ tprintf("st_blocks=%u, ", statbuf.st_blocks);
+ }
+ else
+ tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
+ switch (statbuf.st_mode & S_IFMT) {
+ case S_IFCHR: case S_IFBLK:
+ tprintf("st_rdev=makedev(%lu, %lu), ",
+ (unsigned long) major(statbuf.st_rdev),
+ (unsigned long) minor(statbuf.st_rdev));
+ break;
+ default:
+ tprintf("st_size=%u, ", statbuf.st_size);
+ break;
+ }
+ if (!abbrev(tcp)) {
+ tprintf("st_atime=%s, ", sprinttime(statbuf.st_atime));
+ tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
+ tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
+ tprints("}");
+ }
+ else
+ tprints("...}");
+}
+#endif /* LINUX && POWERPC64 */
+
static const struct xlat fileflags[] = {
#ifdef FREEBSD
{ UF_NODUMP, "UF_NODUMP" },
{ SF_APPEND, "SF_APPEND" },
{ SF_NOUNLINK, "SF_NOUNLINK" },
#elif UNIXWARE >= 2
-#ifdef _S_ISMLD
- { _S_ISMLD, "_S_ISMLD" },
+#ifdef _S_ISMLD
+ { _S_ISMLD, "_S_ISMLD" },
#endif
-#ifdef _S_ISMOUNTED
- { _S_ISMOUNTED, "_S_ISMOUNTED" },
+#ifdef _S_ISMOUNTED
+ { _S_ISMOUNTED, "_S_ISMOUNTED" },
#endif
#endif
{ 0, NULL },
#ifdef FREEBSD
int
-sys_chflags(tcp)
-struct tcb *tcp;
+sys_chflags(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printflags(fileflags, tcp->u_arg[1], "UF_???");
}
return 0;
}
int
-sys_fchflags(tcp)
-struct tcb *tcp;
+sys_fchflags(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
#ifndef HAVE_LONG_LONG_OFF_T
static void
-realprintstat(tcp, statbuf)
-struct tcb *tcp;
-struct stat *statbuf;
-{
- if (!abbrev(tcp)) {
- tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
- (unsigned long) major(statbuf->st_dev),
- (unsigned long) minor(statbuf->st_dev),
- (unsigned long) statbuf->st_ino,
- sprintmode(statbuf->st_mode));
- tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
- (unsigned long) statbuf->st_nlink,
- (unsigned long) statbuf->st_uid,
- (unsigned long) statbuf->st_gid);
+realprintstat(struct tcb *tcp, struct stat *statbuf)
+{
+ if (!abbrev(tcp)) {
+ tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
+ (unsigned long) major(statbuf->st_dev),
+ (unsigned long) minor(statbuf->st_dev),
+ (unsigned long) statbuf->st_ino,
+ sprintmode(statbuf->st_mode));
+ tprintf("st_nlink=%lu, st_uid=%lu, st_gid=%lu, ",
+ (unsigned long) statbuf->st_nlink,
+ (unsigned long) statbuf->st_uid,
+ (unsigned long) statbuf->st_gid);
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
- tprintf("st_blksize=%lu, ", (unsigned long) statbuf->st_blksize);
-#endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
+ tprintf("st_blksize=%lu, ", (unsigned long) statbuf->st_blksize);
+#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
- tprintf("st_blocks=%lu, ", (unsigned long) statbuf->st_blocks);
-#endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
- }
- else
- tprintf("{st_mode=%s, ", sprintmode(statbuf->st_mode));
- switch (statbuf->st_mode & S_IFMT) {
- case S_IFCHR: case S_IFBLK:
+ tprintf("st_blocks=%lu, ", (unsigned long) statbuf->st_blocks);
+#endif
+ }
+ else
+ tprintf("{st_mode=%s, ", sprintmode(statbuf->st_mode));
+ switch (statbuf->st_mode & S_IFMT) {
+ case S_IFCHR: case S_IFBLK:
#ifdef HAVE_STRUCT_STAT_ST_RDEV
- tprintf("st_rdev=makedev(%lu, %lu), ",
- (unsigned long) major(statbuf->st_rdev),
- (unsigned long) minor(statbuf->st_rdev));
+ tprintf("st_rdev=makedev(%lu, %lu), ",
+ (unsigned long) major(statbuf->st_rdev),
+ (unsigned long) minor(statbuf->st_rdev));
#else /* !HAVE_STRUCT_STAT_ST_RDEV */
- tprintf("st_size=makedev(%lu, %lu), ",
- (unsigned long) major(statbuf->st_size),
- (unsigned long) minor(statbuf->st_size));
+ tprintf("st_size=makedev(%lu, %lu), ",
+ (unsigned long) major(statbuf->st_size),
+ (unsigned long) minor(statbuf->st_size));
#endif /* !HAVE_STRUCT_STAT_ST_RDEV */
- break;
- default:
- tprintf("st_size=%lu, ", statbuf->st_size);
- break;
- }
- if (!abbrev(tcp)) {
- tprintf("st_atime=%s, ", sprinttime(statbuf->st_atime));
- tprintf("st_mtime=%s, ", sprinttime(statbuf->st_mtime));
- tprintf("st_ctime=%s", sprinttime(statbuf->st_ctime));
+ break;
+ default:
+ tprintf("st_size=%lu, ", (unsigned long) statbuf->st_size);
+ break;
+ }
+ if (!abbrev(tcp)) {
+ tprintf("st_atime=%s, ", sprinttime(statbuf->st_atime));
+ tprintf("st_mtime=%s, ", sprinttime(statbuf->st_mtime));
+ tprintf("st_ctime=%s", sprinttime(statbuf->st_ctime));
#if HAVE_STRUCT_STAT_ST_FLAGS
- tprintf(", st_flags=");
+ tprints(", st_flags=");
printflags(fileflags, statbuf->st_flags, "UF_???");
#endif
#if HAVE_STRUCT_STAT_ST_ACLCNT
#if HAVE_STRUCT_STAT_ST_GEN
tprintf(", st_gen=%u", statbuf->st_gen);
#endif
- tprintf("}");
- }
- else
- tprintf("...}");
+ tprints("}");
+ }
+ else
+ tprints("...}");
}
static void
-printstat(tcp, addr)
-struct tcb *tcp;
-long addr;
+printstat(struct tcb *tcp, long addr)
{
struct stat statbuf;
+ if (!addr) {
+ tprints("NULL");
+ return;
+ }
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#lx", addr);
+ return;
+ }
+
#ifdef LINUXSPARC
if (current_personality == 1) {
printstatsol(tcp, addr);
#endif
#endif /* LINUXSPARC */
- if (!addr) {
- tprintf("NULL");
- return;
- }
- if (syserror(tcp) || !verbose(tcp)) {
- tprintf("%#lx", addr);
+#if defined LINUX && defined POWERPC64
+ if (current_personality == 1) {
+ printstat_powerpc32(tcp, addr);
return;
}
+#endif
+
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#ifdef HAVE_STAT64
static void
-printstat64(tcp, addr)
-struct tcb *tcp;
-long addr;
+printstat64(struct tcb *tcp, long addr)
{
struct stat64 statbuf;
-#ifdef STAT64_SIZE
+#ifdef STAT64_SIZE
(void) sizeof(char[sizeof statbuf == STAT64_SIZE ? 1 : -1]);
#endif
+ if (!addr) {
+ tprints("NULL");
+ return;
+ }
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#lx", addr);
+ return;
+ }
+
#ifdef LINUXSPARC
if (current_personality == 1) {
printstatsol(tcp, addr);
return;
}
-#ifdef SPARC64
+# ifdef SPARC64
else if (current_personality == 2) {
printstat_sparc64(tcp, addr);
return;
}
-#endif
+# endif
#endif /* LINUXSPARC */
- if (!addr) {
- tprintf("NULL");
- return;
- }
- if (syserror(tcp) || !verbose(tcp)) {
- tprintf("%#lx", addr);
+#if defined LINUX && defined X86_64
+ if (current_personality == 0) {
+ printstat(tcp, addr);
return;
}
+#endif
+
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("st_mtime=%s, ", sprinttime(statbuf.st_mtime));
tprintf("st_ctime=%s", sprinttime(statbuf.st_ctime));
#if HAVE_STRUCT_STAT_ST_FLAGS
- tprintf(", st_flags=");
+ tprints(", st_flags=");
printflags(fileflags, statbuf.st_flags, "UF_???");
#endif
#if HAVE_STRUCT_STAT_ST_ACLCNT
#if HAVE_STRUCT_STAT_ST_GEN
tprintf(", st_gen=%u", statbuf.st_gen);
#endif
- tprintf("}");
+ tprints("}");
}
else
- tprintf("...}");
+ tprints("...}");
}
#endif /* HAVE_STAT64 */
-#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
+#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT) \
+ && !defined(HAVE_LONG_LONG_OFF_T)
static void
-convertoldstat(oldbuf, newbuf)
-const struct __old_kernel_stat *oldbuf;
-struct stat *newbuf;
-{
- newbuf->st_dev=oldbuf->st_dev;
- newbuf->st_ino=oldbuf->st_ino;
- newbuf->st_mode=oldbuf->st_mode;
- newbuf->st_nlink=oldbuf->st_nlink;
- newbuf->st_uid=oldbuf->st_uid;
- newbuf->st_gid=oldbuf->st_gid;
- newbuf->st_rdev=oldbuf->st_rdev;
- newbuf->st_size=oldbuf->st_size;
- newbuf->st_atime=oldbuf->st_atime;
- newbuf->st_mtime=oldbuf->st_mtime;
- newbuf->st_ctime=oldbuf->st_ctime;
- newbuf->st_blksize=0; /* not supported in old_stat */
- newbuf->st_blocks=0; /* not supported in old_stat */
+convertoldstat(const struct __old_kernel_stat *oldbuf, struct stat *newbuf)
+{
+ newbuf->st_dev = oldbuf->st_dev;
+ newbuf->st_ino = oldbuf->st_ino;
+ newbuf->st_mode = oldbuf->st_mode;
+ newbuf->st_nlink = oldbuf->st_nlink;
+ newbuf->st_uid = oldbuf->st_uid;
+ newbuf->st_gid = oldbuf->st_gid;
+ newbuf->st_rdev = oldbuf->st_rdev;
+ newbuf->st_size = oldbuf->st_size;
+ newbuf->st_atime = oldbuf->st_atime;
+ newbuf->st_mtime = oldbuf->st_mtime;
+ newbuf->st_ctime = oldbuf->st_ctime;
+ newbuf->st_blksize = 0; /* not supported in old_stat */
+ newbuf->st_blocks = 0; /* not supported in old_stat */
}
static void
-printoldstat(tcp, addr)
-struct tcb *tcp;
-long addr;
+printoldstat(struct tcb *tcp, long addr)
{
struct __old_kernel_stat statbuf;
struct stat newstatbuf;
-#ifdef LINUXSPARC
- if (current_personality == 1) {
- printstatsol(tcp, addr);
- return;
- }
-#endif /* LINUXSPARC */
-
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
tprintf("%#lx", addr);
return;
}
+
+#ifdef LINUXSPARC
+ if (current_personality == 1) {
+ printstatsol(tcp, addr);
+ return;
+ }
+#endif /* LINUXSPARC */
+
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#ifndef HAVE_LONG_LONG_OFF_T
int
-sys_stat(tcp)
-struct tcb *tcp;
+sys_stat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#endif
int
-sys_stat64(tcp)
-struct tcb *tcp;
+sys_stat64(struct tcb *tcp)
{
#ifdef HAVE_STAT64
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat64(tcp, tcp->u_arg[1]);
}
sys_newfstatat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
-#if defined HAVE_STAT64 && !(defined POWERPC && defined __powerpc64__)
+#ifdef POWERPC64
+ if (current_personality == 0)
+ printstat(tcp, tcp->u_arg[2]);
+ else
+ printstat64(tcp, tcp->u_arg[2]);
+#elif defined HAVE_STAT64
printstat64(tcp, tcp->u_arg[2]);
#else
printstat(tcp, tcp->u_arg[2]);
#endif
- tprintf(", ");
+ tprints(", ");
printflags(fstatatflags, tcp->u_arg[3], "AT_???");
}
return 0;
}
#endif
-#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
+#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT) \
+ && !defined(HAVE_LONG_LONG_OFF_T)
int
-sys_oldstat(tcp)
-struct tcb *tcp;
+sys_oldstat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
#ifndef HAVE_LONG_LONG_OFF_T
int
-sys_fstat(tcp)
-struct tcb *tcp;
+sys_fstat(struct tcb *tcp)
{
- if (entering(tcp))
- tprintf("%ld, ", tcp->u_arg[0]);
- else {
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ } else {
printstat(tcp, tcp->u_arg[1]);
}
return 0;
#endif
int
-sys_fstat64(tcp)
-struct tcb *tcp;
+sys_fstat64(struct tcb *tcp)
{
#ifdef HAVE_STAT64
- if (entering(tcp))
- tprintf("%ld, ", tcp->u_arg[0]);
- else {
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ } else {
printstat64(tcp, tcp->u_arg[1]);
}
return 0;
#endif
}
-#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
+#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT) \
+ && !defined(HAVE_LONG_LONG_OFF_T)
int
-sys_oldfstat(tcp)
-struct tcb *tcp;
+sys_oldfstat(struct tcb *tcp)
{
- if (entering(tcp))
- tprintf("%ld, ", tcp->u_arg[0]);
- else {
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ } else {
printoldstat(tcp, tcp->u_arg[1]);
}
return 0;
#ifndef HAVE_LONG_LONG_OFF_T
int
-sys_lstat(tcp)
-struct tcb *tcp;
+sys_lstat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#endif
int
-sys_lstat64(tcp)
-struct tcb *tcp;
+sys_lstat64(struct tcb *tcp)
{
#ifdef HAVE_STAT64
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat64(tcp, tcp->u_arg[1]);
}
#endif
}
-#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT)
+#if defined(LINUX) && defined(HAVE_STRUCT___OLD_KERNEL_STAT) \
+ && !defined(HAVE_LONG_LONG_OFF_T)
int
-sys_oldlstat(tcp)
-struct tcb *tcp;
+sys_oldlstat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
#if defined(SVR4) || defined(LINUXSPARC)
int
-sys_xstat(tcp)
-struct tcb *tcp;
+sys_xstat(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
#ifdef _STAT64_VER
if (tcp->u_arg[0] == _STAT64_VER)
}
int
-sys_fxstat(tcp)
-struct tcb *tcp;
+sys_fxstat(struct tcb *tcp)
{
if (entering(tcp))
tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
}
int
-sys_lxstat(tcp)
-struct tcb *tcp;
+sys_lxstat(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
} else {
#ifdef _STAT64_VER
if (tcp->u_arg[0] == _STAT64_VER)
}
int
-sys_xmknod(tcp)
-struct tcb *tcp;
+sys_xmknod(struct tcb *tcp)
{
int mode = tcp->u_arg[2];
};
int
-sys_acl(tcp)
-struct tcb *tcp;
+sys_acl(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printxval(aclcmds, tcp->u_arg[1], "???ACL???");
tprintf(", %ld", tcp->u_arg[2]);
/*
if (tcp->u_arg[3])
tprintf(", %#lx", tcp->u_arg[3]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
int
-sys_facl(tcp)
-struct tcb *tcp;
+sys_facl(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%ld, ", tcp->u_arg[0]);
if (tcp->u_arg[3])
tprintf(", %#lx", tcp->u_arg[3]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
int
-sys_aclipc(tcp)
-struct tcb *tcp;
+sys_aclipc(struct tcb *tcp)
{
if (entering(tcp)) {
printxval(aclipc, tcp->u_arg[0], "???IPC???");
if (tcp->u_arg[4])
tprintf(", %#lx", tcp->u_arg[4]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
-
-
#endif /* HAVE_SYS_ACL_H */
#endif /* SVR4 || LINUXSPARC */
#ifndef SVR4
static const char *
-sprintfstype(magic)
-int magic;
+sprintfstype(int magic)
{
static char buf[32];
#ifdef LINUX
}
static void
-printstatfs(tcp, addr)
-struct tcb *tcp;
-long addr;
+printstatfs(struct tcb *tcp, long addr)
{
struct statfs statbuf;
return;
}
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#ifdef ALPHA
sprintfstype(statbuf.f_type),
statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
tprintf("f_bavail=%u, f_files=%u, f_ffree=%u, f_fsid={%d, %d}, f_namelen=%u",
- statbuf.f_bavail,statbuf.f_files, statbuf.f_ffree,
+ statbuf.f_bavail, statbuf.f_files, statbuf.f_ffree,
statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1],
statbuf.f_namelen);
#else /* !ALPHA */
#ifdef _STATFS_F_FRSIZE
tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
#endif
- tprintf("}");
+ tprints("}");
}
int
-sys_statfs(tcp)
-struct tcb *tcp;
+sys_statfs(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
}
}
int
-sys_fstatfs(tcp)
-struct tcb *tcp;
+sys_fstatfs(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%lu, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
}
return 0;
}
-#ifdef LINUX
+#if defined LINUX && defined HAVE_STATFS64
static void
-printstatfs64(tcp, addr)
-struct tcb *tcp;
-long addr;
+printstatfs64(struct tcb *tcp, long addr)
{
struct statfs64 statbuf;
return;
}
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("{f_type=%s, f_bsize=%llu, f_blocks=%llu, f_bfree=%llu, ",
#ifdef _STATFS_F_FRSIZE
tprintf(", f_frsize=%llu", (unsigned long long)statbuf.f_frsize);
#endif
- tprintf("}");
+#ifdef _STATFS_F_FLAGS
+ tprintf(", f_flags=%llu", (unsigned long long)statbuf.f_flags);
+#endif
+ tprints("}");
+}
+
+struct compat_statfs64 {
+ uint32_t f_type;
+ uint32_t f_bsize;
+ uint64_t f_blocks;
+ uint64_t f_bfree;
+ uint64_t f_bavail;
+ uint64_t f_files;
+ uint64_t f_ffree;
+ fsid_t f_fsid;
+ uint32_t f_namelen;
+ uint32_t f_frsize;
+ uint32_t f_flags;
+ uint32_t f_spare[4];
+}
+#if defined(X86_64) || defined(IA64)
+ __attribute__ ((packed, aligned(4)))
+#endif
+;
+
+static void
+printcompat_statfs64(struct tcb *tcp, long addr)
+{
+ struct compat_statfs64 statbuf;
+
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#lx", addr);
+ return;
+ }
+ if (umove(tcp, addr, &statbuf) < 0) {
+ tprints("{...}");
+ return;
+ }
+ tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%llu, f_bfree=%llu, ",
+ sprintfstype(statbuf.f_type),
+ (unsigned long)statbuf.f_bsize,
+ (unsigned long long)statbuf.f_blocks,
+ (unsigned long long)statbuf.f_bfree);
+ tprintf("f_bavail=%llu, f_files=%llu, f_ffree=%llu, f_fsid={%d, %d}",
+ (unsigned long long)statbuf.f_bavail,
+ (unsigned long long)statbuf.f_files,
+ (unsigned long long)statbuf.f_ffree,
+ statbuf.f_fsid.__val[0], statbuf.f_fsid.__val[1]);
+ tprintf(", f_namelen=%lu", (unsigned long)statbuf.f_namelen);
+ tprintf(", f_frsize=%lu", (unsigned long)statbuf.f_frsize);
+ tprintf(", f_flags=%lu", (unsigned long)statbuf.f_frsize);
+ tprints("}");
}
int
-sys_statfs64(tcp)
-struct tcb *tcp;
+sys_statfs64(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
tprintf(", %lu, ", tcp->u_arg[1]);
} else {
- if (tcp->u_arg[1] == sizeof (struct statfs64))
+ if (tcp->u_arg[1] == sizeof(struct statfs64))
printstatfs64(tcp, tcp->u_arg[2]);
+ else if (tcp->u_arg[1] == sizeof(struct compat_statfs64))
+ printcompat_statfs64(tcp, tcp->u_arg[2]);
else
- tprintf("{???}");
+ tprints("{???}");
}
return 0;
}
int
-sys_fstatfs64(tcp)
-struct tcb *tcp;
+sys_fstatfs64(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%lu, %lu, ", tcp->u_arg[0], tcp->u_arg[1]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprintf(", %lu, ", tcp->u_arg[1]);
} else {
- if (tcp->u_arg[1] == sizeof (struct statfs64))
+ if (tcp->u_arg[1] == sizeof(struct statfs64))
printstatfs64(tcp, tcp->u_arg[2]);
+ else if (tcp->u_arg[1] == sizeof(struct compat_statfs64))
+ printcompat_statfs64(tcp, tcp->u_arg[2]);
else
- tprintf("{???}");
+ tprints("{???}");
}
return 0;
}
#if defined(LINUX) && defined(__alpha)
int
-osf_statfs(tcp)
-struct tcb *tcp;
+osf_statfs(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
tprintf(", %lu", tcp->u_arg[2]);
}
int
-osf_fstatfs(tcp)
-struct tcb *tcp;
+osf_fstatfs(struct tcb *tcp)
{
if (entering(tcp)) {
tprintf("%lu, ", tcp->u_arg[0]);
#endif /* !SVR4 */
#ifdef SUNOS4
-
int
-sys_ustat(tcp)
-struct tcb *tcp;
+sys_ustat(struct tcb *tcp)
{
struct ustat statbuf;
if (syserror(tcp) || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umove(tcp, tcp->u_arg[1], &statbuf) < 0)
- tprintf("{...}");
+ tprints("{...}");
else {
tprintf("{f_tfree=%lu, f_tinode=%lu, ",
statbuf.f_tfree, statbuf.f_tinode);
}
return 0;
}
-
#endif /* SUNOS4 */
-int
-sys_pivotroot(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printpath(tcp, tcp->u_arg[1]);
- }
- return 0;
-}
-
-
/* directory */
int
-sys_chdir(tcp)
-struct tcb *tcp;
+sys_chdir(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
sys_mkdirat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_mkdir(tcp, 1);
}
#endif
int
-sys_rmdir(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- }
- return 0;
-}
-
-int
-sys_fchdir(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
- }
- return 0;
-}
-
-int
-sys_chroot(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- }
- return 0;
-}
-
-#if defined(SUNOS4) || defined(SVR4)
-int
-sys_fchroot(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
- }
- return 0;
-}
-#endif /* SUNOS4 || SVR4 */
-
-int
-sys_link(tcp)
-struct tcb *tcp;
+sys_link(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
}
return 0;
sys_linkat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
- print_dirfd(tcp->u_arg[2]);
+ tprints(", ");
+ print_dirfd(tcp, tcp->u_arg[2]);
printpath(tcp, tcp->u_arg[3]);
- tprintf(", %ld", tcp->u_arg[4]);
+ tprints(", ");
+ printfd(tcp, tcp->u_arg[4]);
}
return 0;
}
#endif
-int
-sys_unlink(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- }
- return 0;
-}
-
#ifdef LINUX
static const struct xlat unlinkatflags[] = {
#ifndef AT_REMOVEDIR
sys_unlinkat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(unlinkatflags, tcp->u_arg[2], "AT_???");
}
return 0;
}
#endif
-int
-sys_symlink(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printpath(tcp, tcp->u_arg[1]);
- }
- return 0;
-}
-
#ifdef LINUX
int
sys_symlinkat(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- print_dirfd(tcp->u_arg[1]);
+ tprints(", ");
+ print_dirfd(tcp, tcp->u_arg[1]);
printpath(tcp, tcp->u_arg[2]);
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
} else {
if (syserror(tcp))
tprintf("%#lx", tcp->u_arg[offset + 1]);
else
- printpathn(tcp, tcp->u_arg[offset + 1], tcp->u_rval);
+ /* Used to use printpathn(), but readlink
+ * neither includes NUL in the returned count,
+ * nor actually writes it into memory.
+ * printpathn() would decide on printing
+ * "..." continuation based on garbage
+ * past return buffer's end.
+ */
+ printstr(tcp, tcp->u_arg[offset + 1], tcp->u_rval);
tprintf(", %lu", tcp->u_arg[offset + 2]);
}
return 0;
sys_readlinkat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_readlink(tcp, 1);
}
#endif
-int
-sys_rename(tcp)
-struct tcb *tcp;
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printpath(tcp, tcp->u_arg[1]);
- }
- return 0;
-}
-
#ifdef LINUX
int
sys_renameat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
- print_dirfd(tcp->u_arg[2]);
+ tprints(", ");
+ print_dirfd(tcp, tcp->u_arg[2]);
printpath(tcp, tcp->u_arg[3]);
}
return 0;
#endif
int
-sys_chown(tcp)
-struct tcb *tcp;
+sys_chown(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
sys_fchownat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
printpath(tcp, tcp->u_arg[1]);
printuid(", ", tcp->u_arg[2]);
printuid(", ", tcp->u_arg[3]);
- tprintf(", ");
+ tprints(", ");
printflags(fstatatflags, tcp->u_arg[4], "AT_???");
}
return 0;
#endif
int
-sys_fchown(tcp)
-struct tcb *tcp;
+sys_fchown(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
printuid(", ", tcp->u_arg[1]);
printuid(", ", tcp->u_arg[2]);
}
sys_fchmodat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_chmod(tcp, 1);
}
#endif
int
-sys_fchmod(tcp)
-struct tcb *tcp;
+sys_fchmod(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, %#lo", tcp->u_arg[0], tcp->u_arg[1]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprintf(", %#lo", tcp->u_arg[1]);
}
return 0;
}
#ifdef ALPHA
int
-sys_osf_utimes(tcp)
-struct tcb *tcp;
+sys_osf_utimes(struct tcb *tcp)
{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
- }
- return 0;
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
+ }
+ return 0;
}
#endif
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[offset]);
- tprintf(", ");
+ tprints(", ");
if (tcp->u_arg[offset + 1] == 0)
- tprintf("NULL");
+ tprints("NULL");
else {
- tprintf("{");
+ tprints("{");
printtv_bitness(tcp, tcp->u_arg[offset + 1],
BITNESS_CURRENT, special);
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[offset + 1]
- + sizeof (struct timeval),
+ + sizeof(struct timeval),
BITNESS_CURRENT, special);
- tprintf("}");
+ tprints("}");
}
}
return 0;
sys_futimesat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_utimes(tcp, 1, 0);
}
sys_utimensat(struct tcb *tcp)
{
if (entering(tcp)) {
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
decode_utimes(tcp, 1, 1);
- tprintf(", ");
+ tprints(", ");
printflags(utimensatflags, tcp->u_arg[3], "AT_???");
}
return 0;
#endif
int
-sys_utime(tcp)
-struct tcb *tcp;
+sys_utime(struct tcb *tcp)
{
union {
long utl[2];
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
if (!tcp->u_arg[1])
- tprintf("NULL");
+ tprints("NULL");
else if (!verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
else if (umoven(tcp, tcp->u_arg[1],
2 * personality_wordsize[current_personality],
(char *) &u) < 0)
- tprintf("[?, ?]");
+ tprints("[?, ?]");
else if (personality_wordsize[current_personality]
== sizeof u.utl[0]) {
tprintf("[%s,", sprinttime(u.utl[0]));
sys_mknodat(struct tcb *tcp)
{
if (entering(tcp))
- print_dirfd(tcp->u_arg[0]);
+ print_dirfd(tcp, tcp->u_arg[0]);
return decode_mknod(tcp, 1);
}
#endif
#ifdef FREEBSD
int
-sys_mkfifo(tcp)
-struct tcb *tcp;
+sys_mkfifo(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
#endif /* FREEBSD */
int
-sys_fsync(tcp)
-struct tcb *tcp;
+sys_fsync(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
}
return 0;
}
#ifdef LINUX
static void
-printdir(tcp, addr)
-struct tcb *tcp;
-long addr;
+printdir(struct tcb *tcp, long addr)
{
struct dirent d;
return;
}
if (umove(tcp, addr, &d) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
tprintf("{d_ino=%ld, ", (unsigned long) d.d_ino);
- tprintf("d_name=");
+ tprints("d_name=");
printpathn(tcp, (long) ((struct dirent *) addr)->d_name, d.d_reclen);
- tprintf("}");
+ tprints("}");
}
int
-sys_readdir(tcp)
-struct tcb *tcp;
+sys_readdir(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%lu, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
} else {
if (syserror(tcp) || tcp->u_rval == 0 || !verbose(tcp))
tprintf("%#lx", tcp->u_arg[1]);
#if defined FREEBSD || defined LINUX
static const struct xlat direnttypes[] = {
- { DT_UNKNOWN, "DT_UNKNOWN" },
- { DT_FIFO, "DT_FIFO" },
- { DT_CHR, "DT_CHR" },
- { DT_DIR, "DT_DIR" },
- { DT_BLK, "DT_BLK" },
- { DT_REG, "DT_REG" },
- { DT_LNK, "DT_LNK" },
- { DT_SOCK, "DT_SOCK" },
- { DT_WHT, "DT_WHT" },
+ { DT_UNKNOWN, "DT_UNKNOWN" },
+ { DT_FIFO, "DT_FIFO" },
+ { DT_CHR, "DT_CHR" },
+ { DT_DIR, "DT_DIR" },
+ { DT_BLK, "DT_BLK" },
+ { DT_REG, "DT_REG" },
+ { DT_LNK, "DT_LNK" },
+ { DT_SOCK, "DT_SOCK" },
+ { DT_WHT, "DT_WHT" },
{ 0, NULL },
};
char *buf;
if (entering(tcp)) {
- tprintf("%lu, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
return 0;
}
len = tcp->u_rval;
- if ((buf = malloc(len)) == NULL) {
- tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
- fprintf(stderr, "out of memory\n");
- return 0;
- }
+ /* Beware of insanely large or negative values in tcp->u_rval */
+ if (tcp->u_rval > 1024*1024)
+ len = 1024*1024;
+ if (tcp->u_rval < 0)
+ len = 0;
+ buf = len ? malloc(len) : NULL;
+ if (len && !buf)
+ die_out_of_memory();
if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
free(buf);
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
#ifdef LINUX
}
#endif /* FREEBSD */
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
tprintf(", %lu", tcp->u_arg[2]);
char *buf;
if (entering(tcp)) {
- tprintf("%lu, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
return 0;
}
+
len = tcp->u_rval;
- if ((buf = malloc(len)) == NULL) {
- tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
- fprintf(stderr, "out of memory\n");
- return 0;
- }
+ /* Beware of insanely large or negative tcp->u_rval */
+ if (tcp->u_rval > 1024*1024)
+ len = 1024*1024;
+ if (tcp->u_rval < 0)
+ len = 0;
+ buf = len ? malloc(len) : NULL;
+ if (len && !buf)
+ die_out_of_memory();
+
if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
free(buf);
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct dirent64 *d = (struct dirent64 *) &buf[i];
#if defined(LINUX) || defined(SVR4)
d->d_ino,
d->d_off);
#ifdef LINUX
- tprintf("d_type=");
+ tprints("d_type=");
printxval(direnttypes, d->d_type, "DT_???");
- tprintf(", ");
+ tprints(", ");
#endif
tprintf("d_reclen=%u, d_name=\"%s\"}",
d->d_reclen, d->d_name);
}
#endif /* SUNOS4 */
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
tprintf(", %lu", tcp->u_arg[2]);
char *buf;
if (entering(tcp)) {
- tprintf("%lu, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
return 0;
}
if (syserror(tcp) || !verbose(tcp)) {
tprintf("%#lx, %lu, %#lx", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
return 0;
}
+
len = tcp->u_rval;
- if ((buf = malloc(len)) == NULL) {
- tprintf("%#lx, %lu, %#lx", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
- fprintf(stderr, "out of memory\n");
- return 0;
- }
+ /* Beware of insanely large or negative tcp->u_rval */
+ if (tcp->u_rval > 1024*1024)
+ len = 1024*1024;
+ if (tcp->u_rval < 0)
+ len = 0;
+ buf = malloc(len);
+ if (!buf)
+ die_out_of_memory();
+
if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
tprintf("%#lx, %lu, %#lx", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
free(buf);
return 0;
}
if (!abbrev(tcp))
- tprintf("{");
+ tprints("{");
for (i = 0; i < len;) {
struct kernel_dirent *d = (struct kernel_dirent *) &buf[i];
if (!abbrev(tcp)) {
d->d_namlen, d->d_namlen, d->d_name);
}
if (!d->d_reclen) {
- tprintf("/* d_reclen == 0, problem here */");
+ tprints("/* d_reclen == 0, problem here */");
break;
}
i += d->d_reclen;
dents++;
}
if (!abbrev(tcp))
- tprintf("}");
+ tprints("}");
else
tprintf("/* %u entries */", dents);
free(buf);
#ifdef LINUX
int
-sys_getcwd(tcp)
-struct tcb *tcp;
+sys_getcwd(struct tcb *tcp)
{
- if (exiting(tcp)) {
- if (syserror(tcp))
- tprintf("%#lx", tcp->u_arg[0]);
- else
- printpathn(tcp, tcp->u_arg[0], tcp->u_rval - 1);
- tprintf(", %lu", tcp->u_arg[1]);
- }
- return 0;
+ if (exiting(tcp)) {
+ if (syserror(tcp))
+ tprintf("%#lx", tcp->u_arg[0]);
+ else
+ printpathn(tcp, tcp->u_arg[0], tcp->u_rval - 1);
+ tprintf(", %lu", tcp->u_arg[1]);
+ }
+ return 0;
}
#endif /* LINUX */
#ifdef FREEBSD
int
-sys___getcwd(tcp)
-struct tcb *tcp;
+sys___getcwd(struct tcb *tcp)
{
- if (exiting(tcp)) {
- if (syserror(tcp))
- tprintf("%#lx", tcp->u_arg[0]);
- else
- printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
- tprintf(", %lu", tcp->u_arg[1]);
- }
- return 0;
+ if (exiting(tcp)) {
+ if (syserror(tcp))
+ tprintf("%#lx", tcp->u_arg[0]);
+ else
+ printpathn(tcp, tcp->u_arg[0], tcp->u_arg[1]);
+ tprintf(", %lu", tcp->u_arg[1]);
+ }
+ return 0;
}
#endif
#ifdef HAVE_SYS_ASYNCH_H
int
-sys_aioread(tcp)
-struct tcb *tcp;
+sys_aioread(struct tcb *tcp)
{
struct aio_result_t res;
}
int
-sys_aiowrite(tcp)
-struct tcb *tcp;
+sys_aiowrite(struct tcb *tcp)
{
struct aio_result_t res;
}
else {
if (tcp->u_arg[5] == 0)
- tprintf(", NULL");
+ tprints(", NULL");
else if (syserror(tcp)
|| umove(tcp, tcp->u_arg[5], &res) < 0)
tprintf(", %#lx", tcp->u_arg[5]);
}
int
-sys_aiowait(tcp)
-struct tcb *tcp;
+sys_aiowait(struct tcb *tcp)
{
if (entering(tcp))
printtv(tcp, tcp->u_arg[0]);
}
int
-sys_aiocancel(tcp)
-struct tcb *tcp;
+sys_aiocancel(struct tcb *tcp)
{
struct aio_result_t res;
if (exiting(tcp)) {
if (tcp->u_arg[0] == 0)
- tprintf("NULL");
+ tprints("NULL");
else if (syserror(tcp)
|| umove(tcp, tcp->u_arg[0], &res) < 0)
tprintf("%#lx", tcp->u_arg[0]);
};
static void
-print_xattr_val(tcp, failed, arg, insize, size)
-struct tcb *tcp;
-int failed;
-unsigned long arg;
-unsigned long insize, size;
-{
- if (!failed) {
- unsigned long capacity = 4 * size + 1;
- unsigned char *buf = (capacity < size) ? NULL : malloc(capacity);
- if (buf == NULL || /* probably a bogus size argument */
- umoven(tcp, arg, size, (char *) &buf[3 * size]) < 0) {
- failed = 1;
- }
- else {
- unsigned char *out = buf;
- unsigned char *in = &buf[3 * size];
- size_t i;
- for (i = 0; i < size; ++i)
- if (isprint(in[i]))
- *out++ = in[i];
+print_xattr_val(struct tcb *tcp, int failed,
+ unsigned long arg,
+ unsigned long insize,
+ unsigned long size)
+{
+ if (!failed) {
+ unsigned long capacity = 4 * size + 1;
+ unsigned char *buf = (capacity < size) ? NULL : malloc(capacity);
+ if (buf == NULL || /* probably a bogus size argument */
+ umoven(tcp, arg, size, (char *) &buf[3 * size]) < 0) {
+ failed = 1;
+ }
else {
+ unsigned char *out = buf;
+ unsigned char *in = &buf[3 * size];
+ size_t i;
+ for (i = 0; i < size; ++i) {
+ if (isprint(in[i]))
+ *out++ = in[i];
+ else {
#define tohex(n) "0123456789abcdef"[n]
- *out++ = '\\';
- *out++ = 'x';
- *out++ = tohex(in[i] / 16);
- *out++ = tohex(in[i] % 16);
+ *out++ = '\\';
+ *out++ = 'x';
+ *out++ = tohex(in[i] / 16);
+ *out++ = tohex(in[i] % 16);
+ }
+ }
+ /* Don't print terminating NUL if there is one. */
+ if (i > 0 && in[i - 1] == '\0')
+ out -= 4;
+ *out = '\0';
+ tprintf(", \"%s\", %ld", buf, insize);
}
- /* Don't print terminating NUL if there is one. */
- if (i > 0 && in[i - 1] == '\0')
- out -= 4;
- *out = '\0';
- tprintf(", \"%s\", %ld", buf, insize);
+ free(buf);
}
- free(buf);
- }
- if (failed)
- tprintf(", 0x%lx, %ld", arg, insize);
+ if (failed)
+ tprintf(", 0x%lx, %ld", arg, insize);
}
int
-sys_setxattr(tcp)
-struct tcb *tcp;
+sys_setxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printstr(tcp, tcp->u_arg[1], -1);
- print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
- tprintf(", ");
- printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
- }
- return 0;
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
+ tprints(", ");
+ printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
+ }
+ return 0;
}
int
-sys_fsetxattr(tcp)
-struct tcb *tcp;
+sys_fsetxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
- printstr(tcp, tcp->u_arg[1], -1);
- print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
- tprintf(", ");
- printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
- }
- return 0;
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ print_xattr_val(tcp, 0, tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[3]);
+ tprints(", ");
+ printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
+ }
+ return 0;
}
int
-sys_getxattr(tcp)
-struct tcb *tcp;
+sys_getxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printstr(tcp, tcp->u_arg[1], -1);
- } else {
- print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
- tcp->u_rval);
- }
- return 0;
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ } else {
+ print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
+ tcp->u_rval);
+ }
+ return 0;
}
int
-sys_fgetxattr(tcp)
-struct tcb *tcp;
+sys_fgetxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
- printstr(tcp, tcp->u_arg[1], -1);
- } else {
- print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
- tcp->u_rval);
- }
- return 0;
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ } else {
+ print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
+ tcp->u_rval);
+ }
+ return 0;
}
int
-sys_listxattr(tcp)
-struct tcb *tcp;
+sys_listxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- } else {
- /* XXX Print value in format */
- tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
- }
- return 0;
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ } else {
+ /* XXX Print value in format */
+ tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
+ }
+ return 0;
}
int
-sys_flistxattr(tcp)
-struct tcb *tcp;
+sys_flistxattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
- } else {
- /* XXX Print value in format */
- tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
- }
- return 0;
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ } else {
+ /* XXX Print value in format */
+ tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
+ }
+ return 0;
}
int
-sys_removexattr(tcp)
-struct tcb *tcp;
+sys_removexattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
- printstr(tcp, tcp->u_arg[1], -1);
- }
- return 0;
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ }
+ return 0;
}
int
-sys_fremovexattr(tcp)
-struct tcb *tcp;
+sys_fremovexattr(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
- printstr(tcp, tcp->u_arg[1], -1);
- }
- return 0;
+ if (entering(tcp)) {
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ printstr(tcp, tcp->u_arg[1], -1);
+ }
+ return 0;
}
#ifdef LINUX
int
-sys_fadvise64(tcp)
-struct tcb *tcp;
+sys_fadvise64(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, %lld, %ld, ",
- tcp->u_arg[0],
-# if defined IA64 || defined X86_64 || defined ALPHA
- (long long int) tcp->u_arg[1], tcp->u_arg[2]);
- printxval(advise, tcp->u_arg[3], "POSIX_FADV_???");
-#else
- LONG_LONG(tcp->u_arg[1], tcp->u_arg[2]), tcp->u_arg[3]);
- printxval(advise, tcp->u_arg[4], "POSIX_FADV_???");
-#endif
- }
- return 0;
+ if (entering(tcp)) {
+ int argn;
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+ argn = printllval(tcp, "%lld", 1);
+ tprintf(", %ld, ", tcp->u_arg[argn++]);
+ printxval(advise, tcp->u_arg[argn], "POSIX_FADV_???");
+ }
+ return 0;
}
#endif
int
-sys_fadvise64_64(tcp)
-struct tcb *tcp;
+sys_fadvise64_64(struct tcb *tcp)
{
- if (entering(tcp)) {
- tprintf("%ld, %lld, %lld, ",
- tcp->u_arg[0],
-#if defined LINUX_MIPSN32
- tcp->ext_arg[1], tcp->ext_arg[2]);
- printxval(advise, tcp->u_arg[3], "POSIX_FADV_???");
-#elif defined IA64 || defined X86_64 || defined ALPHA || defined LINUX_MIPSN64
- (long long int) tcp->u_arg[1], (long long int) tcp->u_arg[2]);
- printxval(advise, tcp->u_arg[3], "POSIX_FADV_???");
+ if (entering(tcp)) {
+ int argn;
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
+#if defined ARM || defined POWERPC
+ argn = printllval(tcp, "%lld, ", 2);
+#else
+ argn = printllval(tcp, "%lld, ", 1);
+#endif
+ argn = printllval(tcp, "%lld, ", argn);
+#if defined ARM || defined POWERPC
+ printxval(advise, tcp->u_arg[1], "POSIX_FADV_???");
#else
- LONG_LONG(tcp->u_arg[1], tcp->u_arg[2]),
- LONG_LONG(tcp->u_arg[3], tcp->u_arg[4]));
- printxval(advise, tcp->u_arg[5], "POSIX_FADV_???");
+ printxval(advise, tcp->u_arg[argn], "POSIX_FADV_???");
#endif
- }
- return 0;
+ }
+ return 0;
}
#ifdef LINUX
static const struct xlat inotify_modes[] = {
- { 0x00000001, "IN_ACCESS" },
- { 0x00000002, "IN_MODIFY" },
- { 0x00000004, "IN_ATTRIB" },
- { 0x00000008, "IN_CLOSE_WRITE" },
- { 0x00000010, "IN_CLOSE_NOWRITE" },
- { 0x00000020, "IN_OPEN" },
- { 0x00000040, "IN_MOVED_FROM" },
- { 0x00000080, "IN_MOVED_TO" },
- { 0x00000100, "IN_CREATE" },
- { 0x00000200, "IN_DELETE" },
- { 0x00000400, "IN_DELETE_SELF" },
- { 0x00000800, "IN_MOVE_SELF" },
- { 0x00002000, "IN_UNMOUNT" },
- { 0x00004000, "IN_Q_OVERFLOW" },
- { 0x00008000, "IN_IGNORED" },
- { 0x01000000, "IN_ONLYDIR" },
- { 0x02000000, "IN_DONT_FOLLOW" },
- { 0x20000000, "IN_MASK_ADD" },
- { 0x40000000, "IN_ISDIR" },
- { 0x80000000, "IN_ONESHOT" }
+ { 0x00000001, "IN_ACCESS" },
+ { 0x00000002, "IN_MODIFY" },
+ { 0x00000004, "IN_ATTRIB" },
+ { 0x00000008, "IN_CLOSE_WRITE"},
+ { 0x00000010, "IN_CLOSE_NOWRITE"},
+ { 0x00000020, "IN_OPEN" },
+ { 0x00000040, "IN_MOVED_FROM" },
+ { 0x00000080, "IN_MOVED_TO" },
+ { 0x00000100, "IN_CREATE" },
+ { 0x00000200, "IN_DELETE" },
+ { 0x00000400, "IN_DELETE_SELF"},
+ { 0x00000800, "IN_MOVE_SELF" },
+ { 0x00002000, "IN_UNMOUNT" },
+ { 0x00004000, "IN_Q_OVERFLOW" },
+ { 0x00008000, "IN_IGNORED" },
+ { 0x01000000, "IN_ONLYDIR" },
+ { 0x02000000, "IN_DONT_FOLLOW"},
+ { 0x20000000, "IN_MASK_ADD" },
+ { 0x40000000, "IN_ISDIR" },
+ { 0x80000000, "IN_ONESHOT" },
+ { 0, NULL }
+};
+
+static const struct xlat inotify_init_flags[] = {
+ { 0x00000800, "IN_NONBLOCK" },
+ { 0x00080000, "IN_CLOEXEC" },
+ { 0, NULL }
};
int
sys_inotify_add_watch(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
printpath(tcp, tcp->u_arg[1]);
- tprintf(", ");
+ tprints(", ");
printflags(inotify_modes, tcp->u_arg[2], "IN_???");
}
return 0;
sys_inotify_rm_watch(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, %ld", tcp->u_arg[0], tcp->u_arg[1]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprintf(", %ld", tcp->u_arg[1]);
}
return 0;
}
+int
+sys_inotify_init1(struct tcb *tcp)
+{
+ if (entering(tcp))
+ printflags(inotify_init_flags, tcp->u_arg[0], "IN_???");
+ return 0;
+}
+
int
sys_fallocate(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]); /* fd */
+ int argn;
+ printfd(tcp, tcp->u_arg[0]); /* fd */
+ tprints(", ");
tprintf("%#lo, ", tcp->u_arg[1]); /* mode */
- tprintf("%llu, ", LONG_LONG(tcp->u_arg[2],
- tcp->u_arg[3])); /* offset */
- tprintf("%llu", LONG_LONG(tcp->u_arg[4],
- tcp->u_arg[5])); /* len */
+ argn = printllval(tcp, "%llu, ", 2); /* offset */
+ printllval(tcp, "%llu", argn); /* len */
}
return 0;
}