#define _LINUX_SOCKET_H
#define _LINUX_FS_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 */
+#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 */
+#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
+#define MS_DIRSYNC 128 /* Directory modifications are synchronous */
+#define MS_NOATIME 1024 /* Do not update access times. */
+#define MS_NODIRATIME 2048 /* Do not update directory access times */
+#define MS_BIND 4096
+#define MS_MOVE 8192
+#define MS_REC 16384
+#define MS_SILENT 32768
+#define MS_POSIXACL (1<<16) /* VFS does not apply the umask */
+#define MS_UNBINDABLE (1<<17) /* change to unbindable */
+#define MS_PRIVATE (1<<18) /* change to private */
+#define MS_SLAVE (1<<19) /* change to slave */
+#define MS_SHARED (1<<20) /* change to shared */
+#define MS_RELATIME (1<<21)
+#define MS_KERNMOUNT (1<<22)
+#define MS_I_VERSION (1<<23)
+#define MS_STRICTATIME (1<<24)
+#define MS_BORN (1<<29)
+#define MS_ACTIVE (1<<30)
+#define MS_NOUSER (1<<31)
+#define MS_MGC_VAL 0xc0ed0000 /* Magic flag number */
+#define MS_MGC_MSK 0xffff0000 /* Magic flag mask */
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/syscall.h>
-#ifdef SYS_personality
-/* Workaround for kernel namespace pollution. */
-#define _LINUX_PTRACE_H
-/* Yuck yuck yuck. We can't include linux/ptrace.h, but personality.h
- makes a declaration with struct pt_regs, which is defined there. */
-struct pt_regs;
-#define sys_personality kernel_sys_personality
-#include <linux/personality.h>
-#undef sys_personality
-#endif /* SYS_personality */
-
-#ifdef SYS_capget
+#ifdef HAVE_LINUX_CAPABILITY_H
#include <linux/capability.h>
#endif
-#ifdef SYS_cacheflush
+#ifdef HAVE_ASM_CACHECTL_H
#include <asm/cachectl.h>
#endif
#include <linux/sysctl.h>
-static struct xlat mount_flags[] = {
+static const struct xlat mount_flags[] = {
+ { MS_MGC_VAL, "MS_MGC_VAL" },
{ 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" },
+ { MS_RELATIME, "MS_RELATIME" },
+ { MS_KERNMOUNT, "MS_KERNMOUNT" },
+ { MS_I_VERSION, "MS_I_VERSION" },
+ { MS_STRICTATIME,"MS_STRICTATIME"},
+ { MS_BORN, "MS_BORN" },
+ { MS_MANDLOCK, "MS_MANDLOCK" },
+ { MS_NOATIME, "MS_NOATIME" },
+ { MS_NODIRATIME,"MS_NODIRATIME" },
+ { MS_BIND, "MS_BIND" },
+ { MS_MOVE, "MS_MOVE" },
+ { MS_REC, "MS_REC" },
+ { MS_SILENT, "MS_SILENT" },
+ { MS_POSIXACL, "MS_POSIXACL" },
+ { MS_UNBINDABLE,"MS_UNBINDABLE" },
+ { MS_PRIVATE, "MS_PRIVATE" },
+ { MS_SLAVE, "MS_SLAVE" },
+ { MS_SHARED, "MS_SHARED" },
+ { MS_ACTIVE, "MS_ACTIVE" },
+ { MS_NOUSER, "MS_NOUSER" },
{ 0, NULL },
};
int
-sys_mount(tcp)
-struct tcb *tcp;
+sys_mount(struct tcb *tcp)
{
if (entering(tcp)) {
+ int ignore_type = 0, ignore_data = 0;
+ unsigned long flags = tcp->u_arg[3];
+
+ /* Discard magic */
+ if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
+ flags &= ~MS_MGC_MSK;
+
+ if (flags & MS_REMOUNT)
+ ignore_type = 1;
+ else if (flags & (MS_BIND | MS_MOVE))
+ ignore_type = ignore_data = 1;
+
printpath(tcp, tcp->u_arg[0]);
tprintf(", ");
+
printpath(tcp, tcp->u_arg[1]);
tprintf(", ");
- printpath(tcp, tcp->u_arg[2]);
+
+ if (ignore_type && tcp->u_arg[2])
+ tprintf("%#lx", tcp->u_arg[2]);
+ else
+ printstr(tcp, tcp->u_arg[2], -1);
+ tprintf(", ");
+
+ printflags(mount_flags, tcp->u_arg[3], "MS_???");
tprintf(", ");
- printflags(mount_flags, tcp->u_arg[3]);
- tprintf(", %#lx", tcp->u_arg[4]);
+
+ if (ignore_data && tcp->u_arg[4])
+ tprintf("%#lx", tcp->u_arg[4]);
+ else
+ printstr(tcp, tcp->u_arg[4], -1);
}
return 0;
}
+#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
+#define MNT_DETACH 0x00000002 /* Just detach from the tree */
+#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
+
+static const struct xlat umount_flags[] = {
+ { MNT_FORCE, "MNT_FORCE" },
+ { MNT_DETACH, "MNT_DETACH" },
+ { MNT_EXPIRE, "MNT_EXPIRE" },
+ { 0, NULL },
+};
+
int
-sys_umount2(tcp)
-struct tcb *tcp;
+sys_umount2(struct tcb *tcp)
{
if (entering(tcp)) {
printstr(tcp, tcp->u_arg[0], -1);
tprintf(", ");
- if (tcp->u_arg[1] & 1)
- tprintf("MNT_FORCE");
- else
- tprintf("0");
+ printflags(umount_flags, tcp->u_arg[1], "MNT_???");
}
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
+/* These are not macros, but enums. We just copy the values by hand
+ from Linux 2.6.9 here. */
+static const struct xlat personality_options[] = {
+ { 0, "PER_LINUX" },
+ { 0x00800000, "PER_LINUX_32BIT"},
+ { 0x04100001, "PER_SVR4" },
+ { 0x05000002, "PER_SVR3" },
+ { 0x07000003, "PER_SCOSVR3" },
+ { 0x06000003, "PER_OSR5" },
+ { 0x05000004, "PER_WYSEV386" },
+ { 0x04000005, "PER_ISCR4" },
+ { 0x00000006, "PER_BSD" },
+ { 0x04000006, "PER_SUNOS" },
+ { 0x05000007, "PER_XENIX" },
+ { 0x00000008, "PER_LINUX32" },
+ { 0x08000008, "PER_LINUX32_3GB"},
+ { 0x04000009, "PER_IRIX32" },
+ { 0x0400000a, "PER_IRIXN32" },
+ { 0x0400000b, "PER_IRIX64" },
+ { 0x0000000c, "PER_RISCOS" },
+ { 0x0400000d, "PER_SOLARIS" },
+ { 0x0410000e, "PER_UW7" },
+ { 0x0000000f, "PER_OSF4" },
+ { 0x00000010, "PER_HPUX" },
{ 0, NULL },
};
}
#include <linux/reboot.h>
-static struct xlat bootflags1[] = {
+static const struct xlat bootflags1[] = {
{ LINUX_REBOOT_MAGIC1, "LINUX_REBOOT_MAGIC1" },
{ 0, NULL },
};
-static struct xlat bootflags2[] = {
+static const struct xlat bootflags2[] = {
{ LINUX_REBOOT_MAGIC2, "LINUX_REBOOT_MAGIC2" },
{ LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A" },
{ LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B" },
{ 0, NULL },
};
-static struct xlat bootflags3[] = {
+static const struct xlat bootflags3[] = {
{ LINUX_REBOOT_CMD_CAD_OFF, "LINUX_REBOOT_CMD_CAD_OFF" },
{ LINUX_REBOOT_CMD_RESTART, "LINUX_REBOOT_CMD_RESTART" },
{ LINUX_REBOOT_CMD_HALT, "LINUX_REBOOT_CMD_HALT" },
struct tcb *tcp;
{
if (entering(tcp)) {
- if (!printflags(bootflags1, tcp->u_arg[0]))
- tprintf("LINUX_REBOOT_MAGIC???");
+ printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
tprintf(", ");
- if (!printflags(bootflags2, tcp->u_arg[1]))
- tprintf("LINUX_REBOOT_MAGIC???");
+ printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
tprintf(", ");
- if (!printflags(bootflags3, tcp->u_arg[2]))
- tprintf("LINUX_REBOOT_CMD_???");
+ printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
tprintf(", ");
printstr(tcp, tcp->u_arg[3], -1);
}
#ifdef M68K
-static struct xlat cacheflush_scope[] = {
+static const struct xlat cacheflush_scope[] = {
#ifdef FLUSH_SCOPE_LINE
{ FLUSH_SCOPE_LINE, "FLUSH_SCOPE_LINE" },
#endif
{ 0, NULL },
};
-static struct xlat cacheflush_flags[] = {
+static const struct xlat cacheflush_flags[] = {
#ifdef FLUSH_CACHE_BOTH
{ FLUSH_CACHE_BOTH, "FLUSH_CACHE_BOTH" },
#endif
printxval(cacheflush_scope, tcp->u_arg[1], "FLUSH_SCOPE_???");
tprintf(", ");
/* flags */
- printflags(cacheflush_flags, tcp->u_arg[2]);
+ printflags(cacheflush_flags, tcp->u_arg[2], "FLUSH_CACHE_???");
/* len */
tprintf(", %lu", tcp->u_arg[3]);
}
}
#endif /* M68K */
+#ifdef BFIN
+
+#include <bfin_sram.h>
+
+static const struct xlat sram_alloc_flags[] = {
+ { L1_INST_SRAM, "L1_INST_SRAM" },
+ { L1_DATA_A_SRAM, "L1_DATA_A_SRAM" },
+ { L1_DATA_B_SRAM, "L1_DATA_B_SRAM" },
+ { L1_DATA_SRAM, "L1_DATA_SRAM" },
+ { L2_SRAM, "L2_SRAM" },
+ { 0, NULL },
+};
+
+int
+sys_sram_alloc(struct tcb *tcp)
+{
+ if (entering(tcp)) {
+ /* size */
+ tprintf("%lu, ", tcp->u_arg[0]);
+ /* flags */
+ printxval(sram_alloc_flags, tcp->u_arg[1], "???_SRAM");
+ }
+ return 1;
+}
+
+#include <asm/cachectl.h>
+
+static const struct xlat cacheflush_flags[] = {
+ { ICACHE, "ICACHE" },
+ { DCACHE, "DCACHE" },
+ { BCACHE, "BCACHE" },
+ { 0, NULL },
+};
+
+int
+sys_cacheflush(struct tcb *tcp)
+{
+ if (entering(tcp)) {
+ /* start addr */
+ tprintf("%#lx, ", tcp->u_arg[0]);
+ /* length */
+ tprintf("%ld, ", tcp->u_arg[1]);
+ /* flags */
+ printxval(cacheflush_flags, tcp->u_arg[1], "?CACHE");
+ }
+ return 0;
+}
+
+#endif
+
+#ifdef SH
+static const struct xlat cacheflush_flags[] = {
+#ifdef CACHEFLUSH_D_INVAL
+ { CACHEFLUSH_D_INVAL, "CACHEFLUSH_D_INVAL" },
+#endif
+#ifdef CACHEFLUSH_D_WB
+ { CACHEFLUSH_D_WB, "CACHEFLUSH_D_WB" },
+#endif
+#ifdef CACHEFLUSH_D_PURGE
+ { CACHEFLUSH_D_PURGE, "CACHEFLUSH_D_PURGE" },
+#endif
+#ifdef CACHEFLUSH_I
+ { CACHEFLUSH_I, "CACHEFLUSH_I" },
+#endif
+ { 0, NULL },
+};
+
+int
+sys_cacheflush(struct tcb *tcp)
+{
+ if (entering(tcp)) {
+ /* addr */
+ tprintf("%#lx, ", tcp->u_arg[0]);
+ /* len */
+ tprintf("%lu, ", tcp->u_arg[1]);
+ /* flags */
+ printflags(cacheflush_flags, tcp->u_arg[2], "CACHEFLUSH_???");
+ }
+ return 0;
+}
+#endif /* SH */
+
#endif /* LINUX */
#ifdef SUNOS4
return 0;
}
-static struct xlat bootflags[] = {
+static const 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 */
struct tcb *tcp;
{
if (entering(tcp)) {
- if (!printflags(bootflags, tcp->u_arg[0]))
- tprintf("RB_???");
+ printflags(bootflags, tcp->u_arg[0], "RB_???");
if (tcp->u_arg[0] & RB_STRING) {
printstr(tcp, tcp->u_arg[1], -1);
}
return 0;
}
-static struct xlat mountflags[] = {
+static const struct xlat mountflags[] = {
{ M_RDONLY, "M_RDONLY" },
{ M_NOSUID, "M_NOSUID" },
{ M_NEWTYPE, "M_NEWTYPE" },
{ 0, NULL },
};
-static struct xlat nfsflags[] = {
+static const struct xlat nfsflags[] = {
{ NFSMNT_SOFT, "NFSMNT_SOFT" },
{ NFSMNT_WSIZE, "NFSMNT_WSIZE" },
{ NFSMNT_RSIZE, "NFSMNT_RSIZE" },
}
printstr(tcp, tcp->u_arg[1], -1);
tprintf(", ");
- if (!printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE))
- tprintf("0");
+ printflags(mountflags, tcp->u_arg[2] & ~M_NEWTYPE, "M_???");
tprintf(", ");
if (strcmp(type, "4.2") == 0) {
tprintf("[");
printsock(tcp, (int) a.addr);
tprintf(", ");
- if (!printflags(nfsflags, a.flags))
- tprintf("NFSMNT_???");
+ printflags(nfsflags, a.flags, "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)
return printargs(tcp);
}
-static struct xlat ex_auth_flags[] = {
+static const struct xlat ex_auth_flags[] = {
{ AUTH_UNIX, "AUTH_UNIX" },
{ AUTH_DES, "AUTH_DES" },
{ 0, NULL },
return 0;
}
-static struct xlat sysconflimits[] = {
+static const struct xlat sysconflimits[] = {
#ifdef _SC_ARG_MAX
{ _SC_ARG_MAX, "_SC_ARG_MAX" }, /* space for argv & envp */
#endif
#endif /* SUNOS4 */
#if defined(SUNOS4) || defined(FREEBSD)
-static struct xlat pathconflimits[] = {
+static const struct xlat pathconflimits[] = {
#ifdef _PC_LINK_MAX
{ _PC_LINK_MAX, "_PC_LINK_MAX" }, /* max links to file/dir */
#endif
#include <sys/systeminfo.h>
#include <sys/utsname.h>
-static struct xlat sysconfig_options[] = {
+static const struct xlat sysconfig_options[] = {
#ifdef _CONFIG_NGROUPS
{ _CONFIG_NGROUPS, "_CONFIG_NGROUPS" },
#endif
return 0;
}
-static struct xlat sysinfo_options[] = {
+static const struct xlat sysinfo_options[] = {
{ SI_SYSNAME, "SI_SYSNAME" },
{ SI_HOSTNAME, "SI_HOSTNAME" },
{ SI_RELEASE, "SI_RELEASE" },
#include <sys/syssgi.h>
-static struct xlat syssgi_options[] = {
+static const struct xlat syssgi_options[] = {
{ SGI_SYSID, "SGI_SYSID" },
#ifdef SGI_RDUBLK
{ SGI_RDUBLK, "SGI_RDUBLK" },
#ifdef SGI_GET_FP_PRECISE
{ SGI_GET_FP_PRECISE, "SGI_GET_FP_PRECISE" },
#endif
-#ifdef SGI_GET_CONFIG_SMM
+#ifdef SGI_GET_CONFIG_SMM
{ SGI_GET_CONFIG_SMM, "SGI_GET_CONFIG_SMM" },
#endif
-#ifdef SGI_FP_IMPRECISE_SUPP
+#ifdef SGI_FP_IMPRECISE_SUPP
{ SGI_FP_IMPRECISE_SUPP,"SGI_FP_IMPRECISE_SUPP" },
#endif
-#ifdef SGI_CONFIG_NSMM_SUPP
+#ifdef SGI_CONFIG_NSMM_SUPP
{ SGI_CONFIG_NSMM_SUPP, "SGI_CONFIG_NSMM_SUPP" },
#endif
-#ifdef SGI_RT_TSTAMP_CREATE
+#ifdef SGI_RT_TSTAMP_CREATE
{ SGI_RT_TSTAMP_CREATE, "SGI_RT_TSTAMP_CREATE" },
#endif
-#ifdef SGI_RT_TSTAMP_DELETE
+#ifdef SGI_RT_TSTAMP_DELETE
{ SGI_RT_TSTAMP_DELETE, "SGI_RT_TSTAMP_DELETE" },
#endif
-#ifdef SGI_RT_TSTAMP_START
+#ifdef SGI_RT_TSTAMP_START
{ SGI_RT_TSTAMP_START, "SGI_RT_TSTAMP_START" },
#endif
-#ifdef SGI_RT_TSTAMP_STOP
+#ifdef SGI_RT_TSTAMP_STOP
{ SGI_RT_TSTAMP_STOP, "SGI_RT_TSTAMP_STOP" },
#endif
-#ifdef SGI_RT_TSTAMP_ADDR
+#ifdef SGI_RT_TSTAMP_ADDR
{ SGI_RT_TSTAMP_ADDR, "SGI_RT_TSTAMP_ADDR" },
#endif
-#ifdef SGI_RT_TSTAMP_MASK
+#ifdef SGI_RT_TSTAMP_MASK
{ SGI_RT_TSTAMP_MASK, "SGI_RT_TSTAMP_MASK" },
#endif
-#ifdef SGI_RT_TSTAMP_EOB_MODE
+#ifdef SGI_RT_TSTAMP_EOB_MODE
{ SGI_RT_TSTAMP_EOB_MODE,"SGI_RT_TSTAMP_EOB_MODE"},
#endif
-#ifdef SGI_USE_FP_BCOPY
+#ifdef SGI_USE_FP_BCOPY
{ SGI_USE_FP_BCOPY, "SGI_USE_FP_BCOPY" },
#endif
-#ifdef SGI_GET_UST
+#ifdef SGI_GET_UST
{ SGI_GET_UST, "SGI_GET_UST" },
#endif
-#ifdef SGI_SPECULATIVE_EXEC
+#ifdef SGI_SPECULATIVE_EXEC
{ SGI_SPECULATIVE_EXEC, "SGI_SPECULATIVE_EXEC" },
#endif
-#ifdef SGI_XLV_NEXT_RQST
+#ifdef SGI_XLV_NEXT_RQST
{ SGI_XLV_NEXT_RQST, "SGI_XLV_NEXT_RQST" },
#endif
-#ifdef SGI_XLV_ATTR_CURSOR
+#ifdef SGI_XLV_ATTR_CURSOR
{ SGI_XLV_ATTR_CURSOR, "SGI_XLV_ATTR_CURSOR" },
#endif
-#ifdef SGI_XLV_ATTR_GET
+#ifdef SGI_XLV_ATTR_GET
{ SGI_XLV_ATTR_GET, "SGI_XLV_ATTR_GET" },
#endif
-#ifdef SGI_XLV_ATTR_SET
+#ifdef SGI_XLV_ATTR_SET
{ SGI_XLV_ATTR_SET, "SGI_XLV_ATTR_SET" },
#endif
#ifdef SGI_BTOOLSIZE
{ SGI_BTOOLSIZE, "SGI_BTOOLSIZE" },
#endif
-#ifdef SGI_BTOOLGET
+#ifdef SGI_BTOOLGET
{ SGI_BTOOLGET, "SGI_BTOOLGET" },
#endif
-#ifdef SGI_BTOOLREINIT
+#ifdef SGI_BTOOLREINIT
{ SGI_BTOOLREINIT, "SGI_BTOOLREINIT" },
#endif
-#ifdef SGI_CREATE_UUID
+#ifdef SGI_CREATE_UUID
{ SGI_CREATE_UUID, "SGI_CREATE_UUID" },
#endif
-#ifdef SGI_NOFPE
+#ifdef SGI_NOFPE
{ SGI_NOFPE, "SGI_NOFPE" },
#endif
-#ifdef SGI_OLD_SOFTFP
+#ifdef SGI_OLD_SOFTFP
{ SGI_OLD_SOFTFP, "SGI_OLD_SOFTFP" },
#endif
-#ifdef SGI_FS_INUMBERS
+#ifdef SGI_FS_INUMBERS
{ SGI_FS_INUMBERS, "SGI_FS_INUMBERS" },
#endif
-#ifdef SGI_FS_BULKSTAT
+#ifdef SGI_FS_BULKSTAT
{ SGI_FS_BULKSTAT, "SGI_FS_BULKSTAT" },
#endif
-#ifdef SGI_RT_TSTAMP_WAIT
+#ifdef SGI_RT_TSTAMP_WAIT
{ SGI_RT_TSTAMP_WAIT, "SGI_RT_TSTAMP_WAIT" },
#endif
-#ifdef SGI_RT_TSTAMP_UPDATE
+#ifdef SGI_RT_TSTAMP_UPDATE
{ SGI_RT_TSTAMP_UPDATE, "SGI_RT_TSTAMP_UPDATE" },
#endif
-#ifdef SGI_PATH_TO_HANDLE
+#ifdef SGI_PATH_TO_HANDLE
{ SGI_PATH_TO_HANDLE, "SGI_PATH_TO_HANDLE" },
#endif
-#ifdef SGI_PATH_TO_FSHANDLE
+#ifdef SGI_PATH_TO_FSHANDLE
{ SGI_PATH_TO_FSHANDLE, "SGI_PATH_TO_FSHANDLE" },
#endif
-#ifdef SGI_FD_TO_HANDLE
+#ifdef SGI_FD_TO_HANDLE
{ SGI_FD_TO_HANDLE, "SGI_FD_TO_HANDLE" },
#endif
-#ifdef SGI_OPEN_BY_HANDLE
+#ifdef SGI_OPEN_BY_HANDLE
{ SGI_OPEN_BY_HANDLE, "SGI_OPEN_BY_HANDLE" },
#endif
-#ifdef SGI_READLINK_BY_HANDLE
+#ifdef SGI_READLINK_BY_HANDLE
{ SGI_READLINK_BY_HANDLE,"SGI_READLINK_BY_HANDLE"},
#endif
-#ifdef SGI_READ_DANGID
+#ifdef SGI_READ_DANGID
{ SGI_READ_DANGID, "SGI_READ_DANGID" },
#endif
-#ifdef SGI_CONST
+#ifdef SGI_CONST
{ SGI_CONST, "SGI_CONST" },
#endif
-#ifdef SGI_XFS_FSOPERATIONS
+#ifdef SGI_XFS_FSOPERATIONS
{ SGI_XFS_FSOPERATIONS, "SGI_XFS_FSOPERATIONS" },
#endif
-#ifdef SGI_SETASH
+#ifdef SGI_SETASH
{ SGI_SETASH, "SGI_SETASH" },
#endif
-#ifdef SGI_GETASH
+#ifdef SGI_GETASH
{ SGI_GETASH, "SGI_GETASH" },
#endif
-#ifdef SGI_SETPRID
+#ifdef SGI_SETPRID
{ SGI_SETPRID, "SGI_SETPRID" },
#endif
-#ifdef SGI_GETPRID
+#ifdef SGI_GETPRID
{ SGI_GETPRID, "SGI_GETPRID" },
#endif
-#ifdef SGI_SETSPINFO
+#ifdef SGI_SETSPINFO
{ SGI_SETSPINFO, "SGI_SETSPINFO" },
#endif
-#ifdef SGI_GETSPINFO
+#ifdef SGI_GETSPINFO
{ SGI_GETSPINFO, "SGI_GETSPINFO" },
#endif
-#ifdef SGI_SHAREII
+#ifdef SGI_SHAREII
{ SGI_SHAREII, "SGI_SHAREII" },
#endif
-#ifdef SGI_NEWARRAYSESS
+#ifdef SGI_NEWARRAYSESS
{ SGI_NEWARRAYSESS, "SGI_NEWARRAYSESS" },
#endif
-#ifdef SGI_GETDFLTPRID
+#ifdef SGI_GETDFLTPRID
{ SGI_GETDFLTPRID, "SGI_GETDFLTPRID" },
#endif
-#ifdef SGI_SET_DISMISSED_EXC_CNT
+#ifdef SGI_SET_DISMISSED_EXC_CNT
{ SGI_SET_DISMISSED_EXC_CNT,"SGI_SET_DISMISSED_EXC_CNT" },
#endif
-#ifdef SGI_GET_DISMISSED_EXC_CNT
+#ifdef SGI_GET_DISMISSED_EXC_CNT
{ SGI_GET_DISMISSED_EXC_CNT,"SGI_GET_DISMISSED_EXC_CNT" },
#endif
-#ifdef SGI_CYCLECNTR_SIZE
+#ifdef SGI_CYCLECNTR_SIZE
{ SGI_CYCLECNTR_SIZE, "SGI_CYCLECNTR_SIZE" },
#endif
-#ifdef SGI_QUERY_FASTTIMER
+#ifdef SGI_QUERY_FASTTIMER
{ SGI_QUERY_FASTTIMER, "SGI_QUERY_FASTTIMER" },
#endif
-#ifdef SGI_PIDSINASH
+#ifdef SGI_PIDSINASH
{ SGI_PIDSINASH, "SGI_PIDSINASH" },
#endif
-#ifdef SGI_ULI
+#ifdef SGI_ULI
{ SGI_ULI, "SGI_ULI" },
#endif
-#ifdef SGI_LPG_SHMGET
+#ifdef SGI_LPG_SHMGET
{ SGI_LPG_SHMGET, "SGI_LPG_SHMGET" },
#endif
-#ifdef SGI_LPG_MAP
+#ifdef SGI_LPG_MAP
{ SGI_LPG_MAP, "SGI_LPG_MAP" },
#endif
-#ifdef SGI_CACHEFS_SYS
+#ifdef SGI_CACHEFS_SYS
{ SGI_CACHEFS_SYS, "SGI_CACHEFS_SYS" },
#endif
-#ifdef SGI_NFSNOTIFY
+#ifdef SGI_NFSNOTIFY
{ SGI_NFSNOTIFY, "SGI_NFSNOTIFY" },
#endif
-#ifdef SGI_LOCKDSYS
+#ifdef SGI_LOCKDSYS
{ SGI_LOCKDSYS, "SGI_LOCKDSYS" },
#endif
-#ifdef SGI_EVENTCTR
+#ifdef SGI_EVENTCTR
{ SGI_EVENTCTR, "SGI_EVENTCTR" },
#endif
-#ifdef SGI_GETPRUSAGE
+#ifdef SGI_GETPRUSAGE
{ SGI_GETPRUSAGE, "SGI_GETPRUSAGE" },
#endif
-#ifdef SGI_PROCMASK_LOCATION
+#ifdef SGI_PROCMASK_LOCATION
{ SGI_PROCMASK_LOCATION,"SGI_PROCMASK_LOCATION" },
#endif
-#ifdef SGI_UNUSED
+#ifdef SGI_UNUSED
{ SGI_UNUSED, "SGI_UNUSED" },
#endif
-#ifdef SGI_CKPT_SYS
+#ifdef SGI_CKPT_SYS
{ SGI_CKPT_SYS, "SGI_CKPT_SYS" },
#endif
-#ifdef SGI_CKPT_SYS
+#ifdef SGI_CKPT_SYS
{ SGI_CKPT_SYS, "SGI_CKPT_SYS" },
#endif
-#ifdef SGI_GETGRPPID
+#ifdef SGI_GETGRPPID
{ SGI_GETGRPPID, "SGI_GETGRPPID" },
#endif
-#ifdef SGI_GETSESPID
+#ifdef SGI_GETSESPID
{ SGI_GETSESPID, "SGI_GETSESPID" },
#endif
-#ifdef SGI_ENUMASHS
+#ifdef SGI_ENUMASHS
{ SGI_ENUMASHS, "SGI_ENUMASHS" },
#endif
-#ifdef SGI_SETASMACHID
+#ifdef SGI_SETASMACHID
{ SGI_SETASMACHID, "SGI_SETASMACHID" },
#endif
-#ifdef SGI_GETASMACHID
+#ifdef SGI_GETASMACHID
{ SGI_GETASMACHID, "SGI_GETASMACHID" },
#endif
-#ifdef SGI_GETARSESS
+#ifdef SGI_GETARSESS
{ SGI_GETARSESS, "SGI_GETARSESS" },
#endif
-#ifdef SGI_JOINARRAYSESS
+#ifdef SGI_JOINARRAYSESS
{ SGI_JOINARRAYSESS, "SGI_JOINARRAYSESS" },
#endif
-#ifdef SGI_SPROC_KILL
+#ifdef SGI_SPROC_KILL
{ SGI_SPROC_KILL, "SGI_SPROC_KILL" },
#endif
-#ifdef SGI_DBA_CONFIG
+#ifdef SGI_DBA_CONFIG
{ SGI_DBA_CONFIG, "SGI_DBA_CONFIG" },
#endif
-#ifdef SGI_RELEASE_NAME
+#ifdef SGI_RELEASE_NAME
{ SGI_RELEASE_NAME, "SGI_RELEASE_NAME" },
#endif
-#ifdef SGI_SYNCH_CACHE_HANDLER
+#ifdef SGI_SYNCH_CACHE_HANDLER
{ SGI_SYNCH_CACHE_HANDLER,"SGI_SYNCH_CACHE_HANDLER"},
#endif
-#ifdef SGI_SWASH_INIT
+#ifdef SGI_SWASH_INIT
{ SGI_SWASH_INIT, "SGI_SWASH_INIT" },
#endif
-#ifdef SGI_NUMA_MIGR_PAGE
+#ifdef SGI_NUMA_MIGR_PAGE
{ SGI_NUMA_MIGR_PAGE, "SGI_NUMA_MIGR_PAGE" },
#endif
-#ifdef SGI_NUMA_MIGR_PAGE_ALT
+#ifdef SGI_NUMA_MIGR_PAGE_ALT
{ SGI_NUMA_MIGR_PAGE_ALT,"SGI_NUMA_MIGR_PAGE_ALT"},
#endif
-#ifdef SGI_KAIO_USERINIT
+#ifdef SGI_KAIO_USERINIT
{ SGI_KAIO_USERINIT, "SGI_KAIO_USERINIT" },
#endif
-#ifdef SGI_KAIO_READ
+#ifdef SGI_KAIO_READ
{ SGI_KAIO_READ, "SGI_KAIO_READ" },
#endif
-#ifdef SGI_KAIO_WRITE
+#ifdef SGI_KAIO_WRITE
{ SGI_KAIO_WRITE, "SGI_KAIO_WRITE" },
#endif
-#ifdef SGI_KAIO_SUSPEND
+#ifdef SGI_KAIO_SUSPEND
{ SGI_KAIO_SUSPEND, "SGI_KAIO_SUSPEND" },
#endif
-#ifdef SGI_KAIO_STATS
+#ifdef SGI_KAIO_STATS
{ SGI_KAIO_STATS, "SGI_KAIO_STATS" },
#endif
-#ifdef SGI_INITIAL_PT_SPROC
+#ifdef SGI_INITIAL_PT_SPROC
{ SGI_INITIAL_PT_SPROC, "SGI_INITIAL_PT_SPROC" },
#endif
{ 0, NULL },
#include <sys/fs/nfs.h>
#include <sys/fs/nfs_clnt.h>
-static struct xlat mount_flags[] = {
+static const struct xlat mount_flags[] = {
{ MS_RDONLY, "MS_RDONLY" },
{ MS_FSS, "MS_FSS" },
{ MS_DATA, "MS_DATA" },
{ 0, NULL },
};
-static struct xlat nfs_flags[] = {
+static const struct xlat nfs_flags[] = {
{ NFSMNT_SOFT, "NFSMNT_SOFT" },
{ NFSMNT_WSIZE, "NFSMNT_WSIZE" },
{ NFSMNT_RSIZE, "NFSMNT_RSIZE" },
tprintf(", ");
printpath(tcp, tcp->u_arg[1]);
tprintf(", ");
- printflags(mount_flags, tcp->u_arg[2]);
+ printflags(mount_flags, tcp->u_arg[2], "MS_???");
if (tcp->u_arg[2] & (MS_FSS | MS_DATA)) {
tprintf(", ");
tprintf("%ld", tcp->u_arg[3]);
tprintf("addr=");
printsock(tcp, (int) args.addr);
tprintf(", flags=");
- if (!printflags(nfs_flags, args.flags))
- tprintf("NFSMNT_???");
+ printflags(nfs_flags, args.flags, "NFSMNT_???");
tprintf(", hostname=");
printstr(tcp, (int) args.hostname, -1);
tprintf(", ...}");
#include <sys/fs/vx_ioctl.h>
-static struct xlat mount_flags[] = {
+static const struct xlat mount_flags[] = {
{ MS_RDONLY, "MS_RDONLY" },
{ MS_FSS, "MS_FSS" },
{ MS_DATA, "MS_DATA" },
};
#ifdef VX_MS_MASK
-static struct xlat vxfs_flags[] = {
+static const struct xlat vxfs_flags[] = {
{ VX_MS_NOLOG, "VX_MS_NOLOG" },
{ VX_MS_BLKCLEAR, "VX_MS_BLKCLEAR" },
{ VX_MS_SNAPSHOT, "VX_MS_SNAPSHOT" },
};
#endif
-static struct xlat nfs_flags[] = {
+static const struct xlat nfs_flags[] = {
{ NFSMNT_SOFT, "NFSMNT_SOFT" },
{ NFSMNT_WSIZE, "NFSMNT_WSIZE" },
{ NFSMNT_RSIZE, "NFSMNT_RSIZE" },
tprintf(", ");
printpath(tcp, tcp->u_arg[1]);
tprintf(", ");
- printflags(mount_flags, tcp->u_arg[2]);
+ printflags(mount_flags, tcp->u_arg[2], "MS_???");
/* The doc sez that the file system type is given as a
fsindex, and we should use sysfs to work out the name.
This appears to be untrue for UW. Maybe it's untrue
tprintf("%#lx", tcp->u_arg[4]);
else {
tprintf("{ flags=");
- if (!printflags(vxfs_flags, args.mflags))
- tprintf("0x%08x", args.mflags);
+ printflags(vxfs_flags, args.mflags, "VX_MS_???");
if (args.mflags & VX_MS_SNAPSHOT) {
tprintf (", snapof=");
printstr (tcp,
- (long) args.primaryspec,
+ (long) args.primaryspec,
-1);
if (args.snapsize > 0)
tprintf (", snapsize=%ld", args.snapsize);
printsock(tcp, (int) addr.buf, addr.len);
}
tprintf(", flags=");
- if (!printflags(nfs_flags, args.flags))
- tprintf("NFSMNT_???");
+ printflags(nfs_flags, args.flags, "NFSMNT_???");
tprintf(", hostname=");
printstr(tcp, (int) args.hostname, -1);
tprintf(", ...}");
#ifdef SYS_capget
-static struct xlat capabilities[] = {
+static const struct xlat capabilities[] = {
{ 1<<CAP_CHOWN, "CAP_CHOWN" },
{ 1<<CAP_DAC_OVERRIDE, "CAP_DAC_OVERRIDE"},
{ 1<<CAP_DAC_READ_SEARCH,"CAP_DAC_READ_SEARCH"},
{ 1<<CAP_SYS_RESOURCE, "CAP_SYS_RESOURCE"},
{ 1<<CAP_SYS_TIME, "CAP_SYS_TIME" },
{ 1<<CAP_SYS_TTY_CONFIG,"CAP_SYS_TTY_CONFIG"},
+#ifdef CAP_MKNOD
+ { 1<<CAP_MKNOD, "CAP_MKNOD" },
+#endif
+#ifdef CAP_LEASE
+ { 1<<CAP_LEASE, "CAP_LEASE" },
+#endif
+#ifdef CAP_AUDIT_WRITE
+ { 1<<CAP_AUDIT_WRITE, "CAP_AUDIT_WRITE"},
+#endif
+#ifdef CAP_AUDIT_CONTROL
+ { 1<<CAP_AUDIT_CONTROL, "CAP_AUDIT_CONTROL"},
+#endif
+#ifdef CAP_SETFCAP
+ { 1<<CAP_SETFCAP, "CAP_SETFCAP" },
+#endif
{ 0, NULL },
};
if(!entering(tcp)) {
if (!arg0) {
if ((arg0 = malloc(sizeof(*arg0))) == NULL) {
- fprintf(stderr, "sys_capget: no memory\n");
+ fprintf(stderr, "out of memory\n");
tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
return -1;
}
}
if (!arg1) {
if ((arg1 = malloc(sizeof(*arg1))) == NULL) {
- fprintf(stderr, "sys_capget: no memory\n");
+ fprintf(stderr, "out of memory\n");
tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
return -1;
}
tprintf("???");
else {
tprintf("{");
- printflags(capabilities, arg1->effective);
+ printflags(capabilities, arg1->effective, "CAP_???");
tprintf(", ");
- printflags(capabilities, arg1->permitted);
+ printflags(capabilities, arg1->permitted, "CAP_???");
tprintf(", ");
- printflags(capabilities, arg1->inheritable);
+ printflags(capabilities, arg1->inheritable, "CAP_???");
tprintf("}");
- }
+ }
}
return 0;
}
if(entering(tcp)) {
if (!arg0) {
if ((arg0 = malloc(sizeof(*arg0))) == NULL) {
- fprintf(stderr, "sys_capset: no memory\n");
+ fprintf(stderr, "out of memory\n");
tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
return -1;
}
}
if (!arg1) {
if ((arg1 = malloc(sizeof(*arg1))) == NULL) {
- fprintf(stderr, "sys_capset: no memory\n");
+ fprintf(stderr, "out of memory\n");
tprintf("%#lx, %#lx", tcp->u_arg[0], tcp->u_arg[1]);
return -1;
}
tprintf("???");
else {
tprintf("{");
- printflags(capabilities, arg1->effective);
+ printflags(capabilities, arg1->effective, "CAP_???");
tprintf(", ");
- printflags(capabilities, arg1->permitted);
+ printflags(capabilities, arg1->permitted, "CAP_???");
tprintf(", ");
- printflags(capabilities, arg1->inheritable);
+ printflags(capabilities, arg1->inheritable, "CAP_???");
tprintf("}");
- }
+ }
}
return 0;
}
#endif
#ifdef LINUX
-static struct xlat sysctl_root[] = {
+/* Linux 2.6.18+ headers removed CTL_PROC enum. */
+# define CTL_PROC 4
+# define CTL_CPU 10 /* older headers lack */
+static const struct xlat sysctl_root[] = {
{ CTL_KERN, "CTL_KERN" },
{ CTL_VM, "CTL_VM" },
{ CTL_NET, "CTL_NET" },
{ CTL_FS, "CTL_FS" },
{ CTL_DEBUG, "CTL_DEBUG" },
{ CTL_DEV, "CTL_DEV" },
+ { CTL_BUS, "CTL_BUS" },
+ { CTL_ABI, "CTL_ABI" },
+ { CTL_CPU, "CTL_CPU" },
{ 0, NULL }
};
-static struct xlat sysctl_kern[] = {
+static const struct xlat sysctl_kern[] = {
{ KERN_OSTYPE, "KERN_OSTYPE" },
{ KERN_OSRELEASE, "KERN_OSRELEASE" },
{ KERN_OSREV, "KERN_OSREV" },
{ 0, NULL }
};
-static struct xlat sysctl_vm[] = {
+static const struct xlat sysctl_vm[] = {
+#ifdef VM_SWAPCTL
{ VM_SWAPCTL, "VM_SWAPCTL" },
+#endif
+#ifdef VM_UNUSED1
+ { VM_UNUSED1, "VM_UNUSED1" },
+#endif
+#ifdef VM_SWAPOUT
{ VM_SWAPOUT, "VM_SWAPOUT" },
+#endif
+#ifdef VM_UNUSED2
+ { VM_UNUSED2, "VM_UNUSED2" },
+#endif
+#ifdef VM_FREEPG
{ VM_FREEPG, "VM_FREEPG" },
+#endif
+#ifdef VM_UNUSED3
+ { VM_UNUSED3, "VM_UNUSED3" },
+#endif
+#ifdef VM_BDFLUSH
{ VM_BDFLUSH, "VM_BDFLUSH" },
+#endif
+#ifdef VM_UNUSED4
+ { VM_UNUSED4, "VM_UNUSED4" },
+#endif
{ VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
+#ifdef VM_BUFFERMEM
{ VM_BUFFERMEM, "VM_BUFFERMEM" },
+#endif
+#ifdef VM_UNUSED5
+ { VM_UNUSED5, "VM_UNUSED5" },
+#endif
+#ifdef VM_PAGECACHE
{ VM_PAGECACHE, "VM_PAGECACHE" },
+#endif
+#ifdef VM_UNUSED7
+ { VM_UNUSED7, "VM_UNUSED7" },
+#endif
+#ifdef VM_PAGERDAEMON
{ VM_PAGERDAEMON, "VM_PAGERDAEMON" },
+#endif
+#ifdef VM_UNUSED8
+ { VM_UNUSED8, "VM_UNUSED8" },
+#endif
+#ifdef VM_PGT_CACHE
{ VM_PGT_CACHE, "VM_PGT_CACHE" },
+#endif
+#ifdef VM_UNUSED9
+ { VM_UNUSED9, "VM_UNUSED9" },
+#endif
{ VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
{ 0, NULL },
};
-static struct xlat sysctl_net[] = {
+static const struct xlat sysctl_net[] = {
{ NET_CORE, "NET_CORE" },
{ NET_ETHER, "NET_ETHER" },
{ NET_802, "NET_802" },
{ 0, NULL }
};
-static struct xlat sysctl_net_core[] = {
+static const struct xlat sysctl_net_core[] = {
{ NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
{ NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
{ NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
{ 0, NULL }
};
-static struct xlat sysctl_net_unix[] = {
+static const struct xlat sysctl_net_unix[] = {
{ NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
{ NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
{ 0, NULL }
};
-static struct xlat sysctl_net_ipv4[] = {
+static const struct xlat sysctl_net_ipv4[] = {
{ NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
{ NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
{ NET_IPV4_CONF, "NET_IPV4_CONF" },
{ 0, NULL }
};
-static struct xlat sysctl_net_ipv4_route[] = {
+static const struct xlat sysctl_net_ipv4_route[] = {
{ NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
{ NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
{ NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
{ 0, NULL }
};
-static struct xlat sysctl_net_ipv4_conf[] = {
+static const struct xlat sysctl_net_ipv4_conf[] = {
{ NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
{ NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
{ NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
{ 0, NULL }
};
-static struct xlat sysctl_net_ipv6[] = {
+static const struct xlat sysctl_net_ipv6[] = {
{ NET_IPV6_CONF, "NET_IPV6_CONF" },
{ NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
{ NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
{ 0, NULL }
};
-static struct xlat sysctl_net_ipv6_route[] = {
+static const struct xlat sysctl_net_ipv6_route[] = {
{ NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
{ NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
{ NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
{
struct __sysctl_args info;
int *name;
- umove (tcp, tcp->u_arg[0], &info);
-
- name = alloca (sizeof (int) * info.nlen);
- umoven(tcp, (size_t) info.name, sizeof (int) * info.nlen, (char *) name);
+ unsigned long size;
+
+ if (umove (tcp, tcp->u_arg[0], &info) < 0)
+ return printargs(tcp);
+
+ size = sizeof (int) * (unsigned long) info.nlen;
+ name = (size / sizeof (int) != info.nlen) ? NULL : malloc (size);
+ if (name == NULL ||
+ umoven(tcp, (unsigned long) info.name, size, (char *) name) < 0) {
+ free(name);
+ if (entering(tcp))
+ tprintf("{%p, %d, %p, %p, %p, %Zu}",
+ info.name, info.nlen, info.oldval,
+ info.oldlenp, info.newval, info.newlen);
+ return 0;
+ }
if (entering(tcp)) {
- int cnt = 0;
+ int cnt = 0, max_cnt;
tprintf("{{");
goto out;
}
out:
- while (cnt < info.nlen)
+ max_cnt = info.nlen;
+ if (abbrev(tcp) && max_cnt > max_strlen)
+ max_cnt = max_strlen;
+ while (cnt < max_cnt)
tprintf(", %x", name[cnt++]);
+ if (cnt < info.nlen)
+ tprintf(", ...");
tprintf("}, %d, ", info.nlen);
} else {
size_t oldlen;
- umove(tcp, (size_t)info.oldlenp, &oldlen);
- if (info.nlen >= 2
+ if (umove(tcp, (size_t)info.oldlenp, &oldlen) >= 0
+ && info.nlen >= 2
&& ((name[0] == CTL_KERN
&& (name[1] == KERN_OSRELEASE
|| name[1] == KERN_OSTYPE
}
tprintf("}");
}
+
+ free(name);
return 0;
}
#else
char ctl[1024];
size_t len;
int i, numeric;
-
+
if (entering(tcp)) {
if (tcp->u_arg[1] < 0 || tcp->u_arg[1] > CTL_MAXNAME ||
(umoven(tcp, tcp->u_arg[0], tcp->u_arg[1] * sizeof(int),
if (!syserror(tcp) && (umove(tcp, tcp->u_arg[3], &len) >= 0)) {
printstr(tcp, tcp->u_arg[2], len);
tprintf(", [%u], ", len);
- } else
+ } else
tprintf("%#lx, %#lx, ", tcp->u_arg[2], tcp->u_arg[3]);
printstr(tcp, tcp->u_arg[4], tcp->u_arg[5]);
tprintf(", %lu", tcp->u_arg[5]);
#include <sys/ksym.h>
#include <sys/elf.h>
-static struct xlat ksym_flags[] = {
- { STT_NOTYPE, "STT_NOTYPE" },
- { STT_FUNC, "STT_FUNC" },
- { STT_OBJECT, "STT_OBJECT" },
+static const struct xlat ksym_flags[] = {
+ { STT_NOTYPE, "STT_NOTYPE" },
+ { STT_FUNC, "STT_FUNC" },
+ { STT_OBJECT, "STT_OBJECT" },
{ 0, NULL },
};
return 0;
}
+#ifdef HAVE_SYS_NSCSYS_H
+
+struct cred;
+#include <sys/nscsys.h>
+
+static const struct xlat ssi_cmd [] = {
+ { SSISYS_BADOP, "SSISYS_BADOP" },
+ { SSISYS_LDLVL_INIT,"SSISYS_LDLVL_INIT"},
+ { SSISYS_LDLVL_GETVEC,"SSISYS_LDLVL_GETVEC"},
+ { SSISYS_LDLVL_PUTVEC,"SSISYS_LDLVL_PUTVEC"},
+ { SSISYS_LDLVL_PUTRCMDS,"SSISYS_LDLVL_PUTRCMDS"},
+ { SSISYS_LDLVL_SETREXEC,"SSISYS_LDLVL_SETREXEC"},
+ { SSISYS_CMS_CLUSTERID,"SSISYS_CMS_CLUSTERID"},
+ { SSISYS_CFS_STATVFS,"SSISYS_CFS_STATVFS"},
+ { SSISYS_NODE_GETNUM,"SSISYS_NODE_GETNUM"},
+ { SSISYS_NODE_TABLE,"SSISYS_NODE_TABLE"},
+ { SSISYS_NODE_DOWN,"SSISYS_NODE_DOWN"},
+ { SSISYS_RECLAIM_CHILD,"SSISYS_RECLAIM_CHILD"},
+ { SSISYS_IPC_GETINFO,"SSISYS_IPC_GETINFO"},
+ { SSISYS_ICS_TEST,"SSISYS_ICS_TEST"},
+ { SSISYS_NODE_PID,"SSISYS_NODE_PID"},
+ { SSISYS_ISLOCAL,"SSISYS_ISLOCAL"},
+ { SSISYS_CFS_ISSTACKED,"SSISYS_CFS_ISSTACKED"},
+ { SSISYS_DNET_SYNC,"SSISYS_DNET_SYNC"},
+ { SSISYS_CFS_WAIT_MODE,"SSISYS_CFS_WAIT_MODE"},
+ { SSISYS_CFS_UMOUNT,"SSISYS_CFS_UMOUNT"},
+ { SSISYS_LLSTAT,"SSISYS_LLSTAT" },
+ { SSISYS_LTS_PERFTEST,"SSISYS_LTS_PERFTEST"},
+ { SSISYS_LTS_CONFIG,"SSISYS_LTS_CONFIG"},
+ { SSISYS_SNET_PERFTEST,"SSISYS_SNET_PERFTEST"},
+ { SSISYS_IGNORE_HALFUP,"SSISYS_IGNORE_HALFUP"},
+ { SSISYS_NODE_ROOTDEV,"SSISYS_NODE_ROOTDEV"},
+ { SSISYS_GET_PRIMARY,"SSISYS_GET_PRIMARY"},
+ { SSISYS_GET_SECONDARY,"SSISYS_GET_SECONDARY"},
+ { SSISYS_GET_ROOTDISK,"SSISYS_GET_ROOTDISK"},
+ { SSISYS_CLUSTERNODE_NUM,"SSISYS_CLUSTERNODE_NUM"},
+ { SSISYS_CLUSTER_MEMBERSHIP,"SSISYS_CLUSTER_MEMBERSHIP"},
+ { SSISYS_CLUSTER_DETAILEDTRANS,"SSISYS_CLUSTER_DETAILEDTRANS"},
+ { SSISYS_CLUSTERNODE_INFO,"SSISYS_CLUSTERNODE_INFO"},
+ { SSISYS_CLUSTERNODE_SETINFO,"SSISYS_CLUSTERNODE_SETINFO"},
+ { SSISYS_CLUSTERNODE_AVAIL,"SSISYS_CLUSTERNODE_AVAIL"},
+ { SSISYS_CLUSTER_MAXNODES,"SSISYS_CLUSTER_MAXNODES"},
+ { SSISYS_SET_MEMPRIO,"SSISYS_SET_MEMPRIO"},
+ { SSISYS_GET_USERS,"SSISYS_GET_USERS"},
+ { SSISYS_FORCE_ROOT_NODE,"SSISYS_FORCE_ROOT_NODE"},
+ { SSISYS_CVIP_SET,"SSISYS_CVIP_SET"},
+ { SSISYS_CVIP_GET,"SSISYS_CVIP_GET"},
+ { SSISYS_GET_NODE_COUNTS,"SSISYS_GET_NODE_COUNTS"},
+ { SSISYS_GET_TRANSPORT,"SSISYS_GET_TRANSPORT"},
+ { 0, NULL },
+};
+
+int sys_ssisys (tcp)
+struct tcb *tcp;
+{
+ struct ssisys_iovec iov;
+ cls_nodeinfo_args_t cni;
+ clusternode_info_t info;
+
+ if (entering (tcp)) {
+ ts_reclaim_child_inargs_t trc;
+ if (tcp->u_arg[1] != sizeof iov ||
+ umove (tcp, tcp->u_arg[0], &iov) < 0)
+ {
+ tprintf ("%#lx, %ld", tcp->u_arg[0], tcp->u_arg[1]);
+ return 0;
+ }
+ tprintf ("{id=");
+ printxval(ssi_cmd, iov.tio_id.id_cmd, "SSISYS_???");
+ tprintf (":%d", iov.tio_id.id_ver);
+ switch (iov.tio_id.id_cmd) {
+ case SSISYS_RECLAIM_CHILD:
+ if (iov.tio_udatainlen != sizeof trc ||
+ umove (tcp, (long) iov.tio_udatain, &trc) < 0)
+ goto bad;
+ tprintf (", in={pid=%ld, start=%ld}",
+ trc.trc_pid, trc.trc_start);
+ break;
+ case SSISYS_CLUSTERNODE_INFO:
+ if (iov.tio_udatainlen != sizeof cni ||
+ umove (tcp, (long) iov.tio_udatain, &cni) < 0)
+ goto bad;
+ tprintf (", in={node=%ld, len=%d}",
+ cni.nodenum, cni.info_len);
+ break;
+ default:
+ bad:
+ if (iov.tio_udatainlen) {
+ tprintf (", in=[/* %d bytes */]",
+ iov.tio_udatainlen);
+ }
+ }
+ }
+ else {
+ if (tcp->u_arg[1] != sizeof iov ||
+ umove (tcp, tcp->u_arg[0], &iov) < 0)
+ goto done;
+ switch (iov.tio_id.id_cmd) {
+ case SSISYS_CLUSTERNODE_INFO:
+ if (iov.tio_udatainlen != sizeof cni ||
+ umove (tcp, (long) iov.tio_udatain, &cni) < 0)
+ goto bad_out;
+ if (cni.info_len != sizeof info ||
+ iov.tio_udataoutlen != sizeof &info ||
+ umove (tcp, (long) iov.tio_udataout, &info) < 0)
+ goto bad_out;
+ tprintf (", out={node=%ld, cpus=%d, online=%d}",
+ info.node_num, info.node_totalcpus,
+ info.node_onlinecpus);
+ break;
+
+ default:
+ bad_out:
+ if (iov.tio_udataoutlen) {
+ tprintf (", out=[/* %d bytes */]",
+ iov.tio_udataoutlen);
+ }
+ }
+ done:
+ tprintf ("}, %ld", tcp->u_arg[1]);
+ }
+ return 0;
+}
+
+#endif
+
#endif /* UNIXWARE > 2 */
#ifdef MIPS
#define __NEW_UTS_LEN 64
#endif
-static struct xlat xlat_sysmips[] = {
+static const struct xlat sysmips_operations[] = {
{ SETNAME, "SETNAME" },
{ FLUSH_CACHE, "FLUSH_CACHE" },
{ MIPS_FIXADE, "MIPS_FIXADE" },
struct tcb *tcp;
{
if (entering(tcp)) {
- printxval(xlat_sysmips, tcp->u_arg[0], "???");
+ printxval(sysmips_operations, tcp->u_arg[0], "???");
if (!verbose(tcp)) {
- tprintf("%d, %d, %d", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
+ tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
} else if (tcp->u_arg[0]==SETNAME) {
- char nodename[__NEW_UTS_LEN+1];
- if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN+1), nodename) < 0)
+ char nodename[__NEW_UTS_LEN + 1];
+ if (umovestr(tcp, tcp->u_arg[1], (__NEW_UTS_LEN + 1), nodename) < 0)
tprintf(", %#lx", tcp->u_arg[1]);
else
tprintf(", \"%s\"", nodename);
- } else if (tcp->u_arg[0]==MIPS_ATOMIC_SET) {
- tprintf(", %#lx, 0x%x", tcp->u_arg[1], tcp->u_arg[2]);
- } else if (tcp->u_arg[0]==MIPS_FIXADE) {
- tprintf(", 0x%x", tcp->u_arg[1]);
+ } else if (tcp->u_arg[0] == MIPS_ATOMIC_SET) {
+ tprintf(", %#lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]);
+ } else if (tcp->u_arg[0] == MIPS_FIXADE) {
+ tprintf(", 0x%lx", tcp->u_arg[1]);
} else {
- tprintf("%d, %d, %d", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
+ tprintf("%ld, %ld, %ld", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]);
}
}
projects / strace / blobdiff