Index: lib/libsysdecode/Makefile =================================================================== --- lib/libsysdecode/Makefile +++ lib/libsysdecode/Makefile @@ -5,9 +5,10 @@ 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 @@ -18,7 +19,7 @@ sysdecode_utrace.3 MLINKS+= sysdecode_abi_to_freebsd_errno.3 sysdecode_freebsd_to_abi_errno.3 -CLEANFILES= ioctl.c +CLEANFILES= ioctl.c tables.h .if defined(COMPAT_32BIT) CPP+= -m32 @@ -36,10 +37,13 @@ CFLAGS.gcc+= ${CFLAGS.gcc.${.IMPSRC}} +tables.h: mktables + sh ${.CURDIR}/mktables ${DESTDIR}${INCLUDEDIR} > ${.TARGET} + ioctl.c: mkioctls env MACHINE=${MACHINE} CPP="${CPP}" \ /bin/sh ${.CURDIR}/mkioctls ${DESTDIR}${INCLUDEDIR} > ${.TARGET} -beforedepend: ioctl.c +beforedepend: ioctl.c tables.h .include Index: lib/libsysdecode/errno.c =================================================================== --- lib/libsysdecode/errno.c +++ lib/libsysdecode/errno.c @@ -28,8 +28,11 @@ __FBSDID("$FreeBSD$"); #include +#include +#include #include #include +#include #include #include Index: lib/libsysdecode/flags.c =================================================================== --- /dev/null +++ lib/libsysdecode/flags.c @@ -0,0 +1,958 @@ +/* + * Copyright (c) 2006 "David Kirchner" . 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 +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * 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); +} + +void +sysdecode_atfd(FILE *fp, int fd, int base) +{ + + if (fd == AT_FDCWD) + fprintf(fp, "AT_FDCWD"); + else + print_integer(fp, fd, base); +} + +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_op(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_op(int cmd) +{ + + return (lookup_value(shmctlops, cmd)); +} + +const char * +sysdecode_msgctl_op(int cmd) +{ + + return (sysdecode_shmctl_op(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 value + * referring to a line in /etc/protocols . It might be appropriate + * to use getprotoent(3) here. + */ +void +sysdecode_sockopt_level(FILE *fp, int level, int base) +{ + if (level == SOL_SOCKET) { + fprintf(fp, "SOL_SOCKET"); + } else { + print_integer(fp, level, base); + } +} + +bool +sysdecode_vmprot(FILE *fp, int type, int *rem) +{ + + return (print_mask_int(fp, vmprot, type, rem)); +} + +void +sysdecode_sockettypewithflags(FILE *fp, int type) +{ + const char *str; + + str = sysdecode_sockettype(type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)); + if (str != NULL) + fputs(str, fp); + else + fprintf(fp, "%d", type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)); + if (type & SOCK_CLOEXEC) + fprintf(fp, "|SOCK_CLOEXEC"); + if (type & SOCK_NONBLOCK) + fprintf(fp, "|SOCK_NONBLOCK"); +} + +bool +sysdecode_accessmode(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_capfcntlrights(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_op(FILE *fp, int operation, int *rem) +{ + + return (print_mask_int(fp, flockops, operation, rem)); +} + +bool +sysdecode_getfsstat_flags(FILE *fp, int flags, int *rem) +{ + + return (print_mask_int(fp, getfsstatflags, flags, rem)); +} + +const char * +sysdecode_kldsym_cmd(int command) +{ + + return (lookup_value(kldsymcmd, command)); +} + +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_flags(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(nfssvc, 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); + type = lookup_value(quotatypes, cmd & SUBCMDMASK); + if (primary == NULL && type == NULL) + return (false); + fprintf(fp, "QCMD("); + if (primary != NULL) + fprintf(fp, "%s", primary); + else + fprintf(fp, "%#x", cmd >> SUBCMDSHIFT); + fprintf(fp, ","); + 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)); +} + +/* Accept level and optname? */ +const char * +sysdecode_sockopt_name(int optname) +{ + + return (lookup_value(sockopt, optname)); +} + +const char * +sysdecode_sockettype(int type) +{ + + return (lookup_value(socktype, type)); +} + +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 code) +{ + const char *str; + + str = lookup_value(sigcode, code); + if (str != NULL) + return (str); + + switch (sig) { + case SIGILL: + return (sysdecode_sigill_code(code)); + case SIGBUS: + return (sysdecode_sigbus_code(code)); + case SIGSEGV: + return (sysdecode_sigsegv_code(code)); + case SIGFPE: + return (sysdecode_sigfpe_code(code)); + case SIGTRAP: + return (sysdecode_sigtrap_code(code)); + case SIGCHLD: + return (sysdecode_sigchld_code(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 */ +#define CAPMASK(right) ((right) && (((uint64_t)1 << 57) - 1)) + +void +sysdecode_capname(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; + } + } +} Index: lib/libsysdecode/mkioctls =================================================================== --- lib/libsysdecode/mkioctls +++ lib/libsysdecode/mkioctls @@ -62,6 +62,7 @@ print "#include " print "#include " print "#include " + print "#include " print "#include " print "#include " print "#include " Index: lib/libsysdecode/mktables =================================================================== --- /dev/null +++ lib/libsysdecode/mktables @@ -0,0 +1,140 @@ +#!/bin/sh +# +# Copyright (c) 2006 "David Kirchner" . 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" + exit 1 +fi +include_dir=$1 + +# +# 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 + 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 "getfsstatflags" "MNT_[A-Z]+[[:space:]]+[1-9][0-9]*" "sys/mount.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 "fileflags" "[SU]F_[A-Z]+[[:space:]]+0x[0-9A-Fa-f]+" "sys/stat.h" "UF_COMPRESSED|UF_TRACKED" +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 "nfssvc" "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 "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" Index: lib/libsysdecode/signal.c =================================================================== --- lib/libsysdecode/signal.c +++ lib/libsysdecode/signal.c @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2015 John H. Baldwin + * Copyright (c) 2016 John H. Baldwin * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -22,26 +22,35 @@ * 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$ */ -#ifndef __SYSDECODE_H__ -#define __SYSDECODE_H__ +#include +__FBSDID("$FreeBSD$"); -enum sysdecode_abi { - SYSDECODE_ABI_UNKNOWN = 0, - SYSDECODE_ABI_FREEBSD, - SYSDECODE_ABI_FREEBSD32, - SYSDECODE_ABI_LINUX, - SYSDECODE_ABI_LINUX32, - SYSDECODE_ABI_CLOUDABI64 -}; +#include +#include +#include +#include +#include -int sysdecode_abi_to_freebsd_errno(enum sysdecode_abi _abi, int _error); -int sysdecode_freebsd_to_abi_errno(enum sysdecode_abi _abi, int _error); -const char *sysdecode_ioctlname(unsigned long _val); -const char *sysdecode_syscallname(enum sysdecode_abi _abi, unsigned int _code); -int sysdecode_utrace(FILE *_fp, void *_buf, size_t _len); +const char * +sysdecode_signal(int sig) +{ + static char sigbuf[64]; -#endif /* !__SYSDECODE_H__ */ + if (sig > 0 && sig < NSIG) { + snprintf(sigbuf, sizeof(sigbuf), "SIG%s", sys_signame[sig]); + return (sigbuf); + } + switch (sig) { + case SIGTHR: + return ("SIGTHR"); + case SIGLIBRT: + return ("SIGLIBRT"); + } + if (sig >= SIGRTMIN && sig <= SIGRTMAX) { + snprintf(sigbuf, sizeof(sigbuf), "SIGRT%d", sig - SIGRTMIN); + return (sigbuf); + } + return (NULL); +} Index: lib/libsysdecode/syscallnames.c =================================================================== --- lib/libsysdecode/syscallnames.c +++ lib/libsysdecode/syscallnames.c @@ -35,6 +35,9 @@ */ #include +#include +#include +#include #include #include Index: lib/libsysdecode/sysdecode.h =================================================================== --- lib/libsysdecode/sysdecode.h +++ lib/libsysdecode/sysdecode.h @@ -39,9 +39,80 @@ }; int sysdecode_abi_to_freebsd_errno(enum sysdecode_abi _abi, int _error); +bool sysdecode_accessmode(FILE *_fp, int _mode, int *_rem); +const char *sysdecode_acltype(int _type); +void sysdecode_atfd(FILE *_fp, int _fd, int _base); +bool sysdecode_capfcntlrights(FILE *_fp, uint32_t _rights, uint32_t *_rem); +void sysdecode_capname(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_op(FILE *_fp, int _operation, int *_rem); int sysdecode_freebsd_to_abi_errno(enum sysdecode_abi _abi, int _error); +bool sysdecode_getfsstat_flags(FILE *_fp, int _flags, int *_rem); +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 _command); +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_flags(int _inherit); +const char *sysdecode_msgctl_op(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_op(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_op(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 _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); +const char *sysdecode_sockettype(int _type); +void sysdecode_sockettypewithflags(FILE *_fp, int _type); +void sysdecode_sockopt_level(FILE *_fp, int _level, int _base); +const char *sysdecode_sockopt_name(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__ */ Index: lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 =================================================================== --- lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 +++ lib/libsysdecode/sysdecode_abi_to_freebsd_errno.3 @@ -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 Index: lib/libsysdecode/sysdecode_ioctlname.3 =================================================================== --- lib/libsysdecode/sysdecode_ioctlname.3 +++ lib/libsysdecode/sysdecode_ioctlname.3 @@ -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 Index: lib/libsysdecode/sysdecode_syscallnames.3 =================================================================== --- lib/libsysdecode/sysdecode_syscallnames.3 +++ lib/libsysdecode/sysdecode_syscallnames.3 @@ -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 Index: lib/libsysdecode/sysdecode_utrace.3 =================================================================== --- lib/libsysdecode/sysdecode_utrace.3 +++ lib/libsysdecode/sysdecode_utrace.3 @@ -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 Index: lib/libsysdecode/utrace.c =================================================================== --- lib/libsysdecode/utrace.c +++ lib/libsysdecode/utrace.c @@ -32,6 +32,7 @@ #include #include +#include #include #include #include Index: usr.bin/kdump/Makefile =================================================================== --- usr.bin/kdump/Makefile +++ 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 @@ 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 Index: usr.bin/kdump/kdump.c =================================================================== --- usr.bin/kdump/kdump.c +++ usr.bin/kdump/kdump.c @@ -74,6 +74,7 @@ #include #include #include +#include #include #include #include @@ -83,7 +84,6 @@ #include #include #include "ktrace.h" -#include "kdump_subr.h" #ifdef HAVE_LIBCASPER #include @@ -122,8 +122,6 @@ #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; @@ -132,6 +130,27 @@ #define TIME_FORMAT "%b %e %T %Y" #define eqs(s1, s2) (strcmp((s1), (s2)) == 0) +#define print_number64(first,i,n,c) do { \ + uint64_t __v; \ + \ + if (quad_align && (((ptrdiff_t)((i) - (first))) & 1) == 1) { \ + (i)++; \ + (n)--; \ + } \ + if (quad_slots == 2) \ + __v = (uint64_t)(uint32_t)(i)[0] | \ + ((uint64_t)(uint32_t)(i)[1]) << 32; \ + else \ + __v = (uint64_t)*(i); \ + if (decimal) \ + printf("%c%jd", (c), (intmax_t)__v); \ + else \ + printf("%c%#jx", (c), (uintmax_t)__v); \ + (i) += quad_slots; \ + (n) -= quad_slots; \ + (c) = ','; \ +} while (0) + #define print_number(i,n,c) do { \ if (decimal) \ printf("%c%jd", c, (intmax_t)*i); \ @@ -224,6 +243,116 @@ } #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("", value); + else + printf("", 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("%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("%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("%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("%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("%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("%lu", rem); +} + int main(int argc, char *argv[]) { @@ -701,20 +830,41 @@ } } +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) { int narg = ktr->ktr_narg; - register_t *ip; + register_t *ip, *first; intmax_t arg; + int quad_align, quad_slots; syscallname(ktr->ktr_code, sv_flags); - ip = &ktr->ktr_args[0]; + ip = first = &ktr->ktr_args[0]; if (narg) { char c = '('; if (fancy && (sv_flags == 0 || (sv_flags & SV_ABI_MASK) == SV_ABI_FREEBSD)) { + quad_align = 0; + if (sv_flags & SV_ILP32) { +#ifdef __powerpc__ + quad_align = 1; +#endif + quad_slots = 2; + } else + quad_slots = 1; switch (ktr->ktr_code) { case SYS_bindat: case SYS_connectat: @@ -733,7 +883,7 @@ case SYS_unlinkat: case SYS_utimensat: putchar('('); - atfdname(*ip, decimal); + sysdecode_atfd(stdout, *ip, decimal ? 10 : 16); c = ','; ip++; narg--; @@ -751,7 +901,7 @@ } case SYS_ptrace: putchar('('); - ptraceopname(*ip); + print_integer_arg(sysdecode_ptrace_request, *ip); c = ','; ip++; narg--; @@ -761,7 +911,7 @@ case SYS_faccessat: print_number(ip, narg, c); putchar(','); - accessmodename(*ip); + print_mask_arg(sysdecode_accessmode, *ip); ip++; narg--; break; @@ -769,37 +919,32 @@ 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_number(ip, narg, c); + print_number64(first, ip, narg, c); print_number(ip, narg, c); putchar(','); - wait6optname(*ip); + print_mask_arg(sysdecode_wait6_options, *ip); ip++; narg--; break; @@ -809,7 +954,7 @@ case SYS_fchmodat: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; @@ -817,7 +962,7 @@ case SYS_mknodat: print_number(ip, narg, c); putchar(','); - modename(*ip); + decode_filemode(*ip); ip++; narg--; break; @@ -825,7 +970,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - getfsstatflagsname(*ip); + print_mask_arg(sysdecode_getfsstat_flags, *ip); ip++; narg--; break; @@ -833,14 +978,14 @@ 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; @@ -849,7 +994,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - sendrecvflagsname(*ip); + print_mask_arg0(sysdecode_msg_flags, *ip); ip++; narg--; break; @@ -859,7 +1004,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - sendrecvflagsname(*ip); + print_mask_arg0(sysdecode_msg_flags, *ip); ip++; narg--; break; @@ -868,26 +1013,26 @@ 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; @@ -895,7 +1040,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - msyncflagsname(*ip); + print_mask_arg(sysdecode_msync_flags, *ip); ip++; narg--; break; @@ -904,11 +1049,11 @@ 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; @@ -917,11 +1062,11 @@ 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; @@ -929,7 +1074,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mmapprotname(*ip); + print_mask_arg(sysdecode_mmap_prot, *ip); ip++; narg--; break; @@ -937,7 +1082,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - madvisebehavname(*ip); + print_integer_arg(sysdecode_madvice, *ip); ip++; narg--; break; @@ -945,14 +1090,25 @@ 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; @@ -960,17 +1116,19 @@ int sockdomain; putchar('('); sockdomain = *ip; - sockdomainname(sockdomain); + print_integer_arg(sysdecode_socketdomain, + sockdomain); ip++; narg--; putchar(','); - socktypenamewithflags(*ip); + sysdecode_sockettypewithflags(stdout, *ip); ip++; narg--; if (sockdomain == PF_INET || sockdomain == PF_INET6) { putchar(','); - sockipprotoname(*ip); + print_integer_arg(sysdecode_ipproto, + *ip); ip++; narg--; } @@ -981,12 +1139,14 @@ case SYS_getsockopt: print_number(ip, narg, c); putchar(','); - sockoptlevelname(*ip, decimal); + sysdecode_sockopt_level(stdout, *ip, + decimal ? 10 : 16); if (*ip == SOL_SOCKET) { ip++; narg--; putchar(','); - sockoptname(*ip); + print_integer_arg(sysdecode_sockopt_name, + *ip); } ip++; narg--; @@ -996,26 +1156,25 @@ print_number(ip, narg, c); /* Hidden 'pad' argument, not in lseek(2) */ print_number(ip, narg, c); - print_number(ip, narg, c); + print_number64(first, ip, narg, c); putchar(','); - whencename(*ip); + print_integer_arg(sysdecode_whence, *ip); ip++; narg--; break; #endif case SYS_lseek: print_number(ip, narg, c); - /* Hidden 'pad' argument, not in lseek(2) */ - 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_op, *ip); ip++; narg--; break; @@ -1025,24 +1184,24 @@ 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); + sysdecode_sockettypewithflags(stdout, *ip); ip++; narg--; c = ','; @@ -1050,7 +1209,7 @@ case SYS_getrlimit: case SYS_setrlimit: putchar('('); - rlimitname(*ip); + print_integer_arg(sysdecode_rlimit, *ip); ip++; narg--; c = ','; @@ -1058,21 +1217,28 @@ case SYS_quotactl: print_number(ip, narg, c); putchar(','); - quotactlname(*ip); + if (!sysdecode_quotactl_cmd(stdout, *ip)) { + if (decimal) + printf("", (int)*ip); + else + printf("", + (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 = ','; @@ -1081,7 +1247,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - semctlname(*ip); + print_integer_arg(sysdecode_semctl_op, *ip); ip++; narg--; break; @@ -1089,14 +1255,14 @@ 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_op, *ip); ip++; narg--; break; @@ -1104,64 +1270,68 @@ 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_op, *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_flags, *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; @@ -1173,20 +1343,21 @@ 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 = ','; @@ -1205,13 +1376,13 @@ 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 = ','; @@ -1219,7 +1390,8 @@ case SYS_extattrctl: print_number(ip, narg, c); putchar(','); - extattrctlname(*ip); + print_integer_arg(sysdecode_extattrnamespace, + *ip); ip++; narg--; break; @@ -1227,7 +1399,7 @@ print_number(ip, narg, c); print_number(ip, narg, c); putchar(','); - mountflagsname(*ip); + print_mask_arg(sysdecode_mount_flags, *ip); ip++; narg--; break; @@ -1235,21 +1407,22 @@ 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; @@ -1258,7 +1431,7 @@ case SYS_symlinkat: print_number(ip, narg, c); putchar(','); - atfdname(*ip, decimal); + sysdecode_atfd(stdout, *ip, decimal ? 10 : 16); ip++; narg--; break; @@ -1268,49 +1441,57 @@ arg = *ip; ip++; narg--; - capfcntlname(arg); + print_mask_arg32(sysdecode_capfcntlrights, 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_number(ip, narg, c); + 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++; narg--; + break; + case SYS_ftruncate: + case SYS_truncate: + print_number(ip, narg, c); + print_number64(first, ip, narg, c); + break; } } while (narg > 0) { @@ -1490,32 +1671,25 @@ 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("", psig->code); + putchar('\n'); } void @@ -1557,7 +1731,7 @@ { printf("cap_rights_t "); - capname(rightsp); + sysdecode_capname(stdout, rightsp); printf("\n"); } @@ -1589,6 +1763,7 @@ #include struct sockaddr_nb *nb; */ + const char *str; char addr[64]; /* @@ -1597,7 +1772,11 @@ * 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("", sa->sa_family); printf(", "); #define check_sockaddr_len(n) \ @@ -1811,16 +1990,16 @@ case CAPFAIL_NOTCAPABLE: /* operation on fd with insufficient capabilities */ printf("operation requires "); - capname(&ktr->cap_needed); + sysdecode_capname(stdout, &ktr->cap_needed); printf(", descriptor holds "); - capname(&ktr->cap_held); + sysdecode_capname(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_capname(stdout, &ktr->cap_held); printf(" to "); - capname(&ktr->cap_needed); + sysdecode_capname(stdout, &ktr->cap_needed); break; case CAPFAIL_SYSCALL: /* called restricted syscall */ @@ -1832,9 +2011,9 @@ break; default: printf("unknown capability failure: "); - capname(&ktr->cap_needed); + sysdecode_capname(stdout, &ktr->cap_needed); printf(" "); - capname(&ktr->cap_held); + sysdecode_capname(stdout, &ktr->cap_held); break; } printf("\n"); @@ -1845,15 +2024,20 @@ { 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("", ktr->result); printf("\n"); } Index: usr.bin/kdump/mksubr =================================================================== --- usr.bin/kdump/mksubr +++ /dev/null @@ -1,759 +0,0 @@ -#!/bin/sh -# -# Copyright (c) 2006 "David Kirchner" . 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("%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("", 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("", arg); -} - -_EOF_ -} - -# C start - -cat <<_EOF_ -#include -#include -#include -#include -#include -#include -#include -#define _KERNEL -#include -#undef _KERNEL -#include -#include -#include -#include -#include -#include -#include -#include -#include -#define _KERNEL -#include -#undef _KERNEL -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#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("", 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("", 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("%d", mode); - } else { - printf("%#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("", 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("%d", arg); - else - printf("%#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("%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("", 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("", 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("%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("%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" - }' Index: usr.bin/truss/Makefile =================================================================== --- usr.bin/truss/Makefile +++ 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 Index: usr.bin/truss/aarch64-cloudabi64.c =================================================================== --- usr.bin/truss/aarch64-cloudabi64.c +++ usr.bin/truss/aarch64-cloudabi64.c @@ -31,6 +31,7 @@ #include +#include #include #include Index: usr.bin/truss/aarch64-freebsd.c =================================================================== --- usr.bin/truss/aarch64-freebsd.c +++ usr.bin/truss/aarch64-freebsd.c @@ -38,6 +38,7 @@ #include #include +#include #include #include Index: usr.bin/truss/amd64-cloudabi64.c =================================================================== --- usr.bin/truss/amd64-cloudabi64.c +++ usr.bin/truss/amd64-cloudabi64.c @@ -31,6 +31,7 @@ #include +#include #include #include Index: usr.bin/truss/amd64-freebsd.c =================================================================== --- usr.bin/truss/amd64-freebsd.c +++ usr.bin/truss/amd64-freebsd.c @@ -40,6 +40,7 @@ #include #include +#include #include #include Index: usr.bin/truss/amd64-freebsd32.c =================================================================== --- usr.bin/truss/amd64-freebsd32.c +++ usr.bin/truss/amd64-freebsd32.c @@ -40,6 +40,7 @@ #include #include +#include #include #include #include Index: usr.bin/truss/amd64-linux.c =================================================================== --- usr.bin/truss/amd64-linux.c +++ usr.bin/truss/amd64-linux.c @@ -39,6 +39,7 @@ #include #include +#include #include #include Index: usr.bin/truss/amd64-linux32.c =================================================================== --- usr.bin/truss/amd64-linux32.c +++ usr.bin/truss/amd64-linux32.c @@ -39,6 +39,7 @@ #include #include +#include #include #include Index: usr.bin/truss/arm-freebsd.c =================================================================== --- usr.bin/truss/arm-freebsd.c +++ usr.bin/truss/arm-freebsd.c @@ -41,6 +41,7 @@ #include #include +#include #include #include Index: usr.bin/truss/extern.h =================================================================== --- usr.bin/truss/extern.h +++ usr.bin/truss/extern.h @@ -37,4 +37,3 @@ extern void restore_proc(int); extern void eventloop(struct trussinfo *); extern const char *ioctlname(unsigned long val); -extern char *strsig(int sig); Index: usr.bin/truss/i386-freebsd.c =================================================================== --- usr.bin/truss/i386-freebsd.c +++ usr.bin/truss/i386-freebsd.c @@ -40,6 +40,7 @@ #include #include +#include #include #include Index: usr.bin/truss/i386-linux.c =================================================================== --- usr.bin/truss/i386-linux.c +++ usr.bin/truss/i386-linux.c @@ -39,6 +39,7 @@ #include #include +#include #include #include Index: usr.bin/truss/main.c =================================================================== --- usr.bin/truss/main.c +++ usr.bin/truss/main.c @@ -42,6 +42,7 @@ #include #include +#include #include #include #include @@ -61,18 +62,6 @@ 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) { Index: usr.bin/truss/mips-freebsd.c =================================================================== --- usr.bin/truss/mips-freebsd.c +++ usr.bin/truss/mips-freebsd.c @@ -40,6 +40,7 @@ #include #include +#include #include #include Index: usr.bin/truss/powerpc-freebsd.c =================================================================== --- usr.bin/truss/powerpc-freebsd.c +++ usr.bin/truss/powerpc-freebsd.c @@ -36,6 +36,7 @@ #include #include +#include #include #include Index: usr.bin/truss/powerpc64-freebsd.c =================================================================== --- usr.bin/truss/powerpc64-freebsd.c +++ usr.bin/truss/powerpc64-freebsd.c @@ -36,6 +36,7 @@ #include #include +#include #include #include Index: usr.bin/truss/powerpc64-freebsd32.c =================================================================== --- usr.bin/truss/powerpc64-freebsd32.c +++ usr.bin/truss/powerpc64-freebsd32.c @@ -36,6 +36,7 @@ #include #include +#include #include #include Index: usr.bin/truss/setup.c =================================================================== --- usr.bin/truss/setup.c +++ usr.bin/truss/setup.c @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include @@ -591,12 +592,12 @@ 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); + signame = sysdecode_signal(si->si_status); fprintf(info->outfile, "SIGNAL %u (%s)\n", si->si_status, signame == NULL ? "?" : signame); } Index: usr.bin/truss/sparc64-freebsd.c =================================================================== --- usr.bin/truss/sparc64-freebsd.c +++ usr.bin/truss/sparc64-freebsd.c @@ -41,6 +41,7 @@ #include #include +#include #include #include #include Index: usr.bin/truss/syscall.h =================================================================== --- usr.bin/truss/syscall.h +++ usr.bin/truss/syscall.h @@ -44,7 +44,7 @@ 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, Index: usr.bin/truss/syscalls.c =================================================================== --- usr.bin/truss/syscalls.c +++ usr.bin/truss/syscalls.c @@ -40,14 +40,11 @@ #include #include #include -#include #include -#include #include #include #include #include -#include #include #include #include @@ -60,13 +57,10 @@ #include #include #include -#include -#include #include #include #include #include -#include #include #include @@ -256,7 +250,7 @@ { .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 @@ 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 @@ 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 @@ 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 @@ 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,13 +929,13 @@ } } -static char * +static const char * strsig2(int sig) { static char tmp[sizeof(int) * 3 + 1]; - char *ret; + const char *ret; - ret = strsig(sig); + ret = sysdecode_signal(sig); if (ret == NULL) { snprintf(tmp, sizeof(tmp), "%d", sig); ret = tmp; @@ -1493,7 +1394,7 @@ for (i = 1; i < sys_nsig; i++) { if (sigismember(&ss, i)) { fprintf(fp, "%s%s", !first ? "|" : "", - strsig(i)); + sysdecode_signal(i)); first = 0; } } @@ -1502,92 +1403,48 @@ 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: + sysdecode_sockettypewithflags(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 @@ 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]); + sysdecode_atfd(fp, args[sc->offset], 10); 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_accessmode, fp, args[sc->offset]); break; case Sysarch: fputs(xlookup(sysarch_ops, args[sc->offset]), fp); @@ -1898,6 +1749,9 @@ 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); @@ -1924,9 +1778,9 @@ cloudabi_filestat_t fsb; if (get_struct(pid, (void *)args[sc->offset], &fsb, sizeof(fsb)) != -1) - fprintf(fp, "{ %s, %lu }", + fprintf(fp, "{ %s, %ju }", xlookup(cloudabi_filetype, fsb.st_filetype), - fsb.st_size); + (uintmax_t)fsb.st_size); else fprintf(fp, "0x%lx", args[sc->offset]); break;