diff options
47 files changed, 2725 insertions, 1134 deletions
diff --git a/Makefile.inc1 b/Makefile.inc1 index 6d96cea..ccc6fb1 100644 --- a/Makefile.inc1 +++ b/Makefile.inc1 @@ -655,9 +655,6 @@ _worldtmp: .PHONY .endif .else rm -rf ${WORLDTMP}/legacy/usr/include -# XXX - These can depend on any header file. - rm -f ${OBJTREE}${.CURDIR}/lib/libsysdecode/ioctl.c - rm -f ${OBJTREE}${.CURDIR}/usr.bin/kdump/kdump_subr.c .endif .for _dir in \ lib lib/casper usr legacy/bin legacy/usr diff --git a/ObsoleteFiles.inc b/ObsoleteFiles.inc index d895c89..7e365c4 100644 --- a/ObsoleteFiles.inc +++ b/ObsoleteFiles.inc @@ -38,6 +38,8 @@ # xargs -n1 | sort | uniq -d; # done +# 20170112: sysdecode_getfsstat_flags() renamed to sysdecode_getfsstat_mode() +OLD_FILES+=usr/share/man/man3/sysdecode_getfsstat_flags.3.gz # 20161217: new clang import which bumps version from 3.9.0 to 3.9.1. OLD_FILES+=usr/lib/clang/3.9.0/include/sanitizer/allocator_interface.h OLD_FILES+=usr/lib/clang/3.9.0/include/sanitizer/asan_interface.h diff --git a/lib/libsysdecode/Makefile b/lib/libsysdecode/Makefile index 123ea49..47ba9af 100644 --- a/lib/libsysdecode/Makefile +++ b/lib/libsysdecode/Makefile @@ -5,20 +5,94 @@ PACKAGE=lib${LIB} LIB= sysdecode -SRCS= errno.c ioctl.c syscallnames.c utrace.c +SRCS= errno.c flags.c ioctl.c signal.c syscallnames.c utrace.c INCS= sysdecode.h +CFLAGS+= -I${.OBJDIR} CFLAGS+= -I${.CURDIR}/../../sys CFLAGS+= -I${.CURDIR}/../../libexec/rtld-elf -MAN+= sysdecode.3 \ +MAN= sysdecode.3 \ sysdecode_abi_to_freebsd_errno.3 \ + sysdecode_cap_rights.3 \ + sysdecode_enum.3 \ + sysdecode_fcntl_arg.3 \ sysdecode_ioctlname.3 \ + sysdecode_mask.3 \ + sysdecode_quotactl_cmd.3 \ + sysdecode_sigcode.3 \ + sysdecode_sockopt_name.3 \ sysdecode_syscallnames.3 \ sysdecode_utrace.3 -MLINKS+= sysdecode_abi_to_freebsd_errno.3 sysdecode_freebsd_to_abi_errno.3 +MLINKS= sysdecode_abi_to_freebsd_errno.3 sysdecode_freebsd_to_abi_errno.3 +MLINKS+=sysdecode_enum.3 sysdecode_acltype.3 \ + sysdecode_enum.3 sysdecode_atfd.3 \ + sysdecode_enum.3 sysdecode_extattrnamespace.3 \ + sysdecode_enum.3 sysdecode_fadvice.3 \ + sysdecode_enum.3 sysdecode_fcntl_cmd.3 \ + sysdecode_enum.3 sysdecode_getfsstat_mode.3 \ + sysdecode_enum.3 sysdecode_idtype.3 \ + sysdecode_enum.3 sysdecode_ipproto.3 \ + sysdecode_enum.3 sysdecode_kldsym_cmd.3 \ + sysdecode_enum.3 sysdecode_kldunload_flags.3 \ + sysdecode_enum.3 sysdecode_lio_listio_mode.3 \ + sysdecode_enum.3 sysdecode_madvice.3 \ + sysdecode_enum.3 sysdecode_minherit_flags.3 \ + sysdecode_enum.3 sysdecode_msgctl_cmd.3 \ + sysdecode_enum.3 sysdecode_nfssvc_flags.3 \ + sysdecode_enum.3 sysdecode_prio_which.3 \ + sysdecode_enum.3 sysdecode_procctl_cmd.3 \ + sysdecode_enum.3 sysdecode_ptrace_request.3 \ + sysdecode_enum.3 sysdecode_rlimit.3 \ + sysdecode_enum.3 sysdecode_rtprio_function.3 \ + sysdecode_enum.3 sysdecode_scheduler_policy.3 \ + sysdecode_enum.3 sysdecode_semctl_cmd.3 \ + sysdecode_enum.3 sysdecode_shmctl_cmd.3 \ + sysdecode_enum.3 sysdecode_shutdown_how.3 \ + sysdecode_enum.3 sysdecode_sigbus_code.3 \ + sysdecode_enum.3 sysdecode_sigchld_code.3 \ + sysdecode_enum.3 sysdecode_sigfpe_code.3 \ + sysdecode_enum.3 sysdecode_sigill_code.3 \ + sysdecode_enum.3 sysdecode_signal.3 \ + sysdecode_enum.3 sysdecode_sigprocmask_how.3 \ + sysdecode_enum.3 sysdecode_sigsegv_code.3 \ + sysdecode_enum.3 sysdecode_sigtrap_code.3 \ + sysdecode_enum.3 sysdecode_sockaddr_family.3 \ + sysdecode_enum.3 sysdecode_socketdomain.3 \ + sysdecode_enum.3 sysdecode_sockettype.3 \ + sysdecode_enum.3 sysdecode_sockopt_level.3 \ + sysdecode_enum.3 sysdecode_umtx_op.3 \ + sysdecode_enum.3 sysdecode_vmresult.3 \ + sysdecode_enum.3 sysdecode_whence.3 +MLINKS+=sysdecode_fcntl_arg.3 sysdecode_fcntl_arg_p.3 +MLINKS+=sysdecode_mask.3 sysdecode_accessmode.3 \ + sysdecode_mask.3 sysdecode_capfcntlrights.3 \ + sysdecode_mask.3 sysdecode_fcntl_fileflags.3 \ + sysdecode_mask.3 sysdecode_fileflags.3 \ + sysdecode_mask.3 sysdecode_filemode.3 \ + sysdecode_mask.3 sysdecode_flock_operation.3 \ + sysdecode_mask.3 sysdecode_mlockall_flags.3 \ + sysdecode_mask.3 sysdecode_mmap_flags.3 \ + sysdecode_mask.3 sysdecode_mmap_prot.3 \ + sysdecode_mask.3 sysdecode_mount_flags.3 \ + sysdecode_mask.3 sysdecode_msg_flags.3 \ + sysdecode_mask.3 sysdecode_msync_flags.3 \ + sysdecode_mask.3 sysdecode_open_flags.3 \ + sysdecode_mask.3 sysdecode_pipe2_flags.3 \ + sysdecode_mask.3 sysdecode_reboot_howto.3 \ + sysdecode_mask.3 sysdecode_rfork_flags.3 \ + sysdecode_mask.3 sysdecode_semget_flags.3 \ + sysdecode_mask.3 sysdecode_sendfile_flags.3 \ + sysdecode_mask.3 sysdecode_shmat_flags.3 \ + sysdecode_mask.3 sysdecode_socket_type.3 \ + sysdecode_mask.3 sysdecode_thr_create_flags.3 \ + sysdecode_mask.3 sysdecode_umtx_cvwait_flags.3 \ + sysdecode_mask.3 sysdecode_umtx_rwlock_flags.3 \ + sysdecode_mask.3 sysdecode_vmprot.3 \ + sysdecode_mask.3 sysdecode_wait4_options.3 \ + sysdecode_mask.3 sysdecode_wait6_options.3 -CLEANFILES= ioctl.c +CLEANFILES= ioctl.c tables.h .if defined(COMPAT_32BIT) CPP+= -m32 @@ -36,10 +110,19 @@ CFLAGS.gcc.ioctl.c+= -Wno-unused CFLAGS.gcc+= ${CFLAGS.gcc.${.IMPSRC}} -ioctl.c: mkioctls +DEPENDOBJS+= tables.h +tables.h: mktables + sh ${.CURDIR}/mktables ${DESTDIR}${INCLUDEDIR} ${.TARGET} + +# mkioctls runs find(1) for headers so needs to rebuild every time. This used +# to be a hack only done in buildworld. +.if !defined(_SKIP_BUILD) +ioctl.c: .PHONY +.endif +ioctl.c: mkioctls .META env MACHINE=${MACHINE} CPP="${CPP}" \ /bin/sh ${.CURDIR}/mkioctls ${DESTDIR}${INCLUDEDIR} > ${.TARGET} -beforedepend: ioctl.c +beforedepend: ioctl.c tables.h .include <bsd.lib.mk> diff --git a/lib/libsysdecode/errno.c b/lib/libsysdecode/errno.c index c21d216..9f404e0 100644 --- a/lib/libsysdecode/errno.c +++ b/lib/libsysdecode/errno.c @@ -28,8 +28,11 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> +#include <sys/acl.h> +#include <sys/wait.h> #include <errno.h> #include <limits.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/lib/libsysdecode/flags.c b/lib/libsysdecode/flags.c new file mode 100644 index 0000000..bb8aa58 --- /dev/null +++ b/lib/libsysdecode/flags.c @@ -0,0 +1,986 @@ +/* + * Copyright (c) 2006 "David Kirchner" <dpk@dpk.net>. 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#define L2CAP_SOCKET_CHECKED + +#include <sys/types.h> +#include <sys/acl.h> +#include <sys/capsicum.h> +#include <sys/extattr.h> +#include <sys/linker.h> +#include <sys/mman.h> +#include <sys/mount.h> +#include <sys/procctl.h> +#include <sys/ptrace.h> +#include <sys/reboot.h> +#include <sys/resource.h> +#include <sys/rtprio.h> +#include <sys/sem.h> +#include <sys/shm.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/thr.h> +#include <sys/umtx.h> +#include <netinet/in.h> +#include <netinet/tcp.h> +#include <netinet/udp.h> +#include <nfsserver/nfs.h> +#include <ufs/ufs/quota.h> +#include <vm/vm_param.h> +#include <aio.h> +#include <fcntl.h> +#include <sched.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <strings.h> +#include <sysdecode.h> +#include <unistd.h> +#include <sys/bitstring.h> +#include <netgraph/bluetooth/include/ng_hci.h> +#include <netgraph/bluetooth/include/ng_l2cap.h> +#include <netgraph/bluetooth/include/ng_btsocket.h> + +/* + * This is taken from the xlat tables originally in truss which were + * in turn taken from strace. + */ +struct name_table { + uintmax_t val; + const char *str; +}; + +#define X(a) { a, #a }, +#define XEND { 0, NULL } + +#define TABLE_START(n) static struct name_table n[] = { +#define TABLE_ENTRY X +#define TABLE_END XEND }; + +#include "tables.h" + +#undef TABLE_START +#undef TABLE_ENTRY +#undef TABLE_END + +/* + * These are simple support macros. print_or utilizes a variable + * defined in the calling function to track whether or not it should + * print a logical-OR character ('|') before a string. if_print_or + * simply handles the necessary "if" statement used in many lines + * of this file. + */ +#define print_or(fp,str,orflag) do { \ + if (orflag) fputc(fp, '|'); else orflag = true; \ + fprintf(fp, str); } \ + while (0) +#define if_print_or(fp,i,flag,orflag) do { \ + if ((i & flag) == flag) \ + print_or(fp,#flag,orflag); } \ + while (0) + +static const char * +lookup_value(struct name_table *table, uintmax_t val) +{ + + for (; table->str != NULL; table++) + if (table->val == val) + return (table->str); + return (NULL); +} + +/* + * Used when the value maps to a bitmask of #definition values in the + * table. This is a helper routine which outputs a symbolic mask of + * matched masks. Multiple masks are separated by a pipe ('|'). + * The value is modified on return to only hold unmatched bits. + */ +static void +print_mask_part(FILE *fp, struct name_table *table, uintmax_t *valp, + bool *printed) +{ + uintmax_t rem; + + rem = *valp; + for (; table->str != NULL; table++) { + if ((table->val & rem) == table->val) { + /* + * Only print a zero mask if the raw value is + * zero. + */ + if (table->val == 0 && *valp != 0) + continue; + fprintf(fp, "%s%s", *printed ? "|" : "", table->str); + *printed = true; + rem &= ~table->val; + } + } + + *valp = rem; +} + +/* + * Used when the value maps to a bitmask of #definition values in the + * table. The return value is true if something was printed. If + * rem is not NULL, *rem holds any bits not decoded if something was + * printed. If nothing was printed and rem is not NULL, *rem holds + * the original value. + */ +static bool +print_mask_int(FILE *fp, struct name_table *table, int ival, int *rem) +{ + uintmax_t val; + bool printed; + + printed = false; + val = (unsigned)ival; + print_mask_part(fp, table, &val, &printed); + if (rem != NULL) + *rem = val; + return (printed); +} + +/* + * Used for a mask of optional flags where a value of 0 is valid. + */ +static bool +print_mask_0(FILE *fp, struct name_table *table, int val, int *rem) +{ + + if (val == 0) { + fputs("0", fp); + if (rem != NULL) + *rem = 0; + return (true); + } + return (print_mask_int(fp, table, val, rem)); +} + +/* + * Like print_mask_0 but for a unsigned long instead of an int. + */ +static bool +print_mask_0ul(FILE *fp, struct name_table *table, u_long lval, u_long *rem) +{ + uintmax_t val; + bool printed; + + if (lval == 0) { + fputs("0", fp); + if (rem != NULL) + *rem = 0; + return (true); + } + + printed = false; + val = lval; + print_mask_part(fp, table, &val, &printed); + if (rem != NULL) + *rem = val; + return (printed); +} + +static void +print_integer(FILE *fp, int val, int base) +{ + + switch (base) { + case 8: + fprintf(fp, "0%o", val); + break; + case 10: + fprintf(fp, "%d", val); + break; + case 16: + fprintf(fp, "0x%x", val); + break; + default: + abort2("bad base", 0, NULL); + break; + } +} + +static bool +print_value(FILE *fp, struct name_table *table, uintmax_t val) +{ + const char *str; + + str = lookup_value(table, val); + if (str != NULL) { + fputs(str, fp); + return (true); + } + return (false); +} + +const char * +sysdecode_atfd(int fd) +{ + + if (fd == AT_FDCWD) + return ("AT_FDCWD"); + return (NULL); +} + +static struct name_table semctlops[] = { + X(GETNCNT) X(GETPID) X(GETVAL) X(GETALL) X(GETZCNT) X(SETVAL) X(SETALL) + X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND +}; + +const char * +sysdecode_semctl_cmd(int cmd) +{ + + return (lookup_value(semctlops, cmd)); +} + +static struct name_table shmctlops[] = { + X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND +}; + +const char * +sysdecode_shmctl_cmd(int cmd) +{ + + return (lookup_value(shmctlops, cmd)); +} + +const char * +sysdecode_msgctl_cmd(int cmd) +{ + + return (sysdecode_shmctl_cmd(cmd)); +} + +static struct name_table semgetflags[] = { + X(IPC_CREAT) X(IPC_EXCL) X(SEM_R) X(SEM_A) X((SEM_R>>3)) X((SEM_A>>3)) + X((SEM_R>>6)) X((SEM_A>>6)) XEND +}; + +bool +sysdecode_semget_flags(FILE *fp, int flag, int *rem) +{ + + return (print_mask_int(fp, semgetflags, flag, rem)); +} + +static struct name_table idtypes[] = { + X(P_PID) X(P_PPID) X(P_PGID) X(P_SID) X(P_CID) X(P_UID) X(P_GID) + X(P_ALL) X(P_LWPID) X(P_TASKID) X(P_PROJID) X(P_POOLID) X(P_JAILID) + X(P_CTID) X(P_CPUID) X(P_PSETID) XEND +}; + +/* XXX: idtype is really an idtype_t */ +const char * +sysdecode_idtype(int idtype) +{ + + return (lookup_value(idtypes, idtype)); +} + +/* + * [g|s]etsockopt's level argument can either be SOL_SOCKET or a + * protocol-specific value. + */ +const char * +sysdecode_sockopt_level(int level) +{ + const char *str; + + if (level == SOL_SOCKET) + return ("SOL_SOCKET"); + + /* SOL_* constants for Bluetooth sockets. */ + str = lookup_value(ngbtsolevel, level); + if (str != NULL) + return (str); + + /* + * IP and Infiniband sockets use IP protocols as levels. Not all + * protocols are valid but it is simpler to just allow all of them. + * + * XXX: IPPROTO_IP == 0, but UNIX domain sockets use a level of 0 + * for private options. + */ + str = sysdecode_ipproto(level); + if (str != NULL) + return (str); + + return (NULL); +} + +bool +sysdecode_vmprot(FILE *fp, int type, int *rem) +{ + + return (print_mask_int(fp, vmprot, type, rem)); +} + +static struct name_table sockflags[] = { + X(SOCK_CLOEXEC) X(SOCK_NONBLOCK) XEND +}; + +bool +sysdecode_socket_type(FILE *fp, int type, int *rem) +{ + const char *str; + uintmax_t val; + bool printed; + + str = lookup_value(socktype, type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)); + if (str != NULL) { + fputs(str, fp); + *rem = 0; + printed = true; + } else { + *rem = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK); + printed = false; + } + val = type & (SOCK_CLOEXEC | SOCK_NONBLOCK); + print_mask_part(fp, sockflags, &val, &printed); + return (printed); +} + +bool +sysdecode_access_mode(FILE *fp, int mode, int *rem) +{ + + return (print_mask_int(fp, accessmode, mode, rem)); +} + +/* XXX: 'type' is really an acl_type_t. */ +const char * +sysdecode_acltype(int type) +{ + + return (lookup_value(acltype, type)); +} + +bool +sysdecode_cap_fcntlrights(FILE *fp, uint32_t rights, uint32_t *rem) +{ + + return (print_mask_int(fp, capfcntl, rights, rem)); +} + +const char * +sysdecode_extattrnamespace(int namespace) +{ + + return (lookup_value(extattrns, namespace)); +} + +const char * +sysdecode_fadvice(int advice) +{ + + return (lookup_value(fadvisebehav, advice)); +} + +bool +sysdecode_open_flags(FILE *fp, int flags, int *rem) +{ + bool printed; + int mode; + uintmax_t val; + + mode = flags & O_ACCMODE; + flags &= ~O_ACCMODE; + switch (mode) { + case O_RDONLY: + if (flags & O_EXEC) { + flags &= ~O_EXEC; + fputs("O_EXEC", fp); + } else + fputs("O_RDONLY", fp); + printed = true; + mode = 0; + break; + case O_WRONLY: + fputs("O_WRONLY", fp); + printed = true; + mode = 0; + break; + case O_RDWR: + fputs("O_RDWR", fp); + printed = true; + mode = 0; + break; + default: + printed = false; + } + val = (unsigned)flags; + print_mask_part(fp, openflags, &val, &printed); + if (rem != NULL) + *rem = val | mode; + return (printed); +} + +bool +sysdecode_fcntl_fileflags(FILE *fp, int flags, int *rem) +{ + bool printed; + int oflags; + + /* + * The file flags used with F_GETFL/F_SETFL mostly match the + * flags passed to open(2). However, a few open-only flag + * bits have been repurposed for fcntl-only flags. + */ + oflags = flags & ~(O_NOFOLLOW | FRDAHEAD); + printed = sysdecode_open_flags(fp, oflags, rem); + if (flags & O_NOFOLLOW) { + fprintf(fp, "%sFPOIXSHM", printed ? "|" : ""); + printed = true; + } + if (flags & FRDAHEAD) { + fprintf(fp, "%sFRDAHEAD", printed ? "|" : ""); + printed = true; + } + return (printed); +} + +bool +sysdecode_flock_operation(FILE *fp, int operation, int *rem) +{ + + return (print_mask_int(fp, flockops, operation, rem)); +} + +static struct name_table getfsstatmode[] = { + X(MNT_WAIT) X(MNT_NOWAIT) XEND +}; + +const char * +sysdecode_getfsstat_mode(int mode) +{ + + return (lookup_value(getfsstatmode, mode)); +} + +const char * +sysdecode_kldsym_cmd(int cmd) +{ + + return (lookup_value(kldsymcmd, cmd)); +} + +const char * +sysdecode_kldunload_flags(int flags) +{ + + return (lookup_value(kldunloadfflags, flags)); +} + +const char * +sysdecode_lio_listio_mode(int mode) +{ + + return (lookup_value(lio_listiomodes, mode)); +} + +const char * +sysdecode_madvice(int advice) +{ + + return (lookup_value(madvisebehav, advice)); +} + +const char * +sysdecode_minherit_inherit(int inherit) +{ + + return (lookup_value(minheritflags, inherit)); +} + +bool +sysdecode_mlockall_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, mlockallflags, flags, rem)); +} + +bool +sysdecode_mmap_prot(FILE *fp, int prot, int *rem) +{ + + return (print_mask_int(fp, mmapprot, prot, rem)); +} + +bool +sysdecode_fileflags(FILE *fp, fflags_t flags, fflags_t *rem) +{ + + return (print_mask_0(fp, fileflags, flags, rem)); +} + +bool +sysdecode_filemode(FILE *fp, int mode, int *rem) +{ + + return (print_mask_0(fp, filemode, mode, rem)); +} + +bool +sysdecode_mount_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, mountflags, flags, rem)); +} + +bool +sysdecode_msync_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, msyncflags, flags, rem)); +} + +const char * +sysdecode_nfssvc_flags(int flags) +{ + + return (lookup_value(nfssvcflags, flags)); +} + +static struct name_table pipe2flags[] = { + X(O_CLOEXEC) X(O_NONBLOCK) XEND +}; + +bool +sysdecode_pipe2_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_0(fp, pipe2flags, flags, rem)); +} + +const char * +sysdecode_prio_which(int which) +{ + + return (lookup_value(prio, which)); +} + +const char * +sysdecode_procctl_cmd(int cmd) +{ + + return (lookup_value(procctlcmd, cmd)); +} + +const char * +sysdecode_ptrace_request(int request) +{ + + return (lookup_value(ptraceop, request)); +} + +static struct name_table quotatypes[] = { + X(GRPQUOTA) X(USRQUOTA) XEND +}; + +bool +sysdecode_quotactl_cmd(FILE *fp, int cmd) +{ + const char *primary, *type; + + primary = lookup_value(quotactlcmds, cmd >> SUBCMDSHIFT); + if (primary == NULL) + return (false); + fprintf(fp, "QCMD(%s,", primary); + type = lookup_value(quotatypes, cmd & SUBCMDMASK); + if (type != NULL) + fprintf(fp, "%s", type); + else + fprintf(fp, "%#x", cmd & SUBCMDMASK); + fprintf(fp, ")"); + return (true); +} + +bool +sysdecode_reboot_howto(FILE *fp, int howto, int *rem) +{ + + return (print_mask_int(fp, rebootopt, howto, rem)); +} + +bool +sysdecode_rfork_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, rforkflags, flags, rem)); +} + +const char * +sysdecode_rlimit(int resource) +{ + + return (lookup_value(rlimit, resource)); +} + +const char * +sysdecode_scheduler_policy(int policy) +{ + + return (lookup_value(schedpolicy, policy)); +} + +bool +sysdecode_sendfile_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, sendfileflags, flags, rem)); +} + +bool +sysdecode_shmat_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, shmatflags, flags, rem)); +} + +const char * +sysdecode_shutdown_how(int how) +{ + + return (lookup_value(shutdownhow, how)); +} + +const char * +sysdecode_sigbus_code(int si_code) +{ + + return (lookup_value(sigbuscode, si_code)); +} + +const char * +sysdecode_sigchld_code(int si_code) +{ + + return (lookup_value(sigchldcode, si_code)); +} + +const char * +sysdecode_sigfpe_code(int si_code) +{ + + return (lookup_value(sigfpecode, si_code)); +} + +const char * +sysdecode_sigill_code(int si_code) +{ + + return (lookup_value(sigillcode, si_code)); +} + +const char * +sysdecode_sigsegv_code(int si_code) +{ + + return (lookup_value(sigsegvcode, si_code)); +} + +const char * +sysdecode_sigtrap_code(int si_code) +{ + + return (lookup_value(sigtrapcode, si_code)); +} + +const char * +sysdecode_sigprocmask_how(int how) +{ + + return (lookup_value(sigprocmaskhow, how)); +} + +const char * +sysdecode_socketdomain(int domain) +{ + + return (lookup_value(sockdomain, domain)); +} + +const char * +sysdecode_sockaddr_family(int sa_family) +{ + + return (lookup_value(sockfamily, sa_family)); +} + +const char * +sysdecode_ipproto(int protocol) +{ + + return (lookup_value(sockipproto, protocol)); +} + +const char * +sysdecode_sockopt_name(int level, int optname) +{ + + if (level == SOL_SOCKET) + return (lookup_value(sockopt, optname)); + if (level == IPPROTO_IP) + /* XXX: UNIX domain socket options use a level of 0 also. */ + return (lookup_value(sockoptip, optname)); + if (level == IPPROTO_TCP) + return (lookup_value(sockopttcp, optname)); + if (level == IPPROTO_UDP) + return (lookup_value(sockoptudp, optname)); + return (NULL); +} + +bool +sysdecode_thr_create_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, thrcreateflags, flags, rem)); +} + +const char * +sysdecode_umtx_op(int op) +{ + + return (lookup_value(umtxop, op)); +} + +const char * +sysdecode_vmresult(int result) +{ + + return (lookup_value(vmresult, result)); +} + +bool +sysdecode_wait4_options(FILE *fp, int options, int *rem) +{ + bool printed; + int opt6; + + /* A flags value of 0 is normal. */ + if (options == 0) { + fputs("0", fp); + if (rem != NULL) + *rem = 0; + return (true); + } + + /* + * These flags are implicit and aren't valid flags for wait4() + * directly (though they don't fail with EINVAL). + */ + opt6 = options & (WEXITED | WTRAPPED); + options &= ~opt6; + printed = print_mask_int(fp, wait6opt, options, rem); + if (rem != NULL) + *rem |= opt6; + return (printed); +} + +bool +sysdecode_wait6_options(FILE *fp, int options, int *rem) +{ + + return (print_mask_int(fp, wait6opt, options, rem)); +} + +const char * +sysdecode_whence(int whence) +{ + + return (lookup_value(seekwhence, whence)); +} + +const char * +sysdecode_fcntl_cmd(int cmd) +{ + + return (lookup_value(fcntlcmd, cmd)); +} + +static struct name_table fcntl_fd_arg[] = { + X(FD_CLOEXEC) X(0) XEND +}; + +bool +sysdecode_fcntl_arg_p(int cmd) +{ + + switch (cmd) { + case F_GETFD: + case F_GETFL: + case F_GETOWN: + return (false); + default: + return (true); + } +} + +void +sysdecode_fcntl_arg(FILE *fp, int cmd, uintptr_t arg, int base) +{ + int rem; + + switch (cmd) { + case F_SETFD: + if (!print_value(fp, fcntl_fd_arg, arg)) + print_integer(fp, arg, base); + break; + case F_SETFL: + if (!sysdecode_fcntl_fileflags(fp, arg, &rem)) + fprintf(fp, "%#x", rem); + else if (rem != 0) + fprintf(fp, "|%#x", rem); + break; + case F_GETLK: + case F_SETLK: + case F_SETLKW: + fprintf(fp, "%p", (void *)arg); + break; + default: + print_integer(fp, arg, base); + break; + } +} + +bool +sysdecode_mmap_flags(FILE *fp, int flags, int *rem) +{ + uintmax_t val; + bool printed; + int align; + + /* + * MAP_ALIGNED can't be handled directly by print_mask_int(). + * MAP_32BIT is also problematic since it isn't defined for + * all platforms. + */ + printed = false; + align = flags & MAP_ALIGNMENT_MASK; + val = (unsigned)flags & ~MAP_ALIGNMENT_MASK; + print_mask_part(fp, mmapflags, &val, &printed); +#ifdef MAP_32BIT + if (val & MAP_32BIT) { + fprintf(fp, "%sMAP_32BIT", printed ? "|" : ""); + printed = true; + val &= ~MAP_32BIT; + } +#endif + if (align != 0) { + if (printed) + fputc('|', fp); + if (align == MAP_ALIGNED_SUPER) + fputs("MAP_ALIGNED_SUPER", fp); + else + fprintf(fp, "MAP_ALIGNED(%d)", + align >> MAP_ALIGNMENT_SHIFT); + printed = true; + } + if (rem != NULL) + *rem = val; + return (printed); +} + +const char * +sysdecode_rtprio_function(int function) +{ + + return (lookup_value(rtpriofuncs, function)); +} + +bool +sysdecode_msg_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_0(fp, msgflags, flags, rem)); +} + +const char * +sysdecode_sigcode(int sig, int si_code) +{ + const char *str; + + str = lookup_value(sigcode, si_code); + if (str != NULL) + return (str); + + switch (sig) { + case SIGILL: + return (sysdecode_sigill_code(si_code)); + case SIGBUS: + return (sysdecode_sigbus_code(si_code)); + case SIGSEGV: + return (sysdecode_sigsegv_code(si_code)); + case SIGFPE: + return (sysdecode_sigfpe_code(si_code)); + case SIGTRAP: + return (sysdecode_sigtrap_code(si_code)); + case SIGCHLD: + return (sysdecode_sigchld_code(si_code)); + default: + return (NULL); + } +} + +bool +sysdecode_umtx_cvwait_flags(FILE *fp, u_long flags, u_long *rem) +{ + + return (print_mask_0ul(fp, umtxcvwaitflags, flags, rem)); +} + +bool +sysdecode_umtx_rwlock_flags(FILE *fp, u_long flags, u_long *rem) +{ + + return (print_mask_0ul(fp, umtxrwlockflags, flags, rem)); +} + +/* XXX: This should be in <sys/capsicum.h> */ +#define CAPMASK(right) ((right) & (((uint64_t)1 << 57) - 1)) + +void +sysdecode_cap_rights(FILE *fp, cap_rights_t *rightsp) +{ + struct name_table *t; + int idx; + bool comma; + + comma = false; + for (t = caprights; t->str != NULL; t++) { + idx = ffs(CAPIDXBIT(t->val)) - 1; + if (CAPARSIZE(rightsp) < idx) + continue; + if ((rightsp->cr_rights[CAPIDXBIT(t->val)] & CAPMASK(t->val)) == + CAPMASK(t->val)) { + fprintf(fp, "%s%s", comma ? "," : "", t->str); + comma = true; + } + } +} diff --git a/lib/libsysdecode/mkioctls b/lib/libsysdecode/mkioctls index e174d30..b99ff19 100644 --- a/lib/libsysdecode/mkioctls +++ b/lib/libsysdecode/mkioctls @@ -62,6 +62,7 @@ BEGIN { print "#include <netinet6/ip6_mroute.h>" print "#include <stdio.h>" print "#include <cam/cam.h>" + print "#include <stdbool.h>" print "#include <stddef.h>" print "#include <stdint.h>" print "#include <sysdecode.h>" diff --git a/lib/libsysdecode/mktables b/lib/libsysdecode/mktables new file mode 100644 index 0000000..563bd18 --- /dev/null +++ b/lib/libsysdecode/mktables @@ -0,0 +1,158 @@ +#!/bin/sh +# +# Copyright (c) 2006 "David Kirchner" <dpk@dpk.net>. 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. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +# +# $FreeBSD$ +# +# Generates tables.h +# +# Originally this script was 'mksubr' for kdump which generated a complete +# C file along with function definitions. Now this script generates tables +# of constants and names extracted from header files. + +set -e + +LC_ALL=C; export LC_ALL + +if [ -z "$1" ] +then + echo "usage: sh $0 include-dir [output-file]" + exit 1 +fi +include_dir=$1 +if [ -n "$2" ]; then + output_file="$2" + exec > "$output_file" +fi + +all_headers= +# +# Generate a table C #definitions. The including file can define the +# TABLE_NAME(n), TABLE_ENTRY(x), and TABLE_END macros to define what +# the tables map to. +# +gen_table() +{ + local name grep file excl filter + name=$1 + grep=$2 + file=$3 + excl=$4 + + if [ -z "$excl" ]; then + filter="cat" + else + filter="egrep -v" + fi + all_headers="${all_headers:+${all_headers} }${file}" + cat <<_EOF_ +TABLE_START(${name}) +_EOF_ + egrep "^#[[:space:]]*define[[:space:]]+"${grep}"[[:space:]]*" \ + $include_dir/$file | ${filter} ${excl} | \ + awk '{ for (i = 1; i <= NF; i++) \ + if ($i ~ /define/) \ + break; \ + ++i; \ + printf "TABLE_ENTRY(%s)\n", $i }' +cat <<_EOF_ +TABLE_END + +_EOF_ +} + +cat <<_EOF_ +/* This file is auto-generated. */ + +_EOF_ + +gen_table "accessmode" "[A-Z]_OK[[:space:]]+0?x?[0-9A-Fa-f]+" "sys/unistd.h" +gen_table "acltype" "ACL_TYPE_[A-Z4_]+[[:space:]]+0x[0-9]+" "sys/acl.h" +gen_table "capfcntl" "CAP_FCNTL_[A-Z]+[[:space:]]+\(1" "sys/capsicum.h" +gen_table "extattrns" "EXTATTR_NAMESPACE_[A-Z]+[[:space:]]+0x[0-9]+" "sys/extattr.h" +gen_table "fadvisebehav" "POSIX_FADV_[A-Z]+[[:space:]]+[0-9]+" "sys/fcntl.h" +gen_table "openflags" "O_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/fcntl.h" "O_RDONLY|O_RDWR|O_WRONLY" +gen_table "flockops" "LOCK_[A-Z]+[[:space:]]+0x[0-9]+" "sys/fcntl.h" +gen_table "kldsymcmd" "KLDSYM_[A-Z]+[[:space:]]+[0-9]+" "sys/linker.h" +gen_table "kldunloadfflags" "LINKER_UNLOAD_[A-Z]+[[:space:]]+[0-9]+" "sys/linker.h" +gen_table "lio_listiomodes" "LIO_(NO)?WAIT[[:space:]]+[0-9]+" "aio.h" +gen_table "madvisebehav" "_?MADV_[A-Z]+[[:space:]]+[0-9]+" "sys/mman.h" +gen_table "minheritflags" "INHERIT_[A-Z]+[[:space:]]+[0-9]+" "sys/mman.h" +gen_table "mlockallflags" "MCL_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mman.h" +gen_table "mmapprot" "PROT_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/mman.h" +gen_table "ngbtsolevel" "SOL_[A-Z0-9]+[[:space:]]+0x[0-9A-Fa-f]+" "netgraph/bluetooth/include/ng_btsocket.h" +gen_table "fileflags" "[SU]F_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/stat.h" "UF_COMPRESSED|UF_TRACKED|UF_SETTABLE|SF_SETTABLE" +gen_table "filemode" "S_[A-Z]+[[:space:]]+[0-6]{7}" "sys/stat.h" +gen_table "mountflags" "MNT_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mount.h" +gen_table "msyncflags" "MS_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mman.h" +gen_table "nfssvcflags" "NFSSVC_[A-Z0-9]+[[:space:]]+0x[0-9]+" "nfs/nfssvc.h" +gen_table "prio" "PRIO_[A-Z]+[[:space:]]+[0-9]" "sys/resource.h" +gen_table "procctlcmd" "PROC_[A-Z_]+[[:space:]]+[0-9]" "sys/procctl.h" "PROC_TRACE_CTL_" +gen_table "ptraceop" "PT_[[:alnum:]_]+[[:space:]]+[0-9]+" "sys/ptrace.h" +gen_table "quotactlcmds" "Q_[A-Z]+[[:space:]]+0x[0-9]+" "ufs/ufs/quota.h" +gen_table "rebootopt" "RB_[A-Z]+[[:space:]]+0x[0-9]+" "sys/reboot.h" +gen_table "rforkflags" "RF[A-Z]+[[:space:]]+\([0-9]+<<[0-9]+\)" "sys/unistd.h" +gen_table "rlimit" "RLIMIT_[A-Z]+[[:space:]]+[0-9]+" "sys/resource.h" +gen_table "schedpolicy" "SCHED_[A-Z]+[[:space:]]+[0-9]+" "sched.h" +gen_table "sendfileflags" "SF_[A-Z]+[[:space:]]+[0-9]+" "sys/socket.h" +gen_table "shmatflags" "SHM_[A-Z]+[[:space:]]+[0-9]{6}+" "sys/shm.h" +gen_table "shutdownhow" "SHUT_[A-Z]+[[:space:]]+[0-9]+" "sys/socket.h" +gen_table "sigbuscode" "BUS_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigchldcode" "CLD_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigfpecode" "FPE_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigprocmaskhow" "SIG_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigillcode" "ILL_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigsegvcode" "SEGV_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sigtrapcode" "TRAP_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" +gen_table "sockdomain" "PF_[[:alnum:]]+[[:space:]]+" "sys/socket.h" +gen_table "sockfamily" "AF_[[:alnum:]]+[[:space:]]+" "sys/socket.h" +gen_table "sockipproto" "IPPROTO_[[:alnum:]]+[[:space:]]+" "netinet/in.h" +gen_table "sockopt" "SO_[A-Z]+[[:space:]]+0x[0-9]+" "sys/socket.h" +gen_table "sockoptip" "(IP_[[:alnum:]_]+|MCAST_[[:alnum:]_]+_GROUP)[[:space:]]+" "netinet/in.h" "IP_DEFAULT|IP_MIN|IP_MAX|IP_PORTRANGE" +gen_table "sockopttcp" "TCP_[[:alnum:]_]+[[:space:]]+[0-9]+" "netinet/tcp.h" "TCP_MIN|TCP_MAX[^S]|TCP_MSS|TCP_[[:alnum:]_]+_MAX" +gen_table "sockoptudp" "UDP_[[:alnum:]]+[[:space:]]+[0-9]+" "netinet/udp.h" "UDP_ENCAP_" +gen_table "socktype" "SOCK_[A-Z]+[[:space:]]+[1-9]+[0-9]*" "sys/socket.h" +gen_table "thrcreateflags" "THR_[A-Z]+[[:space:]]+0x[0-9]+" "sys/thr.h" +gen_table "umtxop" "UMTX_OP_[[:alnum:]_]+[[:space:]]+[0-9]+" "sys/umtx.h" +gen_table "vmprot" "VM_PROT_[A-Z]+[[:space:]]+\(\(vm_prot_t\)\)" "vm/vm.h" +gen_table "vmresult" "KERN_[A-Z]+[[:space:]]+[0-9]+" "vm/vm_param.h" +gen_table "wait6opt" "W[A-Z]+[[:space:]]+[0-9]+" "sys/wait.h" +gen_table "seekwhence" "SEEK_[A-Z]+[[:space:]]+[0-9]+" "sys/unistd.h" +gen_table "fcntlcmd" "F_[A-Z0-9_]+[[:space:]]+[0-9]+[[:space:]]+" "sys/fcntl.h" "F_CANCEL|F_..LCK" +gen_table "mmapflags" "MAP_[A-Z_]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/mman.h" +gen_table "rtpriofuncs" "RTP_[A-Z]+[[:space:]]+[0-9]+" "sys/rtprio.h" +gen_table "msgflags" "MSG_[A-Z]+[[:space:]]+0x[0-9]+" "sys/socket.h" "MSG_SOCALLBCK" +gen_table "sigcode" "SI_[A-Z]+[[:space:]]+0(x[0-9abcdef]+)?" "sys/signal.h" +gen_table "umtxcvwaitflags" "CVWAIT_[A-Z_]+[[:space:]]+0x[0-9]+" "sys/umtx.h" +gen_table "umtxrwlockflags" "URWLOCK_PREFER_READER[[:space:]]+0x[0-9]+" "sys/umtx.h" +gen_table "caprights" "CAP_[A-Z_]+[[:space:]]+CAPRIGHT\([0-9],[[:space:]]+0x[0-9]{16}ULL\)" "sys/capsicum.h" + +# Generate a .depend file for our output file +if [ -n "$output_file" ]; then + echo "$output_file: \\" > ".depend.$output_file" + echo "$all_headers" | tr ' ' '\n' | sort -u | + sed -e "s,^, $include_dir/," -e 's,$, \\,' >> \ + ".depend.$output_file" + echo >> ".depend.$output_file" +fi diff --git a/lib/libsysdecode/signal.c b/lib/libsysdecode/signal.c new file mode 100644 index 0000000..e764a5a --- /dev/null +++ b/lib/libsysdecode/signal.c @@ -0,0 +1,143 @@ +/*- + * Copyright (c) 2016 John H. Baldwin <jhb@FreeBSD.org> + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <signal.h> +#include <stdbool.h> +#include <stdio.h> +#include <sysdecode.h> + +static const char *signames[] = { + [SIGHUP] = "SIGHUP", + [SIGINT] = "SIGINT", + [SIGQUIT] = "SIGQUIT", + [SIGILL] = "SIGILL", + [SIGTRAP] = "SIGTRAP", + [SIGABRT] = "SIGABRT", + [SIGEMT] = "SIGEMT", + [SIGFPE] = "SIGFPE", + [SIGKILL] = "SIGKILL", + [SIGBUS] = "SIGBUS", + [SIGSEGV] = "SIGSEGV", + [SIGSYS] = "SIGSYS", + [SIGPIPE] = "SIGPIPE", + [SIGALRM] = "SIGALRM", + [SIGTERM] = "SIGTERM", + [SIGURG] = "SIGURG", + [SIGSTOP] = "SIGSTOP", + [SIGTSTP] = "SIGTSTP", + [SIGCONT] = "SIGCONT", + [SIGCHLD] = "SIGCHLD", + [SIGTTIN] = "SIGTTIN", + [SIGTTOU] = "SIGTTOU", + [SIGIO] = "SIGIO", + [SIGXCPU] = "SIGXCPU", + [SIGXFSZ] = "SIGXFSZ", + [SIGVTALRM] = "SIGVTALRM", + [SIGPROF] = "SIGPROF", + [SIGWINCH] = "SIGWINCH", + [SIGINFO] = "SIGINFO", + [SIGUSR1] = "SIGUSR1", + [SIGUSR2] = "SIGUSR2", + [SIGTHR] = "SIGTHR", + [SIGLIBRT] = "SIGLIBRT", + + /* XXX: Solaris uses SIGRTMIN, SIGRTMIN+<x>...SIGRTMAX-<x>, SIGRTMAX */ + [SIGRTMIN] = "SIGRT0", + [SIGRTMIN + 1] = "SIGRT1", + [SIGRTMIN + 2] = "SIGRT2", + [SIGRTMIN + 3] = "SIGRT3", + [SIGRTMIN + 4] = "SIGRT4", + [SIGRTMIN + 5] = "SIGRT5", + [SIGRTMIN + 6] = "SIGRT6", + [SIGRTMIN + 7] = "SIGRT7", + [SIGRTMIN + 8] = "SIGRT8", + [SIGRTMIN + 9] = "SIGRT9", + [SIGRTMIN + 10] = "SIGRT10", + [SIGRTMIN + 11] = "SIGRT11", + [SIGRTMIN + 12] = "SIGRT12", + [SIGRTMIN + 13] = "SIGRT13", + [SIGRTMIN + 14] = "SIGRT14", + [SIGRTMIN + 15] = "SIGRT15", + [SIGRTMIN + 16] = "SIGRT16", + [SIGRTMIN + 17] = "SIGRT17", + [SIGRTMIN + 18] = "SIGRT18", + [SIGRTMIN + 19] = "SIGRT19", + [SIGRTMIN + 20] = "SIGRT20", + [SIGRTMIN + 21] = "SIGRT21", + [SIGRTMIN + 22] = "SIGRT22", + [SIGRTMIN + 23] = "SIGRT23", + [SIGRTMIN + 24] = "SIGRT24", + [SIGRTMIN + 25] = "SIGRT25", + [SIGRTMIN + 26] = "SIGRT26", + [SIGRTMIN + 27] = "SIGRT27", + [SIGRTMIN + 28] = "SIGRT28", + [SIGRTMIN + 29] = "SIGRT29", + [SIGRTMIN + 30] = "SIGRT30", + [SIGRTMIN + 31] = "SIGRT31", + [SIGRTMIN + 32] = "SIGRT32", + [SIGRTMIN + 33] = "SIGRT33", + [SIGRTMIN + 34] = "SIGRT34", + [SIGRTMIN + 35] = "SIGRT35", + [SIGRTMIN + 36] = "SIGRT36", + [SIGRTMIN + 37] = "SIGRT37", + [SIGRTMIN + 38] = "SIGRT38", + [SIGRTMIN + 39] = "SIGRT39", + [SIGRTMIN + 40] = "SIGRT40", + [SIGRTMIN + 41] = "SIGRT41", + [SIGRTMIN + 42] = "SIGRT42", + [SIGRTMIN + 43] = "SIGRT43", + [SIGRTMIN + 44] = "SIGRT44", + [SIGRTMIN + 45] = "SIGRT45", + [SIGRTMIN + 46] = "SIGRT46", + [SIGRTMIN + 47] = "SIGRT47", + [SIGRTMIN + 48] = "SIGRT48", + [SIGRTMIN + 49] = "SIGRT49", + [SIGRTMIN + 50] = "SIGRT50", + [SIGRTMIN + 51] = "SIGRT51", + [SIGRTMIN + 52] = "SIGRT52", + [SIGRTMIN + 53] = "SIGRT53", + [SIGRTMIN + 54] = "SIGRT54", + [SIGRTMIN + 55] = "SIGRT55", + [SIGRTMIN + 56] = "SIGRT56", + [SIGRTMIN + 57] = "SIGRT57", + [SIGRTMIN + 58] = "SIGRT58", + [SIGRTMIN + 59] = "SIGRT59", + [SIGRTMIN + 60] = "SIGRT60", + [SIGRTMIN + 61] = "SIGRT61", +}; + +const char * +sysdecode_signal(int sig) +{ + + if ((unsigned)sig < nitems(signames)) + return (signames[sig]); + return (NULL); +} diff --git a/lib/libsysdecode/syscallnames.c b/lib/libsysdecode/syscallnames.c index 4ec2cd7..df588c2 100644 --- a/lib/libsysdecode/syscallnames.c +++ b/lib/libsysdecode/syscallnames.c @@ -35,6 +35,9 @@ __FBSDID("$FreeBSD$"); */ #include <sys/param.h> +#include <sys/acl.h> +#include <sys/wait.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/lib/libsysdecode/sysdecode.3 b/lib/libsysdecode/sysdecode.3 index ab7e972..b5ed3c1 100644 --- a/lib/libsysdecode/sysdecode.3 +++ b/lib/libsysdecode/sysdecode.3 @@ -25,7 +25,7 @@ .\" .\" $FreeBSD$ .\" -.Dd January 29, 2016 +.Dd October 17, 2016 .Dt SYSDECODE 3 .Os .Sh NAME @@ -33,6 +33,10 @@ .Nd system argument decoding library .Sh LIBRARY .Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h .Sh DESCRIPTION The .Nm @@ -65,7 +69,14 @@ A placeholder for use when the ABI is not known. .El .Sh SEE ALSO .Xr sysdecode_abi_to_freebsd_errno 3 , +.Xr sysdecode_cap_rights 3 , +.Xr sysdecode_enum 3 , +.Xr sysdecode_fcntl_arg 3 , .Xr sysdecode_ioctlname 3 , +.Xr sysdecode_mask 3 , +.Xr sysdecode_quotactl_cmd 3 , +.Xr sysdecode_sigcode 3 , +.Xr sysdecode_sockopt_name 3 , .Xr sysdecode_syscallnames 3 , .Xr sysdecode_utrace 3 .Sh HISTORY diff --git a/lib/libsysdecode/sysdecode.h b/lib/libsysdecode/sysdecode.h index 8a30206..f8d05be 100644 --- a/lib/libsysdecode/sysdecode.h +++ b/lib/libsysdecode/sysdecode.h @@ -39,9 +39,79 @@ enum sysdecode_abi { }; int sysdecode_abi_to_freebsd_errno(enum sysdecode_abi _abi, int _error); +bool sysdecode_access_mode(FILE *_fp, int _mode, int *_rem); +const char *sysdecode_acltype(int _type); +const char *sysdecode_atfd(int _fd); +bool sysdecode_cap_fcntlrights(FILE *_fp, uint32_t _rights, uint32_t *_rem); +void sysdecode_cap_rights(FILE *_fp, cap_rights_t *_rightsp); +const char *sysdecode_extattrnamespace(int _namespace); +const char *sysdecode_fadvice(int _advice); +void sysdecode_fcntl_arg(FILE *_fp, int _cmd, uintptr_t _arg, int _base); +bool sysdecode_fcntl_arg_p(int _cmd); +const char *sysdecode_fcntl_cmd(int _cmd); +bool sysdecode_fcntl_fileflags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_fileflags(FILE *_fp, fflags_t _flags, fflags_t *_rem); +bool sysdecode_filemode(FILE *_fp, int _mode, int *_rem); +bool sysdecode_flock_operation(FILE *_fp, int _operation, int *_rem); int sysdecode_freebsd_to_abi_errno(enum sysdecode_abi _abi, int _error); +const char *sysdecode_getfsstat_mode(int _mode); +const char *sysdecode_idtype(int _idtype); const char *sysdecode_ioctlname(unsigned long _val); +const char *sysdecode_ipproto(int _protocol); +const char *sysdecode_kldsym_cmd(int _cmd); +const char *sysdecode_kldunload_flags(int _flags); +const char *sysdecode_lio_listio_mode(int _mode); +const char *sysdecode_madvice(int _advice); +const char *sysdecode_minherit_inherit(int _inherit); +const char *sysdecode_msgctl_cmd(int _cmd); +bool sysdecode_mlockall_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_mmap_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_mmap_prot(FILE *_fp, int _prot, int *_rem); +bool sysdecode_mount_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_msg_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_msync_flags(FILE *_fp, int _flags, int *_rem); +const char *sysdecode_nfssvc_flags(int _flags); +bool sysdecode_open_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_pipe2_flags(FILE *_fp, int _flags, int *_rem); +const char *sysdecode_prio_which(int _which); +const char *sysdecode_procctl_cmd(int _cmd); +const char *sysdecode_ptrace_request(int _request); +bool sysdecode_quotactl_cmd(FILE *_fp, int _cmd); +bool sysdecode_reboot_howto(FILE *_fp, int _howto, int *_rem); +bool sysdecode_rfork_flags(FILE *_fp, int _flags, int *_rem); +const char *sysdecode_rlimit(int _resource); +const char *sysdecode_rtprio_function(int _function); +const char *sysdecode_scheduler_policy(int _policy); +const char *sysdecode_semctl_cmd(int _cmd); +bool sysdecode_semget_flags(FILE *_fp, int _flag, int *_rem); +bool sysdecode_sendfile_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_shmat_flags(FILE *_fp, int _flags, int *_rem); +const char *sysdecode_shmctl_cmd(int _cmd); +const char *sysdecode_shutdown_how(int _how); +const char *sysdecode_sigbus_code(int _si_code); +const char *sysdecode_sigchld_code(int _si_code); +const char *sysdecode_sigcode(int _sig, int _si_code); +const char *sysdecode_sigfpe_code(int _si_code); +const char *sysdecode_sigill_code(int _si_code); +const char *sysdecode_signal(int _sig); +const char *sysdecode_sigprocmask_how(int _how); +const char *sysdecode_sigsegv_code(int _si_code); +const char *sysdecode_sigtrap_code(int _si_code); +const char *sysdecode_sockaddr_family(int _sa_family); +const char *sysdecode_socketdomain(int _domain); +bool sysdecode_socket_type(FILE *_fp, int _type, int *_rem); +const char *sysdecode_sockopt_level(int _level); +const char *sysdecode_sockopt_name(int _level, int _optname); const char *sysdecode_syscallname(enum sysdecode_abi _abi, unsigned int _code); +bool sysdecode_thr_create_flags(FILE *_fp, int _flags, int *_rem); +bool sysdecode_umtx_cvwait_flags(FILE *_fp, u_long _flags, u_long *_rem); +const char *sysdecode_umtx_op(int _op); +bool sysdecode_umtx_rwlock_flags(FILE *_fp, u_long _flags, u_long *_rem); int sysdecode_utrace(FILE *_fp, void *_buf, size_t _len); +bool sysdecode_vmprot(FILE *_fp, int _type, int *_rem); +const char *sysdecode_vmresult(int _result); +bool sysdecode_wait4_options(FILE *_fp, int _options, int *_rem); +bool sysdecode_wait6_options(FILE *_fp, int _options, int *_rem); +const char *sysdecode_whence(int _whence); #endif /* !__SYSDECODE_H__ */ diff --git a/lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 b/lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 index fdee211..78eb858 100644 --- a/lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 +++ b/lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 @@ -25,7 +25,7 @@ .\" .\" $FreeBSD$ .\" -.Dd February 23, 2016 +.Dd October 17, 2016 .Dt sysdecode_abi_to_freebsd_errno 3 .Os .Sh NAME @@ -35,6 +35,9 @@ .Sh LIBRARY .Lb libsysdecode .Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h .Ft int .Fn sysdecode_abi_to_freebsd_errno "enum sysdecode_abi abi" "int error" .Ft int diff --git a/lib/libsysdecode/sysdecode_cap_rights.3 b/lib/libsysdecode/sysdecode_cap_rights.3 new file mode 100644 index 0000000..7d916bb --- /dev/null +++ b/lib/libsysdecode/sysdecode_cap_rights.3 @@ -0,0 +1,50 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd October 17, 2016 +.Dt sysdecode_cap_rights 3 +.Os +.Sh NAME +.Nm sysdecode_cap_rights +.Nd output list of capability rights +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft void +.Fn sysdecode_cap_rights "FILE *fp" "cap_rights_t *rightsp" +.Sh DESCRIPTION +The +.Fn sysdecode_cap_rights +function outputs a comma-separated list of capability rights at +.Fa rightsp +to the stream +.Fa fp . +.Sh SEE ALSO +.Xr sysdecode 3 diff --git a/lib/libsysdecode/sysdecode_enum.3 b/lib/libsysdecode/sysdecode_enum.3 new file mode 100644 index 0000000..3e2f390 --- /dev/null +++ b/lib/libsysdecode/sysdecode_enum.3 @@ -0,0 +1,239 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd January 2, 2017 +.Dt sysdecode_enum 3 +.Os +.Sh NAME +.Nm sysdecode_enum , +.Nm sysdecode_acltype , +.Nm sysdecode_atfd , +.Nm sysdecode_extattrnamespace , +.Nm sysdecode_fadvice , +.Nm sysdecode_fcntl_cmd , +.Nm sysdecode_getfsstat_mode , +.Nm sysdecode_idtype , +.Nm sysdecode_ipproto , +.Nm sysdecode_kldsym_cmd , +.Nm sysdecode_kldunload_flags , +.Nm sysdecode_lio_listio_mode , +.Nm sysdecode_madvice , +.Nm sysdecode_minherit_flags , +.Nm sysdecode_msgctl_cmd , +.Nm sysdecode_nfssvc_flags , +.Nm sysdecode_prio_which , +.Nm sysdecode_procctl_cmd , +.Nm sysdecode_ptrace_request , +.Nm sysdecode_rlimit , +.Nm sysdecode_rtprio_function , +.Nm sysdecode_scheduler_policy , +.Nm sysdecode_semctl_cmd , +.Nm sysdecode_shmctl_cmd , +.Nm sysdecode_shutdown_how , +.Nm sysdecode_sigbus_code , +.Nm sysdecode_sigchld_code , +.Nm sysdecode_sigfpe_code , +.Nm sysdecode_sigill_code , +.Nm sysdecode_signal , +.Nm sysdecode_sigprocmask_how , +.Nm sysdecode_sigsegv_code , +.Nm sysdecode_sigtrap_code , +.Nm sysdecode_sockaddr_family , +.Nm sysdecode_socketdomain , +.Nm sysdecode_sockettype , +.Nm sysdecode_sockopt_level , +.Nm sysdecode_umtx_op , +.Nm sysdecode_vmresult , +.Nm sysdecode_whence +.Nd lookup name of various enumerated values +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft const char * +.Fn sysdecode_acltype "int type" +.Ft const char * +.Fn sysdecode_atfd "int fd" +.Ft const char * +.Fn sysdecode_extattrnamespace "int namespace" +.Ft const char * +.Fn sysdecode_fadvice "int advice" +.Ft const char * +.Fn sysdecode_fcntl_cmd "int cmd" +.Ft const char * +.Fn sysdecode_getfsstat_mode "int mode" +.Ft const char * +.Fn sysdecode_idtype "int idtype" +.Ft const char * +.Fn sysdecode_ipproto "int protocol" +.Ft const char * +.Fn sysdecode_kldsym_cmd "int cmd" +.Ft const char * +.Fn sysdecode_kldunload_flags "int flags" +.Ft const char * +.Fn sysdecode_lio_listio_mode "int mode" +.Ft const char * +.Fn sysdecode_madvice "int advice" +.Ft const char * +.Fn sysdecode_minherit_flags "int inherit" +.Ft const char * +.Fn sysdecode_msgctl_cmd "int cmd" +.Ft const char * +.Fn sysdecode_nfssvc_flags "int flags" +.Ft const char * +.Fn sysdecode_prio_which "int which" +.Ft const char * +.Fn sysdecode_procctl_cmd "int cmd" +.Ft const char * +.Fn sysdecode_ptrace_request "int request" +.Ft const char * +.Fn sysdecode_rlimit "int resource" +.Ft const char * +.Fn sysdecode_rtprio_function "int function" +.Ft const char * +.Fn sysdecode_scheduler_policy "int policy" +.Ft const char * +.Fn sysdecode_semctl_cmd "int cmd" +.Ft const char * +.Fn sysdecode_shmctl_cmd "int cmd" +.Ft const char * +.Fn sysdecode_shutdown_how "int how" +.Ft const char * +.Fn sysdecode_sigbus_code "int si_code" +.Ft const char * +.Fn sysdecode_sigchld_code "int si_code" +.Ft const char * +.Fn sysdecode_sigfpe_code "int si_code" +.Ft const char * +.Fn sysdecode_sigill_code "int si_code" +.Ft const char * +.Fn sysdecode_signal "int sig" +.Ft const char * +.Fn sysdecode_sigprocmask_how "int how" +.Ft const char * +.Fn sysdecode_sigsegv_code "int si_code" +.Ft const char * +.Fn sysdecode_sigtrap_code "int si_code" +.Ft const char * +.Fn sysdecode_sockaddr_family "int sa_family" +.Ft const char * +.Fn sysdecode_socketdomain "int domain" +.Ft const char * +.Fn sysdecode_sockettype "int type" +.Ft const char * +.Fn sysdecode_sockopt_level "int level" +.Ft const char * +.Fn sysdecode_umtx_op "int op" +.Ft const char * +.Fn sysdecode_vmresult "int result" +.Ft const char * +.Fn sysdecode_whence "int whence" +.Sh DESCRIPTION +The +.Nm +functions return a text description of an integer value. +The text description matches the name of a C macro with the same value as the +sole function argument. +.Dv NULL +is returned if there is no matching C macro name. +.Pp +Most of these functions decode an argument passed to a system call: +.Bl -column "Fn sysdecode_extattrnamespace" "Xr sched_setscheduler 2" +.It Sy Function Ta Sy System Call Ta Sy Argument +.It Fn sysdecode_acltype Ta Xr acl_get_file 3 Ta Fa type +.It Fn sysdecode_atfd Ta Xr openat 2 Ta Fa fd +.It Fn sysdecode_extattrnamespace Ta Xr extattr_get_fd 2 Ta Fa attrnamespace +.It Fn sysdecode_fadvice Ta Xr posix_fadvise 2 Ta Fa advice +.It Fn sysdecode_fcntl_cmd Ta Xr fcntl 2 Ta Fa cmd +.It Fn sysdecode_getfsstat_mode Ta Xr getfsstat 2 Ta Fa mode +.It Fn sysdecode_idtype Ta +.Xr procctl 2 , +.Xr waitid 2 +.Ta Fa idtype +.It Fn sysdecode_kldsym_cmd Ta Xr kldsym 2 Ta Fa cmd +.It Fn sysdecode_kldunload_flags Ta Xr kldunloadf 2 Ta Fa flags +.It Fn sysdecode_lio_listio_mode Ta Xr lio_listio 2 Ta Fa mode +.It Fn sysdecode_madvice Ta Xr madvise 2 Ta Fa advice +.It Fn sysdecode_minherit_inherit Ta Xr minherit 2 Ta Fa inherit +.It Fn sysdecode_msgctl_cmd Ta Xr msgctl 2 Ta Fa cmd +.It Fn sysdecode_nfssvc_flags Ta Xr nfssvc 2 Ta Fa flags +.It Fn sysdecode_prio_which Ta Xr getpriority 2 Ta Fa which +.It Fn sysdecode_procctl_cmd Ta Xr procctl 2 Ta Fa cmd +.It Fn sysdecode_ptrace_request Ta Xr ptrace 2 Ta Fa request +.It Fn sysdecode_rlimit Ta Xr getrlimit 2 Ta Fa resource +.It Fn sysdecode_rtprio_function Ta Xr rtprio 2 Ta Fa function +.It Fn sysdecode_scheduler_policy Ta Xr sched_setscheduler 2 Ta Fa policy +.It Fn sysdecode_semctl_cmd Ta Xr semctl 2 Ta Fa cmd +.It Fn sysdecode_shmctl_cmd Ta Xr shmctl 2 Ta Fa cmd +.It Fn sysdecode_shutdown_how Ta Xr shutdown 2 Ta Fa how +.It Fn sysdecode_sigprocmask_how Ta Xr sigprocmask 2 Ta Fa how +.It Fn sysdecode_sockopt_level Ta Xr getsockopt 2 Ta Fa level +.It Fn sysdecode_umtx_op Ta Xr _umtx_op 2 Ta Fa op +.It Fn sysdecode_whence Ta Xr lseek 2 Ta Fa whence +.El +.Pp +These functions decode signal-specific signal codes stored in the +.Fa si_code +field of the +.Vt siginfo_t +object associated with an instance of signal: +.Bl -column "Fn sysdecode_sigchld_code" +.It Sy Function Ta Sy Signal +.It Fn sysdecode_sigbus_code Ta Dv SIGBUS +.It Fn sysdecode_sigchld_code Ta Dv SIGCHLD +.It Fn sysdecode_sigfpe_code Ta Dv SIGFPE +.It Fn sysdecode_sigill_code Ta Dv SIGILL +.It Fn sysdecode_sigsegv_code Ta Dv SIGSEGV +.It Fn sysdecode_sigtrap_code Ta Dv SIGBTRAP +.El +.Pp +Other functions decode the values described below: +.Bl -tag -width "Fn sysdecode_sockaddr_family" +.It Fn sysdecode_ipproto +An IP protocol. +.It Fn sysdecode_signal +A process signal. +.It Fn sysdecode_sockaddr_family +A socket address family. +.It Fn sysdecode_socketdomain +A socket domain. +.It Fn sysdecode_vmresult +The return value of a function in the virtual memory subsystem of the kernel +indicating the status of the associated request. +.El +.Sh RETURN VALUES +The +.Nm +functions return the name of a matching C macro or +.Dv NULL +if no matching C macro was found. +.Sh SEE ALSO +.Xr sysdecode 3 , +.Xr sysdecode_mask 3 , +.Xr sysdecode_sigcode 3 diff --git a/lib/libsysdecode/sysdecode_fcntl_arg.3 b/lib/libsysdecode/sysdecode_fcntl_arg.3 new file mode 100644 index 0000000..2dacb01 --- /dev/null +++ b/lib/libsysdecode/sysdecode_fcntl_arg.3 @@ -0,0 +1,121 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd October 17, 2016 +.Dt sysdecode_fcntl_arg 3 +.Os +.Sh NAME +.Nm sysdecode_fcntl_arg , +.Nm sysdecode_fcntl_arg_p +.Nd output description of fcntl argument +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft void +.Fn sysdecode_fcntl_arg "FILE *fp" "int cmd" "uintptr_t arg" "int base" +.Ft bool +.Fn sysdecode_fcntl_arg_p "int cmd" +.Sh DESCRIPTION +The +.Fn sysdecode_fcntl_arg +function outputs a text description of the optional +.Fa arg +argument to +.Xr fcntl 2 +to the stream +.Fa fp . +The type and format of +.Fa arg +are determined by +.Fa cmd : +.Bl -column ".Dv F_SETLKW" "Vt struct flock *" +.It Sy Command Ta Fa arg Sy Type Ta Sy Output Format +.It +.It Dv F_SETFD Ta Vt int Ta +.Dq FD_CLOEXEC +or the value of +.Fa arg +in the indicated +.Fa base +.Pq one of 8, 10, or 16 . +.It +.It Dv F_SETFL Ta Vt int Ta +File flags as output by +.Xr sysdecode_fcntl_fileflags 3 +with any unknown or remaining bits output in hexadecimal. +.It +.It Dv F_GETLK Ta Vt struct flock * Ta +.It Dv F_SETLK Ta Vt struct flock * Ta +.It Dv F_SETLKW Ta Vt struct flock * Ta +The value of +.Fa arg +using the +.Dq %p +conversion specification. +.It +.It Others Ta Vt int Ta +The value of +.Fa arg +in the indicated +.Fa base +.Pq one of 8, 10, or 16 . +.El +.Pp +The +.Fn sysdecode_fcntl_arg_p +function can be used to determine if a +.Xr fcntl 2 +command uses the optional third argument to +.Xr fcntl 2 . +The function returns +.Dv true +if +.Fa cmd +accepts a third argument to +.Xr fcntl 2 +and +.Dv false +if it does not. +.Sh RETURN VALUES +The +.Nm sysdecode_fcntl_arg_p +function returns +.Dv true +if +.Fa cmd +accepts a third argument to +.Xr fcntl 2 +and +.Dv false +if it does not. +.Sh SEE ALSO +.Xr sysdecode 3 , +.Xr sysdecode_fcntl_cmd 3 , +.Xr sysdecode_fcntl_fileflags 3 diff --git a/lib/libsysdecode/sysdecode_ioctlname.3 b/lib/libsysdecode/sysdecode_ioctlname.3 index 6479f03..0baf115 100644 --- a/lib/libsysdecode/sysdecode_ioctlname.3 +++ b/lib/libsysdecode/sysdecode_ioctlname.3 @@ -25,7 +25,7 @@ .\" .\" $FreeBSD$ .\" -.Dd December 12, 2015 +.Dd October 17, 2016 .Dt sysdecode_ioctlname 3 .Os .Sh NAME @@ -34,6 +34,9 @@ .Sh LIBRARY .Lb libsysdecode .Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h .Ft conts char * .Fn sysdecode_ioctlname "unsigned long request" .Sh DESCRIPTION diff --git a/lib/libsysdecode/sysdecode_mask.3 b/lib/libsysdecode/sysdecode_mask.3 new file mode 100644 index 0000000..5ab007b --- /dev/null +++ b/lib/libsysdecode/sysdecode_mask.3 @@ -0,0 +1,214 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd January 2, 2017 +.Dt sysdecode_mask 3 +.Os +.Sh NAME +.Nm sysdecode_mask , +.Nm sysdecode_accessmode , +.Nm sysdecode_capfcntlrights , +.Nm sysdecode_fcntl_fileflags , +.Nm sysdecode_fileflags , +.Nm sysdecode_filemode , +.Nm sysdecode_flock_operation , +.Nm sysdecode_mlockall_flags , +.Nm sysdecode_mmap_flags , +.Nm sysdecode_mmap_prot , +.Nm sysdecode_mount_flags , +.Nm sysdecode_msg_flags , +.Nm sysdecode_msync_flags , +.Nm sysdecode_open_flags , +.Nm sysdecode_pipe2_flags , +.Nm sysdecode_reboot_howto , +.Nm sysdecode_rfork_flags , +.Nm sysdecode_semget_flags , +.Nm sysdecode_sendfile_flags , +.Nm sysdecode_shmat_flags , +.Nm sysdecode_socket_type , +.Nm sysdecode_thr_create_flags , +.Nm sysdecode_umtx_cvwait_flags , +.Nm sysdecode_umtx_rwlock_flags , +.Nm sysdecode_vmprot , +.Nm sysdecode_wait4_options , +.Nm sysdecode_wait6_options +.Nd print name of various bitmask values +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft bool +.Fn sysdecode_access_mode "FILE *fp" "int mode" "int *rem" +.Ft bool +.Fn sysdecode_cap_fcntlrights "FILE *fp" "uint32_t rights" "uint32_t *rem" +.Ft bool +.Fn sysdecode_fcntl_fileflags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_fileflags "FILE *fp" "fflags_t flags" "fflags_t *rem" +.Ft bool +.Fn sysdecode_filemode "FILE *fp" "int mode" "int *rem" +.Ft bool +.Fn sysdecode_flock_operation "FILE *fp" "int operation" "int *rem" +.Ft bool +.Fn sysdecode_mlockall_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_mmap_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_mmap_prot "FILE *fp" "int prot" "int *rem" +.Ft bool +.Fn sysdecode_mount_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_msg_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_msync_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_open_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_pipe2_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_reboot_howto "FILE *fp" "int howto" "int *rem" +.Ft bool +.Fn sysdecode_rfork_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_semget_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_sendfile_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_shmat_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_socket_type "FILE *fp" "int type" "int *rem" +.Ft bool +.Fn sysdecode_thr_create_flags "FILE *fp" "int flags" "int *rem" +.Ft bool +.Fn sysdecode_umtx_cvwait_flags "FILE *fp" "u_long flags" "u_long *rem" +.Ft bool +.Fn sysdecode_umtx_rwlock_flags "FILE *fp" "u_long flags" "u_long *rem" +.Ft bool +.Fn sysdecode_vmprot "FILE *fp" "int type" "int *rem" +.Ft bool +.Fn sysdecode_wait4_options "FILE *fp" "int options" "int *rem" +.Ft bool +.Fn sysdecode_wait6_options "FILE *fp" "int options" "int *rem" +.Sh DESCRIPTION +The +.Nm +functions are used to generate a text description of an integer value +built from a mask of bitfields. +The text description lists the C macros for field values joined by pipe +.Sq | +characters matching the format used in C source code. +Most of the values decoded by these functions are passed as arguments to +system calls, +though some of these values are used internally in the kernel. +.Pp +Each function writes the text description to +.Fa fp . +The second argument should contain the integer value to be decoded. +The +.Fa rem +argument is set to the value of any bits that were not decoded +.Pq bit fields that do not have a corresponding C macro . +.Fa rem +may be set to +.Dv NULL +if the caller does not need this value. +Each function returns +.Dv true +if any bit fields in the value were decoded and +.Dv false +if no bit fields were decoded. +.Pp +Most of these functions decode an argument passed to a system call: +.Bl -column "Fn sysdecode_flock_operation" "Xr cap_fcntls_limit 2" +.It Sy Function Ta Sy System Call Ta Sy Argument +.It Fn sysdecode_access_mode Ta Xr access 2 Ta Fa mode +.It Fn sysdecode_cap_fcntlrights Ta Xr cap_fcntls_limit 2 Ta Fa fcntlrights +.It Fn sysdecode_fileflags Ta Xr chflags 2 Ta Fa flags +.It Fn sysdecode_filemode Ta Xr chmod 2 , Xr open 2 Ta mode +.It Fn sysdecode_flock_operation Ta Xr flock 2 Ta Fa operation +.It Fn sysdecode_mlockall_flags Ta Xr mlockall 2 Ta Fa flags +.It Fn sysdecode_mmap_flags Ta Xr mmap 2 Ta Fa flags +.It Fn sysdecode_mmap_prot Ta Xr mmap 2 Ta Fa prot +.It Fn sysdecode_mount_flags Ta Xr mount 2 Ta Fa flags +.It Fn sysdecode_msg_flags Ta Xr recv 2 , Xr send 2 Ta Fa flags +.It Fn sysdecode_msync_flags Ta Xr msync 2 Ta Fa flags +.It Fn sysdecode_open_flags Ta Xr open 2 Ta Fa flags +.It Fn sysdecode_pipe2_flags Ta Xr pipe2 Ta Fa flags +.It Fn sysdecode_reboot_howto Ta Xr reboot 2 Ta Fa howto +.It Fn sysdecode_rfork_flags Ta Xr rfork 2 Ta Fa flags +.It Fn sysdecode_semget_flags Ta Xr semget 2 Ta Fa flags +.It Fn sysdecode_sendfile_flags Ta Xr sendfile 2 Ta Fa flags +.It Fn sysdecode_shmat_flags Ta Xr shmat 2 Ta Fa flags +.It Fn sysdecode_socket_type Ta Xr socket 2 Ta Fa type +.It Fn sysdecode_thr_create_flags Ta Xr thr_create 2 Ta Fa flags +.It Fn sysdecode_wait4_options Ta Xr wait4 2 Ta Fa options +.It Fn sysdecode_wait6_options Ta Xr wait6 2 Ta Fa options +.El +.Pp +Other functions decode the values described below: +.Bl -tag -width ".Fn sysdecode_umtx_cvwait_flags" +.It Fn sysdecode_fcntl_fileflags +The file flags used with the +.Dv F_GETFL +and +.Dv F_SETFL +.Xr fcntl 2 +commands. +.It Fn sysdecode_umtx_cvwait_flags +The +.Fa val +argument to +.Xr _umtx_op 2 +for +.Dv UMTX_OP_CV_WAIT +operations. +.It Fn sysdecode_umtx_rwlock_flags +The +.Fa val +argument to +.Xr _umtx_op 2 +for +.Dv UMTX_OP_RW_RDLOCK +operations. +.It Fn sysdecode_vmprot +The memory protection flags stored in +.Vt vm_prot_t +variables. +.El +.Sh RETURN VALUES +The +.Nm +functions return +.Dv true +if any bit fields in the value were decoded and +.Dv false +if no bit fields were decoded. +.Sh SEE ALSO +.Xr sysdecode 3 , +.Xr sysdecode_enum 3 diff --git a/lib/libsysdecode/sysdecode_quotactl_cmd.3 b/lib/libsysdecode/sysdecode_quotactl_cmd.3 new file mode 100644 index 0000000..362da17 --- /dev/null +++ b/lib/libsysdecode/sysdecode_quotactl_cmd.3 @@ -0,0 +1,93 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd October 17, 2016 +.Dt sysdecode_quotactl_cmd 3 +.Os +.Sh NAME +.Nm sysdecode_quotactl_cmd +.Nd output name of quotactl command +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft bool +.Fn sysdecode_quotactl_cmd "FILE *fp" "int cmd" +.Sh DESCRIPTION +The +.Fn sysdecode_quotactl_cmd +function outputs a text description of the +.Fa cmd +argument to +.Xr quotactl 2 +to the stream +.Fa fp . +The description is formatted as an invocation of the +.Dv QCMD +macro defined in the +.In ufs/ufs/quota.h +header. +.Pp +The function first computes the primary and secondary values used by +.Dv QCMD +to construct +.Fa cmd . +If the primary command value does not represent a known constant, +.Fn sysdecode_quotactl_cmd +does not generate any output and returns +.Dv false . +Otherwise, +.Fn sysdecode_quotactl_cmd +outputs text depicting an invocation of +.Dv QCMD +with the associated constants for the primary and secondary command values +and returns +.Dv true . +If the secondary command values does not represent a known constant, +its value is output as a hexadecimal integer. +.Sh RETURN VALUES +The +.Nm sysdecode_quotactl_cmd +function returns +.Dv true +if it outputs a description of +.Fa cmd +and +.Dv false +if it does not. +.Sh EXAMPLES +The statement +.Pp +.Dl sysdecode_quotatcl_cmd(stdout, QCMD(Q_GETQUOTA, USRQUOTA); +.Pp +outputs the text +.Dq QCMD(Q_GETQUOTA, USRQUOTA) +to standard output. +.Sh SEE ALSO +.Xr sysdecode 3 diff --git a/lib/libsysdecode/sysdecode_sigcode.3 b/lib/libsysdecode/sysdecode_sigcode.3 new file mode 100644 index 0000000..5675662 --- /dev/null +++ b/lib/libsysdecode/sysdecode_sigcode.3 @@ -0,0 +1,83 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd October 17, 2016 +.Dt sysdecode_sigcode 3 +.Os +.Sh NAME +.Nm sysdecode_sigcode +.Nd lookup name of signal code +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft const char * +.Fn sysdecode_sigcode "int signal" "int si_code" +.Sh DESCRIPTION +The +.Fn sysdecode_sigcode +function returns a text description of the +.Fa si_code +field of the +.Vt siginfo_t +object associated with an instance of signal +.Fa sig . +The text description contains the name of the C macro whose value matches +.Fa si_code . +General purpose signal codes such as +.Dv SI_USER +are handled as well as signal-specific codes for +.Dv SIGBUS , +.Dv SIGCHLD , +.Dv SIGFPE , +.Dv SIGILL , +.Dv SIGSEGV +and +.Dv SIGTRAP . +If +.Fa si_code +does not represent a known signal code, +.Fn sysdecode_sigcode +returns +.Dv NULL . +.Sh RETURN VALUES +The +.Fn sysdecode_sigcode +function returns a pointer to a signal code description or +.Dv NULL +if +.Fa si_code +is not a known signal code. +.Sh SEE ALSO +.Xr sysdecode_sigbus_code 3 , +.Xr sysdecode_sigchld_code 3 , +.Xr sysdecode_sigfpe_code 3 , +.Xr sysdecode_sigill_code 3 , +.Xr sysdecode_sigsegv_code 3 , +.Xr sysdecode_sigtrap_code 3 diff --git a/lib/libsysdecode/sysdecode_sockopt_name.3 b/lib/libsysdecode/sysdecode_sockopt_name.3 new file mode 100644 index 0000000..3db6e0e --- /dev/null +++ b/lib/libsysdecode/sysdecode_sockopt_name.3 @@ -0,0 +1,61 @@ +.\" +.\" Copyright (c) 2016 John Baldwin <jhb@FreeBSD.org> +.\" 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. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. +.\" +.\" $FreeBSD$ +.\" +.Dd October 17, 2016 +.Dt sysdecode_sockopt_name 3 +.Os +.Sh NAME +.Nm sysdecode_sockopt_name +.Nd lookup name of socket option +.Sh LIBRARY +.Lb libsysdecode +.Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h +.Ft const char * +.Fn sysdecode_sockopt_name "int level" "int optname" +.Sh DESCRIPTION +The +.Fn sysdecode_sockopt_name +function returns a text description of the socket option name passed in the +.Fa optname +argument to +.Xr getsockopt 2 . +.Fn sysdecode_sockopt_name +takes the socket option +.Fa level +as well as the option name to uniquely identify the option. +.Sh SEE ALSO +.Xr sysdecode_sockopt_level 3 +.Sh BUGS +Socket option levels and names are protocol-specific. +Both +.Fn sysdecode_sockopt_level +and +.Fn sysdecode_sockopt_name +should possibly accept the protocol family as an additional argument. diff --git a/lib/libsysdecode/sysdecode_syscallnames.3 b/lib/libsysdecode/sysdecode_syscallnames.3 index e920edb..9a57164 100644 --- a/lib/libsysdecode/sysdecode_syscallnames.3 +++ b/lib/libsysdecode/sysdecode_syscallnames.3 @@ -25,7 +25,7 @@ .\" .\" $FreeBSD$ .\" -.Dd January 30, 2016 +.Dd October 17, 2016 .Dt sysdecode_syscallnames 3 .Os .Sh NAME @@ -34,6 +34,9 @@ .Sh LIBRARY .Lb libsysdecode .Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h .Ft const char * .Fn sysdecode_syscallnames "enum sysdecode_abi abi" "unsigned int code" .Sh DESCRIPTION diff --git a/lib/libsysdecode/sysdecode_utrace.3 b/lib/libsysdecode/sysdecode_utrace.3 index 8bf2e85..bf3f5e4 100644 --- a/lib/libsysdecode/sysdecode_utrace.3 +++ b/lib/libsysdecode/sysdecode_utrace.3 @@ -25,7 +25,7 @@ .\" .\" $FreeBSD$ .\" -.Dd December 11, 2015 +.Dd October 17, 2016 .Dt sysdecode_utrace 3 .Os .Sh NAME @@ -34,6 +34,9 @@ .Sh LIBRARY .Lb libsysdecode .Sh SYNOPSIS +.In sys/types.h +.In stdbool.h +.In sysdecode.h .Ft int .Fn sysdecode_utrace "FILE *fp" "void *buf" "size_t len" "int decimal" .Sh DESCRIPTION diff --git a/lib/libsysdecode/utrace.c b/lib/libsysdecode/utrace.c index dfd0e70..8745819 100644 --- a/lib/libsysdecode/utrace.c +++ b/lib/libsysdecode/utrace.c @@ -32,6 +32,7 @@ __FBSDID("$FreeBSD$"); #include <sys/param.h> #include <dlfcn.h> +#include <stdbool.h> #include <stdio.h> #include <string.h> #include <sysdecode.h> diff --git a/usr.bin/kdump/Makefile b/usr.bin/kdump/Makefile index f80f668..e77e241 100644 --- a/usr.bin/kdump/Makefile +++ b/usr.bin/kdump/Makefile @@ -6,8 +6,8 @@ .PATH: ${.CURDIR}/../ktrace PROG= kdump -SRCS= kdump_subr.c kdump_subr.h kdump.c subr.c -CFLAGS+= -I${.CURDIR}/../ktrace -I${.CURDIR} -I${.CURDIR}/../.. -I. +SRCS= kdump.c subr.c +CFLAGS+= -I${.CURDIR}/../ktrace #-I${.CURDIR}/../... LIBADD= sysdecode .if ${MK_CASPER} != "no" @@ -17,15 +17,6 @@ LIBADD+= cap_pwd CFLAGS+=-DHAVE_LIBCASPER .endif -NO_WERROR?= YES - -CLEANFILES= kdump_subr.c kdump_subr.h - -kdump_subr.h: mksubr - sh ${.CURDIR}/mksubr ${DESTDIR}${INCLUDEDIR} | \ - sed -n 's/^\([a-z].*)\)$$/void \1;/p' >${.TARGET} - -kdump_subr.c: mksubr kdump_subr.h - sh ${.CURDIR}/mksubr ${DESTDIR}${INCLUDEDIR} >${.TARGET} +#NO_WERROR?= YES .include <bsd.prog.mk> diff --git a/usr.bin/kdump/kdump.c b/usr.bin/kdump/kdump.c index 35daf28..8b32653 100644 --- a/usr.bin/kdump/kdump.c +++ b/usr.bin/kdump/kdump.c @@ -79,7 +79,6 @@ __FBSDID("$FreeBSD$"); #include <unistd.h> #include <vis.h> #include "ktrace.h" -#include "kdump_subr.h" #ifdef HAVE_LIBCASPER #include <libcasper.h> @@ -118,8 +117,6 @@ void usage(void); #define TIMESTAMP_ELAPSED 0x2 #define TIMESTAMP_RELATIVE 0x4 -extern const char *signames[]; - static int timestamp, decimal, fancy = 1, suppressdata, tail, threads, maxdata, resolv = 0, abiflag = 0, syscallno = 0; static const char *tracefile = DEF_TRACEFILE; @@ -241,6 +238,133 @@ cappwdgrp_setup(cap_channel_t **cappwdp, cap_channel_t **capgrpp) } #endif /* HAVE_LIBCASPER */ +static void +print_integer_arg(const char *(*decoder)(int), int value) +{ + const char *str; + + str = decoder(value); + if (str != NULL) + printf("%s", str); + else { + if (decimal) + printf("<invalid=%d>", value); + else + printf("<invalid=%#x>", value); + } +} + +/* Like print_integer_arg but unknown values are treated as valid. */ +static void +print_integer_arg_valid(const char *(*decoder)(int), int value) +{ + const char *str; + + str = decoder(value); + if (str != NULL) + printf("%s", str); + else { + if (decimal) + printf("%d", value); + else + printf("%#x", value); + } +} + +static void +print_mask_arg(bool (*decoder)(FILE *, int, int *), int value) +{ + bool invalid; + int rem; + + printf("%#x<", value); + invalid = !decoder(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%u", rem); +} + +static void +print_mask_arg0(bool (*decoder)(FILE *, int, int *), int value) +{ + bool invalid; + int rem; + + if (value == 0) { + printf("0"); + return; + } + printf("%#x<", value); + invalid = !decoder(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%u", rem); +} + +static void +decode_fileflags(fflags_t value) +{ + bool invalid; + fflags_t rem; + + if (value == 0) { + printf("0"); + return; + } + printf("%#x<", value); + invalid = !sysdecode_fileflags(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%u", rem); +} + +static void +decode_filemode(int value) +{ + bool invalid; + int rem; + + if (value == 0) { + printf("0"); + return; + } + printf("%#o<", value); + invalid = !sysdecode_filemode(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%u", rem); +} + +static void +print_mask_arg32(bool (*decoder)(FILE *, uint32_t, uint32_t *), uint32_t value) +{ + bool invalid; + uint32_t rem; + + printf("%#x<", value); + invalid = !decoder(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%u", rem); +} + +static void +print_mask_argul(bool (*decoder)(FILE *, u_long, u_long *), u_long value) +{ + bool invalid; + u_long rem; + + if (value == 0) { + printf("0"); + return; + } + printf("%#lx<", value); + invalid = !decoder(stdout, value, &rem); + printf(">"); + if (invalid) + printf("<invalid>%lu", rem); +} + int main(int argc, char *argv[]) { @@ -715,6 +839,18 @@ syscallname(u_int code, u_int sv_flags) } } +static void +print_signal(int signo) +{ + const char *signame; + + signame = sysdecode_signal(signo); + if (signame != NULL) + printf("%s", signame); + else + printf("SIG %d", signo); +} + void ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) { @@ -756,7 +892,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_unlinkat: case SYS_utimensat: putchar('('); - atfdname(*ip, decimal); + print_integer_arg_valid(sysdecode_atfd, *ip); c = ','; ip++; narg--; @@ -774,7 +910,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) } case SYS_ptrace: putchar('('); - ptraceopname(*ip); + print_integer_arg(sysdecode_ptrace_request, *ip); c = ','; ip++; narg--; @@ -784,7 +920,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_faccessat: print_number(ip, narg, c); putchar(','); - accessmodename(*ip); + print_mask_arg(sysdecode_access_mode, *ip); ip++; narg--; break; @@ -792,37 +928,32 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_openat: print_number(ip, narg, c); putchar(','); - flagsandmodename(ip[0], ip[1], decimal); + print_mask_arg(sysdecode_open_flags, ip[0]); + if ((ip[0] & O_CREAT) == O_CREAT) { + putchar(','); + decode_filemode(ip[1]); + } ip += 2; narg -= 2; break; case SYS_wait4: print_number(ip, narg, c); print_number(ip, narg, c); - /* - * A flags value of zero is valid for - * wait4() but not for wait6(), so - * handle zero special here. - */ - if (*ip == 0) { - print_number(ip, narg, c); - } else { - putchar(','); - wait6optname(*ip); - ip++; - narg--; - } + putchar(','); + print_mask_arg0(sysdecode_wait4_options, *ip); + ip++; + narg--; break; case SYS_wait6: putchar('('); - idtypename(*ip, decimal); + print_integer_arg(sysdecode_idtype, *ip); c = ','; ip++; narg--; print_number64(first, ip, narg, c); print_number(ip, narg, c); putchar(','); - wait6optname(*ip); + print_mask_arg(sysdecode_wait6_options, *ip); ip++; narg--; break; @@ -832,7 +963,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_fchmodat: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; @@ -840,7 +971,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_mknodat: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; @@ -848,7 +979,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - getfsstatflagsname(*ip); + print_integer_arg(sysdecode_getfsstat_mode, *ip); ip++; narg--; break; @@ -856,14 +987,14 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mountflagsname(*ip); + print_mask_arg(sysdecode_mount_flags, *ip); ip++; narg--; break; case SYS_unmount: print_number(ip, narg, c); putchar(','); - mountflagsname(*ip); + print_mask_arg(sysdecode_mount_flags, *ip); ip++; narg--; break; @@ -872,7 +1003,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - sendrecvflagsname(*ip); + print_mask_arg0(sysdecode_msg_flags, *ip); ip++; narg--; break; @@ -882,7 +1013,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - sendrecvflagsname(*ip); + print_mask_arg0(sysdecode_msg_flags, *ip); ip++; narg--; break; @@ -891,26 +1022,26 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_lchflags: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_fileflags(*ip); ip++; narg--; break; case SYS_kill: print_number(ip, narg, c); putchar(','); - signame(*ip); + print_signal(*ip); ip++; narg--; break; case SYS_reboot: putchar('('); - rebootoptname(*ip); + print_mask_arg(sysdecode_reboot_howto, *ip); ip++; narg--; break; case SYS_umask: putchar('('); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; @@ -918,7 +1049,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - msyncflagsname(*ip); + print_mask_arg(sysdecode_msync_flags, *ip); ip++; narg--; break; @@ -927,11 +1058,11 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mmapprotname(*ip); + print_mask_arg(sysdecode_mmap_prot, *ip); putchar(','); ip++; narg--; - mmapflagsname(*ip); + print_mask_arg(sysdecode_mmap_flags, *ip); ip++; narg--; break; @@ -940,11 +1071,11 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mmapprotname(*ip); + print_mask_arg(sysdecode_mmap_prot, *ip); putchar(','); ip++; narg--; - mmapflagsname(*ip); + print_mask_arg(sysdecode_mmap_flags, *ip); ip++; narg--; break; @@ -952,7 +1083,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mmapprotname(*ip); + print_mask_arg(sysdecode_mmap_prot, *ip); ip++; narg--; break; @@ -960,7 +1091,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - madvisebehavname(*ip); + print_integer_arg(sysdecode_madvice, *ip); ip++; narg--; break; @@ -968,14 +1099,25 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - prioname(*ip); + print_integer_arg(sysdecode_prio_which, *ip); ip++; narg--; break; case SYS_fcntl: print_number(ip, narg, c); putchar(','); - fcntlcmdname(ip[0], ip[1], decimal); + print_integer_arg(sysdecode_fcntl_cmd, ip[0]); + if (sysdecode_fcntl_arg_p(ip[0])) { + putchar(','); + if (ip[0] == F_SETFL) + print_mask_arg( + sysdecode_fcntl_fileflags, + ip[1]); + else + sysdecode_fcntl_arg(stdout, + ip[0], ip[1], + decimal ? 10 : 16); + } ip += 2; narg -= 2; break; @@ -983,17 +1125,19 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) int sockdomain; putchar('('); sockdomain = *ip; - sockdomainname(sockdomain); + print_integer_arg(sysdecode_socketdomain, + sockdomain); ip++; narg--; putchar(','); - socktypenamewithflags(*ip); + print_mask_arg(sysdecode_socket_type, *ip); ip++; narg--; if (sockdomain == PF_INET || sockdomain == PF_INET6) { putchar(','); - sockipprotoname(*ip); + print_integer_arg(sysdecode_ipproto, + *ip); ip++; narg--; } @@ -1001,19 +1145,23 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) break; } case SYS_setsockopt: - case SYS_getsockopt: + case SYS_getsockopt: { + const char *str; + print_number(ip, narg, c); putchar(','); - sockoptlevelname(*ip, decimal); - if (*ip == SOL_SOCKET) { + print_integer_arg_valid(sysdecode_sockopt_level, + *ip); + str = sysdecode_sockopt_name(ip[0], ip[1]); + if (str != NULL) { + printf(",%s", str); ip++; narg--; - putchar(','); - sockoptname(*ip); } ip++; narg--; break; + } #ifdef SYS_freebsd6_lseek case SYS_freebsd6_lseek: print_number(ip, narg, c); @@ -1021,7 +1169,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number64(first, ip, narg, c); putchar(','); - whencename(*ip); + print_integer_arg(sysdecode_whence, *ip); ip++; narg--; break; @@ -1030,14 +1178,14 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number64(first, ip, narg, c); putchar(','); - whencename(*ip); + print_integer_arg(sysdecode_whence, *ip); ip++; narg--; break; case SYS_flock: print_number(ip, narg, c); putchar(','); - flockname(*ip); + print_mask_arg(sysdecode_flock_operation, *ip); ip++; narg--; break; @@ -1047,24 +1195,24 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_mkdirat: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; case SYS_shutdown: print_number(ip, narg, c); putchar(','); - shutdownhowname(*ip); + print_integer_arg(sysdecode_shutdown_how, *ip); ip++; narg--; break; case SYS_socketpair: putchar('('); - sockdomainname(*ip); + print_integer_arg(sysdecode_socketdomain, *ip); ip++; narg--; putchar(','); - socktypenamewithflags(*ip); + print_mask_arg(sysdecode_socket_type, *ip); ip++; narg--; c = ','; @@ -1072,7 +1220,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_getrlimit: case SYS_setrlimit: putchar('('); - rlimitname(*ip); + print_integer_arg(sysdecode_rlimit, *ip); ip++; narg--; c = ','; @@ -1080,21 +1228,28 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_quotactl: print_number(ip, narg, c); putchar(','); - quotactlname(*ip); + if (!sysdecode_quotactl_cmd(stdout, *ip)) { + if (decimal) + printf("<invalid=%d>", (int)*ip); + else + printf("<invalid=%#x>", + (int)*ip); + } ip++; narg--; c = ','; break; case SYS_nfssvc: putchar('('); - nfssvcname(*ip); + print_integer_arg(sysdecode_nfssvc_flags, *ip); ip++; narg--; c = ','; break; case SYS_rtprio: putchar('('); - rtprioname(*ip); + print_integer_arg(sysdecode_rtprio_function, + *ip); ip++; narg--; c = ','; @@ -1103,7 +1258,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - semctlname(*ip); + print_integer_arg(sysdecode_semctl_cmd, *ip); ip++; narg--; break; @@ -1111,14 +1266,14 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - semgetname(*ip); + print_mask_arg(sysdecode_semget_flags, *ip); ip++; narg--; break; case SYS_msgctl: print_number(ip, narg, c); putchar(','); - shmctlname(*ip); + print_integer_arg(sysdecode_msgctl_cmd, *ip); ip++; narg--; break; @@ -1126,64 +1281,69 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - shmatname(*ip); + print_mask_arg(sysdecode_shmat_flags, *ip); ip++; narg--; break; case SYS_shmctl: print_number(ip, narg, c); putchar(','); - shmctlname(*ip); + print_integer_arg(sysdecode_shmctl_cmd, *ip); ip++; narg--; break; case SYS_shm_open: print_number(ip, narg, c); putchar(','); - flagsname(ip[0]); - printf(",0%o", (unsigned int)ip[1]); - ip += 3; - narg -= 3; + print_mask_arg(sysdecode_open_flags, ip[0]); + putchar(','); + decode_filemode(ip[1]); + ip += 2; + narg -= 2; break; case SYS_minherit: print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - minheritname(*ip); + print_integer_arg(sysdecode_minherit_inherit, + *ip); ip++; narg--; break; case SYS_rfork: putchar('('); - rforkname(*ip); + print_mask_arg(sysdecode_rfork_flags, *ip); ip++; narg--; c = ','; break; case SYS_lio_listio: putchar('('); - lio_listioname(*ip); + print_integer_arg(sysdecode_lio_listio_mode, + *ip); ip++; narg--; c = ','; break; case SYS_mlockall: putchar('('); - mlockallname(*ip); + print_mask_arg(sysdecode_mlockall_flags, *ip); ip++; narg--; break; case SYS_sched_setscheduler: print_number(ip, narg, c); putchar(','); - schedpolicyname(*ip); + print_integer_arg(sysdecode_scheduler_policy, + *ip); ip++; narg--; break; case SYS_sched_get_priority_max: case SYS_sched_get_priority_min: putchar('('); - schedpolicyname(*ip); + print_integer_arg(sysdecode_scheduler_policy, + *ip); ip++; narg--; break; @@ -1195,20 +1355,21 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - sendfileflagsname(*(int *)ip); + print_mask_arg(sysdecode_sendfile_flags, *ip); ip++; narg--; break; case SYS_kldsym: print_number(ip, narg, c); putchar(','); - kldsymcmdname(*ip); + print_integer_arg(sysdecode_kldsym_cmd, *ip); ip++; narg--; break; case SYS_sigprocmask: putchar('('); - sigprocmaskhowname(*ip); + print_integer_arg(sysdecode_sigprocmask_how, + *ip); ip++; narg--; c = ','; @@ -1227,13 +1388,13 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS___acl_aclcheck_link: print_number(ip, narg, c); putchar(','); - acltypename(*ip); + print_integer_arg(sysdecode_acltype, *ip); ip++; narg--; break; case SYS_sigaction: putchar('('); - signame(*ip); + print_signal(*ip); ip++; narg--; c = ','; @@ -1241,7 +1402,8 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_extattrctl: print_number(ip, narg, c); putchar(','); - extattrctlname(*ip); + print_integer_arg(sysdecode_extattrnamespace, + *ip); ip++; narg--; break; @@ -1249,7 +1411,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mountflagsname(*ip); + print_mask_arg(sysdecode_mount_flags, *ip); ip++; narg--; break; @@ -1257,21 +1419,22 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - thrcreateflagsname(*ip); + print_mask_arg(sysdecode_thr_create_flags, *ip); ip++; narg--; break; case SYS_thr_kill: print_number(ip, narg, c); putchar(','); - signame(*ip); + print_signal(*ip); ip++; narg--; break; case SYS_kldunloadf: print_number(ip, narg, c); putchar(','); - kldunloadfflagsname(*ip); + print_integer_arg(sysdecode_kldunload_flags, + *ip); ip++; narg--; break; @@ -1280,7 +1443,7 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) case SYS_symlinkat: print_number(ip, narg, c); putchar(','); - atfdname(*ip, decimal); + print_integer_arg_valid(sysdecode_atfd, *ip); ip++; narg--; break; @@ -1290,45 +1453,47 @@ ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) arg = *ip; ip++; narg--; - capfcntlname(arg); + print_mask_arg32(sysdecode_cap_fcntlrights, arg); break; case SYS_posix_fadvise: print_number(ip, narg, c); print_number(ip, narg, c); print_number(ip, narg, c); (void)putchar(','); - fadvisebehavname((int)*ip); + print_integer_arg(sysdecode_fadvice, *ip); ip++; narg--; break; case SYS_procctl: putchar('('); - idtypename(*ip, decimal); + print_integer_arg(sysdecode_idtype, *ip); c = ','; ip++; narg--; print_number64(first, ip, narg, c); putchar(','); - procctlcmdname(*ip); + print_integer_arg(sysdecode_procctl_cmd, *ip); ip++; narg--; break; case SYS__umtx_op: print_number(ip, narg, c); putchar(','); - umtxopname(*ip); + print_integer_arg(sysdecode_umtx_op, *ip); switch (*ip) { case UMTX_OP_CV_WAIT: ip++; narg--; putchar(','); - umtxcvwaitflags(*ip); + print_mask_argul( + sysdecode_umtx_cvwait_flags, *ip); break; case UMTX_OP_RW_RDLOCK: ip++; narg--; putchar(','); - umtxrwlockflags(*ip); + print_mask_argul( + sysdecode_umtx_rwlock_flags, *ip); break; } ip++; @@ -1518,32 +1683,25 @@ ktrgenio(struct ktr_genio *ktr, int len) visdump(dp, datalen, screenwidth); } -const char *signames[] = { - "NULL", "HUP", "INT", "QUIT", "ILL", "TRAP", "IOT", /* 1 - 6 */ - "EMT", "FPE", "KILL", "BUS", "SEGV", "SYS", /* 7 - 12 */ - "PIPE", "ALRM", "TERM", "URG", "STOP", "TSTP", /* 13 - 18 */ - "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU", /* 19 - 24 */ - "XFSZ", "VTALRM", "PROF", "WINCH", "29", "USR1", /* 25 - 30 */ - "USR2", NULL, /* 31 - 32 */ -}; - void ktrpsig(struct ktr_psig *psig) { - if (psig->signo > 0 && psig->signo < NSIG) - printf("SIG%s ", signames[psig->signo]); - else - printf("SIG %d ", psig->signo); + const char *str; + + print_signal(psig->signo); if (psig->action == SIG_DFL) { - printf("SIG_DFL code="); - sigcodename(psig->signo, psig->code); - putchar('\n'); + printf(" SIG_DFL"); } else { - printf("caught handler=0x%lx mask=0x%x code=", + printf(" caught handler=0x%lx mask=0x%x", (u_long)psig->action, psig->mask.__bits[0]); - sigcodename(psig->signo, psig->code); - putchar('\n'); } + printf(" code="); + str = sysdecode_sigcode(psig->signo, psig->code); + if (str != NULL) + printf("%s", str); + else + printf("<invalid=%#x>", psig->code); + putchar('\n'); } void @@ -1585,7 +1743,7 @@ ktrcaprights(cap_rights_t *rightsp) { printf("cap_rights_t "); - capname(rightsp); + sysdecode_cap_rights(stdout, rightsp); printf("\n"); } @@ -1617,6 +1775,7 @@ ktrsockaddr(struct sockaddr *sa) #include <netsmb/netbios.h> struct sockaddr_nb *nb; */ + const char *str; char addr[64]; /* @@ -1625,7 +1784,11 @@ ktrsockaddr(struct sockaddr *sa) * sa->sa_len bytes long. */ printf("struct sockaddr { "); - sockfamilyname(sa->sa_family); + str = sysdecode_sockaddr_family(sa->sa_family); + if (str != NULL) + printf("%s", str); + else + printf("<invalid=%d>", sa->sa_family); printf(", "); #define check_sockaddr_len(n) \ @@ -1839,16 +2002,16 @@ ktrcapfail(struct ktr_cap_fail *ktr) case CAPFAIL_NOTCAPABLE: /* operation on fd with insufficient capabilities */ printf("operation requires "); - capname(&ktr->cap_needed); + sysdecode_cap_rights(stdout, &ktr->cap_needed); printf(", descriptor holds "); - capname(&ktr->cap_held); + sysdecode_cap_rights(stdout, &ktr->cap_held); break; case CAPFAIL_INCREASE: /* requested more capabilities than fd already has */ printf("attempt to increase capabilities from "); - capname(&ktr->cap_held); + sysdecode_cap_rights(stdout, &ktr->cap_held); printf(" to "); - capname(&ktr->cap_needed); + sysdecode_cap_rights(stdout, &ktr->cap_needed); break; case CAPFAIL_SYSCALL: /* called restricted syscall */ @@ -1860,9 +2023,9 @@ ktrcapfail(struct ktr_cap_fail *ktr) break; default: printf("unknown capability failure: "); - capname(&ktr->cap_needed); + sysdecode_cap_rights(stdout, &ktr->cap_needed); printf(" "); - capname(&ktr->cap_held); + sysdecode_cap_rights(stdout, &ktr->cap_held); break; } printf("\n"); @@ -1873,15 +2036,20 @@ ktrfault(struct ktr_fault *ktr) { printf("0x%jx ", (uintmax_t)ktr->vaddr); - vmprotname(ktr->type); + print_mask_arg(sysdecode_vmprot, ktr->type); printf("\n"); } void ktrfaultend(struct ktr_faultend *ktr) { + const char *str; - vmresultname(ktr->result); + str = sysdecode_vmresult(ktr->result); + if (str != NULL) + printf("%s", str); + else + printf("<invalid=%d>", ktr->result); printf("\n"); } diff --git a/usr.bin/kdump/mksubr b/usr.bin/kdump/mksubr deleted file mode 100644 index aa001f8..0000000 --- a/usr.bin/kdump/mksubr +++ /dev/null @@ -1,759 +0,0 @@ -#!/bin/sh -# -# Copyright (c) 2006 "David Kirchner" <dpk@dpk.net>. 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. -# -# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. -# -# $FreeBSD$ -# -# Generates kdump_subr.c -# mkioctls is a special-purpose script, and works fine as it is -# now, so it remains independent. The idea behind how it generates -# its list was heavily borrowed here. -# -# Some functions here are automatically generated. This can mean -# the user will see unusual kdump output or errors while building -# if the underlying .h files are changed significantly. -# -# Key: -# AUTO: Completely auto-generated with either the "or" or the "switch" -# method. -# AUTO - Special: Generated automatically, but with some extra commands -# that the auto_*_type() functions are inappropriate for. -# MANUAL: Manually entered and must therefore be manually updated. - -set -e - -LC_ALL=C; export LC_ALL - -if [ -z "$1" ] -then - echo "usage: sh $0 include-dir" - exit 1 -fi -include_dir=$1 - -# -# Automatically generates a C function that will print out the -# numeric input as a pipe-delimited string of the appropriate -# #define keys. ex: -# S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH -# The XOR is necessary to prevent including the "0"-value in every -# line. -# -auto_or_type () { - local name grep file - name=$1 - grep=$2 - file=$3 - - cat <<_EOF_ -/* AUTO */ -void -$name(intmax_t arg) -{ - int or = 0; - printf("%#jx<", (uintmax_t)arg); -_EOF_ - egrep "^#[[:space:]]*define[[:space:]]+"${grep}"[[:space:]]*" \ - $include_dir/$file | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tif (!((arg > 0) ^ ((%s) > 0)))\n\t\tif_print_or(arg, %s, or);\n", $i, $i }' -cat <<_EOF_ - printf(">"); - if (or == 0) - printf("<invalid>%jd", arg); -} - -_EOF_ -} - -# -# Automatically generates a C function used when the argument -# maps to a single, specific #definition -# -auto_switch_type () { - local name grep file - name=$1 - grep=$2 - file=$3 - - cat <<_EOF_ -/* AUTO */ -void -$name(intmax_t arg) -{ - switch (arg) { -_EOF_ - egrep "^#[[:space:]]*define[[:space:]]+"${grep}"[[:space:]]*" \ - $include_dir/$file | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tcase %s:\n\t\tprintf(\"%s\");\n\t\tbreak;\n", $i, $i }' -cat <<_EOF_ - default: /* Should not reach */ - printf("<invalid=%jd>", arg); - } -} - -_EOF_ -} - -# -# Automatically generates a C function used when the argument -# maps to a #definition -# -auto_if_type () { - local name grep file - name=$1 - grep=$2 - file=$3 - - cat <<_EOF_ -/* AUTO */ -void -$name(intmax_t arg) -{ -_EOF_ - egrep "^#[[:space:]]*define[[:space:]]+"${grep}"[[:space:]]*" \ - $include_dir/$file | \ - awk '{ printf "\t"; \ - if (NR > 1) \ - printf "else " ; \ - printf "if (arg == %s) \n\t\tprintf(\"%s\");\n", $2, $2 }' -cat <<_EOF_ - else /* Should not reach */ - printf("<invalid=%jd>", arg); -} - -_EOF_ -} - -# C start - -cat <<_EOF_ -#include <stdint.h> -#include <stdio.h> -#include <sys/fcntl.h> -#include <sys/stat.h> -#include <sys/unistd.h> -#include <sys/mman.h> -#include <sys/wait.h> -#define _KERNEL -#include <sys/socket.h> -#undef _KERNEL -#include <netinet/in.h> -#include <sys/param.h> -#include <sys/mount.h> -#include <sys/procctl.h> -#include <sys/ptrace.h> -#include <sys/resource.h> -#include <sys/reboot.h> -#include <sched.h> -#include <sys/linker.h> -#define _KERNEL -#include <sys/thr.h> -#undef _KERNEL -#include <sys/extattr.h> -#include <sys/acl.h> -#include <aio.h> -#include <sys/sem.h> -#include <sys/ipc.h> -#include <sys/rtprio.h> -#include <sys/shm.h> -#include <sys/umtx.h> -#include <nfsserver/nfs.h> -#include <ufs/ufs/quota.h> -#include <sys/capsicum.h> -#include <vm/vm.h> -#include <vm/vm_param.h> - -#include "kdump_subr.h" - -/* - * These are simple support macros. print_or utilizes a variable - * defined in the calling function to track whether or not it should - * print a logical-OR character ('|') before a string. if_print_or - * simply handles the necessary "if" statement used in many lines - * of this file. - */ -#define print_or(str,orflag) do { \\ - if (orflag) putchar('|'); else orflag = 1; \\ - printf (str); } \\ - while (0) -#define if_print_or(i,flag,orflag) do { \\ - if ((i & flag) == flag) \\ - print_or(#flag,orflag); } \\ - while (0) - -/* MANUAL */ -void -atfdname(int fd, int decimal) -{ - if (fd == AT_FDCWD) - printf("AT_FDCWD"); - else if (decimal) - printf("%d", fd); - else - printf("%#x", fd); -} - -/* MANUAL */ -extern char *signames[]; /* from kdump.c */ -void -signame(int sig) -{ - if (sig > 0 && sig < NSIG) - printf("SIG%s",signames[sig]); - else - printf("SIG %d", sig); -} - -/* MANUAL */ -void -semctlname(int cmd) -{ - switch (cmd) { - case GETNCNT: - printf("GETNCNT"); - break; - case GETPID: - printf("GETPID"); - break; - case GETVAL: - printf("GETVAL"); - break; - case GETALL: - printf("GETALL"); - break; - case GETZCNT: - printf("GETZCNT"); - break; - case SETVAL: - printf("SETVAL"); - break; - case SETALL: - printf("SETALL"); - break; - case IPC_RMID: - printf("IPC_RMID"); - break; - case IPC_SET: - printf("IPC_SET"); - break; - case IPC_STAT: - printf("IPC_STAT"); - break; - default: /* Should not reach */ - printf("<invalid=%d>", cmd); - } -} - -/* MANUAL */ -void -shmctlname(int cmd) -{ - switch (cmd) { - case IPC_RMID: - printf("IPC_RMID"); - break; - case IPC_SET: - printf("IPC_SET"); - break; - case IPC_STAT: - printf("IPC_STAT"); - break; - default: /* Should not reach */ - printf("<invalid=%d>", cmd); - } -} - -/* MANUAL */ -void -semgetname(int flag) -{ - int or = 0; - if_print_or(flag, IPC_CREAT, or); - if_print_or(flag, IPC_EXCL, or); - if_print_or(flag, SEM_R, or); - if_print_or(flag, SEM_A, or); - if_print_or(flag, (SEM_R>>3), or); - if_print_or(flag, (SEM_A>>3), or); - if_print_or(flag, (SEM_R>>6), or); - if_print_or(flag, (SEM_A>>6), or); -} - -/* - * MANUAL - * - * Only used by SYS_open. Unless O_CREAT is set in flags, the - * mode argument is unused (and often bogus and misleading). - */ -void -flagsandmodename(int flags, int mode, int decimal) -{ - flagsname(flags); - putchar(','); - if ((flags & O_CREAT) == O_CREAT) { - modename (mode); - } else { - if (decimal) { - printf("<unused>%d", mode); - } else { - printf("<unused>%#x", (unsigned int)mode); - } - } -} - -/* MANUAL */ -void -idtypename(idtype_t idtype, int decimal) -{ - switch(idtype) { - case P_PID: - printf("P_PID"); - break; - case P_PPID: - printf("P_PPID"); - break; - case P_PGID: - printf("P_PGID"); - break; - case P_SID: - printf("P_SID"); - break; - case P_CID: - printf("P_CID"); - break; - case P_UID: - printf("P_UID"); - break; - case P_GID: - printf("P_GID"); - break; - case P_ALL: - printf("P_ALL"); - break; - case P_LWPID: - printf("P_LWPID"); - break; - case P_TASKID: - printf("P_TASKID"); - break; - case P_PROJID: - printf("P_PROJID"); - break; - case P_POOLID: - printf("P_POOLID"); - break; - case P_JAILID: - printf("P_JAILID"); - break; - case P_CTID: - printf("P_CTID"); - break; - case P_CPUID: - printf("P_CPUID"); - break; - case P_PSETID: - printf("P_PSETID"); - break; - default: - if (decimal) { - printf("%d", idtype); - } else { - printf("%#x", idtype); - } - } -} - -/* - * MANUAL - * - * [g|s]etsockopt's level argument can either be SOL_SOCKET or a value - * referring to a line in /etc/protocols . It might be appropriate - * to use getprotoent(3) here. - */ -void -sockoptlevelname(int level, int decimal) -{ - if (level == SOL_SOCKET) { - printf("SOL_SOCKET"); - } else { - if (decimal) { - printf("%d", level); - } else { - printf("%#x", (unsigned int)level); - } - } -} - -/* - * MANUAL - * - * Used for page fault type. Cannot use auto_or_type since the macro - * values contain a cast. Also, VM_PROT_NONE has to be handled specially. - */ -void -vmprotname (int type) -{ - int or = 0; - - if (type == VM_PROT_NONE) { - (void)printf("VM_PROT_NONE"); - return; - } - if_print_or(type, VM_PROT_READ, or); - if_print_or(type, VM_PROT_WRITE, or); - if_print_or(type, VM_PROT_EXECUTE, or); - if_print_or(type, VM_PROT_COPY, or); -} - -/* - * MANUAL - */ -void -socktypenamewithflags(int type) -{ - if (type & SOCK_CLOEXEC) - printf("SOCK_CLOEXEC|"), type &= ~SOCK_CLOEXEC; - if (type & SOCK_NONBLOCK) - printf("SOCK_NONBLOCK|"), type &= ~SOCK_NONBLOCK; - socktypename(type); -} -_EOF_ - -auto_or_type "accessmodename" "[A-Z]_OK[[:space:]]+0?x?[0-9A-Fa-f]+" "sys/unistd.h" -auto_switch_type "acltypename" "ACL_TYPE_[A-Z4_]+[[:space:]]+0x[0-9]+" "sys/acl.h" -auto_or_type "capfcntlname" "CAP_FCNTL_[A-Z]+[[:space:]]+\(1" "sys/capsicum.h" -auto_switch_type "extattrctlname" "EXTATTR_NAMESPACE_[A-Z]+[[:space:]]+0x[0-9]+" "sys/extattr.h" -auto_switch_type "fadvisebehavname" "POSIX_FADV_[A-Z]+[[:space:]]+[0-9]+" "sys/fcntl.h" -auto_or_type "flagsname" "O_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/fcntl.h" -auto_or_type "flockname" "LOCK_[A-Z]+[[:space:]]+0x[0-9]+" "sys/fcntl.h" -auto_or_type "getfsstatflagsname" "MNT_[A-Z]+[[:space:]]+[1-9][0-9]*" "sys/mount.h" -auto_switch_type "kldsymcmdname" "KLDSYM_[A-Z]+[[:space:]]+[0-9]+" "sys/linker.h" -auto_switch_type "kldunloadfflagsname" "LINKER_UNLOAD_[A-Z]+[[:space:]]+[0-9]+" "sys/linker.h" -auto_switch_type "lio_listioname" "LIO_(NO)?WAIT[[:space:]]+[0-9]+" "aio.h" -auto_switch_type "madvisebehavname" "_?MADV_[A-Z]+[[:space:]]+[0-9]+" "sys/mman.h" -auto_switch_type "minheritname" "INHERIT_[A-Z]+[[:space:]]+[0-9]+" "sys/mman.h" -auto_or_type "mlockallname" "MCL_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mman.h" -auto_or_type "mmapprotname" "PROT_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/mman.h" -auto_or_type "modename" "S_[A-Z]+[[:space:]]+[0-6]{7}" "sys/stat.h" -auto_or_type "mountflagsname" "MNT_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mount.h" -auto_switch_type "msyncflagsname" "MS_[A-Z]+[[:space:]]+0x[0-9]+" "sys/mman.h" -auto_or_type "nfssvcname" "NFSSVC_[A-Z0-9]+[[:space:]]+0x[0-9]+" "nfs/nfssvc.h" -auto_switch_type "prioname" "PRIO_[A-Z]+[[:space:]]+[0-9]" "sys/resource.h" -auto_switch_type "procctlcmdname" "PROC_[A-Z]+[[:space:]]+[0-9]" "sys/procctl.h" -auto_switch_type "ptraceopname" "PT_[[:alnum:]_]+[[:space:]]+[0-9]+" "sys/ptrace.h" -auto_switch_type "quotactlname" "Q_[A-Z]+[[:space:]]+0x[0-9]+" "ufs/ufs/quota.h" -auto_or_type "rebootoptname" "RB_[A-Z]+[[:space:]]+0x[0-9]+" "sys/reboot.h" -auto_or_type "rforkname" "RF[A-Z]+[[:space:]]+\([0-9]+<<[0-9]+\)" "sys/unistd.h" -auto_switch_type "rlimitname" "RLIMIT_[A-Z]+[[:space:]]+[0-9]+" "sys/resource.h" -auto_switch_type "schedpolicyname" "SCHED_[A-Z]+[[:space:]]+[0-9]+" "sched.h" -auto_switch_type "sendfileflagsname" "SF_[A-Z]+[[:space:]]+[0-9]+" "sys/socket.h" -auto_or_type "shmatname" "SHM_[A-Z]+[[:space:]]+[0-9]{6}+" "sys/shm.h" -auto_switch_type "shutdownhowname" "SHUT_[A-Z]+[[:space:]]+[0-9]+" "sys/socket.h" -auto_switch_type "sigbuscodename" "BUS_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigchldcodename" "CLD_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigfpecodename" "FPE_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigprocmaskhowname" "SIG_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigillcodename" "ILL_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigsegvcodename" "SEGV_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_switch_type "sigtrapcodename" "TRAP_[A-Z]+[[:space:]]+[0-9]+" "sys/signal.h" -auto_if_type "sockdomainname" "PF_[[:alnum:]]+[[:space:]]+" "sys/socket.h" -auto_if_type "sockfamilyname" "AF_[[:alnum:]]+[[:space:]]+" "sys/socket.h" -auto_if_type "sockipprotoname" "IPPROTO_[[:alnum:]]+[[:space:]]+" "netinet/in.h" -auto_switch_type "sockoptname" "SO_[A-Z]+[[:space:]]+0x[0-9]+" "sys/socket.h" -auto_switch_type "socktypename" "SOCK_[A-Z]+[[:space:]]+[1-9]+[0-9]*" "sys/socket.h" -auto_or_type "thrcreateflagsname" "THR_[A-Z]+[[:space:]]+0x[0-9]+" "sys/thr.h" -auto_switch_type "umtxopname" "UMTX_OP_[[:alnum:]_]+[[:space:]]+[0-9]+" "sys/umtx.h" -auto_switch_type "vmresultname" "KERN_[A-Z]+[[:space:]]+[0-9]+" "vm/vm_param.h" -auto_or_type "wait6optname" "W[A-Z]+[[:space:]]+[0-9]+" "sys/wait.h" -auto_switch_type "whencename" "SEEK_[A-Z]+[[:space:]]+[0-9]+" "sys/unistd.h" - -cat <<_EOF_ -/* - * AUTO - Special - * F_ is used to specify fcntl commands as well as arguments. Both sets are - * grouped in fcntl.h, and this awk script grabs the first group. - */ -void -fcntlcmdname(int cmd, int arg, int decimal) -{ - switch (cmd) { -_EOF_ -egrep "^#[[:space:]]*define[[:space:]]+F_[A-Z0-9_]+[[:space:]]+[0-9]+[[:space:]]*" \ - $include_dir/sys/fcntl.h | \ - awk 'BEGIN { o=0 } { for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - if (o <= $(i+1)) \ - printf "\tcase %s:\n\t\tprintf(\"%s\");\n\t\tbreak;\n", $i, $i; \ - else \ - exit; \ - o = $(i+1) }' -cat <<_EOF_ - default: /* Should not reach */ - printf("<invalid=%d>", cmd); - } - putchar(','); - if (cmd == F_GETFD || cmd == F_SETFD) { - if (arg == FD_CLOEXEC) - printf("FD_CLOEXEC"); - else if (arg == 0) - printf("0"); - else { - if (decimal) - printf("<invalid>%d", arg); - else - printf("<invalid>%#x", (unsigned int)arg); - } - } else if (cmd == F_SETFL) { - flagsname(arg); - } else { - if (decimal) - printf("%d", arg); - else - printf("%#x", (unsigned int)arg); - } -} - -/* - * AUTO - Special - * - * The MAP_ALIGNED flag requires special handling. - */ -void -mmapflagsname(int flags) -{ - int align; - int or = 0; - printf("%#x<", flags); -_EOF_ -egrep "^#[[:space:]]*define[[:space:]]+MAP_[A-Z_]+[[:space:]]+0x[0-9A-Fa-f]+[[:space:]]*" \ - $include_dir/sys/mman.h | grep -v MAP_ALIGNED | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tif (!((flags > 0) ^ ((%s) > 0)))\n\t\tif_print_or(flags, %s, or);\n", $i, $i }' -cat <<_EOF_ -#ifdef MAP_32BIT - if (!((flags > 0) ^ ((MAP_32BIT) > 0))) - if_print_or(flags, MAP_32BIT, or); -#endif - align = flags & MAP_ALIGNMENT_MASK; - if (align != 0) { - if (align == MAP_ALIGNED_SUPER) - print_or("MAP_ALIGNED_SUPER", or); - else { - print_or("MAP_ALIGNED", or); - printf("(%d)", align >> MAP_ALIGNMENT_SHIFT); - } - } - printf(">"); - if (or == 0) - printf("<invalid>%d", flags); -} - -/* - * AUTO - Special - * - * The only reason this is not fully automated is due to the - * grep -v RTP_PRIO statement. A better egrep line should - * make this capable of being a auto_switch_type() function. - */ -void -rtprioname(int func) -{ - switch (func) { -_EOF_ -egrep "^#[[:space:]]*define[[:space:]]+RTP_[A-Z]+[[:space:]]+0x[0-9]+[[:space:]]*" \ - $include_dir/sys/rtprio.h | grep -v RTP_PRIO | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tcase %s:\n\t\tprintf(\"%s\");\n\t\tbreak;\n", $i, $i }' -cat <<_EOF_ - default: /* Should not reach */ - printf("<invalid=%d>", func); - } -} - -/* - * AUTO - Special - * - * The send and recv functions have a flags argument which can be - * set to 0. There is no corresponding #define. The auto_ functions - * detect this as "invalid", which is incorrect here. - */ -void -sendrecvflagsname(int flags) -{ - int or = 0; - - if (flags == 0) { - printf("0"); - return; - } - - printf("%#x<", flags); -_EOF_ -egrep "^#[[:space:]]*define[[:space:]]+MSG_[A-Z]+[[:space:]]+0x[0-9]+[[:space:]]*" $include_dir/sys/socket.h | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tif(!((flags>0)^((%s)>0)))\n\t\tif_print_or(flags, %s, or);\n", $i, $i }' -cat <<_EOF_ - printf(">"); -} - -/* - * AUTO - Special - * - * Check general codes first, then defer to signal-specific codes. - */ -void -sigcodename(int sig, int code) -{ - switch (code) { -_EOF_ -egrep "^#[[:space:]]*define[[:space:]]+SI_[A-Z]+[[:space:]]+0(x[0-9abcdef]+)?[[:space:]]*" \ - $include_dir/sys/signal.h | grep -v SI_UNDEFINED | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tcase %s:\n\t\tprintf(\"%s\");\n\t\tbreak;\n", $i, $i }' -cat <<_EOF_ - default: - switch (sig) { - case SIGILL: - sigillcodename(code); - break; - case SIGBUS: - sigbuscodename(code); - break; - case SIGSEGV: - sigsegvcodename(code); - break; - case SIGFPE: - sigfpecodename(code); - break; - case SIGTRAP: - sigtrapcodename(code); - break; - case SIGCHLD: - sigchldcodename(code); - break; - default: - printf("<invalid=%#x>", code); - } - } -} - -/* - * AUTO - Special - * - * Just print 0 as 0. - */ -void -umtxcvwaitflags(intmax_t arg) -{ - int or = 0; - if (arg == 0) { - printf("0"); - return; - } - printf("%#jx<", (uintmax_t)arg); -_EOF_ - egrep "^#[[:space:]]*define[[:space:]]+CVWAIT_[A-Z_]+[[:space:]]+0x[0-9]+[[:space:]]*" \ - $include_dir/sys/umtx.h | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tif (!((arg > 0) ^ ((%s) > 0)))\n\t\tif_print_or(arg, %s, or);\n", $i, $i }' -cat <<_EOF_ - printf(">"); - if (or == 0) - printf("<invalid>%jd", arg); -} - - -/* - * AUTO - Special - * - * Just print 0 as 0. - */ -void -umtxrwlockflags(intmax_t arg) -{ - int or = 0; - if (arg == 0) { - printf("0"); - return; - } - printf("%#jx<", (uintmax_t)arg); -_EOF_ - egrep "^#[[:space:]]*define[[:space:]]+URWLOCK_PREFER_READER[[:space:]]+0x[0-9]+[[:space:]]*" \ - $include_dir/sys/umtx.h | \ - awk '{ for (i = 1; i <= NF; i++) \ - if ($i ~ /define/) \ - break; \ - ++i; \ - printf "\tif (!((arg > 0) ^ ((%s) > 0)))\n\t\tif_print_or(arg, %s, or);\n", $i, $i }' -cat <<_EOF_ - printf(">"); - if (or == 0) - printf("<invalid>%jd", arg); -} -_EOF_ -egrep '#define[[:space:]]+CAP_[A-Z_]+[[:space:]]+CAPRIGHT\([0-9],[[:space:]]+0x[0-9]{16}ULL\)' \ - $include_dir/sys/capsicum.h | \ - sed -E 's/[ ]+/ /g' | \ - awk -F '[ \(,\)]' ' - BEGIN { - printf "void\n" - printf "capname(const cap_rights_t *rightsp)\n" - printf "{\n" - printf "\tint comma = 0;\n\n" - printf "\tprintf(\"<\");\n" - } - { - printf "\tif ((rightsp->cr_rights[%s] & %s) == %s) {\n", $4, $2, $2 - printf "\t\tif (comma) printf(\",\"); else comma = 1;\n" - printf "\t\tprintf(\"%s\");\n", $2 - printf "\t}\n" - } - END { - printf "\tprintf(\">\");\n" - printf "}\n" - }' diff --git a/usr.bin/truss/Makefile b/usr.bin/truss/Makefile index 480dab0..d077eda 100644 --- a/usr.bin/truss/Makefile +++ b/usr.bin/truss/Makefile @@ -1,12 +1,13 @@ # $FreeBSD$ -NO_WERROR= +#NO_WERROR= PROG= truss SRCS= main.c setup.c syscalls.c LIBADD= sysdecode -CFLAGS+= -I${.CURDIR} -I. -I${.CURDIR}/../../sys +#CFLAGS+= -I${.CURDIR} -I. -I${.CURDIR}/../../sys +CFLAGS+= -I${.CURDIR}/../../sys ABIS+= freebsd # Each ABI is expected to have an ABI.c, MACHINE_ARCH-ABI.c or diff --git a/usr.bin/truss/aarch64-cloudabi64.c b/usr.bin/truss/aarch64-cloudabi64.c index 27906ea..6a1694a 100644 --- a/usr.bin/truss/aarch64-cloudabi64.c +++ b/usr.bin/truss/aarch64-cloudabi64.c @@ -31,6 +31,7 @@ __FBSDID("$FreeBSD$"); #include <machine/armreg.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/aarch64-freebsd.c b/usr.bin/truss/aarch64-freebsd.c index 534441c..a9944f5 100644 --- a/usr.bin/truss/aarch64-freebsd.c +++ b/usr.bin/truss/aarch64-freebsd.c @@ -38,6 +38,7 @@ __FBSDID("$FreeBSD$"); #include <machine/armreg.h> #include <machine/ucontext.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/amd64-cloudabi64.c b/usr.bin/truss/amd64-cloudabi64.c index f7d7c1a..06de944 100644 --- a/usr.bin/truss/amd64-cloudabi64.c +++ b/usr.bin/truss/amd64-cloudabi64.c @@ -31,6 +31,7 @@ __FBSDID("$FreeBSD$"); #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/amd64-freebsd.c b/usr.bin/truss/amd64-freebsd.c index a2f378c..fa844fa 100644 --- a/usr.bin/truss/amd64-freebsd.c +++ b/usr.bin/truss/amd64-freebsd.c @@ -40,6 +40,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/amd64-freebsd32.c b/usr.bin/truss/amd64-freebsd32.c index cfcead2..adbc3e7 100644 --- a/usr.bin/truss/amd64-freebsd32.c +++ b/usr.bin/truss/amd64-freebsd32.c @@ -40,6 +40,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <sysdecode.h> diff --git a/usr.bin/truss/amd64-linux.c b/usr.bin/truss/amd64-linux.c index 4397804..94a3d6a 100644 --- a/usr.bin/truss/amd64-linux.c +++ b/usr.bin/truss/amd64-linux.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/amd64-linux32.c b/usr.bin/truss/amd64-linux32.c index 279d228..3f32c84 100644 --- a/usr.bin/truss/amd64-linux32.c +++ b/usr.bin/truss/amd64-linux32.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/arm-freebsd.c b/usr.bin/truss/arm-freebsd.c index a1b2b21..826a8d8 100644 --- a/usr.bin/truss/arm-freebsd.c +++ b/usr.bin/truss/arm-freebsd.c @@ -41,6 +41,7 @@ __FBSDID("$FreeBSD$"); #include <machine/armreg.h> #include <machine/ucontext.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/extern.h b/usr.bin/truss/extern.h index 5ce3d3b..2cdd9c5 100644 --- a/usr.bin/truss/extern.h +++ b/usr.bin/truss/extern.h @@ -37,4 +37,3 @@ extern void start_tracing(struct trussinfo *, pid_t); extern void restore_proc(int); extern void eventloop(struct trussinfo *); extern const char *ioctlname(unsigned long val); -extern char *strsig(int sig); diff --git a/usr.bin/truss/i386-freebsd.c b/usr.bin/truss/i386-freebsd.c index bf35af2..469ab7d 100644 --- a/usr.bin/truss/i386-freebsd.c +++ b/usr.bin/truss/i386-freebsd.c @@ -40,6 +40,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/i386-linux.c b/usr.bin/truss/i386-linux.c index 52232b4..56fab65 100644 --- a/usr.bin/truss/i386-linux.c +++ b/usr.bin/truss/i386-linux.c @@ -39,6 +39,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/psl.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/main.c b/usr.bin/truss/main.c index 38626fd..84fd37e 100644 --- a/usr.bin/truss/main.c +++ b/usr.bin/truss/main.c @@ -42,6 +42,7 @@ __FBSDID("$FreeBSD$"); #include <err.h> #include <signal.h> +#include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <sysdecode.h> @@ -61,18 +62,6 @@ usage(void) exit(1); } -char * -strsig(int sig) -{ - static char tmp[64]; - - if (sig > 0 && sig < NSIG) { - snprintf(tmp, sizeof(tmp), "SIG%s", sys_signame[sig]); - return (tmp); - } - return (NULL); -} - int main(int ac, char **av) { diff --git a/usr.bin/truss/mips-freebsd.c b/usr.bin/truss/mips-freebsd.c index 3a42a59..ac803b9 100644 --- a/usr.bin/truss/mips-freebsd.c +++ b/usr.bin/truss/mips-freebsd.c @@ -40,6 +40,7 @@ __FBSDID("$FreeBSD$"); #include <machine/frame.h> #include <machine/reg.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/powerpc-freebsd.c b/usr.bin/truss/powerpc-freebsd.c index ee78d03..dbeba2b 100644 --- a/usr.bin/truss/powerpc-freebsd.c +++ b/usr.bin/truss/powerpc-freebsd.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/frame.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/powerpc64-freebsd.c b/usr.bin/truss/powerpc64-freebsd.c index cc64cd6..a8927bb 100644 --- a/usr.bin/truss/powerpc64-freebsd.c +++ b/usr.bin/truss/powerpc64-freebsd.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/frame.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/powerpc64-freebsd32.c b/usr.bin/truss/powerpc64-freebsd32.c index c6f3b10..bc8d2fc 100644 --- a/usr.bin/truss/powerpc64-freebsd32.c +++ b/usr.bin/truss/powerpc64-freebsd32.c @@ -36,6 +36,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/frame.h> +#include <stdbool.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/setup.c b/usr.bin/truss/setup.c index a14c016..036cb8f 100644 --- a/usr.bin/truss/setup.c +++ b/usr.bin/truss/setup.c @@ -45,6 +45,7 @@ __FBSDID("$FreeBSD$"); #include <err.h> #include <errno.h> #include <signal.h> +#include <stdbool.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> @@ -591,14 +592,15 @@ static void report_signal(struct trussinfo *info, siginfo_t *si) { struct threadinfo *t; - char *signame; + const char *signame; t = info->curthread; clock_gettime(CLOCK_REALTIME, &t->after); print_line_prefix(info); - signame = strsig(si->si_status); - fprintf(info->outfile, "SIGNAL %u (%s)\n", si->si_status, - signame == NULL ? "?" : signame); + signame = sysdecode_signal(si->si_status); + if (signame == NULL) + signame = "?"; + fprintf(info->outfile, "SIGNAL %u (%s)\n", si->si_status, signame); } /* diff --git a/usr.bin/truss/sparc64-freebsd.c b/usr.bin/truss/sparc64-freebsd.c index a8569c0..3cbad50 100644 --- a/usr.bin/truss/sparc64-freebsd.c +++ b/usr.bin/truss/sparc64-freebsd.c @@ -41,6 +41,7 @@ __FBSDID("$FreeBSD$"); #include <machine/reg.h> #include <machine/tstate.h> +#include <stdbool.h> #include <stddef.h> #include <stdio.h> #include <sysdecode.h> diff --git a/usr.bin/truss/syscall.h b/usr.bin/truss/syscall.h index 906f799..0cd752d 100644 --- a/usr.bin/truss/syscall.h +++ b/usr.bin/truss/syscall.h @@ -44,7 +44,7 @@ enum Argtype { None = 1, Hex, Octal, Int, UInt, LongHex, Name, Ptr, Stat, Ioctl, Fcntlflag, Rusage, BinString, Shutdown, Resource, Rlimit, Timeval2, Pathconf, Rforkflags, ExitStatus, Waitoptions, Idtype, Procctl, LinuxSockArgs, Umtxop, Atfd, Atflags, Timespec2, Accessmode, Long, - Sysarch, ExecArgs, ExecEnv, PipeFds, QuadHex, Utrace, IntArray, + Sysarch, ExecArgs, ExecEnv, PipeFds, QuadHex, Utrace, IntArray, Pipe2, CloudABIAdvice, CloudABIClockID, ClouduABIFDSFlags, CloudABIFDStat, CloudABIFileStat, CloudABIFileType, diff --git a/usr.bin/truss/syscalls.c b/usr.bin/truss/syscalls.c index 855f5d3..46bc87f 100644 --- a/usr.bin/truss/syscalls.c +++ b/usr.bin/truss/syscalls.c @@ -40,14 +40,11 @@ __FBSDID("$FreeBSD$"); #include <sys/types.h> #include <sys/event.h> #include <sys/ioccom.h> -#include <sys/mman.h> #include <sys/mount.h> -#include <sys/procctl.h> #include <sys/ptrace.h> #include <sys/resource.h> #include <sys/socket.h> #include <sys/stat.h> -#include <sys/umtx.h> #include <sys/un.h> #include <sys/wait.h> #include <machine/sysarch.h> @@ -60,13 +57,10 @@ __FBSDID("$FreeBSD$"); #include <poll.h> #include <signal.h> #include <stdbool.h> -#include <stddef.h> -#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sysdecode.h> -#include <time.h> #include <unistd.h> #include <vis.h> @@ -256,7 +250,7 @@ static struct syscall decoded_syscalls[] = { { .name = "pipe", .ret_type = 1, .nargs = 1, .args = { { PipeFds | OUT, 0 } } }, { .name = "pipe2", .ret_type = 1, .nargs = 2, - .args = { { Ptr, 0 }, { Open, 1 } } }, + .args = { { Ptr, 0 }, { Pipe2, 1 } } }, { .name = "poll", .ret_type = 1, .nargs = 3, .args = { { Pollfd, 0 }, { Int, 1 }, { Int, 2 } } }, { .name = "posix_openpt", .ret_type = 1, .nargs = 1, @@ -553,83 +547,11 @@ static struct xlat poll_flags[] = { X(POLLWRBAND) X(POLLINIGNEOF) XEND }; -static struct xlat mmap_flags[] = { - X(MAP_SHARED) X(MAP_PRIVATE) X(MAP_FIXED) X(MAP_RESERVED0020) - X(MAP_RESERVED0040) X(MAP_RESERVED0080) X(MAP_RESERVED0100) - X(MAP_HASSEMAPHORE) X(MAP_STACK) X(MAP_NOSYNC) X(MAP_ANON) - X(MAP_EXCL) X(MAP_NOCORE) X(MAP_PREFAULT_READ) -#ifdef MAP_32BIT - X(MAP_32BIT) -#endif - XEND -}; - -static struct xlat mprot_flags[] = { - X(PROT_NONE) X(PROT_READ) X(PROT_WRITE) X(PROT_EXEC) XEND -}; - -static struct xlat whence_arg[] = { - X(SEEK_SET) X(SEEK_CUR) X(SEEK_END) X(SEEK_DATA) X(SEEK_HOLE) XEND -}; - static struct xlat sigaction_flags[] = { X(SA_ONSTACK) X(SA_RESTART) X(SA_RESETHAND) X(SA_NOCLDSTOP) X(SA_NODEFER) X(SA_NOCLDWAIT) X(SA_SIGINFO) XEND }; -static struct xlat fcntl_arg[] = { - X(F_DUPFD) X(F_GETFD) X(F_SETFD) X(F_GETFL) X(F_SETFL) - X(F_GETOWN) X(F_SETOWN) X(F_OGETLK) X(F_OSETLK) X(F_OSETLKW) - X(F_DUP2FD) X(F_GETLK) X(F_SETLK) X(F_SETLKW) X(F_SETLK_REMOTE) - X(F_READAHEAD) X(F_RDAHEAD) X(F_DUPFD_CLOEXEC) X(F_DUP2FD_CLOEXEC) - XEND -}; - -static struct xlat fcntlfd_arg[] = { - X(FD_CLOEXEC) XEND -}; - -static struct xlat fcntlfl_arg[] = { - X(O_APPEND) X(O_ASYNC) X(O_FSYNC) X(O_NONBLOCK) X(O_NOFOLLOW) - X(FRDAHEAD) X(O_DIRECT) XEND -}; - -static struct xlat sockdomain_arg[] = { - X(PF_UNSPEC) X(PF_LOCAL) X(PF_UNIX) X(PF_INET) X(PF_IMPLINK) - X(PF_PUP) X(PF_CHAOS) X(PF_NETBIOS) X(PF_ISO) X(PF_OSI) - X(PF_ECMA) X(PF_DATAKIT) X(PF_CCITT) X(PF_SNA) X(PF_DECnet) - X(PF_DLI) X(PF_LAT) X(PF_HYLINK) X(PF_APPLETALK) X(PF_ROUTE) - X(PF_LINK) X(PF_XTP) X(PF_COIP) X(PF_CNT) X(PF_SIP) X(PF_IPX) - X(PF_RTIP) X(PF_PIP) X(PF_ISDN) X(PF_KEY) X(PF_INET6) - X(PF_NATM) X(PF_ATM) X(PF_NETGRAPH) X(PF_SLOW) X(PF_SCLUSTER) - X(PF_ARP) X(PF_BLUETOOTH) X(PF_IEEE80211) X(PF_INET_SDP) - X(PF_INET6_SDP) XEND -}; - -static struct xlat socktype_arg[] = { - X(SOCK_STREAM) X(SOCK_DGRAM) X(SOCK_RAW) X(SOCK_RDM) - X(SOCK_SEQPACKET) XEND -}; - -static struct xlat open_flags[] = { - X(O_RDONLY) X(O_WRONLY) X(O_RDWR) X(O_ACCMODE) X(O_NONBLOCK) - X(O_APPEND) X(O_SHLOCK) X(O_EXLOCK) X(O_ASYNC) X(O_FSYNC) - X(O_NOFOLLOW) X(O_CREAT) X(O_TRUNC) X(O_EXCL) X(O_NOCTTY) - X(O_DIRECT) X(O_DIRECTORY) X(O_EXEC) X(O_TTY_INIT) X(O_CLOEXEC) - X(O_VERIFY) XEND -}; - -static struct xlat shutdown_arg[] = { - X(SHUT_RD) X(SHUT_WR) X(SHUT_RDWR) XEND -}; - -static struct xlat resource_arg[] = { - X(RLIMIT_CPU) X(RLIMIT_FSIZE) X(RLIMIT_DATA) X(RLIMIT_STACK) - X(RLIMIT_CORE) X(RLIMIT_RSS) X(RLIMIT_MEMLOCK) X(RLIMIT_NPROC) - X(RLIMIT_NOFILE) X(RLIMIT_SBSIZE) X(RLIMIT_VMEM) X(RLIMIT_NPTS) - X(RLIMIT_SWAP) X(RLIMIT_KQUEUES) XEND -}; - static struct xlat pathconf_arg[] = { X(_PC_LINK_MAX) X(_PC_MAX_CANON) X(_PC_MAX_INPUT) X(_PC_NAME_MAX) X(_PC_PATH_MAX) X(_PC_PIPE_BUF) @@ -643,50 +565,11 @@ static struct xlat pathconf_arg[] = { X(_PC_ACL_NFS4) X(_PC_MIN_HOLE_SIZE) XEND }; -static struct xlat rfork_flags[] = { - X(RFFDG) X(RFPROC) X(RFMEM) X(RFNOWAIT) X(RFCFDG) X(RFTHREAD) - X(RFSIGSHARE) X(RFLINUXTHPN) X(RFTSIGZMB) X(RFPPWAIT) XEND -}; - -static struct xlat wait_options[] = { - X(WNOHANG) X(WUNTRACED) X(WCONTINUED) X(WNOWAIT) X(WEXITED) - X(WTRAPPED) XEND -}; - -static struct xlat idtype_arg[] = { - X(P_PID) X(P_PPID) X(P_PGID) X(P_SID) X(P_CID) X(P_UID) X(P_GID) - X(P_ALL) X(P_LWPID) X(P_TASKID) X(P_PROJID) X(P_POOLID) X(P_JAILID) - X(P_CTID) X(P_CPUID) X(P_PSETID) XEND -}; - -static struct xlat procctl_arg[] = { - X(PROC_SPROTECT) X(PROC_REAP_ACQUIRE) X(PROC_REAP_RELEASE) - X(PROC_REAP_STATUS) X(PROC_REAP_GETPIDS) X(PROC_REAP_KILL) - X(PROC_TRACE_CTL) X(PROC_TRACE_STATUS) XEND -}; - -static struct xlat umtx_ops[] = { - X(UMTX_OP_RESERVED0) X(UMTX_OP_RESERVED1) X(UMTX_OP_WAIT) - X(UMTX_OP_WAKE) X(UMTX_OP_MUTEX_TRYLOCK) X(UMTX_OP_MUTEX_LOCK) - X(UMTX_OP_MUTEX_UNLOCK) X(UMTX_OP_SET_CEILING) X(UMTX_OP_CV_WAIT) - X(UMTX_OP_CV_SIGNAL) X(UMTX_OP_CV_BROADCAST) X(UMTX_OP_WAIT_UINT) - X(UMTX_OP_RW_RDLOCK) X(UMTX_OP_RW_WRLOCK) X(UMTX_OP_RW_UNLOCK) - X(UMTX_OP_WAIT_UINT_PRIVATE) X(UMTX_OP_WAKE_PRIVATE) - X(UMTX_OP_MUTEX_WAIT) X(UMTX_OP_MUTEX_WAKE) X(UMTX_OP_SEM_WAIT) - X(UMTX_OP_SEM_WAKE) X(UMTX_OP_NWAKE_PRIVATE) X(UMTX_OP_MUTEX_WAKE2) - X(UMTX_OP_SEM2_WAIT) X(UMTX_OP_SEM2_WAKE) - XEND -}; - static struct xlat at_flags[] = { X(AT_EACCESS) X(AT_SYMLINK_NOFOLLOW) X(AT_SYMLINK_FOLLOW) X(AT_REMOVEDIR) XEND }; -static struct xlat access_modes[] = { - X(R_OK) X(W_OK) X(X_OK) XEND -}; - static struct xlat sysarch_ops[] = { #if defined(__i386__) || defined(__amd64__) X(I386_GET_LDT) X(I386_SET_LDT) X(I386_GET_IOPERM) X(I386_SET_IOPERM) @@ -707,11 +590,6 @@ static struct xlat linux_socketcall_ops[] = { XEND }; -static struct xlat sigprocmask_ops[] = { - X(SIG_BLOCK) X(SIG_UNBLOCK) X(SIG_SETMASK) - XEND -}; - #undef X #define X(a) { CLOUDABI_##a, #a }, @@ -909,6 +787,29 @@ xlookup_bits(struct xlat *xlat, int val) return (str); } +static void +print_integer_arg(const char *(*decoder)(int), FILE *fp, int value) +{ + const char *str; + + str = decoder(value); + if (str != NULL) + fputs(str, fp); + else + fprintf(fp, "%d", value); +} + +static void +print_mask_arg(bool (*decoder)(FILE *, int, int *), FILE *fp, int value) +{ + int rem; + + if (!decoder(fp, value, &rem)) + fprintf(fp, "0x%x", rem); + else if (rem != 0) + fprintf(fp, "|0x%x", rem); +} + void init_syscalls(void) { @@ -1028,18 +929,18 @@ get_string(pid_t pid, void *addr, int max) } } -static char * +static const char * strsig2(int sig) { - static char tmp[sizeof(int) * 3 + 1]; - char *ret; + static char tmp[32]; + const char *signame; - ret = strsig(sig); - if (ret == NULL) { + signame = sysdecode_signal(sig); + if (signame == NULL) { snprintf(tmp, sizeof(tmp), "%d", sig); - ret = tmp; + signame = tmp; } - return (ret); + return (signame); } static void @@ -1493,7 +1394,7 @@ print_arg(struct syscall_args *sc, unsigned long *args, long *retval, for (i = 1; i < sys_nsig; i++) { if (sigismember(&ss, i)) { fprintf(fp, "%s%s", !first ? "|" : "", - strsig(i)); + strsig2(i)); first = 0; } } @@ -1502,92 +1403,48 @@ print_arg(struct syscall_args *sc, unsigned long *args, long *retval, fputc('}', fp); break; } - case Sigprocmask: { - fputs(xlookup(sigprocmask_ops, args[sc->offset]), fp); + case Sigprocmask: + print_integer_arg(sysdecode_sigprocmask_how, fp, + args[sc->offset]); break; - } - case Fcntlflag: { + case Fcntlflag: /* XXX: Output depends on the value of the previous argument. */ - switch (args[sc->offset - 1]) { - case F_SETFD: - fputs(xlookup_bits(fcntlfd_arg, args[sc->offset]), fp); - break; - case F_SETFL: - fputs(xlookup_bits(fcntlfl_arg, args[sc->offset]), fp); - break; - case F_GETFD: - case F_GETFL: - case F_GETOWN: - break; - default: - fprintf(fp, "0x%lx", args[sc->offset]); - break; - } + if (sysdecode_fcntl_arg_p(args[sc->offset - 1])) + sysdecode_fcntl_arg(fp, args[sc->offset - 1], + args[sc->offset], 16); break; - } case Open: - fputs(xlookup_bits(open_flags, args[sc->offset]), fp); + print_mask_arg(sysdecode_open_flags, fp, args[sc->offset]); break; case Fcntl: - fputs(xlookup(fcntl_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_fcntl_cmd, fp, args[sc->offset]); break; case Mprot: - fputs(xlookup_bits(mprot_flags, args[sc->offset]), fp); + print_mask_arg(sysdecode_mmap_prot, fp, args[sc->offset]); break; - case Mmapflags: { - int align, flags; - - /* - * MAP_ALIGNED can't be handled by xlookup_bits(), so - * generate that string manually and prepend it to the - * string from xlookup_bits(). Have to be careful to - * avoid outputting MAP_ALIGNED|0 if MAP_ALIGNED is - * the only flag. - */ - flags = args[sc->offset] & ~MAP_ALIGNMENT_MASK; - align = args[sc->offset] & MAP_ALIGNMENT_MASK; - if (align != 0) { - if (align == MAP_ALIGNED_SUPER) - fputs("MAP_ALIGNED_SUPER", fp); - else - fprintf(fp, "MAP_ALIGNED(%d)", - align >> MAP_ALIGNMENT_SHIFT); - if (flags == 0) - break; - fputc('|', fp); - } - fputs(xlookup_bits(mmap_flags, flags), fp); + case Mmapflags: + print_mask_arg(sysdecode_mmap_flags, fp, args[sc->offset]); break; - } case Whence: - fputs(xlookup(whence_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_whence, fp, args[sc->offset]); break; case Sockdomain: - fputs(xlookup(sockdomain_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_socketdomain, fp, args[sc->offset]); break; - case Socktype: { - int type, flags; - - flags = args[sc->offset] & (SOCK_CLOEXEC | SOCK_NONBLOCK); - type = args[sc->offset] & ~flags; - fputs(xlookup(socktype_arg, type), fp); - if (flags & SOCK_CLOEXEC) - fprintf(fp, "|SOCK_CLOEXEC"); - if (flags & SOCK_NONBLOCK) - fprintf(fp, "|SOCK_NONBLOCK"); + case Socktype: + print_mask_arg(sysdecode_socket_type, fp, args[sc->offset]); break; - } case Shutdown: - fputs(xlookup(shutdown_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_shutdown_how, fp, args[sc->offset]); break; case Resource: - fputs(xlookup(resource_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_rlimit, fp, args[sc->offset]); break; case Pathconf: fputs(xlookup(pathconf_arg, args[sc->offset]), fp); break; case Rforkflags: - fputs(xlookup_bits(rfork_flags, args[sc->offset]), fp); + print_mask_arg(sysdecode_rfork_flags, fp, args[sc->offset]); break; case Sockaddr: { char addr[64]; @@ -1818,31 +1675,25 @@ print_arg(struct syscall_args *sc, unsigned long *args, long *retval, break; } case Waitoptions: - fputs(xlookup_bits(wait_options, args[sc->offset]), fp); + print_mask_arg(sysdecode_wait6_options, fp, args[sc->offset]); break; case Idtype: - fputs(xlookup(idtype_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_idtype, fp, args[sc->offset]); break; case Procctl: - fputs(xlookup(procctl_arg, args[sc->offset]), fp); + print_integer_arg(sysdecode_procctl_cmd, fp, args[sc->offset]); break; case Umtxop: - fputs(xlookup(umtx_ops, args[sc->offset]), fp); + print_integer_arg(sysdecode_umtx_op, fp, args[sc->offset]); break; case Atfd: - if ((int)args[sc->offset] == AT_FDCWD) - fputs("AT_FDCWD", fp); - else - fprintf(fp, "%d", (int)args[sc->offset]); + print_integer_arg(sysdecode_atfd, fp, args[sc->offset]); break; case Atflags: fputs(xlookup_bits(at_flags, args[sc->offset]), fp); break; case Accessmode: - if (args[sc->offset] == F_OK) - fputs("F_OK", fp); - else - fputs(xlookup_bits(access_modes, args[sc->offset]), fp); + print_mask_arg(sysdecode_access_mode, fp, args[sc->offset]); break; case Sysarch: fputs(xlookup(sysarch_ops, args[sc->offset]), fp); @@ -1898,6 +1749,9 @@ print_arg(struct syscall_args *sc, unsigned long *args, long *retval, fprintf(fp, "0x%lx", args[sc->offset]); break; } + case Pipe2: + print_mask_arg(sysdecode_pipe2_flags, fp, args[sc->offset]); + break; case CloudABIAdvice: fputs(xlookup(cloudabi_advice, args[sc->offset]), fp); |
