signal: fix omission of field names in sigaction printers

[strace] / seccomp.c

diff --git a/seccomp.c b/seccomp.c
index 4c176a787718207f45a877dbb00f099bab7b68bb..4d8d7e4b2503383cf0024c12548cb264e52d4e36 100644 (file)
--- a/seccomp.c
+++ b/seccomp.c
@@ -68,46 +68,48 @@ decode_bpf_code(uint16_t code)
        switch (BPF_CLASS(code)) {
                case BPF_LD:
                case BPF_LDX:
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_size, BPF_SIZE(code), "BPF_???");
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_mode, BPF_MODE(code), "BPF_???");
                        break;
                case BPF_ST:
                case BPF_STX:
                        if (i)
-                               tprintf(" | %#x /* %s */", i, "BPF_???");
+                               tprintf("|%#x /* %s */", i, "BPF_???");
                        break;
                case BPF_ALU:
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_src, BPF_SRC(code), "BPF_???");
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_op_alu, BPF_OP(code), "BPF_???");
                        break;
                case BPF_JMP:
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_src, BPF_SRC(code), "BPF_???");
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_op_jmp, BPF_OP(code), "BPF_???");
                        break;
                case BPF_RET:
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_rval, BPF_RVAL(code), "BPF_???");
                        i &= ~BPF_RVAL(code);
                        if (i)
-                               tprintf(" | %#x /* %s */", i, "BPF_???");
+                               tprintf("|%#x /* %s */", i, "BPF_???");
                        break;
                case BPF_MISC:
-                       tprints(" | ");
+                       tprints("|");
                        printxval(bpf_miscop, BPF_MISCOP(code), "BPF_???");
                        i &= ~BPF_MISCOP(code);
                        if (i)
-                               tprintf(" | %#x /* %s */", i, "BPF_???");
+                               tprintf("|%#x /* %s */", i, "BPF_???");
                        break;
        }
 
 }
 
+#endif /* HAVE_LINUX_FILTER_H */
+
 static void
 decode_bpf_stmt(const struct bpf_filter *filter)
 {
@@ -121,7 +123,7 @@ decode_bpf_stmt(const struct bpf_filter *filter)
 
                printxval(seccomp_ret_action, action, "SECCOMP_RET_???");
                if (data)
-                       tprintf(" | %#x)", data);
+                       tprintf("|%#x)", data);
                else
                        tprints(")");
        } else {
@@ -146,74 +148,55 @@ decode_bpf_jump(const struct bpf_filter *filter)
 #endif /* HAVE_LINUX_FILTER_H */
 }
 
-static void
-decode_filter(const struct bpf_filter *filter)
+#ifndef BPF_MAXINSNS
+# define BPF_MAXINSNS 4096
+#endif
+
+static bool
+print_bpf_filter(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 {
+       const struct bpf_filter *filter = elem_buf;
+       unsigned int *pn = data;
+
+       if ((*pn)++ >= BPF_MAXINSNS) {
+               tprints("...");
+               return false;
+       }
+
        if (filter->jt || filter->jf)
                decode_bpf_jump(filter);
        else
                decode_bpf_stmt(filter);
-}
-
-#endif /* HAVE_LINUX_FILTER_H */
 
-#ifndef BPF_MAXINSNS
-# define BPF_MAXINSNS 4096
-#endif
+       return true;
+}
 
-static void
-decode_fprog(struct tcb *tcp, unsigned short len, unsigned long addr)
+void
+print_seccomp_fprog(struct tcb *tcp, unsigned long addr, unsigned short len)
 {
-       if (!len || abbrev(tcp)) {
-               tprintf("{len = %u, filter = ", len);
+       if (abbrev(tcp)) {
                printaddr(addr);
-               tprints("}");
        } else {
-               unsigned int i = 0;
-
-               tprints("[");
-               while (i < len && i < BPF_MAXINSNS) {
-                       struct bpf_filter filter;
+               unsigned int insns = 0;
+               struct bpf_filter filter;
 
-                       if (umove(tcp, addr, &filter) < 0)
-                               break;
-                       if (i)
-                               tprints(", ");
-                       decode_filter(&filter);
-
-                       addr += sizeof(filter);
-                       ++i;
-               }
-               if (i < len)
-                       tprints("...");
-               tprints("]");
+               print_array(tcp, addr, len, &filter, sizeof(filter),
+                           umoven_or_printaddr, print_bpf_filter, &insns);
        }
 }
 
+#include "seccomp_fprog.h"
+
 void
 print_seccomp_filter(struct tcb *tcp, unsigned long addr)
 {
-#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
-       if (current_wordsize == 4) {
-               struct {
-                       unsigned short len;
-                       uint32_t filter;
-               } fprog;
-
-               if (!umove_or_printaddr(tcp, addr, &fprog))
-                       decode_fprog(tcp, fprog.len, fprog.filter);
-       } else {
-#endif
-               struct {
-                       unsigned short len;
-                       unsigned long filter;
-               } fprog;
-
-               if (!umove_or_printaddr(tcp, addr, &fprog))
-                       decode_fprog(tcp, fprog.len, fprog.filter);
-#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
+       struct seccomp_fprog fprog;
+
+       if (fetch_seccomp_fprog(tcp, addr, &fprog)) {
+               tprintf("{len=%hu, filter=", fprog.len);
+               print_seccomp_fprog(tcp, fprog.filter, fprog.len);
+               tprints("}");
        }
-#endif
 }
 
 static void
@@ -225,21 +208,20 @@ decode_seccomp_set_mode_strict(unsigned int flags, unsigned long addr)
 
 SYS_FUNC(seccomp)
 {
-       if (entering(tcp)) {
-               unsigned int op = tcp->u_arg[0];
+       unsigned int op = tcp->u_arg[0];
 
-               printxval(seccomp_ops, op, "SECCOMP_SET_MODE_???");
-               tprints(", ");
+       printxval(seccomp_ops, op, "SECCOMP_SET_MODE_???");
+       tprints(", ");
 
-               if (op == SECCOMP_SET_MODE_FILTER) {
-                       printflags(seccomp_filter_flags, tcp->u_arg[1],
-                                  "SECCOMP_FILTER_FLAG_???");
-                       tprints(", ");
-                       print_seccomp_filter(tcp, tcp->u_arg[2]);
-               } else {
-                       decode_seccomp_set_mode_strict(tcp->u_arg[1],
-                                                      tcp->u_arg[2]);
-               }
+       if (op == SECCOMP_SET_MODE_FILTER) {
+               printflags(seccomp_filter_flags, tcp->u_arg[1],
+                          "SECCOMP_FILTER_FLAG_???");
+               tprints(", ");
+               print_seccomp_filter(tcp, tcp->u_arg[2]);
+       } else {
+               decode_seccomp_set_mode_strict(tcp->u_arg[1],
+                                              tcp->u_arg[2]);
        }
-       return 0;
+
+       return RVAL_DECODED;
 }