sunrpc.h 57 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #undef TRACE_SYSTEM
  3. #define TRACE_SYSTEM sunrpc
  4. #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
  5. #define _TRACE_SUNRPC_H
  6. #include <linux/sunrpc/sched.h>
  7. #include <linux/sunrpc/clnt.h>
  8. #include <linux/sunrpc/svc.h>
  9. #include <linux/sunrpc/xprtsock.h>
  10. #include <linux/sunrpc/svc_xprt.h>
  11. #include <net/tcp_states.h>
  12. #include <linux/net.h>
  13. #include <linux/tracepoint.h>
  14. #include <trace/events/sunrpc_base.h>
  15. TRACE_DEFINE_ENUM(SOCK_STREAM);
  16. TRACE_DEFINE_ENUM(SOCK_DGRAM);
  17. TRACE_DEFINE_ENUM(SOCK_RAW);
  18. TRACE_DEFINE_ENUM(SOCK_RDM);
  19. TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
  20. TRACE_DEFINE_ENUM(SOCK_DCCP);
  21. TRACE_DEFINE_ENUM(SOCK_PACKET);
  22. #define show_socket_type(type) \
  23. __print_symbolic(type, \
  24. { SOCK_STREAM, "STREAM" }, \
  25. { SOCK_DGRAM, "DGRAM" }, \
  26. { SOCK_RAW, "RAW" }, \
  27. { SOCK_RDM, "RDM" }, \
  28. { SOCK_SEQPACKET, "SEQPACKET" }, \
  29. { SOCK_DCCP, "DCCP" }, \
  30. { SOCK_PACKET, "PACKET" })
  31. /* This list is known to be incomplete, add new enums as needed. */
  32. TRACE_DEFINE_ENUM(AF_UNSPEC);
  33. TRACE_DEFINE_ENUM(AF_UNIX);
  34. TRACE_DEFINE_ENUM(AF_LOCAL);
  35. TRACE_DEFINE_ENUM(AF_INET);
  36. TRACE_DEFINE_ENUM(AF_INET6);
  37. #define rpc_show_address_family(family) \
  38. __print_symbolic(family, \
  39. { AF_UNSPEC, "AF_UNSPEC" }, \
  40. { AF_UNIX, "AF_UNIX" }, \
  41. { AF_LOCAL, "AF_LOCAL" }, \
  42. { AF_INET, "AF_INET" }, \
  43. { AF_INET6, "AF_INET6" })
  44. DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
  45. TP_PROTO(
  46. const struct rpc_task *task,
  47. const struct xdr_buf *xdr
  48. ),
  49. TP_ARGS(task, xdr),
  50. TP_STRUCT__entry(
  51. __field(unsigned int, task_id)
  52. __field(unsigned int, client_id)
  53. __field(const void *, head_base)
  54. __field(size_t, head_len)
  55. __field(const void *, tail_base)
  56. __field(size_t, tail_len)
  57. __field(unsigned int, page_base)
  58. __field(unsigned int, page_len)
  59. __field(unsigned int, msg_len)
  60. ),
  61. TP_fast_assign(
  62. __entry->task_id = task->tk_pid;
  63. __entry->client_id = task->tk_client ?
  64. task->tk_client->cl_clid : -1;
  65. __entry->head_base = xdr->head[0].iov_base;
  66. __entry->head_len = xdr->head[0].iov_len;
  67. __entry->tail_base = xdr->tail[0].iov_base;
  68. __entry->tail_len = xdr->tail[0].iov_len;
  69. __entry->page_base = xdr->page_base;
  70. __entry->page_len = xdr->page_len;
  71. __entry->msg_len = xdr->len;
  72. ),
  73. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  74. " head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
  75. __entry->task_id, __entry->client_id,
  76. __entry->head_base, __entry->head_len,
  77. __entry->page_len, __entry->page_base,
  78. __entry->tail_base, __entry->tail_len,
  79. __entry->msg_len
  80. )
  81. );
  82. #define DEFINE_RPCXDRBUF_EVENT(name) \
  83. DEFINE_EVENT(rpc_xdr_buf_class, \
  84. rpc_xdr_##name, \
  85. TP_PROTO( \
  86. const struct rpc_task *task, \
  87. const struct xdr_buf *xdr \
  88. ), \
  89. TP_ARGS(task, xdr))
  90. DEFINE_RPCXDRBUF_EVENT(sendto);
  91. DEFINE_RPCXDRBUF_EVENT(recvfrom);
  92. DEFINE_RPCXDRBUF_EVENT(reply_pages);
  93. DECLARE_EVENT_CLASS(rpc_clnt_class,
  94. TP_PROTO(
  95. const struct rpc_clnt *clnt
  96. ),
  97. TP_ARGS(clnt),
  98. TP_STRUCT__entry(
  99. __field(unsigned int, client_id)
  100. ),
  101. TP_fast_assign(
  102. __entry->client_id = clnt->cl_clid;
  103. ),
  104. TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER, __entry->client_id)
  105. );
  106. #define DEFINE_RPC_CLNT_EVENT(name) \
  107. DEFINE_EVENT(rpc_clnt_class, \
  108. rpc_clnt_##name, \
  109. TP_PROTO( \
  110. const struct rpc_clnt *clnt \
  111. ), \
  112. TP_ARGS(clnt))
  113. DEFINE_RPC_CLNT_EVENT(free);
  114. DEFINE_RPC_CLNT_EVENT(killall);
  115. DEFINE_RPC_CLNT_EVENT(shutdown);
  116. DEFINE_RPC_CLNT_EVENT(release);
  117. DEFINE_RPC_CLNT_EVENT(replace_xprt);
  118. DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
  119. TRACE_EVENT(rpc_clnt_new,
  120. TP_PROTO(
  121. const struct rpc_clnt *clnt,
  122. const struct rpc_xprt *xprt,
  123. const char *program,
  124. const char *server
  125. ),
  126. TP_ARGS(clnt, xprt, program, server),
  127. TP_STRUCT__entry(
  128. __field(unsigned int, client_id)
  129. __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
  130. __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
  131. __string(program, program)
  132. __string(server, server)
  133. ),
  134. TP_fast_assign(
  135. __entry->client_id = clnt->cl_clid;
  136. __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
  137. __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
  138. __assign_str(program, program);
  139. __assign_str(server, server);
  140. ),
  141. TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER
  142. " peer=[%s]:%s program=%s server=%s",
  143. __entry->client_id, __get_str(addr), __get_str(port),
  144. __get_str(program), __get_str(server))
  145. );
  146. TRACE_EVENT(rpc_clnt_new_err,
  147. TP_PROTO(
  148. const char *program,
  149. const char *server,
  150. int error
  151. ),
  152. TP_ARGS(program, server, error),
  153. TP_STRUCT__entry(
  154. __field(int, error)
  155. __string(program, program)
  156. __string(server, server)
  157. ),
  158. TP_fast_assign(
  159. __entry->error = error;
  160. __assign_str(program, program);
  161. __assign_str(server, server);
  162. ),
  163. TP_printk("program=%s server=%s error=%d",
  164. __get_str(program), __get_str(server), __entry->error)
  165. );
  166. TRACE_EVENT(rpc_clnt_clone_err,
  167. TP_PROTO(
  168. const struct rpc_clnt *clnt,
  169. int error
  170. ),
  171. TP_ARGS(clnt, error),
  172. TP_STRUCT__entry(
  173. __field(unsigned int, client_id)
  174. __field(int, error)
  175. ),
  176. TP_fast_assign(
  177. __entry->client_id = clnt->cl_clid;
  178. __entry->error = error;
  179. ),
  180. TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER " error=%d",
  181. __entry->client_id, __entry->error)
  182. );
  183. TRACE_DEFINE_ENUM(RPC_AUTH_OK);
  184. TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
  185. TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
  186. TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
  187. TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
  188. TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
  189. TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
  190. TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
  191. #define rpc_show_auth_stat(status) \
  192. __print_symbolic(status, \
  193. { RPC_AUTH_OK, "AUTH_OK" }, \
  194. { RPC_AUTH_BADCRED, "BADCRED" }, \
  195. { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \
  196. { RPC_AUTH_BADVERF, "BADVERF" }, \
  197. { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \
  198. { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \
  199. { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \
  200. { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \
  201. DECLARE_EVENT_CLASS(rpc_task_status,
  202. TP_PROTO(const struct rpc_task *task),
  203. TP_ARGS(task),
  204. TP_STRUCT__entry(
  205. __field(unsigned int, task_id)
  206. __field(unsigned int, client_id)
  207. __field(int, status)
  208. ),
  209. TP_fast_assign(
  210. __entry->task_id = task->tk_pid;
  211. __entry->client_id = task->tk_client->cl_clid;
  212. __entry->status = task->tk_status;
  213. ),
  214. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",
  215. __entry->task_id, __entry->client_id,
  216. __entry->status)
  217. );
  218. #define DEFINE_RPC_STATUS_EVENT(name) \
  219. DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
  220. TP_PROTO( \
  221. const struct rpc_task *task \
  222. ), \
  223. TP_ARGS(task))
  224. DEFINE_RPC_STATUS_EVENT(call);
  225. DEFINE_RPC_STATUS_EVENT(connect);
  226. DEFINE_RPC_STATUS_EVENT(timeout);
  227. DEFINE_RPC_STATUS_EVENT(retry_refresh);
  228. DEFINE_RPC_STATUS_EVENT(refresh);
  229. TRACE_EVENT(rpc_request,
  230. TP_PROTO(const struct rpc_task *task),
  231. TP_ARGS(task),
  232. TP_STRUCT__entry(
  233. __field(unsigned int, task_id)
  234. __field(unsigned int, client_id)
  235. __field(int, version)
  236. __field(bool, async)
  237. __string(progname, task->tk_client->cl_program->name)
  238. __string(procname, rpc_proc_name(task))
  239. ),
  240. TP_fast_assign(
  241. __entry->task_id = task->tk_pid;
  242. __entry->client_id = task->tk_client->cl_clid;
  243. __entry->version = task->tk_client->cl_vers;
  244. __entry->async = RPC_IS_ASYNC(task);
  245. __assign_str(progname, task->tk_client->cl_program->name);
  246. __assign_str(procname, rpc_proc_name(task));
  247. ),
  248. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " %sv%d %s (%ssync)",
  249. __entry->task_id, __entry->client_id,
  250. __get_str(progname), __entry->version,
  251. __get_str(procname), __entry->async ? "a": ""
  252. )
  253. );
  254. #define rpc_show_task_flags(flags) \
  255. __print_flags(flags, "|", \
  256. { RPC_TASK_ASYNC, "ASYNC" }, \
  257. { RPC_TASK_SWAPPER, "SWAPPER" }, \
  258. { RPC_TASK_MOVEABLE, "MOVEABLE" }, \
  259. { RPC_TASK_NULLCREDS, "NULLCREDS" }, \
  260. { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \
  261. { RPC_TASK_DYNAMIC, "DYNAMIC" }, \
  262. { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \
  263. { RPC_TASK_SOFT, "SOFT" }, \
  264. { RPC_TASK_SOFTCONN, "SOFTCONN" }, \
  265. { RPC_TASK_SENT, "SENT" }, \
  266. { RPC_TASK_TIMEOUT, "TIMEOUT" }, \
  267. { RPC_TASK_NOCONNECT, "NOCONNECT" }, \
  268. { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \
  269. { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
  270. #define rpc_show_runstate(flags) \
  271. __print_flags(flags, "|", \
  272. { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \
  273. { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \
  274. { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \
  275. { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \
  276. { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \
  277. { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \
  278. { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
  279. DECLARE_EVENT_CLASS(rpc_task_running,
  280. TP_PROTO(const struct rpc_task *task, const void *action),
  281. TP_ARGS(task, action),
  282. TP_STRUCT__entry(
  283. __field(unsigned int, task_id)
  284. __field(unsigned int, client_id)
  285. __field(const void *, action)
  286. __field(unsigned long, runstate)
  287. __field(int, status)
  288. __field(unsigned short, flags)
  289. ),
  290. TP_fast_assign(
  291. __entry->client_id = task->tk_client ?
  292. task->tk_client->cl_clid : -1;
  293. __entry->task_id = task->tk_pid;
  294. __entry->action = action;
  295. __entry->runstate = task->tk_runstate;
  296. __entry->status = task->tk_status;
  297. __entry->flags = task->tk_flags;
  298. ),
  299. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  300. " flags=%s runstate=%s status=%d action=%ps",
  301. __entry->task_id, __entry->client_id,
  302. rpc_show_task_flags(__entry->flags),
  303. rpc_show_runstate(__entry->runstate),
  304. __entry->status,
  305. __entry->action
  306. )
  307. );
  308. #define DEFINE_RPC_RUNNING_EVENT(name) \
  309. DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
  310. TP_PROTO( \
  311. const struct rpc_task *task, \
  312. const void *action \
  313. ), \
  314. TP_ARGS(task, action))
  315. DEFINE_RPC_RUNNING_EVENT(begin);
  316. DEFINE_RPC_RUNNING_EVENT(run_action);
  317. DEFINE_RPC_RUNNING_EVENT(sync_sleep);
  318. DEFINE_RPC_RUNNING_EVENT(sync_wake);
  319. DEFINE_RPC_RUNNING_EVENT(complete);
  320. DEFINE_RPC_RUNNING_EVENT(timeout);
  321. DEFINE_RPC_RUNNING_EVENT(signalled);
  322. DEFINE_RPC_RUNNING_EVENT(end);
  323. DEFINE_RPC_RUNNING_EVENT(call_done);
  324. DECLARE_EVENT_CLASS(rpc_task_queued,
  325. TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
  326. TP_ARGS(task, q),
  327. TP_STRUCT__entry(
  328. __field(unsigned int, task_id)
  329. __field(unsigned int, client_id)
  330. __field(unsigned long, timeout)
  331. __field(unsigned long, runstate)
  332. __field(int, status)
  333. __field(unsigned short, flags)
  334. __string(q_name, rpc_qname(q))
  335. ),
  336. TP_fast_assign(
  337. __entry->client_id = task->tk_client ?
  338. task->tk_client->cl_clid : -1;
  339. __entry->task_id = task->tk_pid;
  340. __entry->timeout = rpc_task_timeout(task);
  341. __entry->runstate = task->tk_runstate;
  342. __entry->status = task->tk_status;
  343. __entry->flags = task->tk_flags;
  344. __assign_str(q_name, rpc_qname(q));
  345. ),
  346. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  347. " flags=%s runstate=%s status=%d timeout=%lu queue=%s",
  348. __entry->task_id, __entry->client_id,
  349. rpc_show_task_flags(__entry->flags),
  350. rpc_show_runstate(__entry->runstate),
  351. __entry->status,
  352. __entry->timeout,
  353. __get_str(q_name)
  354. )
  355. );
  356. #define DEFINE_RPC_QUEUED_EVENT(name) \
  357. DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
  358. TP_PROTO( \
  359. const struct rpc_task *task, \
  360. const struct rpc_wait_queue *q \
  361. ), \
  362. TP_ARGS(task, q))
  363. DEFINE_RPC_QUEUED_EVENT(sleep);
  364. DEFINE_RPC_QUEUED_EVENT(wakeup);
  365. DECLARE_EVENT_CLASS(rpc_failure,
  366. TP_PROTO(const struct rpc_task *task),
  367. TP_ARGS(task),
  368. TP_STRUCT__entry(
  369. __field(unsigned int, task_id)
  370. __field(unsigned int, client_id)
  371. ),
  372. TP_fast_assign(
  373. __entry->task_id = task->tk_pid;
  374. __entry->client_id = task->tk_client->cl_clid;
  375. ),
  376. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,
  377. __entry->task_id, __entry->client_id)
  378. );
  379. #define DEFINE_RPC_FAILURE(name) \
  380. DEFINE_EVENT(rpc_failure, rpc_bad_##name, \
  381. TP_PROTO( \
  382. const struct rpc_task *task \
  383. ), \
  384. TP_ARGS(task))
  385. DEFINE_RPC_FAILURE(callhdr);
  386. DEFINE_RPC_FAILURE(verifier);
  387. DECLARE_EVENT_CLASS(rpc_reply_event,
  388. TP_PROTO(
  389. const struct rpc_task *task
  390. ),
  391. TP_ARGS(task),
  392. TP_STRUCT__entry(
  393. __field(unsigned int, task_id)
  394. __field(unsigned int, client_id)
  395. __field(u32, xid)
  396. __string(progname, task->tk_client->cl_program->name)
  397. __field(u32, version)
  398. __string(procname, rpc_proc_name(task))
  399. __string(servername, task->tk_xprt->servername)
  400. ),
  401. TP_fast_assign(
  402. __entry->task_id = task->tk_pid;
  403. __entry->client_id = task->tk_client->cl_clid;
  404. __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
  405. __assign_str(progname, task->tk_client->cl_program->name);
  406. __entry->version = task->tk_client->cl_vers;
  407. __assign_str(procname, rpc_proc_name(task));
  408. __assign_str(servername, task->tk_xprt->servername);
  409. ),
  410. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  411. " server=%s xid=0x%08x %sv%d %s",
  412. __entry->task_id, __entry->client_id, __get_str(servername),
  413. __entry->xid, __get_str(progname), __entry->version,
  414. __get_str(procname))
  415. )
  416. #define DEFINE_RPC_REPLY_EVENT(name) \
  417. DEFINE_EVENT(rpc_reply_event, rpc__##name, \
  418. TP_PROTO( \
  419. const struct rpc_task *task \
  420. ), \
  421. TP_ARGS(task))
  422. DEFINE_RPC_REPLY_EVENT(prog_unavail);
  423. DEFINE_RPC_REPLY_EVENT(prog_mismatch);
  424. DEFINE_RPC_REPLY_EVENT(proc_unavail);
  425. DEFINE_RPC_REPLY_EVENT(garbage_args);
  426. DEFINE_RPC_REPLY_EVENT(unparsable);
  427. DEFINE_RPC_REPLY_EVENT(mismatch);
  428. DEFINE_RPC_REPLY_EVENT(stale_creds);
  429. DEFINE_RPC_REPLY_EVENT(bad_creds);
  430. DEFINE_RPC_REPLY_EVENT(auth_tooweak);
  431. #define DEFINE_RPCB_ERROR_EVENT(name) \
  432. DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err, \
  433. TP_PROTO( \
  434. const struct rpc_task *task \
  435. ), \
  436. TP_ARGS(task))
  437. DEFINE_RPCB_ERROR_EVENT(prog_unavail);
  438. DEFINE_RPCB_ERROR_EVENT(timeout);
  439. DEFINE_RPCB_ERROR_EVENT(bind_version);
  440. DEFINE_RPCB_ERROR_EVENT(unreachable);
  441. DEFINE_RPCB_ERROR_EVENT(unrecognized);
  442. TRACE_EVENT(rpc_buf_alloc,
  443. TP_PROTO(
  444. const struct rpc_task *task,
  445. int status
  446. ),
  447. TP_ARGS(task, status),
  448. TP_STRUCT__entry(
  449. __field(unsigned int, task_id)
  450. __field(unsigned int, client_id)
  451. __field(size_t, callsize)
  452. __field(size_t, recvsize)
  453. __field(int, status)
  454. ),
  455. TP_fast_assign(
  456. __entry->task_id = task->tk_pid;
  457. __entry->client_id = task->tk_client->cl_clid;
  458. __entry->callsize = task->tk_rqstp->rq_callsize;
  459. __entry->recvsize = task->tk_rqstp->rq_rcvsize;
  460. __entry->status = status;
  461. ),
  462. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  463. " callsize=%zu recvsize=%zu status=%d",
  464. __entry->task_id, __entry->client_id,
  465. __entry->callsize, __entry->recvsize, __entry->status
  466. )
  467. );
  468. TRACE_EVENT(rpc_call_rpcerror,
  469. TP_PROTO(
  470. const struct rpc_task *task,
  471. int tk_status,
  472. int rpc_status
  473. ),
  474. TP_ARGS(task, tk_status, rpc_status),
  475. TP_STRUCT__entry(
  476. __field(unsigned int, task_id)
  477. __field(unsigned int, client_id)
  478. __field(int, tk_status)
  479. __field(int, rpc_status)
  480. ),
  481. TP_fast_assign(
  482. __entry->client_id = task->tk_client->cl_clid;
  483. __entry->task_id = task->tk_pid;
  484. __entry->tk_status = tk_status;
  485. __entry->rpc_status = rpc_status;
  486. ),
  487. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  488. " tk_status=%d rpc_status=%d",
  489. __entry->task_id, __entry->client_id,
  490. __entry->tk_status, __entry->rpc_status)
  491. );
  492. TRACE_EVENT(rpc_stats_latency,
  493. TP_PROTO(
  494. const struct rpc_task *task,
  495. ktime_t backlog,
  496. ktime_t rtt,
  497. ktime_t execute
  498. ),
  499. TP_ARGS(task, backlog, rtt, execute),
  500. TP_STRUCT__entry(
  501. __field(unsigned int, task_id)
  502. __field(unsigned int, client_id)
  503. __field(u32, xid)
  504. __field(int, version)
  505. __string(progname, task->tk_client->cl_program->name)
  506. __string(procname, rpc_proc_name(task))
  507. __field(unsigned long, backlog)
  508. __field(unsigned long, rtt)
  509. __field(unsigned long, execute)
  510. ),
  511. TP_fast_assign(
  512. __entry->client_id = task->tk_client->cl_clid;
  513. __entry->task_id = task->tk_pid;
  514. __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
  515. __entry->version = task->tk_client->cl_vers;
  516. __assign_str(progname, task->tk_client->cl_program->name);
  517. __assign_str(procname, rpc_proc_name(task));
  518. __entry->backlog = ktime_to_us(backlog);
  519. __entry->rtt = ktime_to_us(rtt);
  520. __entry->execute = ktime_to_us(execute);
  521. ),
  522. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  523. " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
  524. __entry->task_id, __entry->client_id, __entry->xid,
  525. __get_str(progname), __entry->version, __get_str(procname),
  526. __entry->backlog, __entry->rtt, __entry->execute)
  527. );
  528. TRACE_EVENT(rpc_xdr_overflow,
  529. TP_PROTO(
  530. const struct xdr_stream *xdr,
  531. size_t requested
  532. ),
  533. TP_ARGS(xdr, requested),
  534. TP_STRUCT__entry(
  535. __field(unsigned int, task_id)
  536. __field(unsigned int, client_id)
  537. __field(int, version)
  538. __field(size_t, requested)
  539. __field(const void *, end)
  540. __field(const void *, p)
  541. __field(const void *, head_base)
  542. __field(size_t, head_len)
  543. __field(const void *, tail_base)
  544. __field(size_t, tail_len)
  545. __field(unsigned int, page_len)
  546. __field(unsigned int, len)
  547. __string(progname, xdr->rqst ?
  548. xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
  549. __string(procedure, xdr->rqst ?
  550. xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
  551. ),
  552. TP_fast_assign(
  553. if (xdr->rqst) {
  554. const struct rpc_task *task = xdr->rqst->rq_task;
  555. __entry->task_id = task->tk_pid;
  556. __entry->client_id = task->tk_client->cl_clid;
  557. __assign_str(progname,
  558. task->tk_client->cl_program->name);
  559. __entry->version = task->tk_client->cl_vers;
  560. __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
  561. } else {
  562. __entry->task_id = -1;
  563. __entry->client_id = -1;
  564. __assign_str(progname, "unknown");
  565. __entry->version = 0;
  566. __assign_str(procedure, "unknown");
  567. }
  568. __entry->requested = requested;
  569. __entry->end = xdr->end;
  570. __entry->p = xdr->p;
  571. __entry->head_base = xdr->buf->head[0].iov_base,
  572. __entry->head_len = xdr->buf->head[0].iov_len,
  573. __entry->page_len = xdr->buf->page_len,
  574. __entry->tail_base = xdr->buf->tail[0].iov_base,
  575. __entry->tail_len = xdr->buf->tail[0].iov_len,
  576. __entry->len = xdr->buf->len;
  577. ),
  578. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  579. " %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
  580. __entry->task_id, __entry->client_id,
  581. __get_str(progname), __entry->version, __get_str(procedure),
  582. __entry->requested, __entry->p, __entry->end,
  583. __entry->head_base, __entry->head_len,
  584. __entry->page_len,
  585. __entry->tail_base, __entry->tail_len,
  586. __entry->len
  587. )
  588. );
  589. TRACE_EVENT(rpc_xdr_alignment,
  590. TP_PROTO(
  591. const struct xdr_stream *xdr,
  592. size_t offset,
  593. unsigned int copied
  594. ),
  595. TP_ARGS(xdr, offset, copied),
  596. TP_STRUCT__entry(
  597. __field(unsigned int, task_id)
  598. __field(unsigned int, client_id)
  599. __field(int, version)
  600. __field(size_t, offset)
  601. __field(unsigned int, copied)
  602. __field(const void *, head_base)
  603. __field(size_t, head_len)
  604. __field(const void *, tail_base)
  605. __field(size_t, tail_len)
  606. __field(unsigned int, page_len)
  607. __field(unsigned int, len)
  608. __string(progname,
  609. xdr->rqst->rq_task->tk_client->cl_program->name)
  610. __string(procedure,
  611. xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
  612. ),
  613. TP_fast_assign(
  614. const struct rpc_task *task = xdr->rqst->rq_task;
  615. __entry->task_id = task->tk_pid;
  616. __entry->client_id = task->tk_client->cl_clid;
  617. __assign_str(progname,
  618. task->tk_client->cl_program->name);
  619. __entry->version = task->tk_client->cl_vers;
  620. __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
  621. __entry->offset = offset;
  622. __entry->copied = copied;
  623. __entry->head_base = xdr->buf->head[0].iov_base,
  624. __entry->head_len = xdr->buf->head[0].iov_len,
  625. __entry->page_len = xdr->buf->page_len,
  626. __entry->tail_base = xdr->buf->tail[0].iov_base,
  627. __entry->tail_len = xdr->buf->tail[0].iov_len,
  628. __entry->len = xdr->buf->len;
  629. ),
  630. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  631. " %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
  632. __entry->task_id, __entry->client_id,
  633. __get_str(progname), __entry->version, __get_str(procedure),
  634. __entry->offset, __entry->copied,
  635. __entry->head_base, __entry->head_len,
  636. __entry->page_len,
  637. __entry->tail_base, __entry->tail_len,
  638. __entry->len
  639. )
  640. );
  641. /*
  642. * First define the enums in the below macros to be exported to userspace
  643. * via TRACE_DEFINE_ENUM().
  644. */
  645. #undef EM
  646. #undef EMe
  647. #define EM(a, b) TRACE_DEFINE_ENUM(a);
  648. #define EMe(a, b) TRACE_DEFINE_ENUM(a);
  649. #define RPC_SHOW_SOCKET \
  650. EM( SS_FREE, "FREE" ) \
  651. EM( SS_UNCONNECTED, "UNCONNECTED" ) \
  652. EM( SS_CONNECTING, "CONNECTING" ) \
  653. EM( SS_CONNECTED, "CONNECTED" ) \
  654. EMe( SS_DISCONNECTING, "DISCONNECTING" )
  655. #define rpc_show_socket_state(state) \
  656. __print_symbolic(state, RPC_SHOW_SOCKET)
  657. RPC_SHOW_SOCKET
  658. #define RPC_SHOW_SOCK \
  659. EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
  660. EM( TCP_SYN_SENT, "SYN_SENT" ) \
  661. EM( TCP_SYN_RECV, "SYN_RECV" ) \
  662. EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
  663. EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
  664. EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
  665. EM( TCP_CLOSE, "CLOSE" ) \
  666. EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
  667. EM( TCP_LAST_ACK, "LAST_ACK" ) \
  668. EM( TCP_LISTEN, "LISTEN" ) \
  669. EMe( TCP_CLOSING, "CLOSING" )
  670. #define rpc_show_sock_state(state) \
  671. __print_symbolic(state, RPC_SHOW_SOCK)
  672. RPC_SHOW_SOCK
  673. #include <trace/events/net_probe_common.h>
  674. /*
  675. * Now redefine the EM() and EMe() macros to map the enums to the strings
  676. * that will be printed in the output.
  677. */
  678. #undef EM
  679. #undef EMe
  680. #define EM(a, b) {a, b},
  681. #define EMe(a, b) {a, b}
  682. DECLARE_EVENT_CLASS(xs_socket_event,
  683. TP_PROTO(
  684. struct rpc_xprt *xprt,
  685. struct socket *socket
  686. ),
  687. TP_ARGS(xprt, socket),
  688. TP_STRUCT__entry(
  689. __field(unsigned int, socket_state)
  690. __field(unsigned int, sock_state)
  691. __field(unsigned long long, ino)
  692. __array(__u8, saddr, sizeof(struct sockaddr_in6))
  693. __array(__u8, daddr, sizeof(struct sockaddr_in6))
  694. ),
  695. TP_fast_assign(
  696. struct inode *inode = SOCK_INODE(socket);
  697. const struct sock *sk = socket->sk;
  698. const struct inet_sock *inet = inet_sk(sk);
  699. memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
  700. memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
  701. TP_STORE_ADDR_PORTS(__entry, inet, sk);
  702. __entry->socket_state = socket->state;
  703. __entry->sock_state = socket->sk->sk_state;
  704. __entry->ino = (unsigned long long)inode->i_ino;
  705. ),
  706. TP_printk(
  707. "socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
  708. "state=%u (%s) sk_state=%u (%s)",
  709. __entry->ino,
  710. __entry->saddr,
  711. __entry->daddr,
  712. __entry->socket_state,
  713. rpc_show_socket_state(__entry->socket_state),
  714. __entry->sock_state,
  715. rpc_show_sock_state(__entry->sock_state)
  716. )
  717. );
  718. #define DEFINE_RPC_SOCKET_EVENT(name) \
  719. DEFINE_EVENT(xs_socket_event, name, \
  720. TP_PROTO( \
  721. struct rpc_xprt *xprt, \
  722. struct socket *socket \
  723. ), \
  724. TP_ARGS(xprt, socket))
  725. DECLARE_EVENT_CLASS(xs_socket_event_done,
  726. TP_PROTO(
  727. struct rpc_xprt *xprt,
  728. struct socket *socket,
  729. int error
  730. ),
  731. TP_ARGS(xprt, socket, error),
  732. TP_STRUCT__entry(
  733. __field(int, error)
  734. __field(unsigned int, socket_state)
  735. __field(unsigned int, sock_state)
  736. __field(unsigned long long, ino)
  737. __array(__u8, saddr, sizeof(struct sockaddr_in6))
  738. __array(__u8, daddr, sizeof(struct sockaddr_in6))
  739. ),
  740. TP_fast_assign(
  741. struct inode *inode = SOCK_INODE(socket);
  742. const struct sock *sk = socket->sk;
  743. const struct inet_sock *inet = inet_sk(sk);
  744. memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
  745. memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
  746. TP_STORE_ADDR_PORTS(__entry, inet, sk);
  747. __entry->socket_state = socket->state;
  748. __entry->sock_state = socket->sk->sk_state;
  749. __entry->ino = (unsigned long long)inode->i_ino;
  750. __entry->error = error;
  751. ),
  752. TP_printk(
  753. "error=%d socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
  754. "state=%u (%s) sk_state=%u (%s)",
  755. __entry->error,
  756. __entry->ino,
  757. __entry->saddr,
  758. __entry->daddr,
  759. __entry->socket_state,
  760. rpc_show_socket_state(__entry->socket_state),
  761. __entry->sock_state,
  762. rpc_show_sock_state(__entry->sock_state)
  763. )
  764. );
  765. #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
  766. DEFINE_EVENT(xs_socket_event_done, name, \
  767. TP_PROTO( \
  768. struct rpc_xprt *xprt, \
  769. struct socket *socket, \
  770. int error \
  771. ), \
  772. TP_ARGS(xprt, socket, error))
  773. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
  774. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
  775. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
  776. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
  777. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
  778. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
  779. TRACE_EVENT(rpc_socket_nospace,
  780. TP_PROTO(
  781. const struct rpc_rqst *rqst,
  782. const struct sock_xprt *transport
  783. ),
  784. TP_ARGS(rqst, transport),
  785. TP_STRUCT__entry(
  786. __field(unsigned int, task_id)
  787. __field(unsigned int, client_id)
  788. __field(unsigned int, total)
  789. __field(unsigned int, remaining)
  790. ),
  791. TP_fast_assign(
  792. __entry->task_id = rqst->rq_task->tk_pid;
  793. __entry->client_id = rqst->rq_task->tk_client->cl_clid;
  794. __entry->total = rqst->rq_slen;
  795. __entry->remaining = rqst->rq_slen - transport->xmit.offset;
  796. ),
  797. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  798. " total=%u remaining=%u",
  799. __entry->task_id, __entry->client_id,
  800. __entry->total, __entry->remaining
  801. )
  802. );
  803. #define rpc_show_xprt_state(x) \
  804. __print_flags(x, "|", \
  805. { BIT(XPRT_LOCKED), "LOCKED" }, \
  806. { BIT(XPRT_CONNECTED), "CONNECTED" }, \
  807. { BIT(XPRT_CONNECTING), "CONNECTING" }, \
  808. { BIT(XPRT_CLOSE_WAIT), "CLOSE_WAIT" }, \
  809. { BIT(XPRT_BOUND), "BOUND" }, \
  810. { BIT(XPRT_BINDING), "BINDING" }, \
  811. { BIT(XPRT_CLOSING), "CLOSING" }, \
  812. { BIT(XPRT_OFFLINE), "OFFLINE" }, \
  813. { BIT(XPRT_REMOVE), "REMOVE" }, \
  814. { BIT(XPRT_CONGESTED), "CONGESTED" }, \
  815. { BIT(XPRT_CWND_WAIT), "CWND_WAIT" }, \
  816. { BIT(XPRT_WRITE_SPACE), "WRITE_SPACE" }, \
  817. { BIT(XPRT_SND_IS_COOKIE), "SND_IS_COOKIE" })
  818. DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
  819. TP_PROTO(
  820. const struct rpc_xprt *xprt
  821. ),
  822. TP_ARGS(xprt),
  823. TP_STRUCT__entry(
  824. __field(unsigned long, state)
  825. __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
  826. __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
  827. ),
  828. TP_fast_assign(
  829. __entry->state = xprt->state;
  830. __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
  831. __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
  832. ),
  833. TP_printk("peer=[%s]:%s state=%s",
  834. __get_str(addr), __get_str(port),
  835. rpc_show_xprt_state(__entry->state))
  836. );
  837. #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
  838. DEFINE_EVENT(rpc_xprt_lifetime_class, \
  839. xprt_##name, \
  840. TP_PROTO( \
  841. const struct rpc_xprt *xprt \
  842. ), \
  843. TP_ARGS(xprt))
  844. DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
  845. DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
  846. DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
  847. DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
  848. DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
  849. DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
  850. DECLARE_EVENT_CLASS(rpc_xprt_event,
  851. TP_PROTO(
  852. const struct rpc_xprt *xprt,
  853. __be32 xid,
  854. int status
  855. ),
  856. TP_ARGS(xprt, xid, status),
  857. TP_STRUCT__entry(
  858. __field(u32, xid)
  859. __field(int, status)
  860. __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
  861. __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
  862. ),
  863. TP_fast_assign(
  864. __entry->xid = be32_to_cpu(xid);
  865. __entry->status = status;
  866. __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
  867. __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
  868. ),
  869. TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
  870. __get_str(port), __entry->xid,
  871. __entry->status)
  872. );
  873. #define DEFINE_RPC_XPRT_EVENT(name) \
  874. DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
  875. TP_PROTO( \
  876. const struct rpc_xprt *xprt, \
  877. __be32 xid, \
  878. int status \
  879. ), \
  880. TP_ARGS(xprt, xid, status))
  881. DEFINE_RPC_XPRT_EVENT(timer);
  882. DEFINE_RPC_XPRT_EVENT(lookup_rqst);
  883. TRACE_EVENT(xprt_transmit,
  884. TP_PROTO(
  885. const struct rpc_rqst *rqst,
  886. int status
  887. ),
  888. TP_ARGS(rqst, status),
  889. TP_STRUCT__entry(
  890. __field(unsigned int, task_id)
  891. __field(unsigned int, client_id)
  892. __field(u32, xid)
  893. __field(u32, seqno)
  894. __field(int, status)
  895. ),
  896. TP_fast_assign(
  897. __entry->task_id = rqst->rq_task->tk_pid;
  898. __entry->client_id = rqst->rq_task->tk_client ?
  899. rqst->rq_task->tk_client->cl_clid : -1;
  900. __entry->xid = be32_to_cpu(rqst->rq_xid);
  901. __entry->seqno = rqst->rq_seqno;
  902. __entry->status = status;
  903. ),
  904. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  905. " xid=0x%08x seqno=%u status=%d",
  906. __entry->task_id, __entry->client_id, __entry->xid,
  907. __entry->seqno, __entry->status)
  908. );
  909. TRACE_EVENT(xprt_retransmit,
  910. TP_PROTO(
  911. const struct rpc_rqst *rqst
  912. ),
  913. TP_ARGS(rqst),
  914. TP_STRUCT__entry(
  915. __field(unsigned int, task_id)
  916. __field(unsigned int, client_id)
  917. __field(u32, xid)
  918. __field(int, ntrans)
  919. __field(int, version)
  920. __field(unsigned long, timeout)
  921. __string(progname,
  922. rqst->rq_task->tk_client->cl_program->name)
  923. __string(procname, rpc_proc_name(rqst->rq_task))
  924. ),
  925. TP_fast_assign(
  926. struct rpc_task *task = rqst->rq_task;
  927. __entry->task_id = task->tk_pid;
  928. __entry->client_id = task->tk_client ?
  929. task->tk_client->cl_clid : -1;
  930. __entry->xid = be32_to_cpu(rqst->rq_xid);
  931. __entry->ntrans = rqst->rq_ntrans;
  932. __entry->timeout = task->tk_timeout;
  933. __assign_str(progname,
  934. task->tk_client->cl_program->name);
  935. __entry->version = task->tk_client->cl_vers;
  936. __assign_str(procname, rpc_proc_name(task));
  937. ),
  938. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  939. " xid=0x%08x %sv%d %s ntrans=%d timeout=%lu",
  940. __entry->task_id, __entry->client_id, __entry->xid,
  941. __get_str(progname), __entry->version, __get_str(procname),
  942. __entry->ntrans, __entry->timeout
  943. )
  944. );
  945. TRACE_EVENT(xprt_ping,
  946. TP_PROTO(const struct rpc_xprt *xprt, int status),
  947. TP_ARGS(xprt, status),
  948. TP_STRUCT__entry(
  949. __field(int, status)
  950. __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
  951. __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
  952. ),
  953. TP_fast_assign(
  954. __entry->status = status;
  955. __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
  956. __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
  957. ),
  958. TP_printk("peer=[%s]:%s status=%d",
  959. __get_str(addr), __get_str(port), __entry->status)
  960. );
  961. DECLARE_EVENT_CLASS(xprt_writelock_event,
  962. TP_PROTO(
  963. const struct rpc_xprt *xprt, const struct rpc_task *task
  964. ),
  965. TP_ARGS(xprt, task),
  966. TP_STRUCT__entry(
  967. __field(unsigned int, task_id)
  968. __field(unsigned int, client_id)
  969. __field(unsigned int, snd_task_id)
  970. ),
  971. TP_fast_assign(
  972. if (task) {
  973. __entry->task_id = task->tk_pid;
  974. __entry->client_id = task->tk_client ?
  975. task->tk_client->cl_clid : -1;
  976. } else {
  977. __entry->task_id = -1;
  978. __entry->client_id = -1;
  979. }
  980. if (xprt->snd_task &&
  981. !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
  982. __entry->snd_task_id = xprt->snd_task->tk_pid;
  983. else
  984. __entry->snd_task_id = -1;
  985. ),
  986. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  987. " snd_task:" SUNRPC_TRACE_PID_SPECIFIER,
  988. __entry->task_id, __entry->client_id,
  989. __entry->snd_task_id)
  990. );
  991. #define DEFINE_WRITELOCK_EVENT(name) \
  992. DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
  993. TP_PROTO( \
  994. const struct rpc_xprt *xprt, \
  995. const struct rpc_task *task \
  996. ), \
  997. TP_ARGS(xprt, task))
  998. DEFINE_WRITELOCK_EVENT(reserve_xprt);
  999. DEFINE_WRITELOCK_EVENT(release_xprt);
  1000. DECLARE_EVENT_CLASS(xprt_cong_event,
  1001. TP_PROTO(
  1002. const struct rpc_xprt *xprt, const struct rpc_task *task
  1003. ),
  1004. TP_ARGS(xprt, task),
  1005. TP_STRUCT__entry(
  1006. __field(unsigned int, task_id)
  1007. __field(unsigned int, client_id)
  1008. __field(unsigned int, snd_task_id)
  1009. __field(unsigned long, cong)
  1010. __field(unsigned long, cwnd)
  1011. __field(bool, wait)
  1012. ),
  1013. TP_fast_assign(
  1014. if (task) {
  1015. __entry->task_id = task->tk_pid;
  1016. __entry->client_id = task->tk_client ?
  1017. task->tk_client->cl_clid : -1;
  1018. } else {
  1019. __entry->task_id = -1;
  1020. __entry->client_id = -1;
  1021. }
  1022. if (xprt->snd_task &&
  1023. !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
  1024. __entry->snd_task_id = xprt->snd_task->tk_pid;
  1025. else
  1026. __entry->snd_task_id = -1;
  1027. __entry->cong = xprt->cong;
  1028. __entry->cwnd = xprt->cwnd;
  1029. __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
  1030. ),
  1031. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  1032. " snd_task:" SUNRPC_TRACE_PID_SPECIFIER
  1033. " cong=%lu cwnd=%lu%s",
  1034. __entry->task_id, __entry->client_id,
  1035. __entry->snd_task_id, __entry->cong, __entry->cwnd,
  1036. __entry->wait ? " (wait)" : "")
  1037. );
  1038. #define DEFINE_CONG_EVENT(name) \
  1039. DEFINE_EVENT(xprt_cong_event, xprt_##name, \
  1040. TP_PROTO( \
  1041. const struct rpc_xprt *xprt, \
  1042. const struct rpc_task *task \
  1043. ), \
  1044. TP_ARGS(xprt, task))
  1045. DEFINE_CONG_EVENT(reserve_cong);
  1046. DEFINE_CONG_EVENT(release_cong);
  1047. DEFINE_CONG_EVENT(get_cong);
  1048. DEFINE_CONG_EVENT(put_cong);
  1049. TRACE_EVENT(xprt_reserve,
  1050. TP_PROTO(
  1051. const struct rpc_rqst *rqst
  1052. ),
  1053. TP_ARGS(rqst),
  1054. TP_STRUCT__entry(
  1055. __field(unsigned int, task_id)
  1056. __field(unsigned int, client_id)
  1057. __field(u32, xid)
  1058. ),
  1059. TP_fast_assign(
  1060. __entry->task_id = rqst->rq_task->tk_pid;
  1061. __entry->client_id = rqst->rq_task->tk_client->cl_clid;
  1062. __entry->xid = be32_to_cpu(rqst->rq_xid);
  1063. ),
  1064. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",
  1065. __entry->task_id, __entry->client_id, __entry->xid
  1066. )
  1067. );
  1068. TRACE_EVENT(xs_data_ready,
  1069. TP_PROTO(
  1070. const struct rpc_xprt *xprt
  1071. ),
  1072. TP_ARGS(xprt),
  1073. TP_STRUCT__entry(
  1074. __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
  1075. __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
  1076. ),
  1077. TP_fast_assign(
  1078. __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
  1079. __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
  1080. ),
  1081. TP_printk("peer=[%s]:%s", __get_str(addr), __get_str(port))
  1082. );
  1083. TRACE_EVENT(xs_stream_read_data,
  1084. TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
  1085. TP_ARGS(xprt, err, total),
  1086. TP_STRUCT__entry(
  1087. __field(ssize_t, err)
  1088. __field(size_t, total)
  1089. __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
  1090. "(null)")
  1091. __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
  1092. "(null)")
  1093. ),
  1094. TP_fast_assign(
  1095. __entry->err = err;
  1096. __entry->total = total;
  1097. __assign_str(addr, xprt ?
  1098. xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
  1099. __assign_str(port, xprt ?
  1100. xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
  1101. ),
  1102. TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
  1103. __get_str(port), __entry->err, __entry->total)
  1104. );
  1105. TRACE_EVENT(xs_stream_read_request,
  1106. TP_PROTO(struct sock_xprt *xs),
  1107. TP_ARGS(xs),
  1108. TP_STRUCT__entry(
  1109. __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
  1110. __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
  1111. __field(u32, xid)
  1112. __field(unsigned long, copied)
  1113. __field(unsigned int, reclen)
  1114. __field(unsigned int, offset)
  1115. ),
  1116. TP_fast_assign(
  1117. __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
  1118. __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
  1119. __entry->xid = be32_to_cpu(xs->recv.xid);
  1120. __entry->copied = xs->recv.copied;
  1121. __entry->reclen = xs->recv.len;
  1122. __entry->offset = xs->recv.offset;
  1123. ),
  1124. TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
  1125. __get_str(addr), __get_str(port), __entry->xid,
  1126. __entry->copied, __entry->reclen, __entry->offset)
  1127. );
  1128. TRACE_EVENT(rpcb_getport,
  1129. TP_PROTO(
  1130. const struct rpc_clnt *clnt,
  1131. const struct rpc_task *task,
  1132. unsigned int bind_version
  1133. ),
  1134. TP_ARGS(clnt, task, bind_version),
  1135. TP_STRUCT__entry(
  1136. __field(unsigned int, task_id)
  1137. __field(unsigned int, client_id)
  1138. __field(unsigned int, program)
  1139. __field(unsigned int, version)
  1140. __field(int, protocol)
  1141. __field(unsigned int, bind_version)
  1142. __string(servername, task->tk_xprt->servername)
  1143. ),
  1144. TP_fast_assign(
  1145. __entry->task_id = task->tk_pid;
  1146. __entry->client_id = clnt->cl_clid;
  1147. __entry->program = clnt->cl_prog;
  1148. __entry->version = clnt->cl_vers;
  1149. __entry->protocol = task->tk_xprt->prot;
  1150. __entry->bind_version = bind_version;
  1151. __assign_str(servername, task->tk_xprt->servername);
  1152. ),
  1153. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  1154. " server=%s program=%u version=%u protocol=%d bind_version=%u",
  1155. __entry->task_id, __entry->client_id, __get_str(servername),
  1156. __entry->program, __entry->version, __entry->protocol,
  1157. __entry->bind_version
  1158. )
  1159. );
  1160. TRACE_EVENT(rpcb_setport,
  1161. TP_PROTO(
  1162. const struct rpc_task *task,
  1163. int status,
  1164. unsigned short port
  1165. ),
  1166. TP_ARGS(task, status, port),
  1167. TP_STRUCT__entry(
  1168. __field(unsigned int, task_id)
  1169. __field(unsigned int, client_id)
  1170. __field(int, status)
  1171. __field(unsigned short, port)
  1172. ),
  1173. TP_fast_assign(
  1174. __entry->task_id = task->tk_pid;
  1175. __entry->client_id = task->tk_client->cl_clid;
  1176. __entry->status = status;
  1177. __entry->port = port;
  1178. ),
  1179. TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d port=%u",
  1180. __entry->task_id, __entry->client_id,
  1181. __entry->status, __entry->port
  1182. )
  1183. );
  1184. TRACE_EVENT(pmap_register,
  1185. TP_PROTO(
  1186. u32 program,
  1187. u32 version,
  1188. int protocol,
  1189. unsigned short port
  1190. ),
  1191. TP_ARGS(program, version, protocol, port),
  1192. TP_STRUCT__entry(
  1193. __field(unsigned int, program)
  1194. __field(unsigned int, version)
  1195. __field(int, protocol)
  1196. __field(unsigned int, port)
  1197. ),
  1198. TP_fast_assign(
  1199. __entry->program = program;
  1200. __entry->version = version;
  1201. __entry->protocol = protocol;
  1202. __entry->port = port;
  1203. ),
  1204. TP_printk("program=%u version=%u protocol=%d port=%u",
  1205. __entry->program, __entry->version,
  1206. __entry->protocol, __entry->port
  1207. )
  1208. );
  1209. TRACE_EVENT(rpcb_register,
  1210. TP_PROTO(
  1211. u32 program,
  1212. u32 version,
  1213. const char *addr,
  1214. const char *netid
  1215. ),
  1216. TP_ARGS(program, version, addr, netid),
  1217. TP_STRUCT__entry(
  1218. __field(unsigned int, program)
  1219. __field(unsigned int, version)
  1220. __string(addr, addr)
  1221. __string(netid, netid)
  1222. ),
  1223. TP_fast_assign(
  1224. __entry->program = program;
  1225. __entry->version = version;
  1226. __assign_str(addr, addr);
  1227. __assign_str(netid, netid);
  1228. ),
  1229. TP_printk("program=%u version=%u addr=%s netid=%s",
  1230. __entry->program, __entry->version,
  1231. __get_str(addr), __get_str(netid)
  1232. )
  1233. );
  1234. TRACE_EVENT(rpcb_unregister,
  1235. TP_PROTO(
  1236. u32 program,
  1237. u32 version,
  1238. const char *netid
  1239. ),
  1240. TP_ARGS(program, version, netid),
  1241. TP_STRUCT__entry(
  1242. __field(unsigned int, program)
  1243. __field(unsigned int, version)
  1244. __string(netid, netid)
  1245. ),
  1246. TP_fast_assign(
  1247. __entry->program = program;
  1248. __entry->version = version;
  1249. __assign_str(netid, netid);
  1250. ),
  1251. TP_printk("program=%u version=%u netid=%s",
  1252. __entry->program, __entry->version, __get_str(netid)
  1253. )
  1254. );
  1255. /* Record an xdr_buf containing a fully-formed RPC message */
  1256. DECLARE_EVENT_CLASS(svc_xdr_msg_class,
  1257. TP_PROTO(
  1258. const struct xdr_buf *xdr
  1259. ),
  1260. TP_ARGS(xdr),
  1261. TP_STRUCT__entry(
  1262. __field(u32, xid)
  1263. __field(const void *, head_base)
  1264. __field(size_t, head_len)
  1265. __field(const void *, tail_base)
  1266. __field(size_t, tail_len)
  1267. __field(unsigned int, page_len)
  1268. __field(unsigned int, msg_len)
  1269. ),
  1270. TP_fast_assign(
  1271. __be32 *p = (__be32 *)xdr->head[0].iov_base;
  1272. __entry->xid = be32_to_cpu(*p);
  1273. __entry->head_base = p;
  1274. __entry->head_len = xdr->head[0].iov_len;
  1275. __entry->tail_base = xdr->tail[0].iov_base;
  1276. __entry->tail_len = xdr->tail[0].iov_len;
  1277. __entry->page_len = xdr->page_len;
  1278. __entry->msg_len = xdr->len;
  1279. ),
  1280. TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
  1281. __entry->xid,
  1282. __entry->head_base, __entry->head_len, __entry->page_len,
  1283. __entry->tail_base, __entry->tail_len, __entry->msg_len
  1284. )
  1285. );
  1286. #define DEFINE_SVCXDRMSG_EVENT(name) \
  1287. DEFINE_EVENT(svc_xdr_msg_class, \
  1288. svc_xdr_##name, \
  1289. TP_PROTO( \
  1290. const struct xdr_buf *xdr \
  1291. ), \
  1292. TP_ARGS(xdr))
  1293. DEFINE_SVCXDRMSG_EVENT(recvfrom);
  1294. /* Record an xdr_buf containing arbitrary data, tagged with an XID */
  1295. DECLARE_EVENT_CLASS(svc_xdr_buf_class,
  1296. TP_PROTO(
  1297. __be32 xid,
  1298. const struct xdr_buf *xdr
  1299. ),
  1300. TP_ARGS(xid, xdr),
  1301. TP_STRUCT__entry(
  1302. __field(u32, xid)
  1303. __field(const void *, head_base)
  1304. __field(size_t, head_len)
  1305. __field(const void *, tail_base)
  1306. __field(size_t, tail_len)
  1307. __field(unsigned int, page_base)
  1308. __field(unsigned int, page_len)
  1309. __field(unsigned int, msg_len)
  1310. ),
  1311. TP_fast_assign(
  1312. __entry->xid = be32_to_cpu(xid);
  1313. __entry->head_base = xdr->head[0].iov_base;
  1314. __entry->head_len = xdr->head[0].iov_len;
  1315. __entry->tail_base = xdr->tail[0].iov_base;
  1316. __entry->tail_len = xdr->tail[0].iov_len;
  1317. __entry->page_base = xdr->page_base;
  1318. __entry->page_len = xdr->page_len;
  1319. __entry->msg_len = xdr->len;
  1320. ),
  1321. TP_printk("xid=0x%08x head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
  1322. __entry->xid,
  1323. __entry->head_base, __entry->head_len,
  1324. __entry->page_len, __entry->page_base,
  1325. __entry->tail_base, __entry->tail_len,
  1326. __entry->msg_len
  1327. )
  1328. );
  1329. #define DEFINE_SVCXDRBUF_EVENT(name) \
  1330. DEFINE_EVENT(svc_xdr_buf_class, \
  1331. svc_xdr_##name, \
  1332. TP_PROTO( \
  1333. __be32 xid, \
  1334. const struct xdr_buf *xdr \
  1335. ), \
  1336. TP_ARGS(xid, xdr))
  1337. DEFINE_SVCXDRBUF_EVENT(sendto);
  1338. /*
  1339. * from include/linux/sunrpc/svc.h
  1340. */
  1341. #define SVC_RQST_FLAG_LIST \
  1342. svc_rqst_flag(SECURE) \
  1343. svc_rqst_flag(LOCAL) \
  1344. svc_rqst_flag(USEDEFERRAL) \
  1345. svc_rqst_flag(DROPME) \
  1346. svc_rqst_flag(SPLICE_OK) \
  1347. svc_rqst_flag(VICTIM) \
  1348. svc_rqst_flag(BUSY) \
  1349. svc_rqst_flag_end(DATA)
  1350. #undef svc_rqst_flag
  1351. #undef svc_rqst_flag_end
  1352. #define svc_rqst_flag(x) TRACE_DEFINE_ENUM(RQ_##x);
  1353. #define svc_rqst_flag_end(x) TRACE_DEFINE_ENUM(RQ_##x);
  1354. SVC_RQST_FLAG_LIST
  1355. #undef svc_rqst_flag
  1356. #undef svc_rqst_flag_end
  1357. #define svc_rqst_flag(x) { BIT(RQ_##x), #x },
  1358. #define svc_rqst_flag_end(x) { BIT(RQ_##x), #x }
  1359. #define show_rqstp_flags(flags) \
  1360. __print_flags(flags, "|", SVC_RQST_FLAG_LIST)
  1361. TRACE_DEFINE_ENUM(SVC_GARBAGE);
  1362. TRACE_DEFINE_ENUM(SVC_SYSERR);
  1363. TRACE_DEFINE_ENUM(SVC_VALID);
  1364. TRACE_DEFINE_ENUM(SVC_NEGATIVE);
  1365. TRACE_DEFINE_ENUM(SVC_OK);
  1366. TRACE_DEFINE_ENUM(SVC_DROP);
  1367. TRACE_DEFINE_ENUM(SVC_CLOSE);
  1368. TRACE_DEFINE_ENUM(SVC_DENIED);
  1369. TRACE_DEFINE_ENUM(SVC_PENDING);
  1370. TRACE_DEFINE_ENUM(SVC_COMPLETE);
  1371. #define svc_show_status(status) \
  1372. __print_symbolic(status, \
  1373. { SVC_GARBAGE, "SVC_GARBAGE" }, \
  1374. { SVC_SYSERR, "SVC_SYSERR" }, \
  1375. { SVC_VALID, "SVC_VALID" }, \
  1376. { SVC_NEGATIVE, "SVC_NEGATIVE" }, \
  1377. { SVC_OK, "SVC_OK" }, \
  1378. { SVC_DROP, "SVC_DROP" }, \
  1379. { SVC_CLOSE, "SVC_CLOSE" }, \
  1380. { SVC_DENIED, "SVC_DENIED" }, \
  1381. { SVC_PENDING, "SVC_PENDING" }, \
  1382. { SVC_COMPLETE, "SVC_COMPLETE" })
  1383. #define SVC_RQST_ENDPOINT_FIELDS(r) \
  1384. __sockaddr(server, (r)->rq_xprt->xpt_locallen) \
  1385. __sockaddr(client, (r)->rq_xprt->xpt_remotelen) \
  1386. __field(unsigned int, netns_ino) \
  1387. __field(u32, xid)
  1388. #define SVC_RQST_ENDPOINT_ASSIGNMENTS(r) \
  1389. do { \
  1390. struct svc_xprt *xprt = (r)->rq_xprt; \
  1391. __assign_sockaddr(server, &xprt->xpt_local, \
  1392. xprt->xpt_locallen); \
  1393. __assign_sockaddr(client, &xprt->xpt_remote, \
  1394. xprt->xpt_remotelen); \
  1395. __entry->netns_ino = xprt->xpt_net->ns.inum; \
  1396. __entry->xid = be32_to_cpu((r)->rq_xid); \
  1397. } while (0)
  1398. #define SVC_RQST_ENDPOINT_FORMAT \
  1399. "xid=0x%08x server=%pISpc client=%pISpc"
  1400. #define SVC_RQST_ENDPOINT_VARARGS \
  1401. __entry->xid, __get_sockaddr(server), __get_sockaddr(client)
  1402. TRACE_EVENT(svc_authenticate,
  1403. TP_PROTO(const struct svc_rqst *rqst, int auth_res),
  1404. TP_ARGS(rqst, auth_res),
  1405. TP_STRUCT__entry(
  1406. SVC_RQST_ENDPOINT_FIELDS(rqst)
  1407. __field(unsigned long, svc_status)
  1408. __field(unsigned long, auth_stat)
  1409. ),
  1410. TP_fast_assign(
  1411. SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
  1412. __entry->svc_status = auth_res;
  1413. __entry->auth_stat = be32_to_cpu(rqst->rq_auth_stat);
  1414. ),
  1415. TP_printk(SVC_RQST_ENDPOINT_FORMAT
  1416. " auth_res=%s auth_stat=%s",
  1417. SVC_RQST_ENDPOINT_VARARGS,
  1418. svc_show_status(__entry->svc_status),
  1419. rpc_show_auth_stat(__entry->auth_stat))
  1420. );
  1421. TRACE_EVENT(svc_process,
  1422. TP_PROTO(const struct svc_rqst *rqst, const char *name),
  1423. TP_ARGS(rqst, name),
  1424. TP_STRUCT__entry(
  1425. __field(u32, xid)
  1426. __field(u32, vers)
  1427. __field(u32, proc)
  1428. __string(service, name)
  1429. __string(procedure, svc_proc_name(rqst))
  1430. __string(addr, rqst->rq_xprt ?
  1431. rqst->rq_xprt->xpt_remotebuf : "(null)")
  1432. ),
  1433. TP_fast_assign(
  1434. __entry->xid = be32_to_cpu(rqst->rq_xid);
  1435. __entry->vers = rqst->rq_vers;
  1436. __entry->proc = rqst->rq_proc;
  1437. __assign_str(service, name);
  1438. __assign_str(procedure, svc_proc_name(rqst));
  1439. __assign_str(addr, rqst->rq_xprt ?
  1440. rqst->rq_xprt->xpt_remotebuf : "(null)");
  1441. ),
  1442. TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",
  1443. __get_str(addr), __entry->xid,
  1444. __get_str(service), __entry->vers,
  1445. __get_str(procedure)
  1446. )
  1447. );
  1448. DECLARE_EVENT_CLASS(svc_rqst_event,
  1449. TP_PROTO(
  1450. const struct svc_rqst *rqst
  1451. ),
  1452. TP_ARGS(rqst),
  1453. TP_STRUCT__entry(
  1454. SVC_RQST_ENDPOINT_FIELDS(rqst)
  1455. __field(unsigned long, flags)
  1456. ),
  1457. TP_fast_assign(
  1458. SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
  1459. __entry->flags = rqst->rq_flags;
  1460. ),
  1461. TP_printk(SVC_RQST_ENDPOINT_FORMAT " flags=%s",
  1462. SVC_RQST_ENDPOINT_VARARGS,
  1463. show_rqstp_flags(__entry->flags))
  1464. );
  1465. #define DEFINE_SVC_RQST_EVENT(name) \
  1466. DEFINE_EVENT(svc_rqst_event, svc_##name, \
  1467. TP_PROTO( \
  1468. const struct svc_rqst *rqst \
  1469. ), \
  1470. TP_ARGS(rqst))
  1471. DEFINE_SVC_RQST_EVENT(defer);
  1472. DEFINE_SVC_RQST_EVENT(drop);
  1473. DECLARE_EVENT_CLASS(svc_rqst_status,
  1474. TP_PROTO(
  1475. const struct svc_rqst *rqst,
  1476. int status
  1477. ),
  1478. TP_ARGS(rqst, status),
  1479. TP_STRUCT__entry(
  1480. SVC_RQST_ENDPOINT_FIELDS(rqst)
  1481. __field(int, status)
  1482. __field(unsigned long, flags)
  1483. ),
  1484. TP_fast_assign(
  1485. SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
  1486. __entry->status = status;
  1487. __entry->flags = rqst->rq_flags;
  1488. ),
  1489. TP_printk(SVC_RQST_ENDPOINT_FORMAT " status=%d flags=%s",
  1490. SVC_RQST_ENDPOINT_VARARGS,
  1491. __entry->status, show_rqstp_flags(__entry->flags))
  1492. );
  1493. DEFINE_EVENT(svc_rqst_status, svc_send,
  1494. TP_PROTO(const struct svc_rqst *rqst, int status),
  1495. TP_ARGS(rqst, status));
  1496. TRACE_EVENT(svc_stats_latency,
  1497. TP_PROTO(
  1498. const struct svc_rqst *rqst
  1499. ),
  1500. TP_ARGS(rqst),
  1501. TP_STRUCT__entry(
  1502. SVC_RQST_ENDPOINT_FIELDS(rqst)
  1503. __field(unsigned long, execute)
  1504. __string(procedure, svc_proc_name(rqst))
  1505. ),
  1506. TP_fast_assign(
  1507. SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
  1508. __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
  1509. rqst->rq_stime));
  1510. __assign_str(procedure, svc_proc_name(rqst));
  1511. ),
  1512. TP_printk(SVC_RQST_ENDPOINT_FORMAT " proc=%s execute-us=%lu",
  1513. SVC_RQST_ENDPOINT_VARARGS,
  1514. __get_str(procedure), __entry->execute)
  1515. );
  1516. #define show_svc_xprt_flags(flags) \
  1517. __print_flags(flags, "|", \
  1518. { (1UL << XPT_BUSY), "XPT_BUSY"}, \
  1519. { (1UL << XPT_CONN), "XPT_CONN"}, \
  1520. { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
  1521. { (1UL << XPT_DATA), "XPT_DATA"}, \
  1522. { (1UL << XPT_TEMP), "XPT_TEMP"}, \
  1523. { (1UL << XPT_DEAD), "XPT_DEAD"}, \
  1524. { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
  1525. { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
  1526. { (1UL << XPT_OLD), "XPT_OLD"}, \
  1527. { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
  1528. { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
  1529. { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \
  1530. { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \
  1531. { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"})
  1532. TRACE_EVENT(svc_xprt_create_err,
  1533. TP_PROTO(
  1534. const char *program,
  1535. const char *protocol,
  1536. struct sockaddr *sap,
  1537. size_t salen,
  1538. const struct svc_xprt *xprt
  1539. ),
  1540. TP_ARGS(program, protocol, sap, salen, xprt),
  1541. TP_STRUCT__entry(
  1542. __field(long, error)
  1543. __string(program, program)
  1544. __string(protocol, protocol)
  1545. __sockaddr(addr, salen)
  1546. ),
  1547. TP_fast_assign(
  1548. __entry->error = PTR_ERR(xprt);
  1549. __assign_str(program, program);
  1550. __assign_str(protocol, protocol);
  1551. __assign_sockaddr(addr, sap, salen);
  1552. ),
  1553. TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
  1554. __get_sockaddr(addr), __get_str(program), __get_str(protocol),
  1555. __entry->error)
  1556. );
  1557. #define SVC_XPRT_ENDPOINT_FIELDS(x) \
  1558. __sockaddr(server, (x)->xpt_locallen) \
  1559. __sockaddr(client, (x)->xpt_remotelen) \
  1560. __field(unsigned long, flags) \
  1561. __field(unsigned int, netns_ino)
  1562. #define SVC_XPRT_ENDPOINT_ASSIGNMENTS(x) \
  1563. do { \
  1564. __assign_sockaddr(server, &(x)->xpt_local, \
  1565. (x)->xpt_locallen); \
  1566. __assign_sockaddr(client, &(x)->xpt_remote, \
  1567. (x)->xpt_remotelen); \
  1568. __entry->flags = (x)->xpt_flags; \
  1569. __entry->netns_ino = (x)->xpt_net->ns.inum; \
  1570. } while (0)
  1571. #define SVC_XPRT_ENDPOINT_FORMAT \
  1572. "server=%pISpc client=%pISpc flags=%s"
  1573. #define SVC_XPRT_ENDPOINT_VARARGS \
  1574. __get_sockaddr(server), __get_sockaddr(client), \
  1575. show_svc_xprt_flags(__entry->flags)
  1576. TRACE_EVENT(svc_xprt_enqueue,
  1577. TP_PROTO(
  1578. const struct svc_xprt *xprt,
  1579. const struct svc_rqst *rqst
  1580. ),
  1581. TP_ARGS(xprt, rqst),
  1582. TP_STRUCT__entry(
  1583. SVC_XPRT_ENDPOINT_FIELDS(xprt)
  1584. __field(int, pid)
  1585. ),
  1586. TP_fast_assign(
  1587. SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
  1588. __entry->pid = rqst? rqst->rq_task->pid : 0;
  1589. ),
  1590. TP_printk(SVC_XPRT_ENDPOINT_FORMAT " pid=%d",
  1591. SVC_XPRT_ENDPOINT_VARARGS, __entry->pid)
  1592. );
  1593. TRACE_EVENT(svc_xprt_dequeue,
  1594. TP_PROTO(
  1595. const struct svc_rqst *rqst
  1596. ),
  1597. TP_ARGS(rqst),
  1598. TP_STRUCT__entry(
  1599. SVC_XPRT_ENDPOINT_FIELDS(rqst->rq_xprt)
  1600. __field(unsigned long, wakeup)
  1601. ),
  1602. TP_fast_assign(
  1603. SVC_XPRT_ENDPOINT_ASSIGNMENTS(rqst->rq_xprt);
  1604. __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
  1605. rqst->rq_qtime));
  1606. ),
  1607. TP_printk(SVC_XPRT_ENDPOINT_FORMAT " wakeup-us=%lu",
  1608. SVC_XPRT_ENDPOINT_VARARGS, __entry->wakeup)
  1609. );
  1610. DECLARE_EVENT_CLASS(svc_xprt_event,
  1611. TP_PROTO(
  1612. const struct svc_xprt *xprt
  1613. ),
  1614. TP_ARGS(xprt),
  1615. TP_STRUCT__entry(
  1616. SVC_XPRT_ENDPOINT_FIELDS(xprt)
  1617. ),
  1618. TP_fast_assign(
  1619. SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
  1620. ),
  1621. TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)
  1622. );
  1623. #define DEFINE_SVC_XPRT_EVENT(name) \
  1624. DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
  1625. TP_PROTO( \
  1626. const struct svc_xprt *xprt \
  1627. ), \
  1628. TP_ARGS(xprt))
  1629. DEFINE_SVC_XPRT_EVENT(no_write_space);
  1630. DEFINE_SVC_XPRT_EVENT(close);
  1631. DEFINE_SVC_XPRT_EVENT(detach);
  1632. DEFINE_SVC_XPRT_EVENT(free);
  1633. TRACE_EVENT(svc_xprt_accept,
  1634. TP_PROTO(
  1635. const struct svc_xprt *xprt,
  1636. const char *service
  1637. ),
  1638. TP_ARGS(xprt, service),
  1639. TP_STRUCT__entry(
  1640. SVC_XPRT_ENDPOINT_FIELDS(xprt)
  1641. __string(protocol, xprt->xpt_class->xcl_name)
  1642. __string(service, service)
  1643. ),
  1644. TP_fast_assign(
  1645. SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
  1646. __assign_str(protocol, xprt->xpt_class->xcl_name);
  1647. __assign_str(service, service);
  1648. ),
  1649. TP_printk(SVC_XPRT_ENDPOINT_FORMAT " protocol=%s service=%s",
  1650. SVC_XPRT_ENDPOINT_VARARGS,
  1651. __get_str(protocol), __get_str(service)
  1652. )
  1653. );
  1654. TRACE_EVENT(svc_wake_up,
  1655. TP_PROTO(int pid),
  1656. TP_ARGS(pid),
  1657. TP_STRUCT__entry(
  1658. __field(int, pid)
  1659. ),
  1660. TP_fast_assign(
  1661. __entry->pid = pid;
  1662. ),
  1663. TP_printk("pid=%d", __entry->pid)
  1664. );
  1665. TRACE_EVENT(svc_alloc_arg_err,
  1666. TP_PROTO(
  1667. unsigned int requested,
  1668. unsigned int allocated
  1669. ),
  1670. TP_ARGS(requested, allocated),
  1671. TP_STRUCT__entry(
  1672. __field(unsigned int, requested)
  1673. __field(unsigned int, allocated)
  1674. ),
  1675. TP_fast_assign(
  1676. __entry->requested = requested;
  1677. __entry->allocated = allocated;
  1678. ),
  1679. TP_printk("requested=%u allocated=%u",
  1680. __entry->requested, __entry->allocated)
  1681. );
  1682. DECLARE_EVENT_CLASS(svc_deferred_event,
  1683. TP_PROTO(
  1684. const struct svc_deferred_req *dr
  1685. ),
  1686. TP_ARGS(dr),
  1687. TP_STRUCT__entry(
  1688. __field(const void *, dr)
  1689. __field(u32, xid)
  1690. __sockaddr(addr, dr->addrlen)
  1691. ),
  1692. TP_fast_assign(
  1693. __entry->dr = dr;
  1694. __entry->xid = be32_to_cpu(*(__be32 *)dr->args);
  1695. __assign_sockaddr(addr, &dr->addr, dr->addrlen);
  1696. ),
  1697. TP_printk("addr=%pISpc dr=%p xid=0x%08x", __get_sockaddr(addr),
  1698. __entry->dr, __entry->xid)
  1699. );
  1700. #define DEFINE_SVC_DEFERRED_EVENT(name) \
  1701. DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
  1702. TP_PROTO( \
  1703. const struct svc_deferred_req *dr \
  1704. ), \
  1705. TP_ARGS(dr))
  1706. DEFINE_SVC_DEFERRED_EVENT(drop);
  1707. DEFINE_SVC_DEFERRED_EVENT(queue);
  1708. DEFINE_SVC_DEFERRED_EVENT(recv);
  1709. TRACE_EVENT(svcsock_new_socket,
  1710. TP_PROTO(
  1711. const struct socket *socket
  1712. ),
  1713. TP_ARGS(socket),
  1714. TP_STRUCT__entry(
  1715. __field(unsigned long, type)
  1716. __field(unsigned long, family)
  1717. __field(bool, listener)
  1718. ),
  1719. TP_fast_assign(
  1720. __entry->type = socket->type;
  1721. __entry->family = socket->sk->sk_family;
  1722. __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
  1723. ),
  1724. TP_printk("type=%s family=%s%s",
  1725. show_socket_type(__entry->type),
  1726. rpc_show_address_family(__entry->family),
  1727. __entry->listener ? " (listener)" : ""
  1728. )
  1729. );
  1730. TRACE_EVENT(svcsock_marker,
  1731. TP_PROTO(
  1732. const struct svc_xprt *xprt,
  1733. __be32 marker
  1734. ),
  1735. TP_ARGS(xprt, marker),
  1736. TP_STRUCT__entry(
  1737. __field(unsigned int, length)
  1738. __field(bool, last)
  1739. __string(addr, xprt->xpt_remotebuf)
  1740. ),
  1741. TP_fast_assign(
  1742. __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
  1743. __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
  1744. __assign_str(addr, xprt->xpt_remotebuf);
  1745. ),
  1746. TP_printk("addr=%s length=%u%s", __get_str(addr),
  1747. __entry->length, __entry->last ? " (last)" : "")
  1748. );
  1749. DECLARE_EVENT_CLASS(svcsock_class,
  1750. TP_PROTO(
  1751. const struct svc_xprt *xprt,
  1752. ssize_t result
  1753. ),
  1754. TP_ARGS(xprt, result),
  1755. TP_STRUCT__entry(
  1756. __field(ssize_t, result)
  1757. __field(unsigned long, flags)
  1758. __string(addr, xprt->xpt_remotebuf)
  1759. ),
  1760. TP_fast_assign(
  1761. __entry->result = result;
  1762. __entry->flags = xprt->xpt_flags;
  1763. __assign_str(addr, xprt->xpt_remotebuf);
  1764. ),
  1765. TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
  1766. __entry->result, show_svc_xprt_flags(__entry->flags)
  1767. )
  1768. );
  1769. #define DEFINE_SVCSOCK_EVENT(name) \
  1770. DEFINE_EVENT(svcsock_class, svcsock_##name, \
  1771. TP_PROTO( \
  1772. const struct svc_xprt *xprt, \
  1773. ssize_t result \
  1774. ), \
  1775. TP_ARGS(xprt, result))
  1776. DEFINE_SVCSOCK_EVENT(udp_send);
  1777. DEFINE_SVCSOCK_EVENT(udp_recv);
  1778. DEFINE_SVCSOCK_EVENT(udp_recv_err);
  1779. DEFINE_SVCSOCK_EVENT(tcp_send);
  1780. DEFINE_SVCSOCK_EVENT(tcp_recv);
  1781. DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
  1782. DEFINE_SVCSOCK_EVENT(tcp_recv_err);
  1783. DEFINE_SVCSOCK_EVENT(data_ready);
  1784. DEFINE_SVCSOCK_EVENT(write_space);
  1785. TRACE_EVENT(svcsock_tcp_recv_short,
  1786. TP_PROTO(
  1787. const struct svc_xprt *xprt,
  1788. u32 expected,
  1789. u32 received
  1790. ),
  1791. TP_ARGS(xprt, expected, received),
  1792. TP_STRUCT__entry(
  1793. __field(u32, expected)
  1794. __field(u32, received)
  1795. __field(unsigned long, flags)
  1796. __string(addr, xprt->xpt_remotebuf)
  1797. ),
  1798. TP_fast_assign(
  1799. __entry->expected = expected;
  1800. __entry->received = received;
  1801. __entry->flags = xprt->xpt_flags;
  1802. __assign_str(addr, xprt->xpt_remotebuf);
  1803. ),
  1804. TP_printk("addr=%s flags=%s expected=%u received=%u",
  1805. __get_str(addr), show_svc_xprt_flags(__entry->flags),
  1806. __entry->expected, __entry->received
  1807. )
  1808. );
  1809. TRACE_EVENT(svcsock_tcp_state,
  1810. TP_PROTO(
  1811. const struct svc_xprt *xprt,
  1812. const struct socket *socket
  1813. ),
  1814. TP_ARGS(xprt, socket),
  1815. TP_STRUCT__entry(
  1816. __field(unsigned long, socket_state)
  1817. __field(unsigned long, sock_state)
  1818. __field(unsigned long, flags)
  1819. __string(addr, xprt->xpt_remotebuf)
  1820. ),
  1821. TP_fast_assign(
  1822. __entry->socket_state = socket->state;
  1823. __entry->sock_state = socket->sk->sk_state;
  1824. __entry->flags = xprt->xpt_flags;
  1825. __assign_str(addr, xprt->xpt_remotebuf);
  1826. ),
  1827. TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
  1828. rpc_show_socket_state(__entry->socket_state),
  1829. rpc_show_sock_state(__entry->sock_state),
  1830. show_svc_xprt_flags(__entry->flags)
  1831. )
  1832. );
  1833. DECLARE_EVENT_CLASS(svcsock_accept_class,
  1834. TP_PROTO(
  1835. const struct svc_xprt *xprt,
  1836. const char *service,
  1837. long status
  1838. ),
  1839. TP_ARGS(xprt, service, status),
  1840. TP_STRUCT__entry(
  1841. __field(long, status)
  1842. __string(service, service)
  1843. __field(unsigned int, netns_ino)
  1844. ),
  1845. TP_fast_assign(
  1846. __entry->status = status;
  1847. __assign_str(service, service);
  1848. __entry->netns_ino = xprt->xpt_net->ns.inum;
  1849. ),
  1850. TP_printk("addr=listener service=%s status=%ld",
  1851. __get_str(service), __entry->status
  1852. )
  1853. );
  1854. #define DEFINE_ACCEPT_EVENT(name) \
  1855. DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
  1856. TP_PROTO( \
  1857. const struct svc_xprt *xprt, \
  1858. const char *service, \
  1859. long status \
  1860. ), \
  1861. TP_ARGS(xprt, service, status))
  1862. DEFINE_ACCEPT_EVENT(accept);
  1863. DEFINE_ACCEPT_EVENT(getpeername);
  1864. DECLARE_EVENT_CLASS(cache_event,
  1865. TP_PROTO(
  1866. const struct cache_detail *cd,
  1867. const struct cache_head *h
  1868. ),
  1869. TP_ARGS(cd, h),
  1870. TP_STRUCT__entry(
  1871. __field(const struct cache_head *, h)
  1872. __string(name, cd->name)
  1873. ),
  1874. TP_fast_assign(
  1875. __entry->h = h;
  1876. __assign_str(name, cd->name);
  1877. ),
  1878. TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
  1879. );
  1880. #define DEFINE_CACHE_EVENT(name) \
  1881. DEFINE_EVENT(cache_event, name, \
  1882. TP_PROTO( \
  1883. const struct cache_detail *cd, \
  1884. const struct cache_head *h \
  1885. ), \
  1886. TP_ARGS(cd, h))
  1887. DEFINE_CACHE_EVENT(cache_entry_expired);
  1888. DEFINE_CACHE_EVENT(cache_entry_upcall);
  1889. DEFINE_CACHE_EVENT(cache_entry_update);
  1890. DEFINE_CACHE_EVENT(cache_entry_make_negative);
  1891. DEFINE_CACHE_EVENT(cache_entry_no_listener);
  1892. DECLARE_EVENT_CLASS(register_class,
  1893. TP_PROTO(
  1894. const char *program,
  1895. const u32 version,
  1896. const int family,
  1897. const unsigned short protocol,
  1898. const unsigned short port,
  1899. int error
  1900. ),
  1901. TP_ARGS(program, version, family, protocol, port, error),
  1902. TP_STRUCT__entry(
  1903. __field(u32, version)
  1904. __field(unsigned long, family)
  1905. __field(unsigned short, protocol)
  1906. __field(unsigned short, port)
  1907. __field(int, error)
  1908. __string(program, program)
  1909. ),
  1910. TP_fast_assign(
  1911. __entry->version = version;
  1912. __entry->family = family;
  1913. __entry->protocol = protocol;
  1914. __entry->port = port;
  1915. __entry->error = error;
  1916. __assign_str(program, program);
  1917. ),
  1918. TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
  1919. __get_str(program), __entry->version,
  1920. __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
  1921. __entry->port, rpc_show_address_family(__entry->family),
  1922. __entry->error
  1923. )
  1924. );
  1925. #define DEFINE_REGISTER_EVENT(name) \
  1926. DEFINE_EVENT(register_class, svc_##name, \
  1927. TP_PROTO( \
  1928. const char *program, \
  1929. const u32 version, \
  1930. const int family, \
  1931. const unsigned short protocol, \
  1932. const unsigned short port, \
  1933. int error \
  1934. ), \
  1935. TP_ARGS(program, version, family, protocol, \
  1936. port, error))
  1937. DEFINE_REGISTER_EVENT(register);
  1938. DEFINE_REGISTER_EVENT(noregister);
  1939. TRACE_EVENT(svc_unregister,
  1940. TP_PROTO(
  1941. const char *program,
  1942. const u32 version,
  1943. int error
  1944. ),
  1945. TP_ARGS(program, version, error),
  1946. TP_STRUCT__entry(
  1947. __field(u32, version)
  1948. __field(int, error)
  1949. __string(program, program)
  1950. ),
  1951. TP_fast_assign(
  1952. __entry->version = version;
  1953. __entry->error = error;
  1954. __assign_str(program, program);
  1955. ),
  1956. TP_printk("program=%sv%u error=%d",
  1957. __get_str(program), __entry->version, __entry->error
  1958. )
  1959. );
  1960. #endif /* _TRACE_SUNRPC_H */
  1961. #include <trace/define_trace.h>