Initial revision

1 files changed, 886 insertions, 0 deletions

diff --git a/system.c b/system.c
new file mode 100644
index 0000000..16c1648
--- /dev/null
+++ b/system.c
@@ -0,0 +1,886 @@
+/*
+ * 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"
+
+#ifdef LINUX
+#define _LINUX_SOCKET_H
+
+#define MS_RDONLY   1  /* Mount read-only */
+#define MS_NOSUID   2  /* Ignore suid and sgid bits */
+#define MS_NODEV    4  /* Disallow access to device special files */
+#define MS_NOEXEC   8  /* Disallow program execution */
+#define MS_SYNCHRONOUS 16  /* Writes are synced at once */
+#define MS_REMOUNT 32  /* Alter flags of a mounted FS */
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#ifdef LINUX
+/* Workaround for kernel namespace pollution. */
+#define sys_personality kernel_sys_personality
+#include <linux/personality.h>
+#undef sys_personality
+#endif /* __NR_personality */
+
+#ifdef __NR_capget
+#include <linux/capability.h>
+#endif
+
+static struct xlat mount_flags[] = {
+	{ MS_RDONLY,	"MS_RDONLY"	},
+	{ MS_NOSUID,	"MS_NOSUID"	},
+	{ MS_NODEV,	"MS_NODEV"	},
+	{ MS_NOEXEC,	"MS_NOEXEC"	},
+#ifdef MS_SYNCHRONOUS
+	{ MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
+#else
+	{ MS_SYNC,	"MS_SYNC"	},
+#endif
+	{ MS_REMOUNT,	"MS_REMOUNT"	},
+	{ 0,		NULL		},
+};
+
+int
+sys_mount(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printpath(tcp, tcp->u_arg[0]);
+		tprintf(", ");
+		printpath(tcp, tcp->u_arg[1]);
+		tprintf(", ");
+		printpath(tcp, tcp->u_arg[2]);
+		tprintf(", ");
+		printflags(mount_flags, tcp->u_arg[3]);
+		tprintf(", %#lx", tcp->u_arg[4]);
+	}
+	return 0;
+}
+
+static struct xlat personality_options[] = {
+#ifdef PER_LINUX
+	{ PER_LINUX,	"PER_LINUX"	},
+#endif
+#ifdef PER_LINUX_32BIT
+	{ PER_LINUX_32BIT,	"PER_LINUX"	},
+#endif
+#ifdef PER_SVR4
+	{ PER_SVR4,	"PER_SVR4"	},
+#endif
+#ifdef PER_SVR3
+	{ PER_SVR3,	"PER_SVR3"	},
+#endif
+#ifdef PER_SCOSVR3
+	{ PER_SCOSVR3,	"PER_SCOSVR3"	},
+#endif
+#ifdef PER_WYSEV386
+	{ PER_WYSEV386,	"PER_WYSEV386"	},
+#endif
+#ifdef PER_ISCR4
+	{ PER_ISCR4,	"PER_ISCR4"	},
+#endif
+#ifdef PER_BSD
+	{ PER_BSD,	"PER_BSD"	},
+#endif
+#ifdef PER_XENIX
+	{ PER_XENIX,	"PER_XENIX"	},
+#endif
+	{ 0,		NULL		},
+};
+
+int
+sys_personality(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp))
+		printxval(personality_options, tcp->u_arg[0], "PER_???");
+	return 0;
+}
+
+#endif /* LINUX */
+
+#ifdef SUNOS4
+
+#include <sys/reboot.h>
+#define NFSCLIENT
+#define LOFS
+#define RFS
+#define PCFS
+#include <sys/mount.h>
+#include <sys/socket.h>
+#include <nfs/export.h>
+#include <rpc/types.h>
+#include <rpc/auth.h>
+
+/*ARGSUSED*/
+int
+sys_sync(tcp)
+struct tcb *tcp;
+{
+	return 0;
+}
+
+static struct xlat bootflags[] = {
+	{ RB_AUTOBOOT,	"RB_AUTOBOOT"	},	/* for system auto-booting itself */
+	{ RB_ASKNAME,	"RB_ASKNAME"	},	/* ask for file name to reboot from */
+	{ RB_SINGLE,	"RB_SINGLE"	},	/* reboot to single user only */
+	{ RB_NOSYNC,	"RB_NOSYNC"	},	/* dont sync before reboot */
+	{ RB_HALT,	"RB_HALT"	},	/* don't reboot, just halt */
+	{ RB_INITNAME,	"RB_INITNAME"	},	/* name given for /etc/init */
+	{ RB_NOBOOTRC,	"RB_NOBOOTRC"	},	/* don't run /etc/rc.boot */
+	{ RB_DEBUG,	"RB_DEBUG"	},	/* being run under debugger */
+	{ RB_DUMP,	"RB_DUMP"	},	/* dump system core */
+	{ RB_WRITABLE,	"RB_WRITABLE"	},	/* mount root read/write */
+	{ RB_STRING,	"RB_STRING"	},	/* pass boot args to prom monitor */
+	{ 0,		NULL		},
+};
+
+int
+sys_reboot(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		if (!printflags(bootflags, tcp->u_arg[0]))
+			tprintf("RB_???");
+		if (tcp->u_arg[0] & RB_STRING) {
+			printstr(tcp, tcp->u_arg[1], -1);
+		}
+	}
+	return 0;
+}
+
+int
+sys_sysacct(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printstr(tcp, tcp->u_arg[0], -1);
+	}
+	return 0;
+}
+
+int
+sys_swapon(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printstr(tcp, tcp->u_arg[0], -1);
+	}
+	return 0;
+}
+
+int
+sys_nfs_svc(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printsock(tcp, tcp->u_arg[0]);
+	}
+	return 0;
+}
+
+static struct xlat mountflags[] = {
+	{ M_RDONLY,	"M_RDONLY"	},
+	{ M_NOSUID,	"M_NOSUID"	},
+	{ M_NEWTYPE,	"M_NEWTYPE"	},
+	{ M_GRPID,	"M_GRPID"	},
+#ifdef	M_REMOUNT
+	{ M_REMOUNT,	"M_REMOUNT"	},
+#endif
+#ifdef	M_NOSUB
+	{ M_NOSUB,	"M_NOSUB"	},
+#endif
+#ifdef	M_MULTI
+	{ M_MULTI,	"M_MULTI"	},
+#endif
+#ifdef	M_SYS5
+	{ M_SYS5,	"M_SYS5"	},
+#endif
+	{ 0,		NULL		},
+};
+
+static struct xlat nfsflags[] = {
+	{ NFSMNT_SOFT,		"NFSMNT_SOFT"		},
+	{ NFSMNT_WSIZE,		"NFSMNT_WSIZE"		},
+	{ NFSMNT_RSIZE,		"NFSMNT_RSIZE"		},
+	{ NFSMNT_TIMEO,		"NFSMNT_TIMEO"		},
+	{ NFSMNT_RETRANS,	"NFSMNT_RETRANS"	},
+	{ NFSMNT_HOSTNAME,	"NFSMNT_HOSTNAME"	},
+	{ NFSMNT_INT,		"NFSMNT_INT"		},
+	{ NFSMNT_NOAC,		"NFSMNT_NOAC"		},
+	{ NFSMNT_ACREGMIN,	"NFSMNT_ACREGMIN"	},
+	{ NFSMNT_ACREGMAX,	"NFSMNT_ACREGMAX"	},
+	{ NFSMNT_ACDIRMIN,	"NFSMNT_ACDIRMIN"	},
+	{ NFSMNT_ACDIRMAX,	"NFSMNT_ACDIRMAX"	},
+#ifdef	NFSMNT_SECURE
+	{ NFSMNT_SECURE,	"NFSMNT_SECURE"		},
+#endif
+#ifdef	NFSMNT_NOCTO
+	{ NFSMNT_NOCTO,		"NFSMNT_NOCTO"		},
+#endif
+#ifdef	NFSMNT_POSIX
+	{ NFSMNT_POSIX,		"NFSMNT_POSIX"		},
+#endif
+	{ 0,			NULL			},
+};
+
+int
+sys_mount(tcp)
+struct tcb *tcp;
+{
+	char type[4];
+
+	if (entering(tcp)) {
+		if (!(tcp->u_arg[2] & M_NEWTYPE) || umovestr(tcp,
+				tcp->u_arg[0],  sizeof type, type) < 0) {
+			tprintf("OLDTYPE:#%lx", tcp->u_arg[0]);
+		} else {
+			tprintf("\"%s\", ", type);
+		}
+		printstr(tcp, tcp->u_arg[1], -1);
+		tprintf(", ");
+		if (!printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE))
+			tprintf("0");
+		tprintf(", ");
+
+		if (strcmp(type, "4.2") == 0) {
+			struct ufs_args a;
+			if (umove(tcp, tcp->u_arg[3], &a) < 0)
+				return 0;
+			printstr(tcp, (int)a.fspec, -1);
+		} else if (strcmp(type, "lo") == 0) {
+			struct lo_args a;
+			if (umove(tcp, tcp->u_arg[3], &a) < 0)
+				return 0;
+			printstr(tcp, (int)a.fsdir, -1);
+		} else if (strcmp(type, "nfs") == 0) {
+			struct nfs_args a;
+			if (umove(tcp, tcp->u_arg[3], &a) < 0)
+				return 0;
+			tprintf("[");
+			printsock(tcp, (int) a.addr);
+			tprintf(", ");
+			if (!printflags(nfsflags, a.flags))
+				tprintf("NFSMNT_???");
+			tprintf(", ws:%u,rs:%u,to:%u,re:%u,",
+				a.wsize, a.rsize, a.timeo, a.retrans);
+			if (a.flags & NFSMNT_HOSTNAME && a.hostname)
+				printstr(tcp, (int)a.hostname, -1);
+			else
+				tprintf("%#lx", (unsigned long) a.hostname);
+			tprintf(",reg-min:%u,max:%u,dir-min:%u,max:%u,",
+				a.acregmin, a.acregmax, a.acdirmin, a.acdirmax);
+			if ((a.flags & NFSMNT_SECURE) && a.netname)
+				printstr(tcp, (int) a.netname, -1);
+			else
+				tprintf("%#lx", (unsigned long) a.netname);
+			tprintf("]");
+		} else if (strcmp(type, "rfs") == 0) {
+			struct rfs_args a;
+			struct token t;
+			if (umove(tcp, tcp->u_arg[3], &a) < 0)
+				return 0;
+			tprintf("[");
+			printstr(tcp, (int)a.rmtfs, -1);
+			if (umove(tcp, (int)a.token, &t) < 0)
+				return 0;
+			tprintf(", %u, %s]", t.t_id, t.t_uname);
+		} else if (strcmp(type, "pcfs") == 0) {
+			struct pc_args a;
+			if (umove(tcp, tcp->u_arg[3], &a) < 0)
+				return 0;
+			printstr(tcp, (int)a.fspec, -1);
+		}
+	}
+	return 0;
+}
+
+int
+sys_unmount(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printstr(tcp, tcp->u_arg[0], -1);
+	}
+	return 0;
+}
+
+int
+sys_umount(tcp)
+struct tcb *tcp;
+{
+	return sys_unmount(tcp);
+}
+
+int
+sys_auditsys(tcp)
+struct tcb *tcp;
+{
+	/* XXX - no information available */
+	return printargs(tcp);
+}
+
+static struct xlat ex_auth_flags[] = {
+	{ AUTH_UNIX,	"AUTH_UNIX"	},
+	{ AUTH_DES,	"AUTH_DES"	},
+	{ 0,		NULL		},
+};
+
+int
+sys_exportfs(tcp)
+struct tcb *tcp;
+{
+	struct export e;
+	int i;
+
+	if (entering(tcp)) {
+		printstr(tcp, tcp->u_arg[0], -1);
+		if (umove(tcp, tcp->u_arg[1], &e) < 0) {
+			tprintf("%#lx", tcp->u_arg[1]);
+			return 0;
+		}
+		tprintf("{fl:%u, anon:%u, ", e.ex_flags, e.ex_anon);
+		printxval(ex_auth_flags, e.ex_auth, "AUTH_???");
+		tprintf(", roots:[");
+		if (e.ex_auth == AUTH_UNIX) {
+			for (i=0; i<e.ex_u.exunix.rootaddrs.naddrs; i++) {
+				printsock(tcp,
+					(int)&e.ex_u.exunix.rootaddrs.addrvec[i]);
+			}
+			tprintf("], writers:[");
+			for (i=0; i<e.ex_writeaddrs.naddrs; i++) {
+				printsock(tcp,
+					(int)&e.ex_writeaddrs.addrvec[i]);
+			}
+			tprintf("]");
+		} else {
+			for (i=0; i<e.ex_u.exdes.nnames; i++) {
+				printsock(tcp,
+					(int)&e.ex_u.exdes.rootnames[i]);
+				tprintf(", ");
+			}
+			tprintf("], window:%u", e.ex_u.exdes.window);
+		}
+		tprintf("}");
+	}
+	return 0;
+}
+
+static struct xlat sysconflimits[] = {
+#ifdef	_SC_ARG_MAX
+	{ _SC_ARG_MAX,	"_SC_ARG_MAX"	},	/* space for argv & envp */
+#endif
+#ifdef	_SC_CHILD_MAX
+	{ _SC_CHILD_MAX,	"_SC_CHILD_MAX"	},	/* maximum children per process??? */
+#endif
+#ifdef	_SC_CLK_TCK
+	{ _SC_CLK_TCK,	"_SC_CLK_TCK"	},	/* clock ticks/sec */
+#endif
+#ifdef	_SC_NGROUPS_MAX
+	{ _SC_NGROUPS_MAX,	"_SC_NGROUPS_MAX"	},	/* number of groups if multple supp. */
+#endif
+#ifdef	_SC_OPEN_MAX
+	{ _SC_OPEN_MAX,	"_SC_OPEN_MAX"	},	/* max open files per process */
+#endif
+#ifdef	_SC_JOB_CONTROL
+	{ _SC_JOB_CONTROL,	"_SC_JOB_CONTROL"	},	/* do we have job control */
+#endif
+#ifdef	_SC_SAVED_IDS
+	{ _SC_SAVED_IDS,	"_SC_SAVED_IDS"	},	/* do we have saved uid/gids */
+#endif
+#ifdef	_SC_VERSION
+	{ _SC_VERSION,	"_SC_VERSION"	},	/* POSIX version supported */
+#endif
+	{ 0,		NULL		},
+};
+
+static struct xlat pathconflimits[] = {
+#ifdef	_PC_LINK_MAX
+	{ _PC_LINK_MAX,	"_PC_LINK_MAX"	},	/* max links to file/dir */
+#endif
+#ifdef	_PC_MAX_CANON
+	{ _PC_MAX_CANON,	"_PC_MAX_CANON"	},	/* max line length */
+#endif
+#ifdef	_PC_MAX_INPUT
+	{ _PC_MAX_INPUT,	"_PC_MAX_INPUT"	},	/* max "packet" to a tty device */
+#endif
+#ifdef	_PC_NAME_MAX
+	{ _PC_NAME_MAX,	"_PC_NAME_MAX"	},	/* max pathname component length */
+#endif
+#ifdef	_PC_PATH_MAX
+	{ _PC_PATH_MAX,	"_PC_PATH_MAX"	},	/* max pathname length */
+#endif
+#ifdef	_PC_PIPE_BUF
+	{ _PC_PIPE_BUF,	"_PC_PIPE_BUF"	},	/* size of a pipe */
+#endif
+#ifdef	_PC_CHOWN_RESTRICTED
+	{ _PC_CHOWN_RESTRICTED,	"_PC_CHOWN_RESTRICTED"	},	/* can we give away files */
+#endif
+#ifdef	_PC_NO_TRUNC
+	{ _PC_NO_TRUNC,	"_PC_NO_TRUNC"	},	/* trunc or error on >NAME_MAX */
+#endif
+#ifdef	_PC_VDISABLE
+	{ _PC_VDISABLE,	"_PC_VDISABLE"	},	/* best char to shut off tty c_cc */
+#endif
+	{ 0,		NULL		},
+};
+
+int
+sys_sysconf(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printxval(sysconflimits, tcp->u_arg[0], "_SC_???");
+	}
+	return 0;
+}
+
+int
+sys_pathconf(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printstr(tcp, tcp->u_arg[0], -1);
+		tprintf(", ");
+		printxval(pathconflimits, tcp->u_arg[1], "_SC_???");
+	}
+	return 0;
+}
+
+int
+sys_fpathconf(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		tprintf("%lu, ", tcp->u_arg[0]);
+		printxval(pathconflimits, tcp->u_arg[1], "_SC_???");
+	}
+	return 0;
+}
+
+#endif /* SUNOS4 */
+
+#ifdef SVR4
+
+#ifdef HAVE_SYS_SYSCONFIG_H
+#include <sys/sysconfig.h>
+#endif /* HAVE_SYS_SYSCONFIG_H */
+
+#include <sys/mount.h>
+#include <sys/systeminfo.h>
+#include <sys/utsname.h>
+
+static struct xlat sysconfig_options[] = {
+#ifdef _CONFIG_NGROUPS
+	{ _CONFIG_NGROUPS,		"_CONFIG_NGROUPS"		},
+#endif
+#ifdef _CONFIG_CHILD_MAX
+	{ _CONFIG_CHILD_MAX,		"_CONFIG_CHILD_MAX"		},
+#endif
+#ifdef _CONFIG_OPEN_FILES
+	{ _CONFIG_OPEN_FILES,		"_CONFIG_OPEN_FILES"		},
+#endif
+#ifdef _CONFIG_POSIX_VER
+	{ _CONFIG_POSIX_VER,		"_CONFIG_POSIX_VER"		},
+#endif
+#ifdef _CONFIG_PAGESIZE
+	{ _CONFIG_PAGESIZE,		"_CONFIG_PAGESIZE"		},
+#endif
+#ifdef _CONFIG_CLK_TCK
+	{ _CONFIG_CLK_TCK,		"_CONFIG_CLK_TCK"		},
+#endif
+#ifdef _CONFIG_XOPEN_VER
+	{ _CONFIG_XOPEN_VER,		"_CONFIG_XOPEN_VER"		},
+#endif
+#ifdef _CONFIG_PROF_TCK
+	{ _CONFIG_PROF_TCK,		"_CONFIG_PROF_TCK"		},
+#endif
+#ifdef _CONFIG_NPROC_CONF
+	{ _CONFIG_NPROC_CONF,		"_CONFIG_NPROC_CONF"		},
+#endif
+#ifdef _CONFIG_NPROC_ONLN
+	{ _CONFIG_NPROC_ONLN,		"_CONFIG_NPROC_ONLN"		},
+#endif
+#ifdef _CONFIG_AIO_LISTIO_MAX
+	{ _CONFIG_AIO_LISTIO_MAX,	"_CONFIG_AIO_LISTIO_MAX"	},
+#endif
+#ifdef _CONFIG_AIO_MAX
+	{ _CONFIG_AIO_MAX,		"_CONFIG_AIO_MAX"		},
+#endif
+#ifdef _CONFIG_AIO_PRIO_DELTA_MAX
+	{ _CONFIG_AIO_PRIO_DELTA_MAX,	"_CONFIG_AIO_PRIO_DELTA_MAX"	},
+#endif
+#ifdef _CONFIG_CONFIG_DELAYTIMER_MAX
+	{ _CONFIG_DELAYTIMER_MAX,	"_CONFIG_DELAYTIMER_MAX"	},
+#endif
+#ifdef _CONFIG_MQ_OPEN_MAX
+	{ _CONFIG_MQ_OPEN_MAX,		"_CONFIG_MQ_OPEN_MAX"		},
+#endif
+#ifdef _CONFIG_MQ_PRIO_MAX
+	{ _CONFIG_MQ_PRIO_MAX,		"_CONFIG_MQ_PRIO_MAX"		},
+#endif
+#ifdef _CONFIG_RTSIG_MAX
+	{ _CONFIG_RTSIG_MAX,		"_CONFIG_RTSIG_MAX"		},
+#endif
+#ifdef _CONFIG_SEM_NSEMS_MAX
+	{ _CONFIG_SEM_NSEMS_MAX,	"_CONFIG_SEM_NSEMS_MAX"		},
+#endif
+#ifdef _CONFIG_SEM_VALUE_MAX
+	{ _CONFIG_SEM_VALUE_MAX,	"_CONFIG_SEM_VALUE_MAX"		},
+#endif
+#ifdef _CONFIG_SIGQUEUE_MAX
+	{ _CONFIG_SIGQUEUE_MAX,		"_CONFIG_SIGQUEUE_MAX"		},
+#endif
+#ifdef _CONFIG_SIGRT_MIN
+	{ _CONFIG_SIGRT_MIN,		"_CONFIG_SIGRT_MIN"		},
+#endif
+#ifdef _CONFIG_SIGRT_MAX
+	{ _CONFIG_SIGRT_MAX,		"_CONFIG_SIGRT_MAX"		},
+#endif
+#ifdef _CONFIG_TIMER_MAX
+	{ _CONFIG_TIMER_MAX,		"_CONFIG_TIMER_MAX"		},
+#endif
+#ifdef _CONFIG_CONFIG_PHYS_PAGES
+	{ _CONFIG_PHYS_PAGES,		"_CONFIG_PHYS_PAGES"		},
+#endif
+#ifdef _CONFIG_AVPHYS_PAGES
+	{ _CONFIG_AVPHYS_PAGES,		"_CONFIG_AVPHYS_PAGES"		},
+#endif
+	{ 0,				NULL				},
+};
+
+int
+sys_sysconfig(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp))
+		printxval(sysconfig_options, tcp->u_arg[0], "_CONFIG_???");
+	return 0;
+}
+
+static struct xlat sysinfo_options[] = {
+	{ SI_SYSNAME,		"SI_SYSNAME"		},
+	{ SI_HOSTNAME,		"SI_HOSTNAME"		},
+	{ SI_RELEASE,		"SI_RELEASE"		},
+	{ SI_VERSION,		"SI_VERSION"		},
+	{ SI_MACHINE,		"SI_MACHINE"		},
+	{ SI_ARCHITECTURE,	"SI_ARCHITECTURE"	},
+	{ SI_HW_SERIAL,		"SI_HW_SERIAL"		},
+	{ SI_HW_PROVIDER,	"SI_HW_PROVIDER"	},
+	{ SI_SRPC_DOMAIN,	"SI_SRPC_DOMAIN"	},
+#ifdef SI_SET_HOSTNAME
+	{ SI_SET_HOSTNAME,	"SI_SET_HOSTNAME"	},
+#endif
+#ifdef SI_SET_SRPC_DOMAIN
+	{ SI_SET_SRPC_DOMAIN,	"SI_SET_SRPC_DOMAIN"	},
+#endif
+#ifdef SI_SET_KERB_REALM
+	{ SI_SET_KERB_REALM,	"SI_SET_KERB_REALM"	},
+#endif
+#ifdef 	SI_KERB_REALM
+	{ SI_KERB_REALM,	"SI_KERB_REALM"		},
+#endif
+	{ 0,			NULL			},
+};
+
+int
+sys_sysinfo(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printxval(sysinfo_options, tcp->u_arg[0], "SI_???");
+		tprintf(", ");
+	}
+	else {
+		/* Technically some calls write values.  So what. */
+		if (syserror(tcp))
+			tprintf("%#lx", tcp->u_arg[1]);
+		else
+			printpath(tcp, tcp->u_arg[1]);
+		tprintf(", %lu", tcp->u_arg[2]);
+	}
+	return 0;
+}
+
+#ifdef MIPS
+
+#include <sys/syssgi.h>
+
+static struct xlat syssgi_options[] = {
+	{ SGI_SYSID,		"SGI_SYSID"		},
+	{ SGI_RDUBLK,		"SGI_RDUBLK"		},
+	{ SGI_TUNE,		"SGI_TUNE"		},
+	{ SGI_IDBG,		"SGI_IDBG"		},
+	{ SGI_INVENT,		"SGI_INVENT"		},
+	{ SGI_RDNAME,		"SGI_RDNAME"		},
+	{ SGI_SETLED,		"SGI_SETLED"		},
+	{ SGI_SETNVRAM,		"SGI_SETNVRAM"		},
+	{ SGI_GETNVRAM,		"SGI_GETNVRAM"		},
+	{ SGI_QUERY_FTIMER,	"SGI_QUERY_FTIMER"	},
+	{ SGI_QUERY_CYCLECNTR,	"SGI_QUERY_CYCLECNTR"	},
+	{ SGI_PROCSZ,		"SGI_PROCSZ"		},
+	{ SGI_SIGACTION,	"SGI_SIGACTION"		},
+	{ SGI_SIGPENDING,	"SGI_SIGPENDING"	},
+	{ SGI_SIGPROCMASK,	"SGI_SIGPROCMASK"	},
+	{ SGI_SIGSUSPEND,	"SGI_SIGSUSPEND"	},
+	{ SGI_SETSID,		"SGI_SETSID"		},
+	{ SGI_SETPGID,		"SGI_SETPGID"		},
+	{ SGI_SYSCONF,		"SGI_SYSCONF"		},
+	{ SGI_WAIT4,		"SGI_WAIT4"		},
+	{ SGI_PATHCONF,		"SGI_PATHCONF"		},
+	{ SGI_READB,		"SGI_READB"		},
+	{ SGI_WRITEB,		"SGI_WRITEB"		},
+	{ SGI_SETGROUPS,	"SGI_SETGROUPS"		},
+	{ SGI_GETGROUPS,	"SGI_GETGROUPS"		},
+	{ SGI_SETTIMEOFDAY,	"SGI_SETTIMEOFDAY"	},
+	{ SGI_SETTIMETRIM,	"SGI_SETTIMETRIM"	},
+	{ SGI_GETTIMETRIM,	"SGI_GETTIMETRIM"	},
+	{ SGI_SPROFIL,		"SGI_SPROFIL"		},
+	{ SGI_RUSAGE,		"SGI_RUSAGE"		},
+	{ SGI_SIGSTACK,		"SGI_SIGSTACK"		},
+	{ SGI_SIGSTATUS,	"SGI_SIGSTATUS"		},
+	{ SGI_NETPROC,		"SGI_NETPROC"		},
+	{ SGI_SIGALTSTACK,	"SGI_SIGALTSTACK"	},
+	{ SGI_BDFLUSHCNT,	"SGI_BDFLUSHCNT"	},
+	{ SGI_SSYNC,		"SGI_SSYNC"		},
+	{ SGI_NFSCNVT,		"SGI_NFSCNVT"		},
+	{ SGI_GETPGID,		"SGI_GETPGID"		},
+	{ SGI_GETSID,		"SGI_GETSID"		},
+	{ SGI_IOPROBE,		"SGI_IOPROBE"		},
+	{ SGI_CONFIG,		"SGI_CONFIG"		},
+	{ SGI_ELFMAP,		"SGI_ELFMAP"		},
+	{ SGI_MCONFIG,		"SGI_MCONFIG"		},
+	{ SGI_GETPLABEL,	"SGI_GETPLABEL"		},
+	{ SGI_SETPLABEL,	"SGI_SETPLABEL"		},
+	{ SGI_GETLABEL,		"SGI_GETLABEL"		},
+	{ SGI_SETLABEL,		"SGI_SETLABEL"		},
+	{ SGI_SATREAD,		"SGI_SATREAD"		},
+	{ SGI_SATWRITE,		"SGI_SATWRITE"		},
+	{ SGI_SATCTL,		"SGI_SATCTL"		},
+	{ SGI_LOADATTR,		"SGI_LOADATTR"		},
+	{ SGI_UNLOADATTR,	"SGI_UNLOADATTR"	},
+#ifdef SGI_RECVLMSG
+	{ SGI_RECVLMSG,		"SGI_RECVLMSG"		},
+#endif
+	{ SGI_PLANGMOUNT,	"SGI_PLANGMOUNT"	},
+	{ SGI_GETPSOACL,	"SGI_GETPSOACL"		},
+	{ SGI_SETPSOACL,	"SGI_SETPSOACL"		},
+	{ SGI_RMI_FIXECC,	"SGI_RMI_FIXECC"	},
+	{ SGI_R4K_CERRS,	"SGI_R4K_CERRS"		},
+	{ SGI_GET_EVCONF,	"SGI_GET_EVCONF"	},
+	{ SGI_MPCWAROFF,	"SGI_MPCWAROFF"		},
+	{ SGI_SET_AUTOPWRON,	"SGI_SET_AUTOPWRON"	},
+	{ SGI_SPIPE,		"SGI_SPIPE"		},
+	{ SGI_SYMTAB,		"SGI_SYMTAB"		},
+#ifdef SGI_SET_FPDEBUG
+	{ SGI_SET_FPDEBUG,	"SGI_SET_FPDEBUG"	},
+#endif
+	{ SGI_TOSSTSAVE,	"SGI_TOSSTSAVE"		},
+	{ SGI_FDHI,		"SGI_FDHI"		},
+	{ SGI_MINRSS,		"SGI_MINRSS"		},
+	{ 0,			NULL			},
+};
+
+int
+sys_syssgi(tcp)
+struct tcb *tcp;
+{
+	int i;
+
+	if (entering(tcp)) {
+		printxval(syssgi_options, tcp->u_arg[0], "SGI_???");
+		switch (tcp->u_arg[0]) {
+		default:
+			for (i = 1; i < tcp->u_nargs; i++)
+				tprintf(", %#lx", tcp->u_arg[i]);
+			break;
+		}
+	}
+	return 0;
+}
+
+#include <sys/types.h>
+#include <rpc/rpc.h>
+struct cred;
+struct uio;
+#include <sys/fsid.h>
+#include <sys/vnode.h>
+#include <sys/fs/nfs.h>
+#include <sys/fs/nfs_clnt.h>
+
+static struct xlat mount_flags[] = {
+	{ MS_RDONLY,	"MS_RDONLY"	},
+	{ MS_FSS,	"MS_FSS"	},
+	{ MS_DATA,	"MS_DATA"	},
+	{ MS_NOSUID,	"MS_NOSUID"	},
+	{ MS_REMOUNT,	"MS_REMOUNT"	},
+	{ MS_NOTRUNC,	"MS_NOTRUNC"	},
+	{ MS_GRPID,	"MS_GRPID"	},
+	{ MS_NODEV,	"MS_NODEV"	},
+	{ MS_BEFORE,	"MS_BEFORE"	},
+	{ MS_AFTER,	"MS_AFTER"	},
+	{ 0,		NULL		},
+};
+
+static struct xlat nfs_flags[] = {
+	{ NFSMNT_SOFT,		"NFSMNT_SOFT"		},
+	{ NFSMNT_WSIZE,		"NFSMNT_WSIZE"		},
+	{ NFSMNT_RSIZE,		"NFSMNT_RSIZE"		},
+	{ NFSMNT_TIMEO,		"NFSMNT_TIMEO"		},
+	{ NFSMNT_RETRANS,	"NFSMNT_RETRANS"	},
+	{ NFSMNT_HOSTNAME,	"NFSMNT_HOSTNAME"	},
+	{ NFSMNT_INT,		"NFSMNT_INT"		},
+	{ NFSMNT_NOAC,		"NFSMNT_NOAC"		},
+	{ NFSMNT_ACREGMIN,	"NFSMNT_ACREGMIN"	},
+	{ NFSMNT_ACREGMAX,	"NFSMNT_ACREGMAX"	},
+	{ NFSMNT_ACDIRMIN,	"NFSMNT_ACDIRMIN"	},
+	{ NFSMNT_ACDIRMAX,	"NFSMNT_ACDIRMAX"	},
+	{ NFSMNT_PRIVATE,	"NFSMNT_PRIVATE"	},
+	{ NFSMNT_SYMTTL,	"NFSMNT_SYMTTL"		},
+	{ NFSMNT_LOOPBACK,	"NFSMNT_LOOPBACK"	},
+	{ NFSMNT_BASETYPE,	"NFSMNT_BASETYPE"	},
+	{ NFSMNT_NAMEMAX,	"NFSMNT_NAMEMAX"	},
+	{ 0,			NULL			},
+};
+
+int
+sys_mount(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printpath(tcp, tcp->u_arg[0]);
+		tprintf(", ");
+		printpath(tcp, tcp->u_arg[1]);
+		tprintf(", ");
+		printflags(mount_flags, tcp->u_arg[2]);
+		if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
+			tprintf(", ");
+			tprintf("%ld", tcp->u_arg[3]);
+		}
+		if (tcp->u_arg[2] & MS_DATA) {
+			int nfs_type = sysfs(GETFSIND, FSID_NFS);
+
+			tprintf(", ");
+			if (tcp->u_arg[3] == nfs_type) {
+				struct nfs_args args;
+				if (umove(tcp, tcp->u_arg[4], &args) < 0)
+					tprintf("%#lx", tcp->u_arg[4]);
+				else {
+					tprintf("addr=");
+					printsock(tcp, (int) args.addr);
+					tprintf(", flags=");
+					if (!printflags(nfs_flags, args.flags))
+						tprintf("NFSMNT_???");
+					tprintf(", hostname=");
+					printstr(tcp, (int) args.hostname, -1);
+					tprintf(", ...}");
+				}
+			}
+			else
+				tprintf("%#lx", tcp->u_arg[4]);
+			tprintf(", %ld", tcp->u_arg[5]);
+		}
+	}
+	return 0;
+}
+
+#else /* !MIPS */
+
+int
+sys_mount(tcp)
+struct tcb *tcp;
+{
+	if (entering(tcp)) {
+		printpath(tcp, tcp->u_arg[0]);
+		tprintf(", ");
+		printpath(tcp, tcp->u_arg[1]);
+		tprintf(", ...");
+	}
+	return 0;
+}
+
+#endif /* !MIPS */
+
+#endif /* SVR4 */
+
+#ifdef __NR_capget
+int
+sys_capget(tcp)
+struct tcb *tcp;
+{
+	cap_user_header_t       arg0;
+	cap_user_data_t         arg1;
+
+	if(!entering(tcp)) {
+		arg0 = (cap_user_header_t)tcp->u_arg[0];
+		arg1 = (cap_user_data_t)tcp->u_arg[1];
+		tprintf("{%lx, %d}, ", (unsigned long)arg0->version, arg0->pid);
+		tprintf("{%lx, %lx, %lx}", (unsigned long)arg1->effective,
+			(unsigned long)arg1->permitted, (unsigned long)arg1->inheritable);
+	}
+	return 0;
+}
+
+int
+sys_capset(tcp)
+struct tcb *tcp;
+{
+	cap_user_header_t       arg0;
+	cap_user_data_t         arg1;
+
+   	if(entering(tcp)) {
+		arg0 = (cap_user_header_t)tcp->u_arg[0];
+		arg1 = (cap_user_data_t)tcp->u_arg[1];
+		tprintf("{%lx, %d}, ", (unsigned long)arg0->version, arg0->pid);
+		tprintf("{%lx, %lx, %lx}", (unsigned long)arg1->effective,
+			(unsigned long)arg1->permitted, (unsigned long)arg1->inheritable);
+	}
+	return 0;
+}
+
+#else
+
+int sys_capget(tcp)
+struct tcb *tcp;
+{
+	return printargs(tcp);
+}
+
+int sys_capset(tcp)
+struct tcb *tcp;
+{
+	return printargs(tcp);
+}
+
+#endif
+