/*
* Copyright (c) 2015 Bart Van Assche <bart.vanassche@sandisk.com>
- * Copyright (c) 2015-2017 Dmitry V. Levin <ldv@altlinux.org>
+ * Copyright (c) 2015-2018 Dmitry V. Levin <ldv@altlinux.org>
* All rights reserved.
*
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
+ * SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "defs.h"
#ifdef HAVE_LINUX_BSG_H
+# include "print_fields.h"
# include <linux/bsg.h>
# include "xlat/bsg_protocol.h"
# include "xlat/bsg_subprotocol.h"
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);
+ }
}
+#define PRINT_FIELD_SG_IO_BUFFER(prefix_, where_, field_, size_, count_, tcp_) \
+ do { \
+ STRACE_PRINTF("%s%s=", (prefix_), #field_); \
+ print_sg_io_buffer((tcp_), (where_).field_, (size_), (count_)); \
+ } while (0)
+
static int
decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
{
if (umoven_or_printaddr(tcp, arg + skip_iid, sizeof(sg_io) - skip_iid,
&sg_io.protocol)) {
tprints("}");
- return RVAL_DECODED | 1;
+ return RVAL_IOCTL_DECODED;
}
- tprints("protocol=");
- printxval(bsg_protocol, sg_io.protocol, "BSG_PROTOCOL_???");
- tprints(", subprotocol=");
- printxval(bsg_subprotocol, sg_io.subprotocol, "BSG_SUB_PROTOCOL_???");
- tprintf(", request[%u]=", sg_io.request_len);
- print_sg_io_buffer(tcp, sg_io.request, sg_io.request_len);
- tprintf(", request_tag=%" PRI__u64, sg_io.request_tag);
- tprintf(", request_attr=%u", sg_io.request_attr);
- tprintf(", request_priority=%u", sg_io.request_priority);
- tprintf(", request_extra=%u", sg_io.request_extra);
- tprintf(", max_response_len=%u", sg_io.max_response_len);
-
- tprintf(", dout_iovec_count=%u", sg_io.dout_iovec_count);
- tprintf(", dout_xfer_len=%u", sg_io.dout_xfer_len);
- tprintf(", din_iovec_count=%u", sg_io.din_iovec_count);
- tprintf(", din_xfer_len=%u", sg_io.din_xfer_len);
- tprintf(", timeout=%u", sg_io.timeout);
- tprints(", flags=");
- printflags(bsg_flags, sg_io.flags, "BSG_FLAG_???");
- tprintf(", usr_ptr=%" PRI__u64, sg_io.usr_ptr);
- tprintf(", dout[%u]=", sg_io.dout_xfer_len);
- 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);
- return 1;
+ PRINT_FIELD_XVAL("", sg_io, protocol, bsg_protocol, "BSG_PROTOCOL_???");
+ PRINT_FIELD_XVAL(", ", sg_io, subprotocol, bsg_subprotocol,
+ "BSG_SUB_PROTOCOL_???");
+ PRINT_FIELD_U(", ", sg_io, request_len);
+ PRINT_FIELD_SG_IO_BUFFER(", ", sg_io, request, sg_io.request_len,
+ 0, tcp);
+ PRINT_FIELD_X(", ", sg_io, request_tag);
+ PRINT_FIELD_U(", ", sg_io, request_attr);
+ PRINT_FIELD_U(", ", sg_io, request_priority);
+ PRINT_FIELD_U(", ", sg_io, request_extra);
+ PRINT_FIELD_U(", ", sg_io, max_response_len);
+
+ PRINT_FIELD_U(", ", sg_io, dout_iovec_count);
+ PRINT_FIELD_U(", ", sg_io, dout_xfer_len);
+ PRINT_FIELD_U(", ", sg_io, din_iovec_count);
+ PRINT_FIELD_U(", ", sg_io, din_xfer_len);
+ PRINT_FIELD_SG_IO_BUFFER(", ", sg_io, dout_xferp, sg_io.dout_xfer_len,
+ sg_io.dout_iovec_count, tcp);
+
+ PRINT_FIELD_U(", ", sg_io, timeout);
+ PRINT_FIELD_FLAGS(", ", sg_io, flags, bsg_flags, "BSG_FLAG_???");
+ PRINT_FIELD_X(", ", sg_io, usr_ptr);
+
+ struct sg_io_v4 *entering_sg_io = malloc(sizeof(*entering_sg_io));
+ if (entering_sg_io) {
+ memcpy(entering_sg_io, &sg_io, sizeof(sg_io));
+ entering_sg_io->guard = (unsigned char) 'Q';
+ set_tcb_priv_data(tcp, entering_sg_io, free);
+ }
+
+ return 0;
}
static int
decode_response(struct tcb *const tcp, const kernel_ulong_t arg)
{
+ struct sg_io_v4 *entering_sg_io = get_tcb_priv_data(tcp);
struct sg_io_v4 sg_io;
uint32_t din_len;
if (umove(tcp, arg, &sg_io) < 0) {
- tprints(", ???");
- return RVAL_DECODED | 1;
+ /* print i/o fields fetched on entering syscall */
+ PRINT_FIELD_X(", ", *entering_sg_io, response);
+ PRINT_FIELD_X(", ", *entering_sg_io, din_xferp);
+ return RVAL_IOCTL_DECODED;
}
- if (sg_io.guard != (unsigned char) 'Q') {
- tprintf(" => guard=%u", sg_io.guard);
- return RVAL_DECODED | 1;
+ if (sg_io.guard != entering_sg_io->guard) {
+ PRINT_FIELD_U(" => ", sg_io, guard);
+ return RVAL_IOCTL_DECODED;
}
- tprintf(", response[%u]=", sg_io.response_len);
- print_sg_io_buffer(tcp, sg_io.response, sg_io.response_len);
+ PRINT_FIELD_U(", ", sg_io, response_len);
+ PRINT_FIELD_SG_IO_BUFFER(", ", sg_io, response, sg_io.response_len,
+ 0, tcp);
din_len = sg_io.din_xfer_len;
- if (sg_io.din_resid > 0)
+ if (sg_io.din_resid > 0 && (unsigned int) sg_io.din_resid <= din_len)
din_len -= sg_io.din_resid;
- tprintf(", din[%u]=", din_len);
- if (sg_io.din_iovec_count)
- tprint_iov_upto(tcp, sg_io.din_iovec_count, sg_io.din_xferp,
- syserror(tcp) ? IOV_DECODE_ADDR :
- IOV_DECODE_STR, din_len);
- else
- print_sg_io_buffer(tcp, sg_io.din_xferp, din_len);
- tprintf(", driver_status=%u", sg_io.driver_status);
- tprintf(", transport_status=%u", sg_io.transport_status);
- tprintf(", device_status=%u", sg_io.device_status);
- tprintf(", retry_delay=%u", sg_io.retry_delay);
- tprints(", info=");
- printflags(sg_io_info, sg_io.info, "SG_INFO_???");
- tprintf(", duration=%u", sg_io.duration);
- tprintf(", response_len=%u", sg_io.response_len);
- tprintf(", din_resid=%u", sg_io.din_resid);
- tprintf(", dout_resid=%u", sg_io.dout_resid);
- tprintf(", generated_tag=%" PRI__u64, sg_io.generated_tag);
-
- return RVAL_DECODED | 1;
+ PRINT_FIELD_SG_IO_BUFFER(", ", sg_io, din_xferp, din_len,
+ sg_io.din_iovec_count, tcp);
+ PRINT_FIELD_X(", ", sg_io, driver_status);
+ PRINT_FIELD_X(", ", sg_io, transport_status);
+ PRINT_FIELD_X(", ", sg_io, device_status);
+ PRINT_FIELD_U(", ", sg_io, retry_delay);
+ PRINT_FIELD_FLAGS(", ", sg_io, info, sg_io_info, "SG_INFO_???");
+ PRINT_FIELD_U(", ", sg_io, duration);
+ PRINT_FIELD_U(", ", sg_io, response_len);
+ PRINT_FIELD_D(", ", sg_io, din_resid);
+ PRINT_FIELD_D(", ", sg_io, dout_resid);
+ PRINT_FIELD_X(", ", sg_io, generated_tag);
+
+ return RVAL_IOCTL_DECODED;
}
#else /* !HAVE_LINUX_BSG_H */
decode_request(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints("{guard='Q', ...}");
- return RVAL_DECODED | 1;
+ return RVAL_IOCTL_DECODED;
}
static int
projects / strace / blobdiff