Possible patches for v5.8
Subsystems (4)
cover Possible patches for v5.8
Fixes:
- Make sure ASYNC rpc_tasks observe signals
Improvements:
- Adjust reply slack values only once
- More client-side RPC tracepoint curation
- Add/improve tracepoints to capture internal NFS I/O errors
---
Chuck Lever (15):
SUNRPC: Signalled ASYNC tasks need to exit
SUNRPC: receive buffer size estimation values almost never change
SUNRPC: Trace GSS context lifetimes
SUNRPC: Update the rpc_show_task_flags() macro
SUNRPC: Update the RPC_SHOW_SOCKET() macro
SUNRPC: Add tracepoint to rpc_call_rpcerror()
SUNRPC: Split the xdr_buf event class
SUNRPC: Trace transport lifetime events
SUNRPC: trace RPC client lifetime events
SUNRPC: rpc_call_null_helper() already sets RPC_TASK_NULLCREDS
SUNRPC: rpc_call_null_helper() should set RPC_TASK_SOFT
SUNRPC: Set SOFTCONN when destroying GSS contexts
NFS: nfs_xdr_status should record the procedure name
NFS: Trace short NFS READs
NFS: Add a tracepoint in nfs_set_pgio_error()
fs/nfs/nfstrace.h | 106 +++++++++++++- fs/nfs/pagelist.c | 2 fs/nfs/read.c | 2 include/linux/sunrpc/auth.h | 5 - include/trace/events/rpcgss.h | 89 +++++++++++- include/trace/events/rpcrdma.h | 4 - include/trace/events/sunrpc.h | 301 ++++++++++++++++++++++++++++++++------- net/sunrpc/auth_gss/auth_gss.c | 56 +++++-- net/sunrpc/auth_gss/trace.c | 1 net/sunrpc/clnt.c | 59 +++----- net/sunrpc/svc_xprt.c | 4 - net/sunrpc/xprt.c | 23 ++- net/sunrpc/xprtrdma/rpc_rdma.c | 4 - net/sunrpc/xprtrdma/transport.c | 8 - net/sunrpc/xprtrdma/verbs.c | 1 15 files changed, 527 insertions(+), 138 deletions(-)
--
Chuck Lever
PATCH 1/15 SUNRPC: Signalled ASYNC tasks need to exit
Ensure that signalled ASYNC rpc_tasks exit immediately instead of spinning until a timeout (or forever).
To avoid checking for the signal flag on every scheduler iteration, the check is instead introduced into the client's finite state machine.
--- net/sunrpc/clnt.c | 5 +++++ 1 file changed, 5 insertions(+)
net/sunrpc/clnt.c +5 -0
@@ -2433,6 +2433,11 @@ void rpc_force_rebind(struct rpc_clnt *clnt) {struct rpc_clnt *clnt = task->tk_client; +if (RPC_SIGNALLED (task)) { +rpc_call_rpcerror (task, -ERESTARTSYS ); +return ; + } +if (xprt_adjust_timeout (task->tk_rqstp) ==0 )return ;
PATCH 2/15 SUNRPC: receive buffer size estimation values almost never change
In reply to Chuck LeverAvoid unnecessary cache sloshing by placing the buffer size estimation update logic behind an atomic bit flag.
The size of GSS information included in each wrapped Reply does not change during the lifetime of a GSS context. Therefore, the au_rslack and au_ralign fields need to be updated only once after establishing a fresh GSS credential.
Thus a slack size update must occur after a cred is created, duplicated, renewed, or expires. I'm not sure I have this exactly right. A trace point is introduced to track updates to these variables to enable troubleshooting the problem if I missed a spot.
--- include/linux/sunrpc/auth.h | 5 +++-- include/trace/events/rpcgss.h | 34 +++++++++++++++++++++++++++++++ net/sunrpc/auth_gss/auth_gss.c | 44 +++++++++++++++++++++++++++------------- net/sunrpc/xprtrdma/rpc_rdma.c | 4 ++-- 4 files changed, 69 insertions(+), 18 deletions(-)
include/linux/sunrpc/auth.h +3 -2
@@ -76,7 +76,7 @@ struct rpc_auth {unsigned int au_verfsize;/* size of reply verifier */ unsigned int au_ralign;/* words before UL header */ -unsigned int au_flags; +unsigned long au_flags;const struct rpc_authops *au_ops;rpc_authflavor_t au_flavor;/* pseudoflavor (note may * differ from the flavor in
@@ -89,7 +89,8 @@ struct rpc_auth { };/* rpc_auth au_flags */ -#define RPCAUTH_AUTH_DATATOUCH 0x00000002 +#define RPCAUTH_AUTH_DATATOUCH (1) +#define RPCAUTH_AUTH_UPDATE_SLACK (2)struct rpc_auth_create_args {rpc_authflavor_t pseudoflavor;
include/trace/events/rpcgss.h +34 -0
@@ -291,6 +291,40 @@ __entry->ret ? "" : "un") ); +TRACE_EVENT (rpcgss_update_slack, +TP_PROTO ( + const struct rpc_task *task, + const struct rpc_auth *auth + ), + +TP_ARGS (task, auth), + +TP_STRUCT__entry ( + __field(unsigned int, task_id) + __field(unsigned int, client_id) + __field(u32, xid) + __field(const void *, auth) + __field(unsigned int, rslack) + __field(unsigned int, ralign) + __field(unsigned int, verfsize) + ), + +TP_fast_assign ( + __entry->task_id = task->tk_pid; + __entry->client_id = task->tk_client->cl_clid; + __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid); + __entry->auth = auth; + __entry->rslack = auth->au_rslack; + __entry->ralign = auth->au_ralign; + __entry->verfsize = auth->au_verfsize; + ), + +TP_printk ("task:%u@%u xid=0x%08x auth=%p rslack=%u ralign=%u verfsize=%u\n" , + __entry->task_id, __entry->client_id, __entry->xid, + __entry->auth, __entry->rslack, __entry->ralign, + __entry->verfsize) +); + DECLARE_EVENT_CLASS(rpcgss_svc_seqno_class, TP_PROTO( __be32 xid,
net/sunrpc/auth_gss/auth_gss.c +30 -14
104 lines not on this page · raw message
net/sunrpc/xprtrdma/rpc_rdma.c +2 -2
@@ -892,8 +892,8 @@ inline int rpcrdma_prepare_send_sges(struct rpcrdma_xprt *r_xprt,* or privacy, direct data placement of individual data items * is not allowed. */ - ddp_allowed = !(rqst->rq_cred->cr_auth->au_flags & -RPCAUTH_AUTH_DATATOUCH ); + ddp_allowed = !test_bit (RPCAUTH_AUTH_DATATOUCH , + &rqst->rq_cred->cr_auth->au_flags);/* * Chunks needed for results?
PATCH 3/15 SUNRPC: Trace GSS context lifetimes
In reply to Chuck Lever--- include/trace/events/rpcgss.h | 55 +++++++++++++++++++++++++++++++++++++--- net/sunrpc/auth_gss/auth_gss.c | 10 ++++--- net/sunrpc/auth_gss/trace.c | 1 + 3 files changed, 58 insertions(+), 8 deletions(-)
include/trace/events/rpcgss.h +51 -4
@@ -17,6 +17,16 @@** GSS-API related trace events **/ +TRACE_DEFINE_ENUM (RPC_GSS_SVC_NONE ); +TRACE_DEFINE_ENUM (RPC_GSS_SVC_INTEGRITY ); +TRACE_DEFINE_ENUM (RPC_GSS_SVC_PRIVACY ); + +#define show_gss_service (x) \ + __print_symbolic(x, \ + { RPC_GSS_SVC_NONE, "none" }, \ + { RPC_GSS_SVC_INTEGRITY, "integrity" }, \ + { RPC_GSS_SVC_PRIVACY, "privacy" }) +TRACE_DEFINE_ENUM (GSS_S_BAD_MECH );TRACE_DEFINE_ENUM (GSS_S_BAD_NAME );TRACE_DEFINE_ENUM (GSS_S_BAD_NAMETYPE );
@@ -126,6 +136,40 @@DEFINE_GSSAPI_EVENT (wrap);DEFINE_GSSAPI_EVENT (unwrap); +DECLARE_EVENT_CLASS (rpcgss_ctx_class, +TP_PROTO ( + const struct gss_cred *gc + ), + +TP_ARGS (gc), + +TP_STRUCT__entry ( + __field(const void *, cred) + __field(unsigned long, service) +__string (principal, gc->gc_principal) + ), + +TP_fast_assign ( + __entry->cred = gc; + __entry->service = gc->gc_service; +__assign_str (principal, gc->gc_principal) + ), + +TP_printk ("cred=%p service=%s principal='%s'" , + __entry->cred,show_gss_service (__entry->service), +__get_str (principal)) +); + +#define DEFINE_CTX_EVENT (name) \ + DEFINE_EVENT(rpcgss_ctx_class, rpcgss_ctx_##name, \ + TP_PROTO( \ + const struct gss_cred *gc \ + ), \ + TP_ARGS(gc)) + +DEFINE_CTX_EVENT (init); +DEFINE_CTX_EVENT (destroy); + TRACE_EVENT(rpcgss_svc_accept_upcall, TP_PROTO( __be32 xid,
@@ -405,6 +449,7 @@ TRACE_EVENT(rpcgss_context, TP_PROTO( + u32 window_size, unsigned long expiry, unsigned long now, unsigned int timeout,
@@ -412,12 +457,13 @@const u8 *data ), -TP_ARGS (expiry ,now ,timeout ,len ,data ), +TP_ARGS (window_size ,expiry ,now ,timeout ,len ,data ),TP_STRUCT__entry ( __field(unsigned long, expiry)__field (unsigned long ,now ) __field(unsigned int, timeout) +__field (u32, window_size)__field (int, len)__string (acceptor, data) ),
@@ -426,13 +472,14 @@ __entry->expiry = expiry; __entry->now = now; __entry->timeout = timeout; + __entry->window_size = window_size; __entry->len = len;strncpy (__get_str (acceptor), data, len); ), -TP_printk ("gc_expiry=%lu now=%lu timeout=%u acceptor=%.*s" , - __entry->expiry, __entry->now, __entry->timeout, - __entry->len,__get_str (acceptor)) +TP_printk ("win_size=%u expiry=%lu now=%lu timeout=%u acceptor=%.*s" , + __entry->window_size, __entry->expiry, __entry->now, + __entry->timeout, __entry->len,__get_str (acceptor)) );
net/sunrpc/auth_gss/auth_gss.c +6 -4
@@ -254,7 +254,7 @@ struct gss_auth {if (IS_ERR (p)) goto err; done: -trace_rpcgss_context (ctx->gc_expiry, now, timeout, +trace_rpcgss_context (window_size, ctx->gc_expiry, now, timeout, ctx->gc_acceptor.len, ctx->gc_acceptor.data); err:return p;
@@ -697,10 +697,12 @@ static void warn_gssd(void) }schedule (); } -if (gss_msg->ctx) +if (gss_msg->ctx) { +trace_rpcgss_ctx_init (gss_cred);gss_cred_set_ctx (cred, gss_msg->ctx); -else + }else { err = gss_msg->msg.errno; + }spin_unlock (&pipe->lock); out_intr:finish_wait (&gss_msg->waitqueue, &wait);
@@ -1284,6 +1286,7 @@ static void gss_pipe_free(struct gss_pipe *p)if (new) { ctx->gc_proc =RPC_GSS_PROC_DESTROY ; +trace_rpcgss_ctx_destroy (gss_cred); task =rpc_call_null (gss_auth->client, &new->gc_base,RPC_TASK_ASYNC |RPC_TASK_SOFT );if (!IS_ERR (task))
@@ -1349,7 +1352,6 @@ static void gss_pipe_free(struct gss_pipe *p)static void gss_destroy_cred (struct rpc_cred *cred) { -if (test_and_clear_bit (RPCAUTH_CRED_UPTODATE , &cred->cr_flags) !=0 )gss_send_destroy_context (cred);gss_destroy_nullcred (cred);
net/sunrpc/auth_gss/trace.c +1 -0
@@ -6,6 +6,7 @@#include <linux/sunrpc/clnt.h> #include <linux/sunrpc/sched.h> #include <linux/sunrpc/gss_err.h> +#include <linux/sunrpc/auth_gss.h> #define CREATE_TRACE_POINTS #include <trace/events/rpcgss.h>
PATCH 4/15 SUNRPC: Update the rpc_show_task_flags() macro
In reply to Chuck LeverRecent additions to the RPC_TASK flags neglected to update the tracepoint ENUM definitions.
--- include/trace/events/sunrpc.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
include/trace/events/sunrpc.h +7 -1
@@ -142,29 +142,35 @@TRACE_DEFINE_ENUM (RPC_TASK_ASYNC );TRACE_DEFINE_ENUM (RPC_TASK_SWAPPER ); +TRACE_DEFINE_ENUM (RPC_TASK_NULLCREDS );TRACE_DEFINE_ENUM (RPC_CALL_MAJORSEEN );TRACE_DEFINE_ENUM (RPC_TASK_ROOTCREDS );TRACE_DEFINE_ENUM (RPC_TASK_DYNAMIC ); +TRACE_DEFINE_ENUM (RPC_TASK_NO_ROUND_ROBIN );TRACE_DEFINE_ENUM (RPC_TASK_SOFT );TRACE_DEFINE_ENUM (RPC_TASK_SOFTCONN );TRACE_DEFINE_ENUM (RPC_TASK_SENT );TRACE_DEFINE_ENUM (RPC_TASK_TIMEOUT );TRACE_DEFINE_ENUM (RPC_TASK_NOCONNECT );TRACE_DEFINE_ENUM (RPC_TASK_NO_RETRANS_TIMEOUT ); +TRACE_DEFINE_ENUM (RPC_TASK_CRED_NOREF );#define rpc_show_task_flags (flags) \ __print_flags(flags, "|", \ { RPC_TASK_ASYNC, "ASYNC" }, \ { RPC_TASK_SWAPPER, "SWAPPER" }, \ + { RPC_TASK_NULLCREDS, "NULLCREDS" }, \ { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \ { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \ { RPC_TASK_DYNAMIC, "DYNAMIC" }, \ + { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \ { RPC_TASK_SOFT, "SOFT" }, \ { RPC_TASK_SOFTCONN, "SOFTCONN" }, \ { RPC_TASK_SENT, "SENT" }, \ { RPC_TASK_TIMEOUT, "TIMEOUT" }, \ { RPC_TASK_NOCONNECT, "NOCONNECT" }, \ - { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }) + { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \ + { RPC_TASK_CRED_NOREF, "CRED_NOREF" })TRACE_DEFINE_ENUM (RPC_TASK_RUNNING );TRACE_DEFINE_ENUM (RPC_TASK_QUEUED );
PATCH 5/15 SUNRPC: Update the RPC_SHOW_SOCKET() macro
In reply to Chuck LeverClean up: remove unnecessary commas, and fix a white-space nit.
--- include/trace/events/sunrpc.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
include/trace/events/sunrpc.h +3 -3
@@ -581,9 +581,9 @@#define RPC_SHOW_SOCKET \ EM( SS_FREE, "FREE" ) \ EM( SS_UNCONNECTED, "UNCONNECTED" ) \ - EM( SS_CONNECTING, "CONNECTING," ) \ - EM( SS_CONNECTED, "CONNECTED," ) \ - EMe(SS_DISCONNECTING, "DISCONNECTING" ) + EM( SS_CONNECTING, "CONNECTING" ) \ + EM( SS_CONNECTED, "CONNECTED" ) \ + EMe( SS_DISCONNECTING, "DISCONNECTING" )#define rpc_show_socket_state (state) \ __print_symbolic(state, RPC_SHOW_SOCKET)
PATCH 6/15 SUNRPC: Add tracepoint to rpc_call_rpcerror()
In reply to Chuck LeverAdd a tracepoint in another common exit point for failing RPCs.
--- include/trace/events/sunrpc.h | 28 ++++++++++++++++++++++++++++ net/sunrpc/clnt.c | 1 + 2 files changed, 29 insertions(+)
include/trace/events/sunrpc.h +28 -0
@@ -365,6 +365,34 @@DEFINE_RPC_REPLY_EVENT (bad_creds);DEFINE_RPC_REPLY_EVENT (auth_tooweak); +TRACE_EVENT (rpc_call_rpcerror, +TP_PROTO ( + const struct rpc_task *task, + int tk_status, + int rpc_status + ), + +TP_ARGS (task, tk_status, rpc_status), + +TP_STRUCT__entry ( + __field(unsigned int, task_id) + __field(unsigned int, client_id) + __field(int, tk_status) +__field (int, rpc_status) + ), + +TP_fast_assign ( + __entry->client_id = task->tk_client->cl_clid; + __entry->task_id = task->tk_pid; + __entry->tk_status = tk_status; + __entry->rpc_status = rpc_status; + ), + +TP_printk ("task:%u@%u tk_status=%d rpc_status=%d" , + __entry->task_id, __entry->client_id, + __entry->tk_status, __entry->rpc_status) +); + TRACE_EVENT(rpc_stats_latency, TP_PROTO(
net/sunrpc/clnt.c +1 -0
@@ -1624,6 +1624,7 @@ void rpc_force_rebind(struct rpc_clnt *clnt)static void __rpc_call_rpcerror (struct rpc_task *task,int tk_status,int rpc_status) { +trace_rpc_call_rpcerror (task, tk_status, rpc_status); task->tk_rpc_status = rpc_status;rpc_exit (task, tk_status); }
PATCH 7/15 SUNRPC: Split the xdr_buf event class
In reply to Chuck LeverTo 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.
--- include/trace/events/sunrpc.h | 113 ++++++++++++++++++++++++----------------- net/sunrpc/clnt.c | 4 + net/sunrpc/svc_xprt.c | 4 + net/sunrpc/xprt.c | 2 - 4 files changed, 71 insertions(+), 52 deletions(-)
include/trace/events/sunrpc.h +66 -47
@@ -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 @@ ), 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 @@ __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_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 @@ __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"}, \
net/sunrpc/clnt.c +2 -2
@@ -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 @@ void rpc_force_rebind(struct rpc_clnt *clnt) 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,
net/sunrpc/svc_xprt.c +2 -2
@@ -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);
net/sunrpc/xprt.c +1 -1
@@ -1460,7 +1460,7 @@ void xprt_end_transmit(struct rpc_task *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 ) {
PATCH 8/15 SUNRPC: Trace transport lifetime events
In reply to Chuck LeverRefactor: Hoist create/destroy/disconnect tracepoints out of xprtrdma and into the generic RPC client. Some benefits include:
- Enable tracing of xprt lifetime events for the socket transport types
- Expose the different types of disconnect to help run down issues with lingering connections
--- include/trace/events/rpcrdma.h | 4 ---- include/trace/events/sunrpc.h | 35 +++++++++++++++++++++++++++++++++++ net/sunrpc/xprt.c | 21 +++++++++++---------- net/sunrpc/xprtrdma/transport.c | 8 -------- net/sunrpc/xprtrdma/verbs.c | 1 - 5 files changed, 46 insertions(+), 23 deletions(-)
include/trace/events/rpcrdma.h +0 -4
@@ -380,12 +380,8 @@DEFINE_CONN_EVENT (connect);DEFINE_CONN_EVENT (disconnect); -DEFINE_CONN_EVENT (flush_dct); -DEFINE_RXPRT_EVENT (xprtrdma_create); -DEFINE_RXPRT_EVENT (xprtrdma_op_destroy);DEFINE_RXPRT_EVENT (xprtrdma_op_inject_dsc); -DEFINE_RXPRT_EVENT (xprtrdma_op_close);DEFINE_RXPRT_EVENT (xprtrdma_op_setport); TRACE_EVENT(xprtrdma_op_connect,
include/trace/events/sunrpc.h +35 -0
@@ -724,6 +724,41 @@DEFINE_RPC_SOCKET_EVENT (rpc_socket_close);DEFINE_RPC_SOCKET_EVENT (rpc_socket_shutdown); +DECLARE_EVENT_CLASS (rpc_xprt_lifetime_class, +TP_PROTO ( + const struct rpc_xprt *xprt + ), + +TP_ARGS (xprt), + +TP_STRUCT__entry ( + __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) +__string (port, xprt->address_strings[RPC_DISPLAY_PORT ]) + ), + +TP_fast_assign ( + __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); + __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); + ), + +TP_printk ("peer=[%s]:%s" ,__get_str (addr),__get_str (port)) +); + +#define DEFINE_RPC_XPRT_LIFETIME_EVENT (name) \ + DEFINE_EVENT(rpc_xprt_lifetime_class, \ + xprt_##name, \ + TP_PROTO( \ + const struct rpc_xprt *xprt \ + ), \ + TP_ARGS(xprt)) + +DEFINE_RPC_XPRT_LIFETIME_EVENT (create); +DEFINE_RPC_XPRT_LIFETIME_EVENT (disconnect_auto); +DEFINE_RPC_XPRT_LIFETIME_EVENT (disconnect_done); +DEFINE_RPC_XPRT_LIFETIME_EVENT (disconnect_force); +DEFINE_RPC_XPRT_LIFETIME_EVENT (disconnect_cleanup); +DEFINE_RPC_XPRT_LIFETIME_EVENT (destroy); + DECLARE_EVENT_CLASS(rpc_xprt_event, TP_PROTO( const struct rpc_xprt *xprt,
net/sunrpc/xprt.c +11 -10
@@ -663,6 +663,7 @@ static void xprt_autoclose(struct work_struct *work) container_of(work, struct rpc_xprt, task_cleanup);unsigned int pflags =memalloc_nofs_save (); +trace_xprt_disconnect_auto (xprt);clear_bit (XPRT_CLOSE_WAIT , &xprt->state); xprt->ops->close (xprt);xprt_release_write (xprt,NULL );
@@ -677,7 +678,7 @@ static void xprt_autoclose(struct work_struct *work)*/ void xprt_disconnect_done (struct rpc_xprt *xprt) { -dprintk ("RPC: disconnected transport %p\n" , xprt); +trace_xprt_disconnect_done (xprt);spin_lock (&xprt->transport_lock);xprt_clear_connected (xprt);xprt_clear_write_space_locked (xprt);
@@ -694,6 +695,8 @@ void xprt_disconnect_done(struct rpc_xprt *xprt)*/ void xprt_force_disconnect (struct rpc_xprt *xprt) { +trace_xprt_disconnect_force (xprt); +/* Don't race with the test_bit() in xprt_clear_locked() */ spin_lock (&xprt->transport_lock);set_bit (XPRT_CLOSE_WAIT , &xprt->state);
@@ -832,8 +835,10 @@ void xprt_connect(struct rpc_task *task)if (!xprt_lock_write (xprt, task))return ; -if (test_and_clear_bit (XPRT_CLOSE_WAIT , &xprt->state)) +if (test_and_clear_bit (XPRT_CLOSE_WAIT , &xprt->state)) { +trace_xprt_disconnect_cleanup (xprt); xprt->ops->close (xprt); + }if (!xprt_connected (xprt)) { task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie;
@@ -1903,11 +1908,8 @@ struct rpc_xprt *xprt_create_transport(struct xprt_create *args) found: xprt = t->setup (args); -if (IS_ERR (xprt)) { -dprintk ("RPC: xprt_create_transport: failed, %ld\n" , - -PTR_ERR (xprt)); +if (IS_ERR (xprt)) goto out; - }if (args->flags &XPRT_CREATE_NO_IDLE_TIMEOUT ) xprt->idle_timeout =0 ;INIT_WORK (&xprt->task_cleanup, xprt_autoclose);
@@ -1928,8 +1930,7 @@ struct rpc_xprt *xprt_create_transport(struct xprt_create *args)rpc_xprt_debugfs_register (xprt); -dprintk ("RPC: created transport %p with %u slots\n" , xprt, - xprt->max_reqs); +trace_xprt_create (xprt); out:return xprt; }
@@ -1939,6 +1940,8 @@ static void xprt_destroy_cb(struct work_struct *work)struct rpc_xprt *xprt = container_of(work, struct rpc_xprt, task_cleanup); +trace_xprt_destroy (xprt); +rpc_xprt_debugfs_unregister (xprt);rpc_destroy_wait_queue (&xprt->binding);rpc_destroy_wait_queue (&xprt->pending);
@@ -1963,8 +1966,6 @@ static void xprt_destroy_cb(struct work_struct *work)*/ static void xprt_destroy (struct rpc_xprt *xprt) { -dprintk ("RPC: destroying transport %p\n" , xprt); -/* * Exclude transport connect/disconnect handlers and autoclose */
net/sunrpc/xprtrdma/transport.c +0 -8
@@ -281,8 +281,6 @@ {struct rpcrdma_xprt *r_xprt =rpcx_to_rdmax (xprt); -trace_xprtrdma_op_destroy (r_xprt); -cancel_delayed_work_sync (&r_xprt->rx_connect_worker);rpcrdma_xprt_disconnect (r_xprt);
@@ -365,10 +363,6 @@ xprt->max_payload =RPCRDMA_MAX_DATA_SEGS <<PAGE_SHIFT ; -dprintk ("RPC: %s: %s:%s\n" , __func__, - xprt->address_strings[RPC_DISPLAY_ADDR ], - xprt->address_strings[RPC_DISPLAY_PORT ]); -trace_xprtrdma_create (new_xprt);return xprt; }
@@ -385,8 +379,6 @@ void xprt_rdma_close(struct rpc_xprt *xprt) {struct rpcrdma_xprt *r_xprt =rpcx_to_rdmax (xprt); -trace_xprtrdma_op_close (r_xprt); -rpcrdma_xprt_disconnect (r_xprt); xprt->reestablish_timeout =0 ;
net/sunrpc/xprtrdma/verbs.c +0 -1
@@ -141,7 +141,6 @@ void rpcrdma_flush_disconnect(struct ib_cq *cq, struct ib_wc *wc)if (wc->status !=IB_WC_SUCCESS && r_xprt->rx_ep->re_connect_status ==1 ) { r_xprt->rx_ep->re_connect_status = -ECONNABORTED ; -trace_xprtrdma_flush_dct (r_xprt, wc->status);xprt_force_disconnect (xprt); } }
PATCH 9/15 SUNRPC: trace RPC client lifetime events
In reply to Chuck LeverThe "create" tracepoint records parts of the rpc_create arguments, and the shutdown tracepoint records when the rpc_clnt is about to signal pending tasks and destroy auths.
--- include/trace/events/sunrpc.h | 111 +++++++++++++++++++++++++++++++++++++++++ net/sunrpc/clnt.c | 39 ++++++-------- 2 files changed, 126 insertions(+), 24 deletions(-)
include/trace/events/sunrpc.h +111 -0
@@ -65,6 +65,117 @@DEFINE_RPCXDRBUF_EVENT (reply_pages); +DECLARE_EVENT_CLASS (rpc_clnt_class, +TP_PROTO ( + const struct rpc_clnt *clnt + ), + +TP_ARGS (clnt), + +TP_STRUCT__entry ( + __field(unsigned int, client_id) + ), + +TP_fast_assign ( + __entry->client_id = clnt->cl_clid; + ), + +TP_printk ("clid=%u" , __entry->client_id) +); + +#define DEFINE_RPC_CLNT_EVENT (name) \ + DEFINE_EVENT(rpc_clnt_class, \ + rpc_clnt_##name, \ + TP_PROTO( \ + const struct rpc_clnt *clnt \ + ), \ + TP_ARGS(clnt)) + +DEFINE_RPC_CLNT_EVENT (free); +DEFINE_RPC_CLNT_EVENT (killall); +DEFINE_RPC_CLNT_EVENT (shutdown); +DEFINE_RPC_CLNT_EVENT (release); +DEFINE_RPC_CLNT_EVENT (replace_xprt); +DEFINE_RPC_CLNT_EVENT (replace_xprt_err); + +TRACE_EVENT (rpc_clnt_new, +TP_PROTO ( + const struct rpc_clnt *clnt, + const struct rpc_xprt *xprt, + const char *program, + const char *server + ), + +TP_ARGS (clnt, xprt, program, server), + +TP_STRUCT__entry ( + __field(unsigned int, client_id) + __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR]) + __string(port, xprt->address_strings[RPC_DISPLAY_PORT]) + __string(program, program) +__string (server, server) + ), + +TP_fast_assign ( + __entry->client_id = clnt->cl_clid; + __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]); + __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]); + __assign_str(program, program) +__assign_str (server, server) + ), + +TP_printk ("client=%u peer=[%s]:%s program=%s server=%s" , + __entry->client_id,__get_str (addr),__get_str (port), +__get_str (program),__get_str (server)) +); + +TRACE_EVENT (rpc_clnt_new_err, +TP_PROTO ( + const char *program, + const char *server, + int error + ), + +TP_ARGS (program, server, error), + +TP_STRUCT__entry ( + __field(int, error) + __string(program, program) +__string (server, server) + ), + +TP_fast_assign ( + __entry->error = error; + __assign_str(program, program) +__assign_str (server, server) + ), + +TP_printk ("program=%s server=%s error=%d" , +__get_str (program),__get_str (server), __entry->error) +); + +TRACE_EVENT (rpc_clnt_clone_err, +TP_PROTO ( + const struct rpc_clnt *clnt, + int error + ), + +TP_ARGS (clnt, error), + +TP_STRUCT__entry ( + __field(unsigned int, client_id) +__field (int, error) + ), + +TP_fast_assign ( + __entry->client_id = clnt->cl_clid; + __entry->error = error; + ), + +TP_printk ("client=%u error=%d" , __entry->client_id, __entry->error) +); + +TRACE_DEFINE_ENUM (RPC_AUTH_OK );TRACE_DEFINE_ENUM (RPC_AUTH_BADCRED );TRACE_DEFINE_ENUM (RPC_AUTH_REJECTEDCRED );
net/sunrpc/clnt.c +15 -24
@@ -370,10 +370,6 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args,const char *nodename = args->nodename;int err; -/* sanity check the name before trying to print it */ -dprintk ("RPC: creating %s client for %s (xprt %p)\n" , - program->name, args->servername, xprt); - err =rpciod_up ();if (err) goto out_no_rpciod;
@@ -436,6 +432,8 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, goto out_no_path;if (parent)atomic_inc (&parent->cl_count); + +trace_rpc_clnt_new (clnt, xprt, program->name, args->servername);return clnt; out_no_path:
@@ -450,6 +448,7 @@ static struct rpc_clnt * rpc_new_client(const struct rpc_create_args *args, out_no_rpciod:xprt_switch_put (xps);xprt_put (xprt); +trace_rpc_clnt_new_err (program->name, args->servername, err);return ERR_PTR (err); }
@@ -634,10 +633,8 @@ static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args, args->nodename = clnt->cl_nodename; new =rpc_new_client (args, xps, xprt, clnt); -if (IS_ERR (new)) { - err =PTR_ERR (new); - goto out_err; - } +if (IS_ERR (new)) +return new;/* Turn off autobind on clones */ new->cl_autobind =0 ;
@@ -650,7 +647,7 @@ static struct rpc_clnt *__rpc_clone_client(struct rpc_create_args *args,return new; out_err: -dprintk ("RPC: %s: returned error %d\n" , __func__, err); +trace_rpc_clnt_clone_err (clnt, err);return ERR_PTR (err); }
@@ -723,11 +720,8 @@ int rpc_switch_client_transport(struct rpc_clnt *clnt,int err; xprt =xprt_create_transport (args); -if (IS_ERR (xprt)) { -dprintk ("RPC: failed to create new xprt for clnt %p\n" , - clnt); +if (IS_ERR (xprt))return PTR_ERR (xprt); - } xps =xprt_switch_alloc (xprt,GFP_KERNEL );if (xps ==NULL ) {
@@ -767,7 +761,7 @@ int rpc_switch_client_transport(struct rpc_clnt *clnt,rpc_release_client (parent);xprt_switch_put (oldxps);xprt_put (old); -dprintk ("RPC: replaced xprt for clnt %p\n" , clnt); +trace_rpc_clnt_replace_xprt (clnt);return 0 ; out_revert:
@@ -777,7 +771,7 @@ int rpc_switch_client_transport(struct rpc_clnt *clnt,rpc_client_register (clnt, pseudoflavor,NULL );xprt_switch_put (xps);xprt_put (xprt); -dprintk ("RPC: failed to switch xprt for clnt %p\n" , clnt); +trace_rpc_clnt_replace_xprt_err (clnt);return err; }EXPORT_SYMBOL_GPL (rpc_switch_client_transport);
@@ -844,10 +838,11 @@ void rpc_killall_tasks(struct rpc_clnt *clnt)if (list_empty (&clnt->cl_tasks))return ; -dprintk ("RPC: killing all tasks for client %p\n" , clnt); +/* * Spin lock all_tasks to prevent changes... */ +trace_rpc_clnt_killall (clnt);spin_lock (&clnt->cl_lock);list_for_each_entry (rovr, &clnt->cl_tasks, tk_task)rpc_signal_task (rovr);
@@ -863,9 +858,7 @@ void rpc_shutdown_client(struct rpc_clnt *clnt) {might_sleep (); -dprintk_rcu ("RPC: shutting down %s client for %s\n" , - clnt->cl_program->name, -rcu_dereference (clnt->cl_xprt)->servername); +trace_rpc_clnt_shutdown (clnt);while (!list_empty (&clnt->cl_tasks)) {rpc_killall_tasks (clnt);
@@ -884,6 +877,8 @@ static void rpc_free_client_work(struct work_struct *work) { struct rpc_clnt *clnt = container_of(work, struct rpc_clnt, cl_work); +trace_rpc_clnt_free (clnt); +/* These might block on processes that might allocate memory, * so they cannot be called in rpciod, so they are handled separately * here.
@@ -899,9 +894,7 @@ static void rpc_free_client_work(struct work_struct *work) {struct rpc_clnt *parent =NULL ; -dprintk_rcu ("RPC: destroying %s client for %s\n" , - clnt->cl_program->name, -rcu_dereference (clnt->cl_xprt)->servername); +trace_rpc_clnt_release (clnt);if (clnt->cl_parent != clnt) parent = clnt->cl_parent;rpc_unregister_client (clnt);
@@ -945,8 +938,6 @@ static void rpc_free_client_work(struct work_struct *work)void rpc_release_client (struct rpc_clnt *clnt) { -dprintk ("RPC: rpc_release_client(%p)\n" , clnt); - do { if (list_empty(&clnt->cl_tasks)) wake_up(&destroy_wait);
PATCH 10/15 SUNRPC: rpc_call_null_helper() already sets RPC_TASK_NULLCREDS
In reply to Chuck LeverClean up.
Commit a52458b48af1 ("NFS/NFSD/SUNRPC: replace generic creds with 'struct cred'.") made rpc_call_null_helper() set RPC_TASK_NULLCREDS unconditionally. Therefore there's no need for rpc_call_null_helper()'s call sites to set RPC_TASK_NULLCREDS.
--- net/sunrpc/clnt.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/sunrpc/clnt.c +2 -2
@@ -2816,7 +2816,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, } task =rpc_call_null_helper (clnt, xprt,NULL , -RPC_TASK_SOFT |RPC_TASK_SOFTCONN |RPC_TASK_ASYNC |RPC_TASK_NULLCREDS , +RPC_TASK_SOFT |RPC_TASK_SOFTCONN |RPC_TASK_ASYNC , &rpc_cb_add_xprt_call_ops, data);rpc_put_task (task);
@@ -2860,7 +2860,7 @@ int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt,/* Test the connection */ task =rpc_call_null_helper (clnt, xprt,NULL , -RPC_TASK_SOFT |RPC_TASK_SOFTCONN |RPC_TASK_NULLCREDS , +RPC_TASK_SOFT |RPC_TASK_SOFTCONN ,NULL ,NULL );if (IS_ERR (task)) { status =PTR_ERR (task);
PATCH 11/15 SUNRPC: rpc_call_null_helper() should set RPC_TASK_SOFT
In reply to Chuck LeverClean up.
All of rpc_call_null_helper() call sites assert RPC_TASK_SOFT, so move that setting into rpc_call_null_helper() itself.
--- net/sunrpc/auth_gss/auth_gss.c | 2 +- net/sunrpc/clnt.c | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-)
net/sunrpc/auth_gss/auth_gss.c +1 -1
@@ -1288,7 +1288,7 @@ static void gss_pipe_free(struct gss_pipe *p)trace_rpcgss_ctx_destroy (gss_cred); task =rpc_call_null (gss_auth->client, &new->gc_base, -RPC_TASK_ASYNC |RPC_TASK_SOFT ); +RPC_TASK_ASYNC );if (!IS_ERR (task))rpc_put_task (task);
net/sunrpc/clnt.c +3 -4
@@ -2752,7 +2752,7 @@ struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt, .rpc_op_cred = cred, .callback_ops = (ops != NULL) ? ops : &rpc_default_ops, .callback_data = data, - .flags = flags | RPC_TASK_NULLCREDS, + .flags = flags | RPC_TASK_SOFT | RPC_TASK_NULLCREDS, };return rpc_run_task (&task_setup_data);
@@ -2816,7 +2816,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, } task =rpc_call_null_helper (clnt, xprt,NULL , -RPC_TASK_SOFT |RPC_TASK_SOFTCONN |RPC_TASK_ASYNC , +RPC_TASK_SOFTCONN |RPC_TASK_ASYNC , &rpc_cb_add_xprt_call_ops, data);rpc_put_task (task);
@@ -2859,8 +2859,7 @@ int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt, goto out_err;/* Test the connection */ - task =rpc_call_null_helper (clnt, xprt,NULL , -RPC_TASK_SOFT |RPC_TASK_SOFTCONN , + task =rpc_call_null_helper (clnt, xprt,NULL ,RPC_TASK_SOFTCONN ,NULL ,NULL );if (IS_ERR (task)) { status =PTR_ERR (task);
PATCH 12/15 SUNRPC: Set SOFTCONN when destroying GSS contexts
In reply to Chuck LeverMove the RPC_TASK_SOFTCONN flag into rpc_call_null_helper(). The only minor behavior change is that it is now also set when destroying GSS contexts.
This gives a better guarantee that gss_send_destroy_context() will not hang for long if a connection cannot be established.
--- net/sunrpc/clnt.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
net/sunrpc/clnt.c +4 -5
@@ -2752,7 +2752,8 @@ struct rpc_task *rpc_call_null_helper(struct rpc_clnt *clnt, .rpc_op_cred = cred, .callback_ops = (ops != NULL) ? ops : &rpc_default_ops, .callback_data = data, - .flags = flags | RPC_TASK_SOFT | RPC_TASK_NULLCREDS, + .flags = flags | RPC_TASK_SOFT | RPC_TASK_SOFTCONN | + RPC_TASK_NULLCREDS, };return rpc_run_task (&task_setup_data);
@@ -2815,8 +2816,7 @@ int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, goto success; } - task =rpc_call_null_helper (clnt, xprt,NULL , -RPC_TASK_SOFTCONN |RPC_TASK_ASYNC , + task =rpc_call_null_helper (clnt, xprt,NULL ,RPC_TASK_ASYNC , &rpc_cb_add_xprt_call_ops, data);rpc_put_task (task);
@@ -2859,8 +2859,7 @@ int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt, goto out_err;/* Test the connection */ - task =rpc_call_null_helper (clnt, xprt,NULL ,RPC_TASK_SOFTCONN , -NULL ,NULL ); + task =rpc_call_null_helper (clnt, xprt,NULL ,0 ,NULL ,NULL );if (IS_ERR (task)) { status =PTR_ERR (task); goto out_err;
PATCH 13/15 NFS: nfs_xdr_status should record the procedure name
In reply to Chuck LeverWhen sunrpc trace points are not enabled, the recorded task ID information alone is not helpful.
--- fs/nfs/nfstrace.h | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-)
fs/nfs/nfstrace.h +13 -2
@@ -1312,7 +1312,12 @@ __field(unsigned int, task_id) __field(unsigned int, client_id) __field(u32, xid) + __field(int, version) __field(unsigned long, error) + __string(program, + xdr->rqst->rq_task->tk_client->cl_program->name) + __string(procedure, + xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) ), TP_fast_assign(
@@ -1322,13 +1327,19 @@ __entry->task_id = task->tk_pid; __entry->client_id = task->tk_client->cl_clid; __entry->xid =be32_to_cpu (rqstp->rq_xid); + __entry->version = task->tk_client->cl_vers; __entry->error = error; +__assign_str (program, + task->tk_client->cl_program->name) +__assign_str (procedure, task->tk_msg.rpc_proc->p_name) ),TP_printk ( -"task:%u@%d xid=0x%08x error=%ld (%s)" , +"task:%u@%d xid=0x%08x %sv%d %s error=%ld (%s)" , __entry->task_id, __entry->client_id, __entry->xid, - -__entry->error,nfs_show_status (__entry->error) +__get_str (program), __entry->version, +__get_str (procedure), -__entry->error, +nfs_show_status (__entry->error) ) );
PATCH 14/15 NFS: Trace short NFS READs
In reply to Chuck LeverA short read can generate an -EIO error without there being an error on the wire. This tracepoint acts as an eyecatcher when there is no obvious I/O error.
--- fs/nfs/nfstrace.h | 47 +++++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/read.c | 2 ++ 2 files changed, 49 insertions(+)
fs/nfs/nfstrace.h +47 -0
@@ -961,6 +961,53 @@ ) ); +TRACE_EVENT (nfs_readpage_short, +TP_PROTO ( + const struct rpc_task *task, + const struct nfs_pgio_header *hdr + ), + +TP_ARGS (task, hdr), + +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(u32, fhandle) + __field(u64, fileid) + __field(loff_t, offset) + __field(u32, arg_count) + __field(u32, res_count) + __field(bool, eof) +__field (int, status) + ), + +TP_fast_assign ( + const struct inode *inode = hdr->inode; + const struct nfs_inode *nfsi = NFS_I(inode); + const struct nfs_fh *fh = hdr->args.fh ? + hdr->args.fh : &nfsi->fh; + + __entry->status = task->tk_status; + __entry->offset = hdr->args.offset; + __entry->arg_count = hdr->args.count; + __entry->res_count = hdr->res.count; + __entry->eof = hdr->res.eof; + __entry->dev = inode->i_sb->s_dev; + __entry->fileid = nfsi->fileid; + __entry->fhandle = nfs_fhandle_hash(fh); + ), + +TP_printk ( +"fileid=%02x:%02x:%llu fhandle=0x%08x " +"offset=%lld count=%u res=%u status=%d%s" , +MAJOR (__entry->dev),MINOR (__entry->dev), + (unsigned long long )__entry->fileid, + __entry->fhandle, + (long long )__entry->offset, __entry->arg_count, + __entry->res_count, __entry->status, + __entry->eof ?" eof" :"" + ) +); +TRACE_DEFINE_ENUM (NFS_UNSTABLE );TRACE_DEFINE_ENUM (NFS_DATA_SYNC );TRACE_DEFINE_ENUM (NFS_FILE_SYNC );
fs/nfs/read.c +2 -0
@@ -264,6 +264,8 @@ static void nfs_readpage_retry(struct rpc_task *task,/* This is a short read! */ nfs_inc_stats (hdr->inode,NFSIOS_SHORTREAD ); +trace_nfs_readpage_short (task, hdr); +/* Has the server at least made some progress? */ if (resp->count ==0 ) {nfs_set_pgio_error (hdr, -EIO , argp->offset);
PATCH 15/15 NFS: Add a tracepoint in nfs_set_pgio_error()
In reply to Chuck Lever--- fs/nfs/nfstrace.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/pagelist.c | 2 ++ 2 files changed, 46 insertions(+)
fs/nfs/nfstrace.h +44 -0
@@ -1008,6 +1008,50 @@ ) ); +TRACE_EVENT (nfs_pgio_error, +TP_PROTO ( + const struct nfs_pgio_header *hdr, + int error, + loff_t pos + ), + +TP_ARGS (hdr, error, pos), + +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(u32, fhandle) + __field(u64, fileid) + __field(loff_t, offset) + __field(u32, arg_count) + __field(u32, res_count) + __field(loff_t, pos) +__field (int, status) + ), + +TP_fast_assign ( + const struct inode *inode = hdr->inode; + const struct nfs_inode *nfsi = NFS_I(inode); + const struct nfs_fh *fh = hdr->args.fh ? + hdr->args.fh : &nfsi->fh; + + __entry->status = error; + __entry->offset = hdr->args.offset; + __entry->arg_count = hdr->args.count; + __entry->res_count = hdr->res.count; + __entry->dev = inode->i_sb->s_dev; + __entry->fileid = nfsi->fileid; + __entry->fhandle = nfs_fhandle_hash(fh); + ), + +TP_printk ("fileid=%02x:%02x:%llu fhandle=0x%08x " +"offset=%lld count=%u res=%u pos=%llu status=%d" , +MAJOR (__entry->dev),MINOR (__entry->dev), + (unsigned long long )__entry->fileid, __entry->fhandle, + (long long )__entry->offset, __entry->arg_count, __entry->res_count, + __entry->pos, __entry->status + ) +); +TRACE_DEFINE_ENUM (NFS_UNSTABLE );TRACE_DEFINE_ENUM (NFS_DATA_SYNC );TRACE_DEFINE_ENUM (NFS_FILE_SYNC );
fs/nfs/pagelist.c +2 -0
@@ -24,6 +24,7 @@#include "internal.h" #include "pnfs.h" +#include "nfstrace.h" #define NFSDBG_FACILITY NFSDBG_PAGECACHE
@@ -64,6 +65,7 @@ void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos) {unsigned int new = pos - hdr->io_start; +trace_nfs_pgio_error (hdr, error, pos);if (hdr->good_bytes > new) { hdr->good_bytes = new;clear_bit (NFS_IOHDR_EOF , &hdr->flags);