SUNRPC: Split the xdr_buf event class

To help tie the recorded xdr_buf to a particular RPC transaction,
the client side version of this class should display task ID
information and the server side one should show the request's XID.

Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>

diff --git a/include/trace/events/sunrpc.h b/include/trace/events/sunrpc.h
index f1fd3fa..4747803 100644 (file)
--- a/include/trace/events/sunrpc.h
+++ b/include/trace/events/sunrpc.h
@@ -14,14 +14,17 @@
 #include <linux/net.h>
 #include <linux/tracepoint.h>
 
-DECLARE_EVENT_CLASS(xdr_buf_class,
+DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
        TP_PROTO(
+               const struct rpc_task *task,
                const struct xdr_buf *xdr
        ),
 
-       TP_ARGS(xdr),
+       TP_ARGS(task, xdr),
 
        TP_STRUCT__entry(
+               __field(unsigned int, task_id)
+               __field(unsigned int, client_id)
                __field(const void *, head_base)
                __field(size_t, head_len)
                __field(const void *, tail_base)
@@ -31,6 +34,8 @@ DECLARE_EVENT_CLASS(xdr_buf_class,
        ),
 
        TP_fast_assign(
+               __entry->task_id = task->tk_pid;
+               __entry->client_id = task->tk_client->cl_clid;
                __entry->head_base = xdr->head[0].iov_base;
                __entry->head_len = xdr->head[0].iov_len;
                __entry->tail_base = xdr->tail[0].iov_base;
@@ -39,23 +44,26 @@ DECLARE_EVENT_CLASS(xdr_buf_class,
                __entry->msg_len = xdr->len;
        ),
 
-       TP_printk("head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
+       TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
+               __entry->task_id, __entry->client_id,
                __entry->head_base, __entry->head_len, __entry->page_len,
                __entry->tail_base, __entry->tail_len, __entry->msg_len
        )
 );
 
-#define DEFINE_XDRBUF_EVENT(name)                                      \
-               DEFINE_EVENT(xdr_buf_class, name,                       \
+#define DEFINE_RPCXDRBUF_EVENT(name)                                   \
+               DEFINE_EVENT(rpc_xdr_buf_class,                         \
+                               rpc_xdr_##name,                         \
                                TP_PROTO(                               \
+                                       const struct rpc_task *task,    \
                                        const struct xdr_buf *xdr       \
                                ),                                      \
-                               TP_ARGS(xdr))
+                               TP_ARGS(task, xdr))
+
+DEFINE_RPCXDRBUF_EVENT(sendto);
+DEFINE_RPCXDRBUF_EVENT(recvfrom);
+DEFINE_RPCXDRBUF_EVENT(reply_pages);
 
-DEFINE_XDRBUF_EVENT(xprt_sendto);
-DEFINE_XDRBUF_EVENT(xprt_recvfrom);
-DEFINE_XDRBUF_EVENT(svc_recvfrom);
-DEFINE_XDRBUF_EVENT(svc_sendto);
 
 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
@@ -560,43 +568,6 @@ TRACE_EVENT(rpc_xdr_alignment,
        )
 );
 
-TRACE_EVENT(rpc_reply_pages,
-       TP_PROTO(
-               const struct rpc_rqst *req
-       ),
-
-       TP_ARGS(req),
-
-       TP_STRUCT__entry(
-               __field(unsigned int, task_id)
-               __field(unsigned int, client_id)
-               __field(const void *, head_base)
-               __field(size_t, head_len)
-               __field(const void *, tail_base)
-               __field(size_t, tail_len)
-               __field(unsigned int, page_len)
-       ),
-
-       TP_fast_assign(
-               __entry->task_id = req->rq_task->tk_pid;
-               __entry->client_id = req->rq_task->tk_client->cl_clid;
-
-               __entry->head_base = req->rq_rcv_buf.head[0].iov_base;
-               __entry->head_len = req->rq_rcv_buf.head[0].iov_len;
-               __entry->page_len = req->rq_rcv_buf.page_len;
-               __entry->tail_base = req->rq_rcv_buf.tail[0].iov_base;
-               __entry->tail_len = req->rq_rcv_buf.tail[0].iov_len;
-       ),
-
-       TP_printk(
-               "task:%u@%u xdr=[%p,%zu]/%u/[%p,%zu]\n",
-               __entry->task_id, __entry->client_id,
-               __entry->head_base, __entry->head_len,
-               __entry->page_len,
-               __entry->tail_base, __entry->tail_len
-       )
-);
-
 /*
  * First define the enums in the below macros to be exported to userspace
  * via TRACE_DEFINE_ENUM().
@@ -1024,6 +995,54 @@ TRACE_EVENT(xs_stream_read_request,
                        __entry->copied, __entry->reclen, __entry->offset)
 );
 
+
+DECLARE_EVENT_CLASS(svc_xdr_buf_class,
+       TP_PROTO(
+               const struct svc_rqst *rqst,
+               const struct xdr_buf *xdr
+       ),
+
+       TP_ARGS(rqst, xdr),
+
+       TP_STRUCT__entry(
+               __field(u32, xid)
+               __field(const void *, head_base)
+               __field(size_t, head_len)
+               __field(const void *, tail_base)
+               __field(size_t, tail_len)
+               __field(unsigned int, page_len)
+               __field(unsigned int, msg_len)
+       ),
+
+       TP_fast_assign(
+               __entry->xid = be32_to_cpu(rqst->rq_xid);
+               __entry->head_base = xdr->head[0].iov_base;
+               __entry->head_len = xdr->head[0].iov_len;
+               __entry->tail_base = xdr->tail[0].iov_base;
+               __entry->tail_len = xdr->tail[0].iov_len;
+               __entry->page_len = xdr->page_len;
+               __entry->msg_len = xdr->len;
+       ),
+
+       TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
+               __entry->xid,
+               __entry->head_base, __entry->head_len, __entry->page_len,
+               __entry->tail_base, __entry->tail_len, __entry->msg_len
+       )
+);
+
+#define DEFINE_SVCXDRBUF_EVENT(name)                                   \
+               DEFINE_EVENT(svc_xdr_buf_class,                         \
+                               svc_xdr_##name,                         \
+                               TP_PROTO(                               \
+                                       const struct svc_rqst *rqst,    \
+                                       const struct xdr_buf *xdr       \
+                               ),                                      \
+                               TP_ARGS(rqst, xdr))
+
+DEFINE_SVCXDRBUF_EVENT(recvfrom);
+DEFINE_SVCXDRBUF_EVENT(sendto);
+
 #define show_rqstp_flags(flags)                                                \
        __print_flags(flags, "|",                                       \
                { (1UL << RQ_SECURE),           "RQ_SECURE"},           \

diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 2621258..0e684d9 100644 (file)
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -1270,7 +1270,7 @@ void rpc_prepare_reply_pages(struct rpc_rqst *req, struct page **pages,
        hdrsize += RPC_REPHDRSIZE + req->rq_cred->cr_auth->au_ralign - 1;
 
        xdr_inline_pages(&req->rq_rcv_buf, hdrsize << 2, pages, base, len);
-       trace_rpc_reply_pages(req);
+       trace_rpc_xdr_reply_pages(req->rq_task, &req->rq_rcv_buf);
 }
 EXPORT_SYMBOL_GPL(rpc_prepare_reply_pages);
 
@@ -2532,7 +2532,7 @@ call_decode(struct rpc_task *task)
                goto out;
 
        req->rq_rcv_buf.len = req->rq_private_buf.len;
-       trace_xprt_recvfrom(&req->rq_rcv_buf);
+       trace_rpc_xdr_recvfrom(task, &req->rq_rcv_buf);
 
        /* Check that the softirq receive buffer is valid */
        WARN_ON(memcmp(&req->rq_rcv_buf, &req->rq_private_buf,

diff --git a/net/sunrpc/svc_xprt.c b/net/sunrpc/svc_xprt.c
index 2284ff0..8ef4427 100644 (file)
--- a/net/sunrpc/svc_xprt.c
+++ b/net/sunrpc/svc_xprt.c
@@ -812,7 +812,7 @@ static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
                else
                        len = xprt->xpt_ops->xpo_recvfrom(rqstp);
                if (len > 0)
-                       trace_svc_recvfrom(&rqstp->rq_arg);
+                       trace_svc_xdr_recvfrom(rqstp, &rqstp->rq_arg);
                rqstp->rq_stime = ktime_get();
                rqstp->rq_reserved = serv->sv_max_mesg;
                atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
@@ -913,7 +913,7 @@ int svc_send(struct svc_rqst *rqstp)
        xb->len = xb->head[0].iov_len +
                xb->page_len +
                xb->tail[0].iov_len;
-       trace_svc_sendto(xb);
+       trace_svc_xdr_sendto(rqstp, xb);
 
        /* Grab mutex to serialize outgoing data. */
        mutex_lock(&xprt->xpt_mutex);

diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 493a30a..053de05 100644 (file)
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -1460,7 +1460,7 @@ xprt_request_transmit(struct rpc_rqst *req, struct rpc_task *snd_task)
         */
        req->rq_ntrans++;
 
-       trace_xprt_sendto(&req->rq_snd_buf);
+       trace_rpc_xdr_sendto(task, &req->rq_snd_buf);
        connect_cookie = xprt->connect_cookie;
        status = xprt->ops->send_request(req);
        if (status != 0) {