Initial revision
diff --git a/file.c b/file.c
new file mode 100644
index 0000000..7da1241
--- /dev/null
+++ b/file.c
@@ -0,0 +1,1302 @@
+/*
+ * 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>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
+
+#include "defs.h"
+
+#include <dirent.h>
+
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#ifdef SVR4
+# include <sys/cred.h>
+#endif /* SVR4 */
+
+#include <sys/vfs.h>
+
+#ifdef MAJOR_IN_SYSMACROS
+#include <sys/sysmacros.h>
+#endif
+
+#ifdef MAJOR_IN_MKDEV
+#include <sys/mkdev.h>
+#endif
+
+#ifdef HAVE_SYS_ASYNCH_H
+#include <sys/asynch.h>
+#endif
+
+#ifdef SUNOS4
+#include <ustat.h>
+#endif
+
+/*
+ * This is a really dirty trick but it should always work. Traditional
+ * Unix says r/w/rw are 0/1/2, so we make them true flags 1/2/3 by
+ * adding 1. Just remember to add 1 to any arg decoded with openmodes.
+ */
+struct xlat openmodes[] = {
+ { O_RDWR+1, "O_RDWR" },
+ { O_RDONLY+1, "O_RDONLY" },
+ { O_WRONLY+1, "O_WRONLY" },
+ { O_NONBLOCK, "O_NONBLOCK" },
+ { O_APPEND, "O_APPEND" },
+ { O_CREAT, "O_CREAT" },
+ { O_TRUNC, "O_TRUNC" },
+ { O_EXCL, "O_EXCL" },
+ { O_NOCTTY, "O_NOCTTY" },
+#ifdef O_SYNC
+ { O_SYNC, "O_SYNC" },
+#endif
+#ifdef O_ASYNC
+ { O_ASYNC, "O_ASYNC" },
+#endif
+#ifdef O_DSYNC
+ { O_DSYNC, "O_DSYNC" },
+#endif
+#ifdef O_RSYNC
+ { O_RSYNC, "O_RSYNC" },
+#endif
+#ifdef O_NDELAY
+ { O_NDELAY, "O_NDELAY" },
+#endif
+#ifdef O_PRIV
+ { O_PRIV, "O_PRIV" },
+#endif
+#ifdef O_DIRECT
+ { O_DIRECT, "O_DIRECT" },
+#endif
+#ifdef O_LARGEFILE
+ { O_LARGEFILE, "O_LARGEFILE" },
+#endif
+#ifdef O_DIRECTORY
+ { O_DIRECTORY, "O_DIRECTORY" },
+#endif
+
+#ifdef FNDELAY
+ { FNDELAY, "FNDELAY" },
+#endif
+#ifdef FAPPEND
+ { FAPPEND, "FAPPEND" },
+#endif
+#ifdef FMARK
+ { FMARK, "FMARK" },
+#endif
+#ifdef FDEFER
+ { FDEFER, "FDEFER" },
+#endif
+#ifdef FASYNC
+ { FASYNC, "FASYNC" },
+#endif
+#ifdef FSHLOCK
+ { FSHLOCK, "FSHLOCK" },
+#endif
+#ifdef FEXLOCK
+ { FEXLOCK, "FEXLOCK" },
+#endif
+#ifdef FCREAT
+ { FCREAT, "FCREAT" },
+#endif
+#ifdef FTRUNC
+ { FTRUNC, "FTRUNC" },
+#endif
+#ifdef FEXCL
+ { FEXCL, "FEXCL" },
+#endif
+#ifdef FNBIO
+ { FNBIO, "FNBIO" },
+#endif
+#ifdef FSYNC
+ { FSYNC, "FSYNC" },
+#endif
+#ifdef FNOCTTY
+ { FNOCTTY, "FNOCTTY" },
+#endif
+ { 0, NULL },
+};
+
+int
+sys_open(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ /* flags */
+ printflags(openmodes, tcp->u_arg[1] + 1);
+ if (tcp->u_arg[1] & O_CREAT) {
+ /* mode */
+ tprintf(", %#lo", tcp->u_arg[2]);
+ }
+ }
+ return 0;
+}
+
+#ifdef LINUXSPARC
+struct xlat openmodessol[] = {
+ { 0, "O_RDWR" },
+ { 1, "O_RDONLY" },
+ { 2, "O_WRONLY" },
+ { 0x80, "O_NONBLOCK" },
+ { 8, "O_APPEND" },
+ { 0x100, "O_CREAT" },
+ { 0x200, "O_TRUNC" },
+ { 0x400, "O_EXCL" },
+ { 0x800, "O_NOCTTY" },
+ { 0x10, "O_SYNC" },
+ { 0x40, "O_DSYNC" },
+ { 0x8000, "O_RSYNC" },
+ { 4, "O_NDELAY" },
+ { 0x1000, "O_PRIV" },
+ { 0, NULL },
+};
+
+int
+solaris_open(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ /* flags */
+ printflags(openmodessol, tcp->u_arg[1] + 1);
+ if (tcp->u_arg[1] & 0x100) {
+ /* mode */
+ tprintf(", %#lo", tcp->u_arg[2]);
+ }
+ }
+ return 0;
+}
+
+#endif
+
+int
+sys_creat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %#lo", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+static struct xlat access_flags[] = {
+ { F_OK, "F_OK", },
+ { R_OK, "R_OK" },
+ { W_OK, "W_OK" },
+ { X_OK, "X_OK" },
+#ifdef EFF_ONLY_OK
+ { EFF_ONLY_OK, "EFF_ONLY_OK" },
+#endif
+#ifdef EX_OK
+ { EX_OK, "EX_OK" },
+#endif
+ { 0, NULL },
+};
+
+int
+sys_access(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ printflags(access_flags, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_umask(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%#lo", tcp->u_arg[0]);
+ }
+ return RVAL_OCTAL;
+}
+
+static struct xlat whence[] = {
+ { SEEK_SET, "SEEK_SET" },
+ { SEEK_CUR, "SEEK_CUR" },
+ { SEEK_END, "SEEK_END" },
+ { 0, NULL },
+};
+
+int
+sys_lseek(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, ", tcp->u_arg[0]);
+ if (tcp->u_arg[2] == SEEK_SET)
+ tprintf("%lu, ", tcp->u_arg[1]);
+ else
+ tprintf("%ld, ", tcp->u_arg[1]);
+ printxval(whence, tcp->u_arg[2], "SEEK_???");
+ }
+ return RVAL_UDECIMAL;
+}
+
+#ifdef LINUX
+int
+sys_llseek (tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ if (tcp->u_arg[4] == SEEK_SET)
+ tprintf("%ld, %llu, ", tcp->u_arg[0],
+ (((unsigned long long int) tcp->u_arg[1]) << 32
+ | (unsigned long) tcp->u_arg[2]));
+ else
+ tprintf("%ld, %lld, ", tcp->u_arg[0],
+ (((long long int) tcp->u_arg[1]) << 32
+ | (unsigned long) tcp->u_arg[2]));
+ }
+ else {
+ if (syserror(tcp))
+ tprintf("%#lx, ", tcp->u_arg[3]);
+ else {
+ long long int off;
+ umove(tcp, tcp->u_arg[3], &off);
+ tprintf("{%lld}, ", off);
+ }
+ printxval(whence, tcp->u_arg[4], "SEEK_???");
+ }
+ return 0;
+}
+#endif
+
+int
+sys_truncate(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %lu", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_ftruncate(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, %lu", tcp->u_arg[0], tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+/* several stats */
+
+static struct xlat modetypes[] = {
+ { S_IFREG, "S_IFREG" },
+ { S_IFSOCK, "S_IFSOCK" },
+ { S_IFIFO, "S_IFIFO" },
+ { S_IFLNK, "S_IFLNK" },
+ { S_IFDIR, "S_IFDIR" },
+ { S_IFBLK, "S_IFBLK" },
+ { S_IFCHR, "S_IFCHR" },
+ { 0, NULL },
+};
+
+static char *
+sprintmode(mode)
+int mode;
+{
+ static char buf[64];
+ char *s;
+
+ if ((mode & S_IFMT) == 0)
+ s = "";
+ else if ((s = xlookup(modetypes, mode & S_IFMT)) == NULL) {
+ sprintf(buf, "%#o", mode);
+ return buf;
+ }
+ sprintf(buf, "%s%s%s%s", s,
+ (mode & S_ISUID) ? "|S_ISUID" : "",
+ (mode & S_ISGID) ? "|S_ISGID" : "",
+ (mode & S_ISVTX) ? "|S_ISVTX" : "");
+ mode &= ~(S_IFMT|S_ISUID|S_ISGID|S_ISVTX);
+ if (mode)
+ sprintf(buf + strlen(buf), "|%#o", mode);
+ s = (*buf == '|') ? buf + 1 : buf;
+ return *s ? s : "0";
+}
+
+static char *
+sprinttime(t)
+time_t t;
+{
+ struct tm *tmp;
+ static char buf[32];
+
+ if (t == 0) {
+ sprintf(buf, "0");
+ return buf;
+ }
+ tmp = localtime(&t);
+ sprintf(buf, "%02d/%02d/%02d-%02d:%02d:%02d",
+ tmp->tm_year, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
+ return buf;
+}
+
+#ifdef LINUXSPARC
+typedef struct {
+ int tv_sec;
+ int tv_nsec;
+} timestruct_t;
+
+struct solstat {
+ unsigned st_dev;
+ int st_pad1[3]; /* network id */
+ unsigned st_ino;
+ unsigned st_mode;
+ unsigned st_nlink;
+ unsigned st_uid;
+ unsigned st_gid;
+ unsigned st_rdev;
+ int st_pad2[2];
+ int st_size;
+ int st_pad3; /* st_size, off_t expansion */
+ timestruct_t st_atime;
+ timestruct_t st_mtime;
+ timestruct_t st_ctime;
+ int st_blksize;
+ int st_blocks;
+ char st_fstype[16];
+ int st_pad4[8]; /* expansion area */
+};
+
+static void
+printstatsol(tcp, addr)
+struct tcb *tcp;
+int addr;
+{
+ struct solstat statbuf;
+
+ if (!addr) {
+ tprintf("NULL");
+ return;
+ }
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#x", addr);
+ return;
+ }
+ if (umove(tcp, addr, &statbuf) < 0) {
+ tprintf("{...}");
+ return;
+ }
+ if (!abbrev(tcp)) {
+ tprintf("{st_dev=makedev(%lu, %lu), st_ino=%lu, st_mode=%s, ",
+ (unsigned long) ((statbuf.st_dev >> 18) & 0x3fff),
+ (unsigned long) (statbuf.st_dev & 0x3ffff),
+ (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);
+ tprintf("st_blksize=%lu, ", (unsigned long) statbuf.st_blksize);
+ tprintf("st_blocks=%lu, ", (unsigned long) 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) ((statbuf.st_rdev >> 18) & 0x3fff),
+ (unsigned long) (statbuf.st_rdev & 0x3ffff));
+ 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));
+ }
+ else
+ tprintf("...}");
+}
+#endif
+
+#ifdef LINUXSPARC
+/* Ugly, bug GLIBC makes this necessary. */
+struct kernel_stat
+{
+ unsigned short int st_dev;
+ unsigned long int st_ino;
+ unsigned short int st_mode;
+ short int st_nlink;
+ unsigned short int st_uid;
+ unsigned short int st_gid;
+ unsigned short int st_rdev;
+ long int st_size;
+ long int st_atime;
+ unsigned long int __unused1;
+ long int st_mtime;
+ unsigned long int __unused2;
+ long int st_ctime;
+ unsigned long int __unused3;
+ long int st_blksize;
+ long int st_blocks;
+ unsigned long int __unused4;
+ unsigned long int __unused5;
+};
+#endif
+static void
+printstat(tcp, addr)
+struct tcb *tcp;
+int addr;
+{
+ struct stat statbuf;
+
+#ifdef LINUXSPARC
+ if (current_personality == 1) {
+ printstatsol(tcp, addr);
+ return;
+ }
+#endif /* LINUXSPARC */
+
+ if (!addr) {
+ tprintf("NULL");
+ return;
+ }
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#x", addr);
+ return;
+ }
+ if (umove(tcp, addr, &statbuf) < 0) {
+ tprintf("{...}");
+ return;
+ }
+ 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_ST_BLKSIZE
+ tprintf("st_blksize=%lu, ", (unsigned long) statbuf.st_blksize);
+#endif /* HAVE_ST_BLKSIZE */
+#ifdef HAVE_ST_BLOCKS
+ tprintf("st_blocks=%lu, ", (unsigned long) statbuf.st_blocks);
+#endif /* HAVE_ST_BLOCKS */
+ }
+ else
+ tprintf("{st_mode=%s, ", sprintmode(statbuf.st_mode));
+ switch (statbuf.st_mode & S_IFMT) {
+ case S_IFCHR: case S_IFBLK:
+#ifdef HAVE_ST_RDEV
+ tprintf("st_rdev=makedev(%lu, %lu), ",
+ (unsigned long) major(statbuf.st_rdev),
+ (unsigned long) minor(statbuf.st_rdev));
+#else /* !HAVE_ST_RDEV */
+ tprintf("st_size=makedev(%lu, %lu), ",
+ (unsigned long) major(statbuf.st_size),
+ (unsigned long) minor(statbuf.st_size));
+#endif /* !HAVE_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));
+ }
+ else
+ tprintf("...}");
+}
+
+int
+sys_stat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ } else {
+ printstat(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_fstat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp))
+ tprintf("%ld, ", tcp->u_arg[0]);
+ else {
+ printstat(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_lstat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ } else {
+ printstat(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+#if defined(SVR4) || defined(LINUXSPARC)
+
+int
+sys_xstat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, ", tcp->u_arg[0]);
+ printpath(tcp, tcp->u_arg[1]);
+ tprintf(", ");
+ } else {
+ printstat(tcp, tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+sys_fxstat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp))
+ tprintf("%ld, %ld, ", tcp->u_arg[0], tcp->u_arg[1]);
+ else {
+ printstat(tcp, tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+sys_lxstat(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, ", tcp->u_arg[0]);
+ printpath(tcp, tcp->u_arg[1]);
+ tprintf(", ");
+ } else {
+ printstat(tcp, tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+sys_xmknod(tcp)
+struct tcb *tcp;
+{
+ int mode = tcp->u_arg[2];
+
+ if (entering(tcp)) {
+ tprintf("%ld, ", tcp->u_arg[0]);
+ printpath(tcp, tcp->u_arg[1]);
+ tprintf(", %s", sprintmode(mode));
+ switch (mode & S_IFMT) {
+ case S_IFCHR: case S_IFBLK:
+#ifdef LINUXSPARC
+ tprintf(", makedev(%lu, %lu)",
+ (unsigned long) ((tcp->u_arg[3] >> 18) & 0x3fff),
+ (unsigned long) (tcp->u_arg[3] & 0x3ffff));
+#else
+ tprintf(", makedev(%lu, %lu)",
+ (unsigned long) major(tcp->u_arg[3]),
+ (unsigned long) minor(tcp->u_arg[3]));
+#endif
+ break;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
+#endif /* SVR4 || LINUXSPARC */
+
+#ifdef LINUX
+
+static struct xlat fsmagic[] = {
+ { 0xef51, "EXT2_OLD_SUPER_MAGIC" },
+ { 0xef53, "EXT2_SUPER_MAGIC" },
+ { 0x137d, "EXT_SUPER_MAGIC" },
+ { 0x9660, "ISOFS_SUPER_MAGIC" },
+ { 0x137f, "MINIX_SUPER_MAGIC" },
+ { 0x138f, "MINIX_SUPER_MAGIC2" },
+ { 0x2468, "NEW_MINIX_SUPER_MAGIC" },
+ { 0x4d44, "MSDOS_SUPER_MAGIC" },
+ { 0x6969, "NFS_SUPER_MAGIC" },
+ { 0x9fa0, "PROC_SUPER_MAGIC" },
+ { 0x012fd16d, "XIAFS_SUPER_MAGIC" },
+ { 0, NULL },
+};
+
+#endif /* LINUX */
+
+#ifndef SVR4
+
+static char *
+sprintfstype(magic)
+int magic;
+{
+ static char buf[32];
+#ifdef LINUX
+ char *s;
+
+ s = xlookup(fsmagic, magic);
+ if (s) {
+ sprintf(buf, "\"%s\"", s);
+ return buf;
+ }
+#endif /* LINUX */
+ sprintf(buf, "%#x", magic);
+ return buf;
+}
+
+static void
+printstatfs(tcp, addr)
+struct tcb *tcp;
+long addr;
+{
+ struct statfs statbuf;
+
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#lx", addr);
+ return;
+ }
+ if (umove(tcp, addr, &statbuf) < 0) {
+ tprintf("{...}");
+ return;
+ }
+#ifdef ALPHA
+
+ tprintf("{f_type=%s, f_fbsize=%u, f_blocks=%u, f_bfree=%u, ",
+ sprintfstype(statbuf.f_type),
+ statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
+ tprintf("f_bavail=%u, f_files=%u, f_ffree=%u, f_namelen=%u}",
+ statbuf.f_bavail,statbuf.f_files, statbuf.f_ffree, statbuf.f_namelen);
+#else /* !ALPHA */
+ tprintf("{f_type=%s, f_bsize=%lu, f_blocks=%lu, f_bfree=%lu, ",
+ sprintfstype(statbuf.f_type),
+ statbuf.f_bsize, statbuf.f_blocks, statbuf.f_bfree);
+ tprintf("f_files=%lu, f_ffree=%lu",
+ statbuf.f_files, statbuf.f_ffree);
+#ifdef LINUX
+ tprintf(", f_namelen=%lu}", statbuf.f_namelen);
+#endif /* LINUX */
+#endif /* !ALPHA */
+ tprintf("}");
+}
+
+int
+sys_statfs(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ } else {
+ printstatfs(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_fstatfs(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ } else {
+ printstatfs(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+#ifdef LINUX
+#ifdef ALPHA
+
+int
+osf_statfs(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ } else {
+ printstatfs(tcp, tcp->u_arg[1]);
+ tprintf(", %lu", tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+osf_fstatfs(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ } else {
+ printstatfs(tcp, tcp->u_arg[1]);
+ tprintf(", %lu", tcp->u_arg[2]);
+ }
+ return 0;
+}
+#endif /* ALPHA */
+#endif /* LINUX */
+
+#endif /* !SVR4 */
+
+#ifdef SUNOS4
+
+int
+sys_ustat(tcp)
+struct tcb *tcp;
+{
+ struct ustat statbuf;
+
+ if (entering(tcp)) {
+ tprintf("makedev(%lu, %lu), ",
+ (long) major(tcp->u_arg[0]),
+ (long) minor(tcp->u_arg[0]));
+ }
+ else {
+ if (syserror(tcp) || !verbose(tcp))
+ tprintf("%#lx", tcp->u_arg[1]);
+ else if (umove(tcp, tcp->u_arg[1], &statbuf) < 0)
+ tprintf("{...}");
+ else {
+ tprintf("{f_tfree=%lu, f_tinode=%lu, ",
+ statbuf.f_tfree, statbuf.f_tinode);
+ tprintf("f_fname=\"%.*s\", ",
+ (int) sizeof(statbuf.f_fname),
+ statbuf.f_fname);
+ tprintf("f_fpack=\"%.*s\"}",
+ (int) sizeof(statbuf.f_fpack),
+ statbuf.f_fpack);
+ }
+ }
+ return 0;
+}
+
+#endif /* SUNOS4 */
+
+/* directory */
+int
+sys_chdir(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ }
+ return 0;
+}
+
+int
+sys_mkdir(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %#lo", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+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;
+}
+
+int
+sys_fchroot(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld", tcp->u_arg[0]);
+ }
+ return 0;
+}
+
+int
+sys_link(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ printpath(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_unlink(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ }
+ return 0;
+}
+
+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;
+}
+
+int
+sys_readlink(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ } else {
+ if (syserror(tcp))
+ tprintf("%#lx", tcp->u_arg[1]);
+ else
+ printpathn(tcp, tcp->u_arg[1], tcp->u_rval);
+ tprintf(", %lu", tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+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;
+}
+
+int
+sys_chown(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %lu, %lu", tcp->u_arg[1], tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+sys_fchown(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, %lu, %lu",
+ tcp->u_arg[0], tcp->u_arg[1], tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+int
+sys_chmod(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %#lo", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_fchmod(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld, %#lo", tcp->u_arg[0], tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_utimes(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ printtv(tcp, tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_utime(tcp)
+struct tcb *tcp;
+{
+ long ut[2];
+
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", ");
+ if (!tcp->u_arg[1])
+ tprintf("NULL");
+ else if (!verbose(tcp))
+ tprintf("%#lx", tcp->u_arg[1]);
+ else if (umoven(tcp, tcp->u_arg[1], sizeof ut,
+ (char *) ut) < 0)
+ tprintf("[?, ?]");
+ else {
+ tprintf("[%s,", sprinttime(ut[0]));
+ tprintf(" %s]", sprinttime(ut[1]));
+ }
+ }
+ return 0;
+}
+
+int
+sys_mknod(tcp)
+struct tcb *tcp;
+{
+ int mode = tcp->u_arg[1];
+
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %s", sprintmode(mode));
+ switch (mode & S_IFMT) {
+ case S_IFCHR: case S_IFBLK:
+#ifdef LINUXSPARC
+ if (current_personality == 1)
+ tprintf(", makedev(%lu, %lu)",
+ (unsigned long) ((tcp->u_arg[2] >> 18) & 0x3fff),
+ (unsigned long) (tcp->u_arg[2] & 0x3ffff));
+ else
+#endif
+ tprintf(", makedev(%lu, %lu)",
+ (unsigned long) major(tcp->u_arg[2]),
+ (unsigned long) minor(tcp->u_arg[2]));
+ break;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
+int
+sys_mkfifo(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ printpath(tcp, tcp->u_arg[0]);
+ tprintf(", %#lo", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+int
+sys_fsync(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%ld", tcp->u_arg[0]);
+ }
+ return 0;
+}
+
+#ifdef LINUX
+
+static void
+printdir(tcp, addr)
+struct tcb *tcp;
+long addr;
+{
+ struct dirent d;
+
+ if (!verbose(tcp)) {
+ tprintf("%#lx", addr);
+ return;
+ }
+ if (umove(tcp, addr, &d) < 0) {
+ tprintf("{...}");
+ return;
+ }
+ tprintf("{d_ino=%ld, ", (unsigned long) d.d_ino);
+#ifndef LINUX
+ /* This contains garbage under Linux. */
+ tprintf("d_off=%d, ", d.d_off);
+#endif /* !LINUX */
+#ifndef LINUX
+ /* No point in printing this out since the syscall returns it. */
+ tprintf("d_reclen=%u, ", d.d_reclen);
+#endif /* !LINUX */
+ tprintf("d_name=");
+ printpathn(tcp, (long) ((struct dirent *) addr)->d_name, d.d_reclen);
+ tprintf("}");
+}
+
+int
+sys_readdir(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ } else {
+ if (syserror(tcp) || tcp->u_rval == 0 || !verbose(tcp))
+ tprintf("%#lx", tcp->u_arg[1]);
+ else
+ printdir(tcp, tcp->u_arg[1]);
+ /* Not much point in printing this out, it is always 1. */
+ if (tcp->u_arg[2] != 1)
+ tprintf(", %lu", tcp->u_arg[2]);
+ }
+ return 0;
+}
+
+#endif /* LINUX */
+
+int
+sys_getdents(tcp)
+struct tcb *tcp;
+{
+ int i, len, dents = 0;
+ char *buf;
+
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ return 0;
+ }
+ if (syserror(tcp) || !verbose(tcp)) {
+ tprintf("%#lx, %lu", tcp->u_arg[1], tcp->u_arg[2]);
+ return 0;
+ }
+#ifdef linux
+#ifdef __sparc__
+ tprintf (" = Unknown value\n");
+ return 0;
+#endif
+#endif
+ len = tcp->u_rval;
+ if ((buf = malloc(len)) == NULL) {
+ tprintf("out of memory\n");
+ return 0;
+ }
+ if (umoven(tcp, tcp->u_arg[1], len, buf) < 0) {
+ tprintf("{...}, %lu", tcp->u_arg[2]);
+ free(buf);
+ return 0;
+ }
+ if (!abbrev(tcp))
+ tprintf("{");
+ for (i = 0; i < len;) {
+ struct dirent *d = (struct dirent *) &buf[i];
+#ifdef LINUX
+ if (!abbrev(tcp)) {
+ tprintf("%s{d_ino=%lu, d_off=%lu, ",
+ i ? " " : "", d->d_ino, d->d_off);
+ tprintf("d_reclen=%u, d_name=\"%s\"}",
+ d->d_reclen, d->d_name);
+ }
+#endif /* LINUX */
+#ifdef SVR4
+ if (!abbrev(tcp)) {
+ tprintf("%s{d_ino=%lu, d_off=%lu, ",
+ i ? " " : "", d->d_ino, d->d_off);
+ tprintf("d_reclen=%u, d_name=\"%s\"}",
+ d->d_reclen, d->d_name);
+ }
+#endif /* SVR4 */
+#ifdef SUNOS4
+ if (!abbrev(tcp)) {
+ tprintf("%s{d_off=%lu, d_fileno=%lu, d_reclen=%u, ",
+ i ? " " : "", d->d_off, d->d_fileno,
+ d->d_reclen);
+ tprintf("d_namlen=%u, d_name=\"%.*s\"}",
+ d->d_namlen, d->d_namlen, d->d_name);
+ }
+#endif /* SUNOS4 */
+ i += d->d_reclen;
+ dents++;
+ }
+ if (!abbrev(tcp))
+ tprintf("}");
+ else
+ tprintf("/* %u entries */", dents);
+ tprintf(", %lu", tcp->u_arg[2]);
+ free(buf);
+ return 0;
+}
+
+#ifdef LINUX
+
+int
+sys_getcwd(tcp)
+struct tcb *tcp;
+{
+ if (exiting(tcp)) {
+ if (syserror(tcp))
+ tprintf("%#lx", tcp->u_arg[0]);
+ else
+ printstr(tcp, tcp->u_arg[0], tcp->u_arg[1]);
+ tprintf(", %lu", tcp->u_arg[1]);
+ }
+ return 0;
+}
+#endif /* LINUX */
+
+#ifdef HAVE_SYS_ASYNCH_H
+
+int
+sys_aioread(tcp)
+struct tcb *tcp;
+{
+ struct aio_result_t res;
+
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ } else {
+ if (syserror(tcp))
+ tprintf("%#lx", tcp->u_arg[1]);
+ else
+ printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
+ tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
+ printxval(whence, tcp->u_arg[4], "L_???");
+ if (syserror(tcp) || tcp->u_arg[5] == 0
+ || umove(tcp, tcp->u_arg[5], &res) < 0)
+ tprintf(", %#lx", tcp->u_arg[5]);
+ else
+ tprintf(", {aio_return %d aio_errno %d}",
+ res.aio_return, res.aio_errno);
+ }
+ return 0;
+}
+
+int
+sys_aiowrite(tcp)
+struct tcb *tcp;
+{
+ struct aio_result_t res;
+
+ if (entering(tcp)) {
+ tprintf("%lu, ", tcp->u_arg[0]);
+ printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]);
+ tprintf(", %lu, %lu, ", tcp->u_arg[2], tcp->u_arg[3]);
+ printxval(whence, tcp->u_arg[4], "L_???");
+ }
+ else {
+ if (tcp->u_arg[5] == 0)
+ tprintf(", NULL");
+ else if (syserror(tcp)
+ || umove(tcp, tcp->u_arg[5], &res) < 0)
+ tprintf(", %#lx", tcp->u_arg[5]);
+ else
+ tprintf(", {aio_return %d aio_errno %d}",
+ res.aio_return, res.aio_errno);
+ }
+ return 0;
+}
+
+int
+sys_aiowait(tcp)
+struct tcb *tcp;
+{
+ if (entering(tcp))
+ printtv(tcp, tcp->u_arg[0]);
+ return 0;
+}
+
+int
+sys_aiocancel(tcp)
+struct tcb *tcp;
+{
+ struct aio_result_t res;
+
+ if (exiting(tcp)) {
+ if (tcp->u_arg[0] == 0)
+ tprintf("NULL");
+ else if (syserror(tcp)
+ || umove(tcp, tcp->u_arg[0], &res) < 0)
+ tprintf("%#lx", tcp->u_arg[0]);
+ else
+ tprintf("{aio_return %d aio_errno %d}",
+ res.aio_return, res.aio_errno);
+ }
+ return 0;
+}
+
+#endif /* HAVE_SYS_ASYNCH_H */