forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/include/trace/events/sunrpc.h
....@@ -14,42 +14,224 @@
1414 #include <linux/net.h>
1515 #include <linux/tracepoint.h>
1616 
17
-DECLARE_EVENT_CLASS(rpc_task_status,
17
+TRACE_DEFINE_ENUM(SOCK_STREAM);
18
+TRACE_DEFINE_ENUM(SOCK_DGRAM);
19
+TRACE_DEFINE_ENUM(SOCK_RAW);
20
+TRACE_DEFINE_ENUM(SOCK_RDM);
21
+TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
22
+TRACE_DEFINE_ENUM(SOCK_DCCP);
23
+TRACE_DEFINE_ENUM(SOCK_PACKET);
1824 
19
-	TP_PROTO(struct rpc_task *task),
25
+#define show_socket_type(type)					\
26
+	__print_symbolic(type,					\
27
+		{ SOCK_STREAM,		"STREAM" },		\
28
+		{ SOCK_DGRAM,		"DGRAM" },		\
29
+		{ SOCK_RAW,		"RAW" },		\
30
+		{ SOCK_RDM,		"RDM" },		\
31
+		{ SOCK_SEQPACKET,	"SEQPACKET" },		\
32
+		{ SOCK_DCCP,		"DCCP" },		\
33
+		{ SOCK_PACKET,		"PACKET" })
2034 
21
-	TP_ARGS(task),
35
+/* This list is known to be incomplete, add new enums as needed. */
36
+TRACE_DEFINE_ENUM(AF_UNSPEC);
37
+TRACE_DEFINE_ENUM(AF_UNIX);
38
+TRACE_DEFINE_ENUM(AF_LOCAL);
39
+TRACE_DEFINE_ENUM(AF_INET);
40
+TRACE_DEFINE_ENUM(AF_INET6);
41
+
42
+#define rpc_show_address_family(family)				\
43
+	__print_symbolic(family,				\
44
+		{ AF_UNSPEC,		"AF_UNSPEC" },		\
45
+		{ AF_UNIX,		"AF_UNIX" },		\
46
+		{ AF_LOCAL,		"AF_LOCAL" },		\
47
+		{ AF_INET,		"AF_INET" },		\
48
+		{ AF_INET6,		"AF_INET6" })
49
+
50
+DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
51
+	TP_PROTO(
52
+		const struct rpc_task *task,
53
+		const struct xdr_buf *xdr
54
+	),
55
+
56
+	TP_ARGS(task, xdr),
2257 
2358 	TP_STRUCT__entry(
2459 		__field(unsigned int, task_id)
2560 		__field(unsigned int, client_id)
26
-		__field(int, status)
61
+		__field(const void *, head_base)
62
+		__field(size_t, head_len)
63
+		__field(const void *, tail_base)
64
+		__field(size_t, tail_len)
65
+		__field(unsigned int, page_len)
66
+		__field(unsigned int, msg_len)
2767 	),
2868 
2969 	TP_fast_assign(
3070 		__entry->task_id = task->tk_pid;
31
-		__entry->client_id = task->tk_client->cl_clid;
32
-		__entry->status = task->tk_status;
71
+		__entry->client_id = task->tk_client ?
72
+				     task->tk_client->cl_clid : -1;
73
+		__entry->head_base = xdr->head[0].iov_base;
74
+		__entry->head_len = xdr->head[0].iov_len;
75
+		__entry->tail_base = xdr->tail[0].iov_base;
76
+		__entry->tail_len = xdr->tail[0].iov_len;
77
+		__entry->page_len = xdr->page_len;
78
+		__entry->msg_len = xdr->len;
3379 	),
3480 
35
-	TP_printk("task:%u@%u status=%d",
81
+	TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
3682 		__entry->task_id, __entry->client_id,
37
-		__entry->status)
83
+		__entry->head_base, __entry->head_len, __entry->page_len,
84
+		__entry->tail_base, __entry->tail_len, __entry->msg_len
85
+	)
3886 );
3987 
40
-DEFINE_EVENT(rpc_task_status, rpc_call_status,
41
-	TP_PROTO(struct rpc_task *task),
88
+#define DEFINE_RPCXDRBUF_EVENT(name)					\
89
+		DEFINE_EVENT(rpc_xdr_buf_class,				\
90
+				rpc_xdr_##name,				\
91
+				TP_PROTO(				\
92
+					const struct rpc_task *task,	\
93
+					const struct xdr_buf *xdr	\
94
+				),					\
95
+				TP_ARGS(task, xdr))
4296 
43
-	TP_ARGS(task)
97
+DEFINE_RPCXDRBUF_EVENT(sendto);
98
+DEFINE_RPCXDRBUF_EVENT(recvfrom);
99
+DEFINE_RPCXDRBUF_EVENT(reply_pages);
100
+
101
+
102
+DECLARE_EVENT_CLASS(rpc_clnt_class,
103
+	TP_PROTO(
104
+		const struct rpc_clnt *clnt
105
+	),
106
+
107
+	TP_ARGS(clnt),
108
+
109
+	TP_STRUCT__entry(
110
+		__field(unsigned int, client_id)
111
+	),
112
+
113
+	TP_fast_assign(
114
+		__entry->client_id = clnt->cl_clid;
115
+	),
116
+
117
+	TP_printk("clid=%u", __entry->client_id)
44118 );
45119 
46
-DEFINE_EVENT(rpc_task_status, rpc_bind_status,
47
-	TP_PROTO(struct rpc_task *task),
120
+#define DEFINE_RPC_CLNT_EVENT(name)					\
121
+		DEFINE_EVENT(rpc_clnt_class,				\
122
+				rpc_clnt_##name,			\
123
+				TP_PROTO(				\
124
+					const struct rpc_clnt *clnt	\
125
+				),					\
126
+				TP_ARGS(clnt))
48127 
49
-	TP_ARGS(task)
128
+DEFINE_RPC_CLNT_EVENT(free);
129
+DEFINE_RPC_CLNT_EVENT(killall);
130
+DEFINE_RPC_CLNT_EVENT(shutdown);
131
+DEFINE_RPC_CLNT_EVENT(release);
132
+DEFINE_RPC_CLNT_EVENT(replace_xprt);
133
+DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
134
+
135
+TRACE_EVENT(rpc_clnt_new,
136
+	TP_PROTO(
137
+		const struct rpc_clnt *clnt,
138
+		const struct rpc_xprt *xprt,
139
+		const char *program,
140
+		const char *server
141
+	),
142
+
143
+	TP_ARGS(clnt, xprt, program, server),
144
+
145
+	TP_STRUCT__entry(
146
+		__field(unsigned int, client_id)
147
+		__string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
148
+		__string(port, xprt->address_strings[RPC_DISPLAY_PORT])
149
+		__string(program, program)
150
+		__string(server, server)
151
+	),
152
+
153
+	TP_fast_assign(
154
+		__entry->client_id = clnt->cl_clid;
155
+		__assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
156
+		__assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
157
+		__assign_str(program, program)
158
+		__assign_str(server, server)
159
+	),
160
+
161
+	TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
162
+		__entry->client_id, __get_str(addr), __get_str(port),
163
+		__get_str(program), __get_str(server))
50164 );
51165 
52
-TRACE_EVENT(rpc_connect_status,
166
+TRACE_EVENT(rpc_clnt_new_err,
167
+	TP_PROTO(
168
+		const char *program,
169
+		const char *server,
170
+		int error
171
+	),
172
+
173
+	TP_ARGS(program, server, error),
174
+
175
+	TP_STRUCT__entry(
176
+		__field(int, error)
177
+		__string(program, program)
178
+		__string(server, server)
179
+	),
180
+
181
+	TP_fast_assign(
182
+		__entry->error = error;
183
+		__assign_str(program, program)
184
+		__assign_str(server, server)
185
+	),
186
+
187
+	TP_printk("program=%s server=%s error=%d",
188
+		__get_str(program), __get_str(server), __entry->error)
189
+);
190
+
191
+TRACE_EVENT(rpc_clnt_clone_err,
192
+	TP_PROTO(
193
+		const struct rpc_clnt *clnt,
194
+		int error
195
+	),
196
+
197
+	TP_ARGS(clnt, error),
198
+
199
+	TP_STRUCT__entry(
200
+		__field(unsigned int, client_id)
201
+		__field(int, error)
202
+	),
203
+
204
+	TP_fast_assign(
205
+		__entry->client_id = clnt->cl_clid;
206
+		__entry->error = error;
207
+	),
208
+
209
+	TP_printk("client=%u error=%d", __entry->client_id, __entry->error)
210
+);
211
+
212
+
213
+TRACE_DEFINE_ENUM(RPC_AUTH_OK);
214
+TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
215
+TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
216
+TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
217
+TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
218
+TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
219
+TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
220
+TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
221
+
222
+#define rpc_show_auth_stat(status)					\
223
+	__print_symbolic(status,					\
224
+		{ RPC_AUTH_OK,			"AUTH_OK" },		\
225
+		{ RPC_AUTH_BADCRED,		"BADCRED" },		\
226
+		{ RPC_AUTH_REJECTEDCRED,	"REJECTEDCRED" },	\
227
+		{ RPC_AUTH_BADVERF,		"BADVERF" },		\
228
+		{ RPC_AUTH_REJECTEDVERF,	"REJECTEDVERF" },	\
229
+		{ RPC_AUTH_TOOWEAK,		"TOOWEAK" },		\
230
+		{ RPCSEC_GSS_CREDPROBLEM,	"GSS_CREDPROBLEM" },	\
231
+		{ RPCSEC_GSS_CTXPROBLEM,	"GSS_CTXPROBLEM" })	\
232
+
233
+DECLARE_EVENT_CLASS(rpc_task_status,
234
+
53235 	TP_PROTO(const struct rpc_task *task),
54236 
55237 	TP_ARGS(task),
....@@ -70,6 +252,18 @@
70252 		__entry->task_id, __entry->client_id,
71253 		__entry->status)
72254 );
255
+#define DEFINE_RPC_STATUS_EVENT(name) \
256
+	DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
257
+			TP_PROTO( \
258
+				const struct rpc_task *task \
259
+			), \
260
+			TP_ARGS(task))
261
+
262
+DEFINE_RPC_STATUS_EVENT(call);
263
+DEFINE_RPC_STATUS_EVENT(connect);
264
+DEFINE_RPC_STATUS_EVENT(timeout);
265
+DEFINE_RPC_STATUS_EVENT(retry_refresh);
266
+DEFINE_RPC_STATUS_EVENT(refresh);
73267 
74268 TRACE_EVENT(rpc_request,
75269 	TP_PROTO(const struct rpc_task *task),
....@@ -101,6 +295,56 @@
101295 		)
102296 );
103297 
298
+TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
299
+TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
300
+TRACE_DEFINE_ENUM(RPC_TASK_NULLCREDS);
301
+TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
302
+TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
303
+TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
304
+TRACE_DEFINE_ENUM(RPC_TASK_NO_ROUND_ROBIN);
305
+TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
306
+TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
307
+TRACE_DEFINE_ENUM(RPC_TASK_SENT);
308
+TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
309
+TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
310
+TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
311
+TRACE_DEFINE_ENUM(RPC_TASK_CRED_NOREF);
312
+
313
+#define rpc_show_task_flags(flags)					\
314
+	__print_flags(flags, "|",					\
315
+		{ RPC_TASK_ASYNC, "ASYNC" },				\
316
+		{ RPC_TASK_SWAPPER, "SWAPPER" },			\
317
+		{ RPC_TASK_NULLCREDS, "NULLCREDS" },			\
318
+		{ RPC_CALL_MAJORSEEN, "MAJORSEEN" },			\
319
+		{ RPC_TASK_ROOTCREDS, "ROOTCREDS" },			\
320
+		{ RPC_TASK_DYNAMIC, "DYNAMIC" },			\
321
+		{ RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" },		\
322
+		{ RPC_TASK_SOFT, "SOFT" },				\
323
+		{ RPC_TASK_SOFTCONN, "SOFTCONN" },			\
324
+		{ RPC_TASK_SENT, "SENT" },				\
325
+		{ RPC_TASK_TIMEOUT, "TIMEOUT" },			\
326
+		{ RPC_TASK_NOCONNECT, "NOCONNECT" },			\
327
+		{ RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" },		\
328
+		{ RPC_TASK_CRED_NOREF, "CRED_NOREF" })
329
+
330
+TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
331
+TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
332
+TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
333
+TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
334
+TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
335
+TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
336
+TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
337
+
338
+#define rpc_show_runstate(flags)					\
339
+	__print_flags(flags, "|",					\
340
+		{ (1UL << RPC_TASK_RUNNING), "RUNNING" },		\
341
+		{ (1UL << RPC_TASK_QUEUED), "QUEUED" },			\
342
+		{ (1UL << RPC_TASK_ACTIVE), "ACTIVE" },			\
343
+		{ (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },		\
344
+		{ (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },		\
345
+		{ (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" },	\
346
+		{ (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
347
+
104348 DECLARE_EVENT_CLASS(rpc_task_running,
105349 
106350 	TP_PROTO(const struct rpc_task *task, const void *action),
....@@ -126,38 +370,30 @@
126370 		__entry->flags = task->tk_flags;
127371 		),
128372 
129
-	TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
373
+	TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
130374 		__entry->task_id, __entry->client_id,
131
-		__entry->flags,
132
-		__entry->runstate,
375
+		rpc_show_task_flags(__entry->flags),
376
+		rpc_show_runstate(__entry->runstate),
133377 		__entry->status,
134378 		__entry->action
135379 		)
136380 );
381
+#define DEFINE_RPC_RUNNING_EVENT(name) \
382
+	DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
383
+			TP_PROTO( \
384
+				const struct rpc_task *task, \
385
+				const void *action \
386
+			), \
387
+			TP_ARGS(task, action))
137388 
138
-DEFINE_EVENT(rpc_task_running, rpc_task_begin,
139
-
140
-	TP_PROTO(const struct rpc_task *task, const void *action),
141
-
142
-	TP_ARGS(task, action)
143
-
144
-);
145
-
146
-DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
147
-
148
-	TP_PROTO(const struct rpc_task *task, const void *action),
149
-
150
-	TP_ARGS(task, action)
151
-
152
-);
153
-
154
-DEFINE_EVENT(rpc_task_running, rpc_task_complete,
155
-
156
-	TP_PROTO(const struct rpc_task *task, const void *action),
157
-
158
-	TP_ARGS(task, action)
159
-
160
-);
389
+DEFINE_RPC_RUNNING_EVENT(begin);
390
+DEFINE_RPC_RUNNING_EVENT(run_action);
391
+DEFINE_RPC_RUNNING_EVENT(sync_sleep);
392
+DEFINE_RPC_RUNNING_EVENT(sync_wake);
393
+DEFINE_RPC_RUNNING_EVENT(complete);
394
+DEFINE_RPC_RUNNING_EVENT(timeout);
395
+DEFINE_RPC_RUNNING_EVENT(signalled);
396
+DEFINE_RPC_RUNNING_EVENT(end);
161397 
162398 DECLARE_EVENT_CLASS(rpc_task_queued,
163399 
....@@ -179,37 +415,183 @@
179415 		__entry->client_id = task->tk_client ?
180416 				     task->tk_client->cl_clid : -1;
181417 		__entry->task_id = task->tk_pid;
182
-		__entry->timeout = task->tk_timeout;
418
+		__entry->timeout = rpc_task_timeout(task);
183419 		__entry->runstate = task->tk_runstate;
184420 		__entry->status = task->tk_status;
185421 		__entry->flags = task->tk_flags;
186422 		__assign_str(q_name, rpc_qname(q));
187423 		),
188424 
189
-	TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
425
+	TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
190426 		__entry->task_id, __entry->client_id,
191
-		__entry->flags,
192
-		__entry->runstate,
427
+		rpc_show_task_flags(__entry->flags),
428
+		rpc_show_runstate(__entry->runstate),
193429 		__entry->status,
194430 		__entry->timeout,
195431 		__get_str(q_name)
196432 		)
197433 );
434
+#define DEFINE_RPC_QUEUED_EVENT(name) \
435
+	DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
436
+			TP_PROTO( \
437
+				const struct rpc_task *task, \
438
+				const struct rpc_wait_queue *q \
439
+			), \
440
+			TP_ARGS(task, q))
198441 
199
-DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
442
+DEFINE_RPC_QUEUED_EVENT(sleep);
443
+DEFINE_RPC_QUEUED_EVENT(wakeup);
200444 
201
-	TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
445
+DECLARE_EVENT_CLASS(rpc_failure,
202446 
203
-	TP_ARGS(task, q)
447
+	TP_PROTO(const struct rpc_task *task),
204448 
449
+	TP_ARGS(task),
450
+
451
+	TP_STRUCT__entry(
452
+		__field(unsigned int, task_id)
453
+		__field(unsigned int, client_id)
454
+	),
455
+
456
+	TP_fast_assign(
457
+		__entry->task_id = task->tk_pid;
458
+		__entry->client_id = task->tk_client->cl_clid;
459
+	),
460
+
461
+	TP_printk("task:%u@%u",
462
+		__entry->task_id, __entry->client_id)
205463 );
206464 
207
-DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
465
+#define DEFINE_RPC_FAILURE(name)					\
466
+	DEFINE_EVENT(rpc_failure, rpc_bad_##name,			\
467
+			TP_PROTO(					\
468
+				const struct rpc_task *task		\
469
+			),						\
470
+			TP_ARGS(task))
208471 
209
-	TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
472
+DEFINE_RPC_FAILURE(callhdr);
473
+DEFINE_RPC_FAILURE(verifier);
210474 
211
-	TP_ARGS(task, q)
475
+DECLARE_EVENT_CLASS(rpc_reply_event,
212476 
477
+	TP_PROTO(
478
+		const struct rpc_task *task
479
+	),
480
+
481
+	TP_ARGS(task),
482
+
483
+	TP_STRUCT__entry(
484
+		__field(unsigned int, task_id)
485
+		__field(unsigned int, client_id)
486
+		__field(u32, xid)
487
+		__string(progname, task->tk_client->cl_program->name)
488
+		__field(u32, version)
489
+		__string(procname, rpc_proc_name(task))
490
+		__string(servername, task->tk_xprt->servername)
491
+	),
492
+
493
+	TP_fast_assign(
494
+		__entry->task_id = task->tk_pid;
495
+		__entry->client_id = task->tk_client->cl_clid;
496
+		__entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
497
+		__assign_str(progname, task->tk_client->cl_program->name)
498
+		__entry->version = task->tk_client->cl_vers;
499
+		__assign_str(procname, rpc_proc_name(task))
500
+		__assign_str(servername, task->tk_xprt->servername)
501
+	),
502
+
503
+	TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
504
+		__entry->task_id, __entry->client_id, __get_str(servername),
505
+		__entry->xid, __get_str(progname), __entry->version,
506
+		__get_str(procname))
507
+)
508
+
509
+#define DEFINE_RPC_REPLY_EVENT(name)					\
510
+	DEFINE_EVENT(rpc_reply_event, rpc__##name,			\
511
+			TP_PROTO(					\
512
+				const struct rpc_task *task		\
513
+			),						\
514
+			TP_ARGS(task))
515
+
516
+DEFINE_RPC_REPLY_EVENT(prog_unavail);
517
+DEFINE_RPC_REPLY_EVENT(prog_mismatch);
518
+DEFINE_RPC_REPLY_EVENT(proc_unavail);
519
+DEFINE_RPC_REPLY_EVENT(garbage_args);
520
+DEFINE_RPC_REPLY_EVENT(unparsable);
521
+DEFINE_RPC_REPLY_EVENT(mismatch);
522
+DEFINE_RPC_REPLY_EVENT(stale_creds);
523
+DEFINE_RPC_REPLY_EVENT(bad_creds);
524
+DEFINE_RPC_REPLY_EVENT(auth_tooweak);
525
+
526
+#define DEFINE_RPCB_ERROR_EVENT(name)					\
527
+	DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err,		\
528
+			TP_PROTO(					\
529
+				const struct rpc_task *task		\
530
+			),						\
531
+			TP_ARGS(task))
532
+
533
+DEFINE_RPCB_ERROR_EVENT(prog_unavail);
534
+DEFINE_RPCB_ERROR_EVENT(timeout);
535
+DEFINE_RPCB_ERROR_EVENT(bind_version);
536
+DEFINE_RPCB_ERROR_EVENT(unreachable);
537
+DEFINE_RPCB_ERROR_EVENT(unrecognized);
538
+
539
+TRACE_EVENT(rpc_buf_alloc,
540
+	TP_PROTO(
541
+		const struct rpc_task *task,
542
+		int status
543
+	),
544
+
545
+	TP_ARGS(task, status),
546
+
547
+	TP_STRUCT__entry(
548
+		__field(unsigned int, task_id)
549
+		__field(unsigned int, client_id)
550
+		__field(size_t, callsize)
551
+		__field(size_t, recvsize)
552
+		__field(int, status)
553
+	),
554
+
555
+	TP_fast_assign(
556
+		__entry->task_id = task->tk_pid;
557
+		__entry->client_id = task->tk_client->cl_clid;
558
+		__entry->callsize = task->tk_rqstp->rq_callsize;
559
+		__entry->recvsize = task->tk_rqstp->rq_rcvsize;
560
+		__entry->status = status;
561
+	),
562
+
563
+	TP_printk("task:%u@%u callsize=%zu recvsize=%zu status=%d",
564
+		__entry->task_id, __entry->client_id,
565
+		__entry->callsize, __entry->recvsize, __entry->status
566
+	)
567
+);
568
+
569
+TRACE_EVENT(rpc_call_rpcerror,
570
+	TP_PROTO(
571
+		const struct rpc_task *task,
572
+		int tk_status,
573
+		int rpc_status
574
+	),
575
+
576
+	TP_ARGS(task, tk_status, rpc_status),
577
+
578
+	TP_STRUCT__entry(
579
+		__field(unsigned int, task_id)
580
+		__field(unsigned int, client_id)
581
+		__field(int, tk_status)
582
+		__field(int, rpc_status)
583
+	),
584
+
585
+	TP_fast_assign(
586
+		__entry->client_id = task->tk_client->cl_clid;
587
+		__entry->task_id = task->tk_pid;
588
+		__entry->tk_status = tk_status;
589
+		__entry->rpc_status = rpc_status;
590
+	),
591
+
592
+	TP_printk("task:%u@%u tk_status=%d rpc_status=%d",
593
+		__entry->task_id, __entry->client_id,
594
+		__entry->tk_status, __entry->rpc_status)
213595 );
214596 
215597 TRACE_EVENT(rpc_stats_latency,
....@@ -253,6 +635,132 @@
253635 		__entry->backlog, __entry->rtt, __entry->execute)
254636 );
255637 
638
+TRACE_EVENT(rpc_xdr_overflow,
639
+	TP_PROTO(
640
+		const struct xdr_stream *xdr,
641
+		size_t requested
642
+	),
643
+
644
+	TP_ARGS(xdr, requested),
645
+
646
+	TP_STRUCT__entry(
647
+		__field(unsigned int, task_id)
648
+		__field(unsigned int, client_id)
649
+		__field(int, version)
650
+		__field(size_t, requested)
651
+		__field(const void *, end)
652
+		__field(const void *, p)
653
+		__field(const void *, head_base)
654
+		__field(size_t, head_len)
655
+		__field(const void *, tail_base)
656
+		__field(size_t, tail_len)
657
+		__field(unsigned int, page_len)
658
+		__field(unsigned int, len)
659
+		__string(progname, xdr->rqst ?
660
+			 xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
661
+		__string(procedure, xdr->rqst ?
662
+			 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
663
+	),
664
+
665
+	TP_fast_assign(
666
+		if (xdr->rqst) {
667
+			const struct rpc_task *task = xdr->rqst->rq_task;
668
+
669
+			__entry->task_id = task->tk_pid;
670
+			__entry->client_id = task->tk_client->cl_clid;
671
+			__assign_str(progname,
672
+				     task->tk_client->cl_program->name)
673
+			__entry->version = task->tk_client->cl_vers;
674
+			__assign_str(procedure, task->tk_msg.rpc_proc->p_name)
675
+		} else {
676
+			__entry->task_id = 0;
677
+			__entry->client_id = 0;
678
+			__assign_str(progname, "unknown")
679
+			__entry->version = 0;
680
+			__assign_str(procedure, "unknown")
681
+		}
682
+		__entry->requested = requested;
683
+		__entry->end = xdr->end;
684
+		__entry->p = xdr->p;
685
+		__entry->head_base = xdr->buf->head[0].iov_base,
686
+		__entry->head_len = xdr->buf->head[0].iov_len,
687
+		__entry->page_len = xdr->buf->page_len,
688
+		__entry->tail_base = xdr->buf->tail[0].iov_base,
689
+		__entry->tail_len = xdr->buf->tail[0].iov_len,
690
+		__entry->len = xdr->buf->len;
691
+	),
692
+
693
+	TP_printk(
694
+		"task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
695
+		__entry->task_id, __entry->client_id,
696
+		__get_str(progname), __entry->version, __get_str(procedure),
697
+		__entry->requested, __entry->p, __entry->end,
698
+		__entry->head_base, __entry->head_len,
699
+		__entry->page_len,
700
+		__entry->tail_base, __entry->tail_len,
701
+		__entry->len
702
+	)
703
+);
704
+
705
+TRACE_EVENT(rpc_xdr_alignment,
706
+	TP_PROTO(
707
+		const struct xdr_stream *xdr,
708
+		size_t offset,
709
+		unsigned int copied
710
+	),
711
+
712
+	TP_ARGS(xdr, offset, copied),
713
+
714
+	TP_STRUCT__entry(
715
+		__field(unsigned int, task_id)
716
+		__field(unsigned int, client_id)
717
+		__field(int, version)
718
+		__field(size_t, offset)
719
+		__field(unsigned int, copied)
720
+		__field(const void *, head_base)
721
+		__field(size_t, head_len)
722
+		__field(const void *, tail_base)
723
+		__field(size_t, tail_len)
724
+		__field(unsigned int, page_len)
725
+		__field(unsigned int, len)
726
+		__string(progname,
727
+			 xdr->rqst->rq_task->tk_client->cl_program->name)
728
+		__string(procedure,
729
+			 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
730
+	),
731
+
732
+	TP_fast_assign(
733
+		const struct rpc_task *task = xdr->rqst->rq_task;
734
+
735
+		__entry->task_id = task->tk_pid;
736
+		__entry->client_id = task->tk_client->cl_clid;
737
+		__assign_str(progname,
738
+			     task->tk_client->cl_program->name)
739
+		__entry->version = task->tk_client->cl_vers;
740
+		__assign_str(procedure, task->tk_msg.rpc_proc->p_name)
741
+
742
+		__entry->offset = offset;
743
+		__entry->copied = copied;
744
+		__entry->head_base = xdr->buf->head[0].iov_base,
745
+		__entry->head_len = xdr->buf->head[0].iov_len,
746
+		__entry->page_len = xdr->buf->page_len,
747
+		__entry->tail_base = xdr->buf->tail[0].iov_base,
748
+		__entry->tail_len = xdr->buf->tail[0].iov_len,
749
+		__entry->len = xdr->buf->len;
750
+	),
751
+
752
+	TP_printk(
753
+		"task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
754
+		__entry->task_id, __entry->client_id,
755
+		__get_str(progname), __entry->version, __get_str(procedure),
756
+		__entry->offset, __entry->copied,
757
+		__entry->head_base, __entry->head_len,
758
+		__entry->page_len,
759
+		__entry->tail_base, __entry->tail_len,
760
+		__entry->len
761
+	)
762
+);
763
+
256764 /*
257765  * First define the enums in the below macros to be exported to userspace
258766  * via TRACE_DEFINE_ENUM().
....@@ -265,9 +773,9 @@
265773 #define RPC_SHOW_SOCKET				\
266774 	EM( SS_FREE, "FREE" )			\
267775 	EM( SS_UNCONNECTED, "UNCONNECTED" )	\
268
-	EM( SS_CONNECTING, "CONNECTING," )	\
269
-	EM( SS_CONNECTED, "CONNECTED," )	\
270
-	EMe(SS_DISCONNECTING, "DISCONNECTING" )
776
+	EM( SS_CONNECTING, "CONNECTING" )	\
777
+	EM( SS_CONNECTED, "CONNECTED" )		\
778
+	EMe( SS_DISCONNECTING, "DISCONNECTING" )
271779 
272780 #define rpc_show_socket_state(state) \
273781 	__print_symbolic(state, RPC_SHOW_SOCKET)
....@@ -409,8 +917,103 @@
409917 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
410918 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
411919 
920
+TRACE_EVENT(rpc_socket_nospace,
921
+	TP_PROTO(
922
+		const struct rpc_rqst *rqst,
923
+		const struct sock_xprt *transport
924
+	),
925
+
926
+	TP_ARGS(rqst, transport),
927
+
928
+	TP_STRUCT__entry(
929
+		__field(unsigned int, task_id)
930
+		__field(unsigned int, client_id)
931
+		__field(unsigned int, total)
932
+		__field(unsigned int, remaining)
933
+	),
934
+
935
+	TP_fast_assign(
936
+		__entry->task_id = rqst->rq_task->tk_pid;
937
+		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
938
+		__entry->total = rqst->rq_slen;
939
+		__entry->remaining = rqst->rq_slen - transport->xmit.offset;
940
+	),
941
+
942
+	TP_printk("task:%u@%u total=%u remaining=%u",
943
+		__entry->task_id, __entry->client_id,
944
+		__entry->total, __entry->remaining
945
+	)
946
+);
947
+
948
+TRACE_DEFINE_ENUM(XPRT_LOCKED);
949
+TRACE_DEFINE_ENUM(XPRT_CONNECTED);
950
+TRACE_DEFINE_ENUM(XPRT_CONNECTING);
951
+TRACE_DEFINE_ENUM(XPRT_CLOSE_WAIT);
952
+TRACE_DEFINE_ENUM(XPRT_BOUND);
953
+TRACE_DEFINE_ENUM(XPRT_BINDING);
954
+TRACE_DEFINE_ENUM(XPRT_CLOSING);
955
+TRACE_DEFINE_ENUM(XPRT_CONGESTED);
956
+TRACE_DEFINE_ENUM(XPRT_CWND_WAIT);
957
+TRACE_DEFINE_ENUM(XPRT_WRITE_SPACE);
958
+
959
+#define rpc_show_xprt_state(x)						\
960
+	__print_flags(x, "|",						\
961
+		{ (1UL << XPRT_LOCKED),		"LOCKED"},		\
962
+		{ (1UL << XPRT_CONNECTED),	"CONNECTED"},		\
963
+		{ (1UL << XPRT_CONNECTING),	"CONNECTING"},		\
964
+		{ (1UL << XPRT_CLOSE_WAIT),	"CLOSE_WAIT"},		\
965
+		{ (1UL << XPRT_BOUND),		"BOUND"},		\
966
+		{ (1UL << XPRT_BINDING),	"BINDING"},		\
967
+		{ (1UL << XPRT_CLOSING),	"CLOSING"},		\
968
+		{ (1UL << XPRT_CONGESTED),	"CONGESTED"},		\
969
+		{ (1UL << XPRT_CWND_WAIT),	"CWND_WAIT"},		\
970
+		{ (1UL << XPRT_WRITE_SPACE),	"WRITE_SPACE"})
971
+
972
+DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
973
+	TP_PROTO(
974
+		const struct rpc_xprt *xprt
975
+	),
976
+
977
+	TP_ARGS(xprt),
978
+
979
+	TP_STRUCT__entry(
980
+		__field(unsigned long, state)
981
+		__string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
982
+		__string(port, xprt->address_strings[RPC_DISPLAY_PORT])
983
+	),
984
+
985
+	TP_fast_assign(
986
+		__entry->state = xprt->state;
987
+		__assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
988
+		__assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
989
+	),
990
+
991
+	TP_printk("peer=[%s]:%s state=%s",
992
+		__get_str(addr), __get_str(port),
993
+		rpc_show_xprt_state(__entry->state))
994
+);
995
+
996
+#define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
997
+	DEFINE_EVENT(rpc_xprt_lifetime_class, \
998
+			xprt_##name, \
999
+			TP_PROTO( \
1000
+				const struct rpc_xprt *xprt \
1001
+			), \
1002
+			TP_ARGS(xprt))
1003
+
1004
+DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
1005
+DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
1006
+DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
1007
+DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
1008
+DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
1009
+DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
1010
+
4121011 DECLARE_EVENT_CLASS(rpc_xprt_event,
413
-	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
1012
+	TP_PROTO(
1013
+		const struct rpc_xprt *xprt,
1014
+		__be32 xid,
1015
+		int status
1016
+	),
4141017 
4151018 	TP_ARGS(xprt, xid, status),
4161019 
....@@ -432,22 +1035,48 @@
4321035 			__get_str(port), __entry->xid,
4331036 			__entry->status)
4341037 );
1038
+#define DEFINE_RPC_XPRT_EVENT(name) \
1039
+	DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
1040
+			TP_PROTO( \
1041
+				const struct rpc_xprt *xprt, \
1042
+				__be32 xid, \
1043
+				int status \
1044
+			), \
1045
+			TP_ARGS(xprt, xid, status))
4351046 
436
-DEFINE_EVENT(rpc_xprt_event, xprt_timer,
437
-	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
438
-	TP_ARGS(xprt, xid, status));
1047
+DEFINE_RPC_XPRT_EVENT(timer);
1048
+DEFINE_RPC_XPRT_EVENT(lookup_rqst);
4391049 
440
-DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
441
-	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
442
-	TP_ARGS(xprt, xid, status));
1050
+TRACE_EVENT(xprt_transmit,
1051
+	TP_PROTO(
1052
+		const struct rpc_rqst *rqst,
1053
+		int status
1054
+	),
4431055 
444
-DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
445
-	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
446
-	TP_ARGS(xprt, xid, status));
1056
+	TP_ARGS(rqst, status),
4471057 
448
-DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
449
-	TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
450
-	TP_ARGS(xprt, xid, status));
1058
+	TP_STRUCT__entry(
1059
+		__field(unsigned int, task_id)
1060
+		__field(unsigned int, client_id)
1061
+		__field(u32, xid)
1062
+		__field(u32, seqno)
1063
+		__field(int, status)
1064
+	),
1065
+
1066
+	TP_fast_assign(
1067
+		__entry->task_id = rqst->rq_task->tk_pid;
1068
+		__entry->client_id = rqst->rq_task->tk_client ?
1069
+			rqst->rq_task->tk_client->cl_clid : -1;
1070
+		__entry->xid = be32_to_cpu(rqst->rq_xid);
1071
+		__entry->seqno = rqst->rq_seqno;
1072
+		__entry->status = status;
1073
+	),
1074
+
1075
+	TP_printk(
1076
+		"task:%u@%u xid=0x%08x seqno=%u status=%d",
1077
+		__entry->task_id, __entry->client_id, __entry->xid,
1078
+		__entry->seqno, __entry->status)
1079
+);
4511080 
4521081 TRACE_EVENT(xprt_ping,
4531082 	TP_PROTO(const struct rpc_xprt *xprt, int status),
....@@ -470,14 +1099,131 @@
4701099 			__get_str(addr), __get_str(port), __entry->status)
4711100 );
4721101 
473
-TRACE_EVENT(xs_tcp_data_ready,
474
-	TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),
1102
+DECLARE_EVENT_CLASS(xprt_writelock_event,
1103
+	TP_PROTO(
1104
+		const struct rpc_xprt *xprt, const struct rpc_task *task
1105
+	),
1106
+
1107
+	TP_ARGS(xprt, task),
1108
+
1109
+	TP_STRUCT__entry(
1110
+		__field(unsigned int, task_id)
1111
+		__field(unsigned int, client_id)
1112
+		__field(unsigned int, snd_task_id)
1113
+	),
1114
+
1115
+	TP_fast_assign(
1116
+		if (task) {
1117
+			__entry->task_id = task->tk_pid;
1118
+			__entry->client_id = task->tk_client ?
1119
+					     task->tk_client->cl_clid : -1;
1120
+		} else {
1121
+			__entry->task_id = -1;
1122
+			__entry->client_id = -1;
1123
+		}
1124
+		__entry->snd_task_id = xprt->snd_task ?
1125
+					xprt->snd_task->tk_pid : -1;
1126
+	),
1127
+
1128
+	TP_printk("task:%u@%u snd_task:%u",
1129
+			__entry->task_id, __entry->client_id,
1130
+			__entry->snd_task_id)
1131
+);
1132
+
1133
+#define DEFINE_WRITELOCK_EVENT(name) \
1134
+	DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1135
+			TP_PROTO( \
1136
+				const struct rpc_xprt *xprt, \
1137
+				const struct rpc_task *task \
1138
+			), \
1139
+			TP_ARGS(xprt, task))
1140
+
1141
+DEFINE_WRITELOCK_EVENT(reserve_xprt);
1142
+DEFINE_WRITELOCK_EVENT(release_xprt);
1143
+
1144
+DECLARE_EVENT_CLASS(xprt_cong_event,
1145
+	TP_PROTO(
1146
+		const struct rpc_xprt *xprt, const struct rpc_task *task
1147
+	),
1148
+
1149
+	TP_ARGS(xprt, task),
1150
+
1151
+	TP_STRUCT__entry(
1152
+		__field(unsigned int, task_id)
1153
+		__field(unsigned int, client_id)
1154
+		__field(unsigned int, snd_task_id)
1155
+		__field(unsigned long, cong)
1156
+		__field(unsigned long, cwnd)
1157
+		__field(bool, wait)
1158
+	),
1159
+
1160
+	TP_fast_assign(
1161
+		if (task) {
1162
+			__entry->task_id = task->tk_pid;
1163
+			__entry->client_id = task->tk_client ?
1164
+					     task->tk_client->cl_clid : -1;
1165
+		} else {
1166
+			__entry->task_id = -1;
1167
+			__entry->client_id = -1;
1168
+		}
1169
+		__entry->snd_task_id = xprt->snd_task ?
1170
+					xprt->snd_task->tk_pid : -1;
1171
+		__entry->cong = xprt->cong;
1172
+		__entry->cwnd = xprt->cwnd;
1173
+		__entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1174
+	),
1175
+
1176
+	TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
1177
+			__entry->task_id, __entry->client_id,
1178
+			__entry->snd_task_id, __entry->cong, __entry->cwnd,
1179
+			__entry->wait ? " (wait)" : "")
1180
+);
1181
+
1182
+#define DEFINE_CONG_EVENT(name) \
1183
+	DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1184
+			TP_PROTO( \
1185
+				const struct rpc_xprt *xprt, \
1186
+				const struct rpc_task *task \
1187
+			), \
1188
+			TP_ARGS(xprt, task))
1189
+
1190
+DEFINE_CONG_EVENT(reserve_cong);
1191
+DEFINE_CONG_EVENT(release_cong);
1192
+DEFINE_CONG_EVENT(get_cong);
1193
+DEFINE_CONG_EVENT(put_cong);
1194
+
1195
+TRACE_EVENT(xprt_reserve,
1196
+	TP_PROTO(
1197
+		const struct rpc_rqst *rqst
1198
+	),
1199
+
1200
+	TP_ARGS(rqst),
1201
+
1202
+	TP_STRUCT__entry(
1203
+		__field(unsigned int, task_id)
1204
+		__field(unsigned int, client_id)
1205
+		__field(u32, xid)
1206
+	),
1207
+
1208
+	TP_fast_assign(
1209
+		__entry->task_id = rqst->rq_task->tk_pid;
1210
+		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1211
+		__entry->xid = be32_to_cpu(rqst->rq_xid);
1212
+	),
1213
+
1214
+	TP_printk("task:%u@%u xid=0x%08x",
1215
+		__entry->task_id, __entry->client_id, __entry->xid
1216
+	)
1217
+);
1218
+
1219
+TRACE_EVENT(xs_stream_read_data,
1220
+	TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
4751221 
4761222 	TP_ARGS(xprt, err, total),
4771223 
4781224 	TP_STRUCT__entry(
479
-		__field(int, err)
480
-		__field(unsigned int, total)
1225
+		__field(ssize_t, err)
1226
+		__field(size_t, total)
4811227 		__string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
4821228 				"(null)")
4831229 		__string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
....@@ -493,21 +1239,11 @@
4931239 			xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
4941240 	),
4951241 
496
-	TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
1242
+	TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
4971243 			__get_str(port), __entry->err, __entry->total)
4981244 );
4991245 
500
-#define rpc_show_sock_xprt_flags(flags) \
501
-	__print_flags(flags, "|", \
502
-		{ TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
503
-		{ TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
504
-		{ TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
505
-		{ TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
506
-		{ TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
507
-		{ TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
508
-		{ TCP_RPC_REPLY, "TCP_RPC_REPLY" })
509
-
510
-TRACE_EVENT(xs_tcp_data_recv,
1246
+TRACE_EVENT(xs_stream_read_request,
5111247 	TP_PROTO(struct sock_xprt *xs),
5121248 
5131249 	TP_ARGS(xs),
....@@ -516,37 +1252,251 @@
5161252 		__string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
5171253 		__string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
5181254 		__field(u32, xid)
519
-		__field(unsigned long, flags)
5201255 		__field(unsigned long, copied)
5211256 		__field(unsigned int, reclen)
522
-		__field(unsigned long, offset)
1257
+		__field(unsigned int, offset)
5231258 	),
5241259 
5251260 	TP_fast_assign(
5261261 		__assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
5271262 		__assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
528
-		__entry->xid = be32_to_cpu(xs->tcp_xid);
529
-		__entry->flags = xs->tcp_flags;
530
-		__entry->copied = xs->tcp_copied;
531
-		__entry->reclen = xs->tcp_reclen;
532
-		__entry->offset = xs->tcp_offset;
1263
+		__entry->xid = be32_to_cpu(xs->recv.xid);
1264
+		__entry->copied = xs->recv.copied;
1265
+		__entry->reclen = xs->recv.len;
1266
+		__entry->offset = xs->recv.offset;
5331267 	),
5341268 
535
-	TP_printk("peer=[%s]:%s xid=0x%08x flags=%s copied=%lu reclen=%u offset=%lu",
1269
+	TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
5361270 			__get_str(addr), __get_str(port), __entry->xid,
537
-			rpc_show_sock_xprt_flags(__entry->flags),
5381271 			__entry->copied, __entry->reclen, __entry->offset)
5391272 );
5401273 
1274
+TRACE_EVENT(rpcb_getport,
1275
+	TP_PROTO(
1276
+		const struct rpc_clnt *clnt,
1277
+		const struct rpc_task *task,
1278
+		unsigned int bind_version
1279
+	),
1280
+
1281
+	TP_ARGS(clnt, task, bind_version),
1282
+
1283
+	TP_STRUCT__entry(
1284
+		__field(unsigned int, task_id)
1285
+		__field(unsigned int, client_id)
1286
+		__field(unsigned int, program)
1287
+		__field(unsigned int, version)
1288
+		__field(int, protocol)
1289
+		__field(unsigned int, bind_version)
1290
+		__string(servername, task->tk_xprt->servername)
1291
+	),
1292
+
1293
+	TP_fast_assign(
1294
+		__entry->task_id = task->tk_pid;
1295
+		__entry->client_id = clnt->cl_clid;
1296
+		__entry->program = clnt->cl_prog;
1297
+		__entry->version = clnt->cl_vers;
1298
+		__entry->protocol = task->tk_xprt->prot;
1299
+		__entry->bind_version = bind_version;
1300
+		__assign_str(servername, task->tk_xprt->servername);
1301
+	),
1302
+
1303
+	TP_printk("task:%u@%u server=%s program=%u version=%u protocol=%d bind_version=%u",
1304
+		__entry->task_id, __entry->client_id, __get_str(servername),
1305
+		__entry->program, __entry->version, __entry->protocol,
1306
+		__entry->bind_version
1307
+	)
1308
+);
1309
+
1310
+TRACE_EVENT(rpcb_setport,
1311
+	TP_PROTO(
1312
+		const struct rpc_task *task,
1313
+		int status,
1314
+		unsigned short port
1315
+	),
1316
+
1317
+	TP_ARGS(task, status, port),
1318
+
1319
+	TP_STRUCT__entry(
1320
+		__field(unsigned int, task_id)
1321
+		__field(unsigned int, client_id)
1322
+		__field(int, status)
1323
+		__field(unsigned short, port)
1324
+	),
1325
+
1326
+	TP_fast_assign(
1327
+		__entry->task_id = task->tk_pid;
1328
+		__entry->client_id = task->tk_client->cl_clid;
1329
+		__entry->status = status;
1330
+		__entry->port = port;
1331
+	),
1332
+
1333
+	TP_printk("task:%u@%u status=%d port=%u",
1334
+		__entry->task_id, __entry->client_id,
1335
+		__entry->status, __entry->port
1336
+	)
1337
+);
1338
+
1339
+TRACE_EVENT(pmap_register,
1340
+	TP_PROTO(
1341
+		u32 program,
1342
+		u32 version,
1343
+		int protocol,
1344
+		unsigned short port
1345
+	),
1346
+
1347
+	TP_ARGS(program, version, protocol, port),
1348
+
1349
+	TP_STRUCT__entry(
1350
+		__field(unsigned int, program)
1351
+		__field(unsigned int, version)
1352
+		__field(int, protocol)
1353
+		__field(unsigned int, port)
1354
+	),
1355
+
1356
+	TP_fast_assign(
1357
+		__entry->program = program;
1358
+		__entry->version = version;
1359
+		__entry->protocol = protocol;
1360
+		__entry->port = port;
1361
+	),
1362
+
1363
+	TP_printk("program=%u version=%u protocol=%d port=%u",
1364
+		__entry->program, __entry->version,
1365
+		__entry->protocol, __entry->port
1366
+	)
1367
+);
1368
+
1369
+TRACE_EVENT(rpcb_register,
1370
+	TP_PROTO(
1371
+		u32 program,
1372
+		u32 version,
1373
+		const char *addr,
1374
+		const char *netid
1375
+	),
1376
+
1377
+	TP_ARGS(program, version, addr, netid),
1378
+
1379
+	TP_STRUCT__entry(
1380
+		__field(unsigned int, program)
1381
+		__field(unsigned int, version)
1382
+		__string(addr, addr)
1383
+		__string(netid, netid)
1384
+	),
1385
+
1386
+	TP_fast_assign(
1387
+		__entry->program = program;
1388
+		__entry->version = version;
1389
+		__assign_str(addr, addr);
1390
+		__assign_str(netid, netid);
1391
+	),
1392
+
1393
+	TP_printk("program=%u version=%u addr=%s netid=%s",
1394
+		__entry->program, __entry->version,
1395
+		__get_str(addr), __get_str(netid)
1396
+	)
1397
+);
1398
+
1399
+TRACE_EVENT(rpcb_unregister,
1400
+	TP_PROTO(
1401
+		u32 program,
1402
+		u32 version,
1403
+		const char *netid
1404
+	),
1405
+
1406
+	TP_ARGS(program, version, netid),
1407
+
1408
+	TP_STRUCT__entry(
1409
+		__field(unsigned int, program)
1410
+		__field(unsigned int, version)
1411
+		__string(netid, netid)
1412
+	),
1413
+
1414
+	TP_fast_assign(
1415
+		__entry->program = program;
1416
+		__entry->version = version;
1417
+		__assign_str(netid, netid);
1418
+	),
1419
+
1420
+	TP_printk("program=%u version=%u netid=%s",
1421
+		__entry->program, __entry->version, __get_str(netid)
1422
+	)
1423
+);
1424
+
1425
+DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1426
+	TP_PROTO(
1427
+		const struct svc_rqst *rqst,
1428
+		const struct xdr_buf *xdr
1429
+	),
1430
+
1431
+	TP_ARGS(rqst, xdr),
1432
+
1433
+	TP_STRUCT__entry(
1434
+		__field(u32, xid)
1435
+		__field(const void *, head_base)
1436
+		__field(size_t, head_len)
1437
+		__field(const void *, tail_base)
1438
+		__field(size_t, tail_len)
1439
+		__field(unsigned int, page_len)
1440
+		__field(unsigned int, msg_len)
1441
+	),
1442
+
1443
+	TP_fast_assign(
1444
+		__entry->xid = be32_to_cpu(rqst->rq_xid);
1445
+		__entry->head_base = xdr->head[0].iov_base;
1446
+		__entry->head_len = xdr->head[0].iov_len;
1447
+		__entry->tail_base = xdr->tail[0].iov_base;
1448
+		__entry->tail_len = xdr->tail[0].iov_len;
1449
+		__entry->page_len = xdr->page_len;
1450
+		__entry->msg_len = xdr->len;
1451
+	),
1452
+
1453
+	TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1454
+		__entry->xid,
1455
+		__entry->head_base, __entry->head_len, __entry->page_len,
1456
+		__entry->tail_base, __entry->tail_len, __entry->msg_len
1457
+	)
1458
+);
1459
+
1460
+#define DEFINE_SVCXDRBUF_EVENT(name)					\
1461
+		DEFINE_EVENT(svc_xdr_buf_class,				\
1462
+				svc_xdr_##name,				\
1463
+				TP_PROTO(				\
1464
+					const struct svc_rqst *rqst,	\
1465
+					const struct xdr_buf *xdr	\
1466
+				),					\
1467
+				TP_ARGS(rqst, xdr))
1468
+
1469
+DEFINE_SVCXDRBUF_EVENT(recvfrom);
1470
+DEFINE_SVCXDRBUF_EVENT(sendto);
1471
+
1472
+/*
1473
+ * from include/linux/sunrpc/svc.h
1474
+ */
1475
+#define SVC_RQST_FLAG_LIST						\
1476
+	svc_rqst_flag(SECURE)						\
1477
+	svc_rqst_flag(LOCAL)						\
1478
+	svc_rqst_flag(USEDEFERRAL)					\
1479
+	svc_rqst_flag(DROPME)						\
1480
+	svc_rqst_flag(SPLICE_OK)					\
1481
+	svc_rqst_flag(VICTIM)						\
1482
+	svc_rqst_flag(BUSY)						\
1483
+	svc_rqst_flag(DATA)						\
1484
+	svc_rqst_flag_end(AUTHERR)
1485
+
1486
+#undef svc_rqst_flag
1487
+#undef svc_rqst_flag_end
1488
+#define svc_rqst_flag(x)	TRACE_DEFINE_ENUM(RQ_##x);
1489
+#define svc_rqst_flag_end(x)	TRACE_DEFINE_ENUM(RQ_##x);
1490
+
1491
+SVC_RQST_FLAG_LIST
1492
+
1493
+#undef svc_rqst_flag
1494
+#undef svc_rqst_flag_end
1495
+#define svc_rqst_flag(x)	{ BIT(RQ_##x), #x },
1496
+#define svc_rqst_flag_end(x)	{ BIT(RQ_##x), #x }
1497
+
5411498 #define show_rqstp_flags(flags)						\
542
-	__print_flags(flags, "|",					\
543
-		{ (1UL << RQ_SECURE),		"RQ_SECURE"},		\
544
-		{ (1UL << RQ_LOCAL),		"RQ_LOCAL"},		\
545
-		{ (1UL << RQ_USEDEFERRAL),	"RQ_USEDEFERRAL"},	\
546
-		{ (1UL << RQ_DROPME),		"RQ_DROPME"},		\
547
-		{ (1UL << RQ_SPLICE_OK),	"RQ_SPLICE_OK"},	\
548
-		{ (1UL << RQ_VICTIM),		"RQ_VICTIM"},		\
549
-		{ (1UL << RQ_BUSY),		"RQ_BUSY"})
1499
+		__print_flags(flags, "|", SVC_RQST_FLAG_LIST)
5501500 
5511501 TRACE_EVENT(svc_recv,
5521502 	TP_PROTO(struct svc_rqst *rqst, int len),
....@@ -570,6 +1520,52 @@
5701520 	TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
5711521 			__get_str(addr), __entry->xid, __entry->len,
5721522 			show_rqstp_flags(__entry->flags))
1523
+);
1524
+
1525
+TRACE_DEFINE_ENUM(SVC_GARBAGE);
1526
+TRACE_DEFINE_ENUM(SVC_SYSERR);
1527
+TRACE_DEFINE_ENUM(SVC_VALID);
1528
+TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1529
+TRACE_DEFINE_ENUM(SVC_OK);
1530
+TRACE_DEFINE_ENUM(SVC_DROP);
1531
+TRACE_DEFINE_ENUM(SVC_CLOSE);
1532
+TRACE_DEFINE_ENUM(SVC_DENIED);
1533
+TRACE_DEFINE_ENUM(SVC_PENDING);
1534
+TRACE_DEFINE_ENUM(SVC_COMPLETE);
1535
+
1536
+#define svc_show_status(status)				\
1537
+	__print_symbolic(status,			\
1538
+		{ SVC_GARBAGE,	"SVC_GARBAGE" },	\
1539
+		{ SVC_SYSERR,	"SVC_SYSERR" },		\
1540
+		{ SVC_VALID,	"SVC_VALID" },		\
1541
+		{ SVC_NEGATIVE,	"SVC_NEGATIVE" },	\
1542
+		{ SVC_OK,	"SVC_OK" },		\
1543
+		{ SVC_DROP,	"SVC_DROP" },		\
1544
+		{ SVC_CLOSE,	"SVC_CLOSE" },		\
1545
+		{ SVC_DENIED,	"SVC_DENIED" },		\
1546
+		{ SVC_PENDING,	"SVC_PENDING" },	\
1547
+		{ SVC_COMPLETE,	"SVC_COMPLETE" })
1548
+
1549
+TRACE_EVENT(svc_authenticate,
1550
+	TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat),
1551
+
1552
+	TP_ARGS(rqst, auth_res, auth_stat),
1553
+
1554
+	TP_STRUCT__entry(
1555
+		__field(u32, xid)
1556
+		__field(unsigned long, svc_status)
1557
+		__field(unsigned long, auth_stat)
1558
+	),
1559
+
1560
+	TP_fast_assign(
1561
+		__entry->xid = be32_to_cpu(rqst->rq_xid);
1562
+		__entry->svc_status = auth_res;
1563
+		__entry->auth_stat = be32_to_cpu(auth_stat);
1564
+	),
1565
+
1566
+	TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1567
+			__entry->xid, svc_show_status(__entry->svc_status),
1568
+			rpc_show_auth_stat(__entry->auth_stat))
5731569 );
5741570 
5751571 TRACE_EVENT(svc_process,
....@@ -602,7 +1598,9 @@
6021598 
6031599 DECLARE_EVENT_CLASS(svc_rqst_event,
6041600 
605
-	TP_PROTO(struct svc_rqst *rqst),
1601
+	TP_PROTO(
1602
+		const struct svc_rqst *rqst
1603
+	),
6061604 
6071605 	TP_ARGS(rqst),
6081606 
....@@ -622,14 +1620,15 @@
6221620 			__get_str(addr), __entry->xid,
6231621 			show_rqstp_flags(__entry->flags))
6241622 );
1623
+#define DEFINE_SVC_RQST_EVENT(name) \
1624
+	DEFINE_EVENT(svc_rqst_event, svc_##name, \
1625
+			TP_PROTO( \
1626
+				const struct svc_rqst *rqst \
1627
+			), \
1628
+			TP_ARGS(rqst))
6251629 
626
-DEFINE_EVENT(svc_rqst_event, svc_defer,
627
-	TP_PROTO(struct svc_rqst *rqst),
628
-	TP_ARGS(rqst));
629
-
630
-DEFINE_EVENT(svc_rqst_event, svc_drop,
631
-	TP_PROTO(struct svc_rqst *rqst),
632
-	TP_ARGS(rqst));
1630
+DEFINE_SVC_RQST_EVENT(defer);
1631
+DEFINE_SVC_RQST_EVENT(drop);
6331632 
6341633 DECLARE_EVENT_CLASS(svc_rqst_status,
6351634 
....@@ -677,28 +1676,54 @@
6771676 		{ (1UL << XPT_KILL_TEMP),	"XPT_KILL_TEMP"},	\
6781677 		{ (1UL << XPT_CONG_CTRL),	"XPT_CONG_CTRL"})
6791678 
1679
+TRACE_EVENT(svc_xprt_create_err,
1680
+	TP_PROTO(
1681
+		const char *program,
1682
+		const char *protocol,
1683
+		struct sockaddr *sap,
1684
+		const struct svc_xprt *xprt
1685
+	),
1686
+
1687
+	TP_ARGS(program, protocol, sap, xprt),
1688
+
1689
+	TP_STRUCT__entry(
1690
+		__field(long, error)
1691
+		__string(program, program)
1692
+		__string(protocol, protocol)
1693
+		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
1694
+	),
1695
+
1696
+	TP_fast_assign(
1697
+		__entry->error = PTR_ERR(xprt);
1698
+		__assign_str(program, program);
1699
+		__assign_str(protocol, protocol);
1700
+		memcpy(__entry->addr, sap, sizeof(__entry->addr));
1701
+	),
1702
+
1703
+	TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1704
+		__entry->addr, __get_str(program), __get_str(protocol),
1705
+		__entry->error)
1706
+);
1707
+
6801708 TRACE_EVENT(svc_xprt_do_enqueue,
6811709 	TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
6821710 
6831711 	TP_ARGS(xprt, rqst),
6841712 
6851713 	TP_STRUCT__entry(
686
-		__field(struct svc_xprt *, xprt)
6871714 		__field(int, pid)
6881715 		__field(unsigned long, flags)
6891716 		__string(addr, xprt->xpt_remotebuf)
6901717 	),
6911718 
6921719 	TP_fast_assign(
693
-		__entry->xprt = xprt;
6941720 		__entry->pid = rqst? rqst->rq_task->pid : 0;
6951721 		__entry->flags = xprt->xpt_flags;
6961722 		__assign_str(addr, xprt->xpt_remotebuf);
6971723 	),
6981724 
699
-	TP_printk("xprt=%p addr=%s pid=%d flags=%s",
700
-			__entry->xprt, __get_str(addr),
701
-			__entry->pid, show_svc_xprt_flags(__entry->flags))
1725
+	TP_printk("addr=%s pid=%d flags=%s", __get_str(addr),
1726
+		__entry->pid, show_svc_xprt_flags(__entry->flags))
7021727 );
7031728 
7041729 DECLARE_EVENT_CLASS(svc_xprt_event,
....@@ -707,25 +1732,55 @@
7071732 	TP_ARGS(xprt),
7081733 
7091734 	TP_STRUCT__entry(
710
-		__field(struct svc_xprt *, xprt)
7111735 		__field(unsigned long, flags)
7121736 		__string(addr, xprt->xpt_remotebuf)
7131737 	),
7141738 
7151739 	TP_fast_assign(
716
-		__entry->xprt = xprt;
7171740 		__entry->flags = xprt->xpt_flags;
7181741 		__assign_str(addr, xprt->xpt_remotebuf);
7191742 	),
7201743 
721
-	TP_printk("xprt=%p addr=%s flags=%s",
722
-			__entry->xprt, __get_str(addr),
723
-			show_svc_xprt_flags(__entry->flags))
1744
+	TP_printk("addr=%s flags=%s", __get_str(addr),
1745
+		show_svc_xprt_flags(__entry->flags))
7241746 );
7251747 
726
-DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
727
-	TP_PROTO(struct svc_xprt *xprt),
728
-	TP_ARGS(xprt));
1748
+#define DEFINE_SVC_XPRT_EVENT(name) \
1749
+	DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1750
+			TP_PROTO( \
1751
+				struct svc_xprt *xprt \
1752
+			), \
1753
+			TP_ARGS(xprt))
1754
+
1755
+DEFINE_SVC_XPRT_EVENT(no_write_space);
1756
+DEFINE_SVC_XPRT_EVENT(close);
1757
+DEFINE_SVC_XPRT_EVENT(detach);
1758
+DEFINE_SVC_XPRT_EVENT(free);
1759
+
1760
+TRACE_EVENT(svc_xprt_accept,
1761
+	TP_PROTO(
1762
+		const struct svc_xprt *xprt,
1763
+		const char *service
1764
+	),
1765
+
1766
+	TP_ARGS(xprt, service),
1767
+
1768
+	TP_STRUCT__entry(
1769
+		__string(addr, xprt->xpt_remotebuf)
1770
+		__string(protocol, xprt->xpt_class->xcl_name)
1771
+		__string(service, service)
1772
+	),
1773
+
1774
+	TP_fast_assign(
1775
+		__assign_str(addr, xprt->xpt_remotebuf);
1776
+		__assign_str(protocol, xprt->xpt_class->xcl_name)
1777
+		__assign_str(service, service);
1778
+	),
1779
+
1780
+	TP_printk("addr=%s protocol=%s service=%s",
1781
+		__get_str(addr), __get_str(protocol), __get_str(service)
1782
+	)
1783
+);
7291784 
7301785 TRACE_EVENT(svc_xprt_dequeue,
7311786 	TP_PROTO(struct svc_rqst *rqst),
....@@ -733,24 +1788,20 @@
7331788 	TP_ARGS(rqst),
7341789 
7351790 	TP_STRUCT__entry(
736
-		__field(struct svc_xprt *, xprt)
7371791 		__field(unsigned long, flags)
7381792 		__field(unsigned long, wakeup)
7391793 		__string(addr, rqst->rq_xprt->xpt_remotebuf)
7401794 	),
7411795 
7421796 	TP_fast_assign(
743
-		__entry->xprt = rqst->rq_xprt;
7441797 		__entry->flags = rqst->rq_xprt->xpt_flags;
7451798 		__entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
7461799 							rqst->rq_qtime));
7471800 		__assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
7481801 	),
7491802 
750
-	TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
751
-			__entry->xprt, __get_str(addr),
752
-			show_svc_xprt_flags(__entry->flags),
753
-			__entry->wakeup)
1803
+	TP_printk("addr=%s flags=%s wakeup-us=%lu", __get_str(addr),
1804
+		show_svc_xprt_flags(__entry->flags), __entry->wakeup)
7541805 );
7551806 
7561807 TRACE_EVENT(svc_wake_up,
....@@ -775,21 +1826,18 @@
7751826 	TP_ARGS(xprt, len),
7761827 
7771828 	TP_STRUCT__entry(
778
-		__field(struct svc_xprt *, xprt)
7791829 		__field(int, len)
7801830 		__field(unsigned long, flags)
7811831 		__string(addr, xprt->xpt_remotebuf)
7821832 	),
7831833 
7841834 	TP_fast_assign(
785
-		__entry->xprt = xprt;
7861835 		__entry->len = len;
7871836 		__entry->flags = xprt->xpt_flags;
7881837 		__assign_str(addr, xprt->xpt_remotebuf);
7891838 	),
7901839 
791
-	TP_printk("xprt=%p addr=%s len=%d flags=%s",
792
-		__entry->xprt, __get_str(addr),
1840
+	TP_printk("addr=%s len=%d flags=%s", __get_str(addr),
7931841 		__entry->len, show_svc_xprt_flags(__entry->flags))
7941842 );
7951843 
....@@ -816,30 +1864,343 @@
8161864 );
8171865 
8181866 DECLARE_EVENT_CLASS(svc_deferred_event,
819
-	TP_PROTO(struct svc_deferred_req *dr),
1867
+	TP_PROTO(
1868
+		const struct svc_deferred_req *dr
1869
+	),
8201870 
8211871 	TP_ARGS(dr),
8221872 
8231873 	TP_STRUCT__entry(
1874
+		__field(const void *, dr)
8241875 		__field(u32, xid)
825
-		__string(addr, dr->xprt->xpt_remotebuf)
1876
+		__array(__u8, addr, INET6_ADDRSTRLEN + 10)
8261877 	),
8271878 
8281879 	TP_fast_assign(
1880
+		__entry->dr = dr;
8291881 		__entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
8301882 						       (dr->xprt_hlen>>2)));
831
-		__assign_str(addr, dr->xprt->xpt_remotebuf);
1883
+		snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1884
+			 "%pISpc", (struct sockaddr *)&dr->addr);
8321885 	),
8331886 
834
-	TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
1887
+	TP_printk("addr=%s dr=%p xid=0x%08x", __entry->addr, __entry->dr,
1888
+		__entry->xid)
8351889 );
8361890 
837
-DEFINE_EVENT(svc_deferred_event, svc_drop_deferred,
838
-	TP_PROTO(struct svc_deferred_req *dr),
839
-	TP_ARGS(dr));
840
-DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred,
841
-	TP_PROTO(struct svc_deferred_req *dr),
842
-	TP_ARGS(dr));
1891
+#define DEFINE_SVC_DEFERRED_EVENT(name) \
1892
+	DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
1893
+			TP_PROTO( \
1894
+				const struct svc_deferred_req *dr \
1895
+			), \
1896
+			TP_ARGS(dr))
1897
+
1898
+DEFINE_SVC_DEFERRED_EVENT(drop);
1899
+DEFINE_SVC_DEFERRED_EVENT(queue);
1900
+DEFINE_SVC_DEFERRED_EVENT(recv);
1901
+
1902
+TRACE_EVENT(svcsock_new_socket,
1903
+	TP_PROTO(
1904
+		const struct socket *socket
1905
+	),
1906
+
1907
+	TP_ARGS(socket),
1908
+
1909
+	TP_STRUCT__entry(
1910
+		__field(unsigned long, type)
1911
+		__field(unsigned long, family)
1912
+		__field(bool, listener)
1913
+	),
1914
+
1915
+	TP_fast_assign(
1916
+		__entry->type = socket->type;
1917
+		__entry->family = socket->sk->sk_family;
1918
+		__entry->listener = (socket->sk->sk_state == TCP_LISTEN);
1919
+	),
1920
+
1921
+	TP_printk("type=%s family=%s%s",
1922
+		show_socket_type(__entry->type),
1923
+		rpc_show_address_family(__entry->family),
1924
+		__entry->listener ? " (listener)" : ""
1925
+	)
1926
+);
1927
+
1928
+TRACE_EVENT(svcsock_marker,
1929
+	TP_PROTO(
1930
+		const struct svc_xprt *xprt,
1931
+		__be32 marker
1932
+	),
1933
+
1934
+	TP_ARGS(xprt, marker),
1935
+
1936
+	TP_STRUCT__entry(
1937
+		__field(unsigned int, length)
1938
+		__field(bool, last)
1939
+		__string(addr, xprt->xpt_remotebuf)
1940
+	),
1941
+
1942
+	TP_fast_assign(
1943
+		__entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
1944
+		__entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
1945
+		__assign_str(addr, xprt->xpt_remotebuf);
1946
+	),
1947
+
1948
+	TP_printk("addr=%s length=%u%s", __get_str(addr),
1949
+		__entry->length, __entry->last ? " (last)" : "")
1950
+);
1951
+
1952
+DECLARE_EVENT_CLASS(svcsock_class,
1953
+	TP_PROTO(
1954
+		const struct svc_xprt *xprt,
1955
+		ssize_t result
1956
+	),
1957
+
1958
+	TP_ARGS(xprt, result),
1959
+
1960
+	TP_STRUCT__entry(
1961
+		__field(ssize_t, result)
1962
+		__field(unsigned long, flags)
1963
+		__string(addr, xprt->xpt_remotebuf)
1964
+	),
1965
+
1966
+	TP_fast_assign(
1967
+		__entry->result = result;
1968
+		__entry->flags = xprt->xpt_flags;
1969
+		__assign_str(addr, xprt->xpt_remotebuf);
1970
+	),
1971
+
1972
+	TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
1973
+		__entry->result, show_svc_xprt_flags(__entry->flags)
1974
+	)
1975
+);
1976
+
1977
+#define DEFINE_SVCSOCK_EVENT(name) \
1978
+	DEFINE_EVENT(svcsock_class, svcsock_##name, \
1979
+			TP_PROTO( \
1980
+				const struct svc_xprt *xprt, \
1981
+				ssize_t result \
1982
+			), \
1983
+			TP_ARGS(xprt, result))
1984
+
1985
+DEFINE_SVCSOCK_EVENT(udp_send);
1986
+DEFINE_SVCSOCK_EVENT(udp_recv);
1987
+DEFINE_SVCSOCK_EVENT(udp_recv_err);
1988
+DEFINE_SVCSOCK_EVENT(tcp_send);
1989
+DEFINE_SVCSOCK_EVENT(tcp_recv);
1990
+DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
1991
+DEFINE_SVCSOCK_EVENT(tcp_recv_err);
1992
+DEFINE_SVCSOCK_EVENT(data_ready);
1993
+DEFINE_SVCSOCK_EVENT(write_space);
1994
+
1995
+TRACE_EVENT(svcsock_tcp_recv_short,
1996
+	TP_PROTO(
1997
+		const struct svc_xprt *xprt,
1998
+		u32 expected,
1999
+		u32 received
2000
+	),
2001
+
2002
+	TP_ARGS(xprt, expected, received),
2003
+
2004
+	TP_STRUCT__entry(
2005
+		__field(u32, expected)
2006
+		__field(u32, received)
2007
+		__field(unsigned long, flags)
2008
+		__string(addr, xprt->xpt_remotebuf)
2009
+	),
2010
+
2011
+	TP_fast_assign(
2012
+		__entry->expected = expected;
2013
+		__entry->received = received;
2014
+		__entry->flags = xprt->xpt_flags;
2015
+		__assign_str(addr, xprt->xpt_remotebuf);
2016
+	),
2017
+
2018
+	TP_printk("addr=%s flags=%s expected=%u received=%u",
2019
+		__get_str(addr), show_svc_xprt_flags(__entry->flags),
2020
+		__entry->expected, __entry->received
2021
+	)
2022
+);
2023
+
2024
+TRACE_EVENT(svcsock_tcp_state,
2025
+	TP_PROTO(
2026
+		const struct svc_xprt *xprt,
2027
+		const struct socket *socket
2028
+	),
2029
+
2030
+	TP_ARGS(xprt, socket),
2031
+
2032
+	TP_STRUCT__entry(
2033
+		__field(unsigned long, socket_state)
2034
+		__field(unsigned long, sock_state)
2035
+		__field(unsigned long, flags)
2036
+		__string(addr, xprt->xpt_remotebuf)
2037
+	),
2038
+
2039
+	TP_fast_assign(
2040
+		__entry->socket_state = socket->state;
2041
+		__entry->sock_state = socket->sk->sk_state;
2042
+		__entry->flags = xprt->xpt_flags;
2043
+		__assign_str(addr, xprt->xpt_remotebuf);
2044
+	),
2045
+
2046
+	TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2047
+		rpc_show_socket_state(__entry->socket_state),
2048
+		rpc_show_sock_state(__entry->sock_state),
2049
+		show_svc_xprt_flags(__entry->flags)
2050
+	)
2051
+);
2052
+
2053
+DECLARE_EVENT_CLASS(svcsock_accept_class,
2054
+	TP_PROTO(
2055
+		const struct svc_xprt *xprt,
2056
+		const char *service,
2057
+		long status
2058
+	),
2059
+
2060
+	TP_ARGS(xprt, service, status),
2061
+
2062
+	TP_STRUCT__entry(
2063
+		__field(long, status)
2064
+		__string(service, service)
2065
+		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
2066
+	),
2067
+
2068
+	TP_fast_assign(
2069
+		__entry->status = status;
2070
+		__assign_str(service, service);
2071
+		memcpy(__entry->addr, &xprt->xpt_local, sizeof(__entry->addr));
2072
+	),
2073
+
2074
+	TP_printk("listener=%pISpc service=%s status=%ld",
2075
+		__entry->addr, __get_str(service), __entry->status
2076
+	)
2077
+);
2078
+
2079
+#define DEFINE_ACCEPT_EVENT(name) \
2080
+	DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2081
+			TP_PROTO( \
2082
+				const struct svc_xprt *xprt, \
2083
+				const char *service, \
2084
+				long status \
2085
+			), \
2086
+			TP_ARGS(xprt, service, status))
2087
+
2088
+DEFINE_ACCEPT_EVENT(accept);
2089
+DEFINE_ACCEPT_EVENT(getpeername);
2090
+
2091
+DECLARE_EVENT_CLASS(cache_event,
2092
+	TP_PROTO(
2093
+		const struct cache_detail *cd,
2094
+		const struct cache_head *h
2095
+	),
2096
+
2097
+	TP_ARGS(cd, h),
2098
+
2099
+	TP_STRUCT__entry(
2100
+		__field(const struct cache_head *, h)
2101
+		__string(name, cd->name)
2102
+	),
2103
+
2104
+	TP_fast_assign(
2105
+		__entry->h = h;
2106
+		__assign_str(name, cd->name);
2107
+	),
2108
+
2109
+	TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2110
+);
2111
+#define DEFINE_CACHE_EVENT(name) \
2112
+	DEFINE_EVENT(cache_event, name, \
2113
+			TP_PROTO( \
2114
+				const struct cache_detail *cd, \
2115
+				const struct cache_head *h \
2116
+			), \
2117
+			TP_ARGS(cd, h))
2118
+DEFINE_CACHE_EVENT(cache_entry_expired);
2119
+DEFINE_CACHE_EVENT(cache_entry_upcall);
2120
+DEFINE_CACHE_EVENT(cache_entry_update);
2121
+DEFINE_CACHE_EVENT(cache_entry_make_negative);
2122
+DEFINE_CACHE_EVENT(cache_entry_no_listener);
2123
+
2124
+DECLARE_EVENT_CLASS(register_class,
2125
+	TP_PROTO(
2126
+		const char *program,
2127
+		const u32 version,
2128
+		const int family,
2129
+		const unsigned short protocol,
2130
+		const unsigned short port,
2131
+		int error
2132
+	),
2133
+
2134
+	TP_ARGS(program, version, family, protocol, port, error),
2135
+
2136
+	TP_STRUCT__entry(
2137
+		__field(u32, version)
2138
+		__field(unsigned long, family)
2139
+		__field(unsigned short, protocol)
2140
+		__field(unsigned short, port)
2141
+		__field(int, error)
2142
+		__string(program, program)
2143
+	),
2144
+
2145
+	TP_fast_assign(
2146
+		__entry->version = version;
2147
+		__entry->family = family;
2148
+		__entry->protocol = protocol;
2149
+		__entry->port = port;
2150
+		__entry->error = error;
2151
+		__assign_str(program, program);
2152
+	),
2153
+
2154
+	TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2155
+		__get_str(program), __entry->version,
2156
+		__entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2157
+		__entry->port, rpc_show_address_family(__entry->family),
2158
+		__entry->error
2159
+	)
2160
+);
2161
+
2162
+#define DEFINE_REGISTER_EVENT(name) \
2163
+	DEFINE_EVENT(register_class, svc_##name, \
2164
+			TP_PROTO( \
2165
+				const char *program, \
2166
+				const u32 version, \
2167
+				const int family, \
2168
+				const unsigned short protocol, \
2169
+				const unsigned short port, \
2170
+				int error \
2171
+			), \
2172
+			TP_ARGS(program, version, family, protocol, \
2173
+				port, error))
2174
+
2175
+DEFINE_REGISTER_EVENT(register);
2176
+DEFINE_REGISTER_EVENT(noregister);
2177
+
2178
+TRACE_EVENT(svc_unregister,
2179
+	TP_PROTO(
2180
+		const char *program,
2181
+		const u32 version,
2182
+		int error
2183
+	),
2184
+
2185
+	TP_ARGS(program, version, error),
2186
+
2187
+	TP_STRUCT__entry(
2188
+		__field(u32, version)
2189
+		__field(int, error)
2190
+		__string(program, program)
2191
+	),
2192
+
2193
+	TP_fast_assign(
2194
+		__entry->version = version;
2195
+		__entry->error = error;
2196
+		__assign_str(program, program);
2197
+	),
2198
+
2199
+	TP_printk("program=%sv%u error=%d",
2200
+		__get_str(program), __entry->version, __entry->error
2201
+	)
2202
+);
2203
+
8432204 #endif /* _TRACE_SUNRPC_H */
8442205 
8452206 #include <trace/define_trace.h>