# 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
* extension to get the right value. We do this by declaring fd as int here.
*/
static void
-print_dirfd(int fd)
+print_dirfd(struct tcb *tcp, int fd)
{
if (fd == AT_FDCWD)
- tprintf("AT_FDCWD, ");
- else
- tprintf("%d, ", fd);
+ tprints("AT_FDCWD, ");
+ else {
+ printfd(tcp, fd);
+ tprints(", ");
+ }
}
#endif
-/*
- * Pity stpcpy() is not standardized...
- */
-static char *
-str_append(char *dst, const char *src)
-{
- while ((*dst = *src++) != '\0')
- dst++;
- return dst;
-}
-
/*
* low bits of the open(2) flags define access mode,
* other bits are real flags.
const char *
sprint_open_modes(mode_t flags)
{
- static char outstr[1024];
+ static char outstr[(1 + ARRAY_SIZE(open_mode_flags)) * sizeof("O_LARGEFILE")];
char *p;
- char sep = 0;
+ char sep;
const char *str;
const struct xlat *x;
- p = str_append(outstr, "flags ");
+ sep = ' ';
+ p = stpcpy(outstr, "flags");
str = xlookup(open_access_modes, flags & 3);
if (str) {
- p = str_append(p, str);
+ *p++ = sep;
+ p = stpcpy(p, str);
flags &= ~3;
if (!flags)
return outstr;
for (x = open_mode_flags; x->str; x++) {
if ((flags & x->val) == x->val) {
- if (sep)
- *p++ = sep;
- p = str_append(p, x->str);
+ *p++ = sep;
+ p = stpcpy(p, x->str);
flags &= ~x->val;
if (!flags)
return outstr;
}
}
/* flags is still nonzero */
- if (sep)
- *p++ = sep;
+ *p++ = sep;
sprintf(p, "%#x", flags);
return outstr;
}
void
tprint_open_modes(mode_t flags)
{
- tprintf("%s", sprint_open_modes(flags) + sizeof("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->u_arg[offset + 1]);
if (tcp->u_arg[offset + 1] & O_CREAT) {
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
{
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) {
{
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 _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)
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)
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("%ld, %llu, ", tcp->u_arg[0],
- (((long long int) tcp->u_arg[1]) << 32
- | (unsigned long long) (unsigned) tcp->u_arg[2]));
+ tprintf(", %llu, ",
+ ((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]));
+ tprintf(", %lld, ",
+ ((long long int) tcp->u_arg[1]) << 32 |
+ (unsigned long long) (unsigned) tcp->u_arg[2]);
}
else {
long long int off;
{
if (entering(tcp)) {
int argn;
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
argn = printllval(tcp, "%lld", 1);
tprintf(", %ld", tcp->u_arg[argn]);
}
{
if (entering(tcp)) {
int argn;
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
if (tcp->u_arg[3] == SEEK_SET)
argn = printllval(tcp, "%llu, ", 1);
else
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;
}
sys_ftruncate64(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
printllval(tcp, "%llu", 1);
}
return 0;
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 (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)
struct stat_sparc64 statbuf;
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 */
struct stat_powerpc32 statbuf;
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 /* LINUX && POWERPC64 */
{ 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 },
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printflags(fileflags, tcp->u_arg[1], "UF_???");
}
return 0;
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("...}");
}
struct stat statbuf;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#endif
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
#endif
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#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(const struct __old_kernel_stat *oldbuf, struct stat *newbuf)
{
struct stat newstatbuf;
if (!addr) {
- tprintf("NULL");
+ tprints("NULL");
return;
}
if (syserror(tcp) || !verbose(tcp)) {
#endif /* LINUXSPARC */
if (umove(tcp, addr, &statbuf) < 0) {
- tprintf("{...}");
+ tprints("{...}");
return;
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#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 {
#ifdef POWERPC64
if (current_personality == 0)
#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(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
int
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;
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(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;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstat(tcp, tcp->u_arg[1]);
}
#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(struct tcb *tcp)
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printoldstat(tcp, tcp->u_arg[1]);
}
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)
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)
{
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;
}
if (tcp->u_arg[3])
tprintf(", %#lx", tcp->u_arg[3]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
if (tcp->u_arg[4])
tprintf(", %#lx", tcp->u_arg[4]);
else
- tprintf(", NULL");
+ tprints(", NULL");
}
return 0;
}
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
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
}
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;
}
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
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;
}
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 (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
} else {
printstatfs(tcp, tcp->u_arg[1]);
tprintf(", %lu", tcp->u_arg[2]);
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);
}
#endif /* SUNOS4 */
-int
-sys_pivotroot(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(struct tcb *tcp)
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(struct tcb *tcp)
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- }
- return 0;
-}
-
-int
-sys_fchdir(struct tcb *tcp)
-{
- if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
- }
- return 0;
-}
-
-int
-sys_chroot(struct tcb *tcp)
-{
- if (entering(tcp)) {
- printpath(tcp, tcp->u_arg[0]);
- }
- return 0;
-}
-
-#if defined(SUNOS4) || defined(SVR4)
-int
-sys_fchroot(struct tcb *tcp)
-{
- if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
- }
- return 0;
-}
-#endif /* SUNOS4 || SVR4 */
-
int
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(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(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(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;
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;
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
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;
}
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printtv_bitness(tcp, tcp->u_arg[1], BITNESS_32, 0);
}
return 0;
{
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;
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
sys_fsync(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
}
return 0;
}
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(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;
+ /* 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) {
- tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
- fprintf(stderr, "out of memory\n");
- return 0;
- }
+ 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;
+ /* 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) {
- tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
- fprintf(stderr, "out of memory\n");
- return 0;
- }
+ 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);
}
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]);
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]);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ 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]);
- tprintf(", ");
+ tprints(", ");
printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
}
return 0;
sys_fsetxattr(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ 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]);
- tprintf(", ");
+ tprints(", ");
printflags(xattrflags, tcp->u_arg[4], "XATTR_???");
}
return 0;
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
} else {
print_xattr_val(tcp, syserror(tcp), tcp->u_arg[2], tcp->u_arg[3],
sys_fgetxattr(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ 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],
sys_flistxattr(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
} else {
/* XXX Print value in format */
tprintf(", %p, %lu", (void *) tcp->u_arg[1], tcp->u_arg[2]);
{
if (entering(tcp)) {
printpath(tcp, tcp->u_arg[0]);
- tprintf(", ");
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
}
return 0;
sys_fremovexattr(struct tcb *tcp)
{
if (entering(tcp)) {
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
printstr(tcp, tcp->u_arg[1], -1);
}
return 0;
{
if (entering(tcp)) {
int argn;
- tprintf("%ld, ", tcp->u_arg[0]);
+ 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_???");
{
if (entering(tcp)) {
int argn;
- tprintf("%ld, ", tcp->u_arg[0]);
+ printfd(tcp, tcp->u_arg[0]);
+ tprints(", ");
#if defined ARM || defined POWERPC
argn = printllval(tcp, "%lld, ", 2);
#else
#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;
}
sys_inotify_init1(struct tcb *tcp)
{
if (entering(tcp))
- printflags(open_mode_flags, tcp->u_arg[0], "O_???");
+ printflags(inotify_init_flags, tcp->u_arg[0], "IN_???");
return 0;
}
{
if (entering(tcp)) {
int argn;
- tprintf("%ld, ", tcp->u_arg[0]); /* fd */
+ printfd(tcp, tcp->u_arg[0]); /* fd */
+ tprints(", ");
tprintf("%#lo, ", tcp->u_arg[1]); /* mode */
argn = printllval(tcp, "%llu, ", 2); /* offset */
printllval(tcp, "%llu", argn); /* len */