]> granicus.if.org Git - strace/blobdiff - numa.c
Fix the length argument passed from print_iovec to decode_netlink
[strace] / numa.c
diff --git a/numa.c b/numa.c
index e57fe3f22d2d168aee14a923d1b2368531ec70fe..eccd4ee78a32567f220c53f8c6580dbfbb17b41a 100644 (file)
--- a/numa.c
+++ b/numa.c
 
 #include "defs.h"
 
-static void
-print_nodemask(struct tcb *tcp, unsigned long addr, unsigned long maxnodes)
+static bool
+print_node(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 {
-       const unsigned long nlongs =
-               (maxnodes + 8 * current_wordsize - 2) / (8 * current_wordsize);
-       const unsigned long size = nlongs * current_wordsize;
-       const unsigned long end = addr + size;
-
-       if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))
-           || end <= addr || size / current_wordsize != nlongs
-           || nlongs < maxnodes / (8 * current_wordsize)) {
-               printaddr(addr);
-               return;
+       if (elem_size < sizeof(kernel_ulong_t)) {
+               tprintf("%#0*x", (int) elem_size * 2 + 2,
+                       * (unsigned int *) elem_buf);
+       } else {
+               tprintf("%#0*" PRI_klx, (int) elem_size * 2 + 2,
+                       * (kernel_ulong_t *) elem_buf);
        }
 
-       const unsigned long abbrev_end =
-               (abbrev(tcp) && max_strlen < nlongs) ?
-                       addr + max_strlen * current_wordsize : end;
-       unsigned long cur;
-       for (cur = addr; cur < end; cur += current_wordsize) {
-               if (cur != addr)
-                       tprints(", ");
-
-               unsigned long n;
-               if (umove_ulong_or_printaddr(tcp, cur, &n))
-                       break;
-
-               if (cur == addr)
-                       tprints("[");
+       return true;
+}
 
-               if (cur >= abbrev_end) {
-                       tprints("...");
-                       cur = end;
-                       break;
-               }
+static void
+print_nodemask(struct tcb *const tcp, const kernel_ulong_t addr,
+              const kernel_ulong_t maxnodes)
+{
+       const unsigned int bits_per_long = 8 * current_wordsize;
+       const kernel_ulong_t nmemb =
+               (maxnodes + bits_per_long - 2) / bits_per_long;
 
-               tprintf("%#0*lx", (int) current_wordsize * 2 + 2, n);
+       if (nmemb < maxnodes / bits_per_long ||
+           (maxnodes && !nmemb)) {
+               printaddr(addr);
+               return;
        }
-       if (cur != addr)
-               tprints("]");
+
+       kernel_ulong_t buf;
+       print_array(tcp, addr, nmemb, &buf, current_wordsize,
+                   umoven_or_printaddr, print_node, 0);
 }
 
 SYS_FUNC(migrate_pages)
 {
-       tprintf("%d, %lu, ", (int) tcp->u_arg[0], tcp->u_arg[1]);
+       tprintf("%d, %" PRI_klu ", ", (int) tcp->u_arg[0], tcp->u_arg[1]);
        print_nodemask(tcp, tcp->u_arg[2], tcp->u_arg[1]);
        tprints(", ");
        print_nodemask(tcp, tcp->u_arg[3], tcp->u_arg[1]);
@@ -86,11 +77,11 @@ SYS_FUNC(migrate_pages)
 SYS_FUNC(mbind)
 {
        printaddr(tcp->u_arg[0]);
-       tprintf(", %lu, ", tcp->u_arg[1]);
-       printxval(policies, tcp->u_arg[2], "MPOL_???");
+       tprintf(", %" PRI_klu ", ", tcp->u_arg[1]);
+       printxval64(policies, tcp->u_arg[2], "MPOL_???");
        tprints(", ");
        print_nodemask(tcp, tcp->u_arg[3], tcp->u_arg[4]);
-       tprintf(", %lu, ", tcp->u_arg[4]);
+       tprintf(", %" PRI_klu ", ", tcp->u_arg[4]);
        printflags(mbindflags, tcp->u_arg[5], "MPOL_???");
 
        return RVAL_DECODED;
@@ -101,7 +92,7 @@ SYS_FUNC(set_mempolicy)
        printxval(policies, tcp->u_arg[0], "MPOL_???");
        tprints(", ");
        print_nodemask(tcp, tcp->u_arg[1], tcp->u_arg[2]);
-       tprintf(", %lu", tcp->u_arg[2]);
+       tprintf(", %" PRI_klu, tcp->u_arg[2]);
 
        return RVAL_DECODED;
 }
@@ -119,117 +110,69 @@ SYS_FUNC(get_mempolicy)
                }
                tprints(", ");
                print_nodemask(tcp, tcp->u_arg[1], tcp->u_arg[2]);
-               tprintf(", %lu, ", tcp->u_arg[2]);
+               tprintf(", %" PRI_klu ", ", tcp->u_arg[2]);
                printaddr(tcp->u_arg[3]);
                tprints(", ");
-               printflags(mempolicyflags, tcp->u_arg[4], "MPOL_???");
+               printflags64(mempolicyflags, tcp->u_arg[4], "MPOL_???");
        }
        return 0;
 }
 
 #include "xlat/move_pages_flags.h"
 
-static void
-print_page_array(struct tcb *tcp, const unsigned long addr,
-                const unsigned long count)
+static bool
+print_addr(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 {
-       const unsigned long size = count * current_wordsize;
-       const unsigned long end = addr + size;
+       kernel_ulong_t addr;
 
-       if (end <= addr || size / current_wordsize != count) {
-               printaddr(addr);
-               return;
+       if (elem_size < sizeof(addr)) {
+               addr = * (unsigned int *) elem_buf;
+       } else {
+               addr = * (kernel_ulong_t *) elem_buf;
        }
-       const unsigned long abbrev_end =
-               (abbrev(tcp) && max_strlen < count) ?
-                       addr + max_strlen * current_wordsize : end;
-       unsigned long cur;
-       for (cur = addr; cur < end; cur += current_wordsize) {
-               if (cur != addr)
-                       tprints(", ");
-
-               unsigned long n;
-               if (umove_ulong_or_printaddr(tcp, cur, &n))
-                       break;
-
-               if (cur == addr)
-                       tprints("[");
 
-               if (cur >= abbrev_end) {
-                       tprints("...");
-                       cur = end;
-                       break;
-               }
-               printaddr(n);
-       }
-       if (cur != addr)
-               tprints("]");
+       printaddr(addr);
+
+       return true;
 }
 
-static void
-print_status(const int status)
+static bool
+print_status(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 {
+       const int status = * (int *) elem_buf;
+
        if (status < 0 && (unsigned) -status < nerrnos)
-               tprintf("%s", errnoent[-status]);
+               tprintf("-%s", errnoent[-status]);
        else
                tprintf("%d", status);
-}
 
-static void
-print_int(const int i)
-{
-       tprintf("%d", i);
+       return true;
 }
 
-static void
-print_int_array(struct tcb *tcp, const unsigned long addr,
-               const unsigned long count, void (*func)(int))
+static bool
+print_int(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 {
-       int i;
-       const unsigned long size = count * sizeof(i);
-       const unsigned long end = addr + size;
-
-       if (end <= addr || size / sizeof(i) != count) {
-               printaddr(addr);
-               return;
-       }
-       const unsigned long abbrev_end =
-               (abbrev(tcp) && max_strlen < count) ?
-                       addr + max_strlen * sizeof(i) : end;
-       unsigned long cur;
-       for (cur = addr; cur < end; cur += sizeof(i)) {
-               if (cur != addr)
-                       tprints(", ");
-
-               if (umove_or_printaddr(tcp, cur, &i))
-                       break;
-
-               if (cur == addr)
-                       tprints("[");
+       tprintf("%d", * (int *) elem_buf);
 
-               if (cur >= abbrev_end) {
-                       tprints("...");
-                       cur = end;
-                       break;
-               }
-               func(i);
-       }
-       if (cur != addr)
-               tprints("]");
+       return true;
 }
 
 SYS_FUNC(move_pages)
 {
-       const unsigned long npages = tcp->u_arg[1];
+       const kernel_ulong_t npages = tcp->u_arg[1];
+       kernel_ulong_t buf;
 
        if (entering(tcp)) {
-               tprintf("%d, %lu, ", (int) tcp->u_arg[0], npages);
-               print_page_array(tcp, tcp->u_arg[2], npages);
+               tprintf("%d, %" PRI_klu ", ", (int) tcp->u_arg[0], npages);
+               print_array(tcp, tcp->u_arg[2], npages, &buf, current_wordsize,
+                           umoven_or_printaddr, print_addr, 0);
                tprints(", ");
-               print_int_array(tcp, tcp->u_arg[3], npages, print_int);
+               print_array(tcp, tcp->u_arg[3], npages, &buf, sizeof(int),
+                           umoven_or_printaddr, print_int, 0);
                tprints(", ");
        } else {
-               print_int_array(tcp, tcp->u_arg[4], npages, print_status);
+               print_array(tcp, tcp->u_arg[4], npages, &buf, sizeof(int),
+                           umoven_or_printaddr, print_status, 0);
                tprints(", ");
                printflags(move_pages_flags, tcp->u_arg[5], "MPOL_???");
        }