sg_io: cleanup printing of sg_io buffers

Turn print_sg_io_buffer into a universal sg_io buffer printer.

* sg_io_v3.c (print_sg_io_buffer): Add iovec_count argument.
Call tprint_iov_upto when iovec_count is non-zero.
(decode_request, decode_response): Do not call tprint_iov_upto directly,
use print_sg_io_buffer instead.
* sg_io_v4.c: Likewise.

diff --git a/sg_io_v3.c b/sg_io_v3.c
index 2c1045c5d90cff0b3c50404fe43e0e0fe2942c24..33aff50667605e684b89b5b6489a2539b674d3cb 100644 (file)
--- a/sg_io_v3.c
+++ b/sg_io_v3.c
@@ -49,9 +49,14 @@ typedef struct sg_io_hdr struct_sg_io_hdr;
 
 static void
 print_sg_io_buffer(struct tcb *const tcp, const kernel_ulong_t addr,
-                  const unsigned int len)
+                  const unsigned int data_size, const unsigned int iovec_count)
 {
-       printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
+       if (iovec_count) {
+               tprint_iov_upto(tcp, iovec_count, addr, IOV_DECODE_STR,
+                               data_size);
+       } else {
+               printstr_ex(tcp, addr, data_size, QUOTE_FORCE_HEX);
+       }
 }
 
 static int
@@ -72,7 +77,7 @@ decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
        printxval(sg_io_dxfer_direction, sg_io.dxfer_direction,
                  "SG_DXFER_???");
        tprintf(", cmd_len=%u, cmdp=", sg_io.cmd_len);
-       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.cmdp), sg_io.cmd_len);
+       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.cmdp), sg_io.cmd_len, 0);
        tprintf(", mx_sb_len=%d", sg_io.mx_sb_len);
        tprintf(", iovec_count=%d", sg_io.iovec_count);
        tprintf(", dxfer_len=%u", sg_io.dxfer_len);
@@ -83,14 +88,8 @@ decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
        if (sg_io.dxfer_direction == SG_DXFER_TO_DEV ||
            sg_io.dxfer_direction == SG_DXFER_TO_FROM_DEV) {
                tprints(", dxferp=");
-               if (sg_io.iovec_count)
-                       tprint_iov_upto(tcp, sg_io.iovec_count,
-                                       ptr_to_kulong(sg_io.dxferp),
-                                       IOV_DECODE_STR,
-                                       sg_io.dxfer_len);
-               else
-                       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
-                                          sg_io.dxfer_len);
+               print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
+                                  sg_io.dxfer_len, sg_io.iovec_count);
        }
 
        struct_sg_io_hdr *entering_sg_io = malloc(sizeof(*entering_sg_io));
@@ -137,20 +136,15 @@ decode_response(struct tcb *const tcp, const kernel_ulong_t arg)
                        tprints(" => dxferp=");
                }
                if (sg_io.dxfer_direction == SG_DXFER_FROM_DEV || din_len) {
-                       if (sg_io.iovec_count)
-                               tprint_iov_upto(tcp, sg_io.iovec_count,
-                                               ptr_to_kulong(sg_io.dxferp),
-                                               IOV_DECODE_STR, din_len);
-                       else
-                               print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
-                                                  din_len);
+                       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
+                                          din_len, sg_io.iovec_count);
                }
        }
        tprintf(", status=%#x", sg_io.status);
        tprintf(", masked_status=%#x", sg_io.masked_status);
        tprintf(", msg_status=%#x", sg_io.msg_status);
        tprintf(", sb_len_wr=%u, sbp=", sg_io.sb_len_wr);
-       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.sbp), sg_io.sb_len_wr);
+       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.sbp), sg_io.sb_len_wr, 0);
        tprintf(", host_status=%#x", sg_io.host_status);
        tprintf(", driver_status=%#x", sg_io.driver_status);
        tprintf(", resid=%d", sg_io.resid);

diff --git a/sg_io_v4.c b/sg_io_v4.c
index c1ef38cdd02fc1139847622425213692b8998f36..d647a800960fbe7958c9a15896c753fb1021684f 100644 (file)
--- a/sg_io_v4.c
+++ b/sg_io_v4.c
@@ -37,9 +37,14 @@
 
 static void
 print_sg_io_buffer(struct tcb *const tcp, const kernel_ulong_t addr,
-                  const unsigned int len)
+                  const unsigned int data_size, const unsigned int iovec_count)
 {
-       printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
+       if (iovec_count) {
+               tprint_iov_upto(tcp, iovec_count, addr, IOV_DECODE_STR,
+                               data_size);
+       } else {
+               printstr_ex(tcp, addr, data_size, QUOTE_FORCE_HEX);
+       }
 }
 
 static int
@@ -60,7 +65,7 @@ decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
        tprints(", subprotocol=");
        printxval(bsg_subprotocol, sg_io.subprotocol, "BSG_SUB_PROTOCOL_???");
        tprintf(", request_len=%u, request=", sg_io.request_len);
-       print_sg_io_buffer(tcp, sg_io.request, sg_io.request_len);
+       print_sg_io_buffer(tcp, sg_io.request, sg_io.request_len, 0);
        tprintf(", request_tag=%#" PRI__x64, sg_io.request_tag);
        tprintf(", request_attr=%u", sg_io.request_attr);
        tprintf(", request_priority=%u", sg_io.request_priority);
@@ -72,11 +77,8 @@ decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
        tprintf(", din_iovec_count=%u", sg_io.din_iovec_count);
        tprintf(", din_xfer_len=%u", sg_io.din_xfer_len);
        tprints(", dout_xferp=");
-       if (sg_io.dout_iovec_count)
-               tprint_iov_upto(tcp, sg_io.dout_iovec_count, sg_io.dout_xferp,
-                               IOV_DECODE_STR, sg_io.dout_xfer_len);
-       else
-               print_sg_io_buffer(tcp, sg_io.dout_xferp, sg_io.dout_xfer_len);
+       print_sg_io_buffer(tcp, sg_io.dout_xferp, sg_io.dout_xfer_len,
+                          sg_io.dout_iovec_count);
 
        tprintf(", timeout=%u", sg_io.timeout);
        tprints(", flags=");
@@ -115,16 +117,13 @@ decode_response(struct tcb *const tcp, const kernel_ulong_t arg)
        }
 
        tprintf(", response_len=%u, response=", sg_io.response_len);
-       print_sg_io_buffer(tcp, sg_io.response, sg_io.response_len);
+       print_sg_io_buffer(tcp, sg_io.response, sg_io.response_len, 0);
        din_len = sg_io.din_xfer_len;
        if (sg_io.din_resid > 0 && (unsigned int) sg_io.din_resid <= din_len)
                din_len -= sg_io.din_resid;
        tprints(", din_xferp=");
-       if (sg_io.din_iovec_count)
-               tprint_iov_upto(tcp, sg_io.din_iovec_count, sg_io.din_xferp,
-                               IOV_DECODE_STR, din_len);
-       else
-               print_sg_io_buffer(tcp, sg_io.din_xferp, din_len);
+       print_sg_io_buffer(tcp, sg_io.din_xferp, din_len,
+                          sg_io.din_iovec_count);
        tprintf(", driver_status=%#x", sg_io.driver_status);
        tprintf(", transport_status=%#x", sg_io.transport_status);
        tprintf(", device_status=%#x", sg_io.device_status);