PageRenderTime 53ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/fs/nfs/nfs4trace.h

https://bitbucket.org/alfredchen/linux-gc
C Header | 1592 lines | 1440 code | 148 blank | 4 comment | 18 complexity | b3f9860c706b02fe9156d01751d9ab44 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0 
    

  1. /*
    2. 

  2.  * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
    3. 

  3.  */
    4. 

  4. #undef TRACE_SYSTEM
    5. 

  5. #define TRACE_SYSTEM nfs4
    6. 

  6. 

  7. #if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
    8. 

  8. #define _TRACE_NFS4_H
    9. 

  9. 

  10. #include <linux/tracepoint.h>
    11. 

  11. 

  12. #define show_nfsv4_errors(error) \
    13. 

  13. 	__print_symbolic(error, \
    14. 

  14. 		{ NFS4_OK, "OK" }, \
    15. 

  15. 		/* Mapped by nfs4_stat_to_errno() */ \
    16. 

  16. 		{ -EPERM, "EPERM" }, \
    17. 

  17. 		{ -ENOENT, "ENOENT" }, \
    18. 

  18. 		{ -EIO, "EIO" }, \
    19. 

  19. 		{ -ENXIO, "ENXIO" }, \
    20. 

  20. 		{ -EACCES, "EACCES" }, \
    21. 

  21. 		{ -EEXIST, "EEXIST" }, \
    22. 

  22. 		{ -EXDEV, "EXDEV" }, \
    23. 

  23. 		{ -ENOTDIR, "ENOTDIR" }, \
    24. 

  24. 		{ -EISDIR, "EISDIR" }, \
    25. 

  25. 		{ -EFBIG, "EFBIG" }, \
    26. 

  26. 		{ -ENOSPC, "ENOSPC" }, \
    27. 

  27. 		{ -EROFS, "EROFS" }, \
    28. 

  28. 		{ -EMLINK, "EMLINK" }, \
    29. 

  29. 		{ -ENAMETOOLONG, "ENAMETOOLONG" }, \
    30. 

  30. 		{ -ENOTEMPTY, "ENOTEMPTY" }, \
    31. 

  31. 		{ -EDQUOT, "EDQUOT" }, \
    32. 

  32. 		{ -ESTALE, "ESTALE" }, \
    33. 

  33. 		{ -EBADHANDLE, "EBADHANDLE" }, \
    34. 

  34. 		{ -EBADCOOKIE, "EBADCOOKIE" }, \
    35. 

  35. 		{ -ENOTSUPP, "ENOTSUPP" }, \
    36. 

  36. 		{ -ETOOSMALL, "ETOOSMALL" }, \
    37. 

  37. 		{ -EREMOTEIO, "EREMOTEIO" }, \
    38. 

  38. 		{ -EBADTYPE, "EBADTYPE" }, \
    39. 

  39. 		{ -EAGAIN, "EAGAIN" }, \
    40. 

  40. 		{ -ELOOP, "ELOOP" }, \
    41. 

  41. 		{ -EOPNOTSUPP, "EOPNOTSUPP" }, \
    42. 

  42. 		{ -EDEADLK, "EDEADLK" }, \
    43. 

  43. 		/* RPC errors */ \
    44. 

  44. 		{ -ENOMEM, "ENOMEM" }, \
    45. 

  45. 		{ -EKEYEXPIRED, "EKEYEXPIRED" }, \
    46. 

  46. 		{ -ETIMEDOUT, "ETIMEDOUT" }, \
    47. 

  47. 		{ -ERESTARTSYS, "ERESTARTSYS" }, \
    48. 

  48. 		{ -ECONNREFUSED, "ECONNREFUSED" }, \
    49. 

  49. 		{ -ECONNRESET, "ECONNRESET" }, \
    50. 

  50. 		{ -ENETUNREACH, "ENETUNREACH" }, \
    51. 

  51. 		{ -EHOSTUNREACH, "EHOSTUNREACH" }, \
    52. 

  52. 		{ -EHOSTDOWN, "EHOSTDOWN" }, \
    53. 

  53. 		{ -EPIPE, "EPIPE" }, \
    54. 

  54. 		{ -EPFNOSUPPORT, "EPFNOSUPPORT" }, \
    55. 

  55. 		{ -EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
    56. 

  56. 		/* NFSv4 native errors */ \
    57. 

  57. 		{ -NFS4ERR_ACCESS, "ACCESS" }, \
    58. 

  58. 		{ -NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
    59. 

  59. 		{ -NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
    60. 

  60. 		{ -NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
    61. 

  61. 		{ -NFS4ERR_BADCHAR, "BADCHAR" }, \
    62. 

  62. 		{ -NFS4ERR_BADHANDLE, "BADHANDLE" }, \
    63. 

  63. 		{ -NFS4ERR_BADIOMODE, "BADIOMODE" }, \
    64. 

  64. 		{ -NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
    65. 

  65. 		{ -NFS4ERR_BADLABEL, "BADLABEL" }, \
    66. 

  66. 		{ -NFS4ERR_BADNAME, "BADNAME" }, \
    67. 

  67. 		{ -NFS4ERR_BADOWNER, "BADOWNER" }, \
    68. 

  68. 		{ -NFS4ERR_BADSESSION, "BADSESSION" }, \
    69. 

  69. 		{ -NFS4ERR_BADSLOT, "BADSLOT" }, \
    70. 

  70. 		{ -NFS4ERR_BADTYPE, "BADTYPE" }, \
    71. 

  71. 		{ -NFS4ERR_BADXDR, "BADXDR" }, \
    72. 

  72. 		{ -NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
    73. 

  73. 		{ -NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
    74. 

  74. 		{ -NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
    75. 

  75. 		{ -NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
    76. 

  76. 		{ -NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
    77. 

  77. 		{ -NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
    78. 

  78. 		{ -NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
    79. 

  79. 		{ -NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
    80. 

  80. 		{ -NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
    81. 

  81. 		{ -NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
    82. 

  82. 		{ -NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
    83. 

  83. 			"CONN_NOT_BOUND_TO_SESSION" }, \
    84. 

  84. 		{ -NFS4ERR_DEADLOCK, "DEADLOCK" }, \
    85. 

  85. 		{ -NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
    86. 

  86. 		{ -NFS4ERR_DELAY, "DELAY" }, \
    87. 

  87. 		{ -NFS4ERR_DELEG_ALREADY_WANTED, \
    88. 

  88. 			"DELEG_ALREADY_WANTED" }, \
    89. 

  89. 		{ -NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
    90. 

  90. 		{ -NFS4ERR_DENIED, "DENIED" }, \
    91. 

  91. 		{ -NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
    92. 

  92. 		{ -NFS4ERR_DQUOT, "DQUOT" }, \
    93. 

  93. 		{ -NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
    94. 

  94. 		{ -NFS4ERR_EXIST, "EXIST" }, \
    95. 

  95. 		{ -NFS4ERR_EXPIRED, "EXPIRED" }, \
    96. 

  96. 		{ -NFS4ERR_FBIG, "FBIG" }, \
    97. 

  97. 		{ -NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
    98. 

  98. 		{ -NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
    99. 

  99. 		{ -NFS4ERR_GRACE, "GRACE" }, \
    100. 

  100. 		{ -NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
    101. 

  101. 		{ -NFS4ERR_INVAL, "INVAL" }, \
    102. 

  102. 		{ -NFS4ERR_IO, "IO" }, \
    103. 

  103. 		{ -NFS4ERR_ISDIR, "ISDIR" }, \
    104. 

  104. 		{ -NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
    105. 

  105. 		{ -NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
    106. 

  106. 		{ -NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
    107. 

  107. 		{ -NFS4ERR_LOCKED, "LOCKED" }, \
    108. 

  108. 		{ -NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
    109. 

  109. 		{ -NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
    110. 

  110. 		{ -NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
    111. 

  111. 		{ -NFS4ERR_MLINK, "MLINK" }, \
    112. 

  112. 		{ -NFS4ERR_MOVED, "MOVED" }, \
    113. 

  113. 		{ -NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
    114. 

  114. 		{ -NFS4ERR_NOENT, "NOENT" }, \
    115. 

  115. 		{ -NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
    116. 

  116. 		{ -NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
    117. 

  117. 		{ -NFS4ERR_NOSPC, "NOSPC" }, \
    118. 

  118. 		{ -NFS4ERR_NOTDIR, "NOTDIR" }, \
    119. 

  119. 		{ -NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
    120. 

  120. 		{ -NFS4ERR_NOTSUPP, "NOTSUPP" }, \
    121. 

  121. 		{ -NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
    122. 

  122. 		{ -NFS4ERR_NOT_SAME, "NOT_SAME" }, \
    123. 

  123. 		{ -NFS4ERR_NO_GRACE, "NO_GRACE" }, \
    124. 

  124. 		{ -NFS4ERR_NXIO, "NXIO" }, \
    125. 

  125. 		{ -NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
    126. 

  126. 		{ -NFS4ERR_OPENMODE, "OPENMODE" }, \
    127. 

  127. 		{ -NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
    128. 

  128. 		{ -NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
    129. 

  129. 		{ -NFS4ERR_PERM, "PERM" }, \
    130. 

  130. 		{ -NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
    131. 

  131. 		{ -NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
    132. 

  132. 		{ -NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
    133. 

  133. 		{ -NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
    134. 

  134. 		{ -NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
    135. 

  135. 		{ -NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
    136. 

  136. 		{ -NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
    137. 

  137. 		{ -NFS4ERR_REP_TOO_BIG_TO_CACHE, \
    138. 

  138. 			"REP_TOO_BIG_TO_CACHE" }, \
    139. 

  139. 		{ -NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
    140. 

  140. 		{ -NFS4ERR_RESOURCE, "RESOURCE" }, \
    141. 

  141. 		{ -NFS4ERR_RESTOREFH, "RESTOREFH" }, \
    142. 

  142. 		{ -NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
    143. 

  143. 		{ -NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
    144. 

  144. 		{ -NFS4ERR_ROFS, "ROFS" }, \
    145. 

  145. 		{ -NFS4ERR_SAME, "SAME" }, \
    146. 

  146. 		{ -NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
    147. 

  147. 		{ -NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
    148. 

  148. 		{ -NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
    149. 

  149. 		{ -NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
    150. 

  150. 		{ -NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
    151. 

  151. 		{ -NFS4ERR_STALE, "STALE" }, \
    152. 

  152. 		{ -NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
    153. 

  153. 		{ -NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
    154. 

  154. 		{ -NFS4ERR_SYMLINK, "SYMLINK" }, \
    155. 

  155. 		{ -NFS4ERR_TOOSMALL, "TOOSMALL" }, \
    156. 

  156. 		{ -NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
    157. 

  157. 		{ -NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
    158. 

  158. 		{ -NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
    159. 

  159. 		{ -NFS4ERR_WRONGSEC, "WRONGSEC" }, \
    160. 

  160. 		{ -NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
    161. 

  161. 		{ -NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
    162. 

  162. 		{ -NFS4ERR_XDEV, "XDEV" })
    163. 

  163. 

  164. #define show_open_flags(flags) \
    165. 

  165. 	__print_flags(flags, "|", \
    166. 

  166. 		{ O_CREAT, "O_CREAT" }, \
    167. 

  167. 		{ O_EXCL, "O_EXCL" }, \
    168. 

  168. 		{ O_TRUNC, "O_TRUNC" }, \
    169. 

  169. 		{ O_DIRECT, "O_DIRECT" })
    170. 

  170. 

  171. #define show_fmode_flags(mode) \
    172. 

  172. 	__print_flags(mode, "|", \
    173. 

  173. 		{ ((__force unsigned long)FMODE_READ), "READ" }, \
    174. 

  174. 		{ ((__force unsigned long)FMODE_WRITE), "WRITE" }, \
    175. 

  175. 		{ ((__force unsigned long)FMODE_EXEC), "EXEC" })
    176. 

  176. 

  177. #define show_nfs_fattr_flags(valid) \
    178. 

  178. 	__print_flags((unsigned long)valid, "|", \
    179. 

  179. 		{ NFS_ATTR_FATTR_TYPE, "TYPE" }, \
    180. 

  180. 		{ NFS_ATTR_FATTR_MODE, "MODE" }, \
    181. 

  181. 		{ NFS_ATTR_FATTR_NLINK, "NLINK" }, \
    182. 

  182. 		{ NFS_ATTR_FATTR_OWNER, "OWNER" }, \
    183. 

  183. 		{ NFS_ATTR_FATTR_GROUP, "GROUP" }, \
    184. 

  184. 		{ NFS_ATTR_FATTR_RDEV, "RDEV" }, \
    185. 

  185. 		{ NFS_ATTR_FATTR_SIZE, "SIZE" }, \
    186. 

  186. 		{ NFS_ATTR_FATTR_FSID, "FSID" }, \
    187. 

  187. 		{ NFS_ATTR_FATTR_FILEID, "FILEID" }, \
    188. 

  188. 		{ NFS_ATTR_FATTR_ATIME, "ATIME" }, \
    189. 

  189. 		{ NFS_ATTR_FATTR_MTIME, "MTIME" }, \
    190. 

  190. 		{ NFS_ATTR_FATTR_CTIME, "CTIME" }, \
    191. 

  191. 		{ NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
    192. 

  192. 		{ NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
    193. 

  193. 		{ NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" })
    194. 

  194. 

  195. DECLARE_EVENT_CLASS(nfs4_clientid_event,
    196. 

  196. 		TP_PROTO(
    197. 

  197. 			const struct nfs_client *clp,
    198. 

  198. 			int error
    199. 

  199. 		),
    200. 

  200. 

  201. 		TP_ARGS(clp, error),
    202. 

  202. 

  203. 		TP_STRUCT__entry(
    204. 

  204. 			__string(dstaddr,
    205. 

  205. 				rpc_peeraddr2str(clp->cl_rpcclient,
    206. 

  206. 					RPC_DISPLAY_ADDR))
    207. 

  207. 			__field(int, error)
    208. 

  208. 		),
    209. 

  209. 

  210. 		TP_fast_assign(
    211. 

  211. 			__entry->error = error;
    212. 

  212. 			__assign_str(dstaddr,
    213. 

  213. 				rpc_peeraddr2str(clp->cl_rpcclient,
    214. 

  214. 						RPC_DISPLAY_ADDR));
    215. 

  215. 		),
    216. 

  216. 

  217. 		TP_printk(
    218. 

  218. 			"error=%d (%s) dstaddr=%s",
    219. 

  219. 			__entry->error,
    220. 

  220. 			show_nfsv4_errors(__entry->error),
    221. 

  221. 			__get_str(dstaddr)
    222. 

  222. 		)
    223. 

  223. );
    224. 

  224. #define DEFINE_NFS4_CLIENTID_EVENT(name) \
    225. 

  225. 	DEFINE_EVENT(nfs4_clientid_event, name,	 \
    226. 

  226. 			TP_PROTO( \
    227. 

  227. 				const struct nfs_client *clp, \
    228. 

  228. 				int error \
    229. 

  229. 			), \
    230. 

  230. 			TP_ARGS(clp, error))
    231. 

  231. DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
    232. 

  232. DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
    233. 

  233. DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew);
    234. 

  234. DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async);
    235. 

  235. #ifdef CONFIG_NFS_V4_1
    236. 

  236. DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
    237. 

  237. DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
    238. 

  238. DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
    239. 

  239. DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
    240. 

  240. DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
    241. 

  241. DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence);
    242. 

  242. DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete);
    243. 

  243. 

  244. #define show_nfs4_sequence_status_flags(status) \
    245. 

  245. 	__print_flags((unsigned long)status, "|", \
    246. 

  246. 		{ SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
    247. 

  247. 		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \
    248. 

  248. 			"CB_GSS_CONTEXTS_EXPIRING" }, \
    249. 

  249. 		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \
    250. 

  250. 			"CB_GSS_CONTEXTS_EXPIRED" }, \
    251. 

  251. 		{ SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \
    252. 

  252. 			"EXPIRED_ALL_STATE_REVOKED" }, \
    253. 

  253. 		{ SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \
    254. 

  254. 			"EXPIRED_SOME_STATE_REVOKED" }, \
    255. 

  255. 		{ SEQ4_STATUS_ADMIN_STATE_REVOKED, \
    256. 

  256. 			"ADMIN_STATE_REVOKED" }, \
    257. 

  257. 		{ SEQ4_STATUS_RECALLABLE_STATE_REVOKED,	 \
    258. 

  258. 			"RECALLABLE_STATE_REVOKED" }, \
    259. 

  259. 		{ SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \
    260. 

  260. 		{ SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \
    261. 

  261. 			"RESTART_RECLAIM_NEEDED" }, \
    262. 

  262. 		{ SEQ4_STATUS_CB_PATH_DOWN_SESSION, \
    263. 

  263. 			"CB_PATH_DOWN_SESSION" }, \
    264. 

  264. 		{ SEQ4_STATUS_BACKCHANNEL_FAULT, \
    265. 

  265. 			"BACKCHANNEL_FAULT" })
    266. 

  266. 

  267. TRACE_EVENT(nfs4_sequence_done,
    268. 

  268. 		TP_PROTO(
    269. 

  269. 			const struct nfs4_session *session,
    270. 

  270. 			const struct nfs4_sequence_res *res
    271. 

  271. 		),
    272. 

  272. 		TP_ARGS(session, res),
    273. 

  273. 

  274. 		TP_STRUCT__entry(
    275. 

  275. 			__field(unsigned int, session)
    276. 

  276. 			__field(unsigned int, slot_nr)
    277. 

  277. 			__field(unsigned int, seq_nr)
    278. 

  278. 			__field(unsigned int, highest_slotid)
    279. 

  279. 			__field(unsigned int, target_highest_slotid)
    280. 

  280. 			__field(unsigned int, status_flags)
    281. 

  281. 			__field(int, error)
    282. 

  282. 		),
    283. 

  283. 

  284. 		TP_fast_assign(
    285. 

  285. 			const struct nfs4_slot *sr_slot = res->sr_slot;
    286. 

  286. 			__entry->session = nfs_session_id_hash(&session->sess_id);
    287. 

  287. 			__entry->slot_nr = sr_slot->slot_nr;
    288. 

  288. 			__entry->seq_nr = sr_slot->seq_nr;
    289. 

  289. 			__entry->highest_slotid = res->sr_highest_slotid;
    290. 

  290. 			__entry->target_highest_slotid =
    291. 

  291. 					res->sr_target_highest_slotid;
    292. 

  292. 			__entry->status_flags = res->sr_status_flags;
    293. 

  293. 			__entry->error = res->sr_status;
    294. 

  294. 		),
    295. 

  295. 		TP_printk(
    296. 

  296. 			"error=%d (%s) session=0x%08x slot_nr=%u seq_nr=%u "
    297. 

  297. 			"highest_slotid=%u target_highest_slotid=%u "
    298. 

  298. 			"status_flags=%u (%s)",
    299. 

  299. 			__entry->error,
    300. 

  300. 			show_nfsv4_errors(__entry->error),
    301. 

  301. 			__entry->session,
    302. 

  302. 			__entry->slot_nr,
    303. 

  303. 			__entry->seq_nr,
    304. 

  304. 			__entry->highest_slotid,
    305. 

  305. 			__entry->target_highest_slotid,
    306. 

  306. 			__entry->status_flags,
    307. 

  307. 			show_nfs4_sequence_status_flags(__entry->status_flags)
    308. 

  308. 		)
    309. 

  309. );
    310. 

  310. 

  311. struct cb_sequenceargs;
    312. 

  312. struct cb_sequenceres;
    313. 

  313. 

  314. TRACE_EVENT(nfs4_cb_sequence,
    315. 

  315. 		TP_PROTO(
    316. 

  316. 			const struct cb_sequenceargs *args,
    317. 

  317. 			const struct cb_sequenceres *res,
    318. 

  318. 			__be32 status
    319. 

  319. 		),
    320. 

  320. 		TP_ARGS(args, res, status),
    321. 

  321. 

  322. 		TP_STRUCT__entry(
    323. 

  323. 			__field(unsigned int, session)
    324. 

  324. 			__field(unsigned int, slot_nr)
    325. 

  325. 			__field(unsigned int, seq_nr)
    326. 

  326. 			__field(unsigned int, highest_slotid)
    327. 

  327. 			__field(unsigned int, cachethis)
    328. 

  328. 			__field(int, error)
    329. 

  329. 		),
    330. 

  330. 

  331. 		TP_fast_assign(
    332. 

  332. 			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
    333. 

  333. 			__entry->slot_nr = args->csa_slotid;
    334. 

  334. 			__entry->seq_nr = args->csa_sequenceid;
    335. 

  335. 			__entry->highest_slotid = args->csa_highestslotid;
    336. 

  336. 			__entry->cachethis = args->csa_cachethis;
    337. 

  337. 			__entry->error = -be32_to_cpu(status);
    338. 

  338. 		),
    339. 

  339. 

  340. 		TP_printk(
    341. 

  341. 			"error=%d (%s) session=0x%08x slot_nr=%u seq_nr=%u "
    342. 

  342. 			"highest_slotid=%u",
    343. 

  343. 			__entry->error,
    344. 

  344. 			show_nfsv4_errors(__entry->error),
    345. 

  345. 			__entry->session,
    346. 

  346. 			__entry->slot_nr,
    347. 

  347. 			__entry->seq_nr,
    348. 

  348. 			__entry->highest_slotid
    349. 

  349. 		)
    350. 

  350. );
    351. 

  351. #endif /* CONFIG_NFS_V4_1 */
    352. 

  352. 

  353. TRACE_EVENT(nfs4_setup_sequence,
    354. 

  354. 		TP_PROTO(
    355. 

  355. 			const struct nfs4_session *session,
    356. 

  356. 			const struct nfs4_sequence_args *args
    357. 

  357. 		),
    358. 

  358. 		TP_ARGS(session, args),
    359. 

  359. 

  360. 		TP_STRUCT__entry(
    361. 

  361. 			__field(unsigned int, session)
    362. 

  362. 			__field(unsigned int, slot_nr)
    363. 

  363. 			__field(unsigned int, seq_nr)
    364. 

  364. 			__field(unsigned int, highest_used_slotid)
    365. 

  365. 		),
    366. 

  366. 

  367. 		TP_fast_assign(
    368. 

  368. 			const struct nfs4_slot *sa_slot = args->sa_slot;
    369. 

  369. 			__entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0;
    370. 

  370. 			__entry->slot_nr = sa_slot->slot_nr;
    371. 

  371. 			__entry->seq_nr = sa_slot->seq_nr;
    372. 

  372. 			__entry->highest_used_slotid =
    373. 

  373. 					sa_slot->table->highest_used_slotid;
    374. 

  374. 		),
    375. 

  375. 		TP_printk(
    376. 

  376. 			"session=0x%08x slot_nr=%u seq_nr=%u "
    377. 

  377. 			"highest_used_slotid=%u",
    378. 

  378. 			__entry->session,
    379. 

  379. 			__entry->slot_nr,
    380. 

  380. 			__entry->seq_nr,
    381. 

  381. 			__entry->highest_used_slotid
    382. 

  382. 		)
    383. 

  383. );
    384. 

  384. 

  385. DECLARE_EVENT_CLASS(nfs4_open_event,
    386. 

  386. 		TP_PROTO(
    387. 

  387. 			const struct nfs_open_context *ctx,
    388. 

  388. 			int flags,
    389. 

  389. 			int error
    390. 

  390. 		),
    391. 

  391. 

  392. 		TP_ARGS(ctx, flags, error),
    393. 

  393. 

  394. 		TP_STRUCT__entry(
    395. 

  395. 			__field(int, error)
    396. 

  396. 			__field(unsigned int, flags)
    397. 

  397. 			__field(unsigned int, fmode)
    398. 

  398. 			__field(dev_t, dev)
    399. 

  399. 			__field(u32, fhandle)
    400. 

  400. 			__field(u64, fileid)
    401. 

  401. 			__field(u64, dir)
    402. 

  402. 			__string(name, ctx->dentry->d_name.name)
    403. 

  403. 			__field(int, stateid_seq)
    404. 

  404. 			__field(u32, stateid_hash)
    405. 

  405. 			__field(int, openstateid_seq)
    406. 

  406. 			__field(u32, openstateid_hash)
    407. 

  407. 		),
    408. 

  408. 

  409. 		TP_fast_assign(
    410. 

  410. 			const struct nfs4_state *state = ctx->state;
    411. 

  411. 			const struct inode *inode = NULL;
    412. 

  412. 

  413. 			__entry->error = error;
    414. 

  414. 			__entry->flags = flags;
    415. 

  415. 			__entry->fmode = (__force unsigned int)ctx->mode;
    416. 

  416. 			__entry->dev = ctx->dentry->d_sb->s_dev;
    417. 

  417. 			if (!IS_ERR_OR_NULL(state)) {
    418. 

  418. 				inode = state->inode;
    419. 

  419. 				__entry->stateid_seq =
    420. 

  420. 					be32_to_cpu(state->stateid.seqid);
    421. 

  421. 				__entry->stateid_hash =
    422. 

  422. 					nfs_stateid_hash(&state->stateid);
    423. 

  423. 				__entry->openstateid_seq =
    424. 

  424. 					be32_to_cpu(state->open_stateid.seqid);
    425. 

  425. 				__entry->openstateid_hash =
    426. 

  426. 					nfs_stateid_hash(&state->open_stateid);
    427. 

  427. 			} else {
    428. 

  428. 				__entry->stateid_seq = 0;
    429. 

  429. 				__entry->stateid_hash = 0;
    430. 

  430. 				__entry->openstateid_seq = 0;
    431. 

  431. 				__entry->openstateid_hash = 0;
    432. 

  432. 			}
    433. 

  433. 			if (inode != NULL) {
    434. 

  434. 				__entry->fileid = NFS_FILEID(inode);
    435. 

  435. 				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    436. 

  436. 			} else {
    437. 

  437. 				__entry->fileid = 0;
    438. 

  438. 				__entry->fhandle = 0;
    439. 

  439. 			}
    440. 

  440. 			__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
    441. 

  441. 			__assign_str(name, ctx->dentry->d_name.name);
    442. 

  442. 		),
    443. 

  443. 

  444. 		TP_printk(
    445. 

  445. 			"error=%d (%s) flags=%d (%s) fmode=%s "
    446. 

  446. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    447. 

  447. 			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
    448. 

  448. 			"openstateid=%d:0x%08x",
    449. 

  449. 			 __entry->error,
    450. 

  450. 			 show_nfsv4_errors(__entry->error),
    451. 

  451. 			 __entry->flags,
    452. 

  452. 			 show_open_flags(__entry->flags),
    453. 

  453. 			 show_fmode_flags(__entry->fmode),
    454. 

  454. 			 MAJOR(__entry->dev), MINOR(__entry->dev),
    455. 

  455. 			 (unsigned long long)__entry->fileid,
    456. 

  456. 			 __entry->fhandle,
    457. 

  457. 			 MAJOR(__entry->dev), MINOR(__entry->dev),
    458. 

  458. 			 (unsigned long long)__entry->dir,
    459. 

  459. 			 __get_str(name),
    460. 

  460. 			 __entry->stateid_seq, __entry->stateid_hash,
    461. 

  461. 			 __entry->openstateid_seq, __entry->openstateid_hash
    462. 

  462. 		)
    463. 

  463. );
    464. 

  464. 

  465. #define DEFINE_NFS4_OPEN_EVENT(name) \
    466. 

  466. 	DEFINE_EVENT(nfs4_open_event, name, \
    467. 

  467. 			TP_PROTO( \
    468. 

  468. 				const struct nfs_open_context *ctx, \
    469. 

  469. 				int flags, \
    470. 

  470. 				int error \
    471. 

  471. 			), \
    472. 

  472. 			TP_ARGS(ctx, flags, error))
    473. 

  473. DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
    474. 

  474. DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
    475. 

  475. DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
    476. 

  476. 

  477. TRACE_EVENT(nfs4_cached_open,
    478. 

  478. 		TP_PROTO(
    479. 

  479. 			const struct nfs4_state *state
    480. 

  480. 		),
    481. 

  481. 		TP_ARGS(state),
    482. 

  482. 		TP_STRUCT__entry(
    483. 

  483. 			__field(dev_t, dev)
    484. 

  484. 			__field(u32, fhandle)
    485. 

  485. 			__field(u64, fileid)
    486. 

  486. 			__field(unsigned int, fmode)
    487. 

  487. 			__field(int, stateid_seq)
    488. 

  488. 			__field(u32, stateid_hash)
    489. 

  489. 		),
    490. 

  490. 

  491. 		TP_fast_assign(
    492. 

  492. 			const struct inode *inode = state->inode;
    493. 

  493. 

  494. 			__entry->dev = inode->i_sb->s_dev;
    495. 

  495. 			__entry->fileid = NFS_FILEID(inode);
    496. 

  496. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    497. 

  497. 			__entry->fmode = (__force unsigned int)state->state;
    498. 

  498. 			__entry->stateid_seq =
    499. 

  499. 				be32_to_cpu(state->stateid.seqid);
    500. 

  500. 			__entry->stateid_hash =
    501. 

  501. 				nfs_stateid_hash(&state->stateid);
    502. 

  502. 		),
    503. 

  503. 

  504. 		TP_printk(
    505. 

  505. 			"fmode=%s fileid=%02x:%02x:%llu "
    506. 

  506. 			"fhandle=0x%08x stateid=%d:0x%08x",
    507. 

  507. 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
    508. 

  508. 					  "closed",
    509. 

  509. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    510. 

  510. 			(unsigned long long)__entry->fileid,
    511. 

  511. 			__entry->fhandle,
    512. 

  512. 			__entry->stateid_seq, __entry->stateid_hash
    513. 

  513. 		)
    514. 

  514. );
    515. 

  515. 

  516. TRACE_EVENT(nfs4_close,
    517. 

  517. 		TP_PROTO(
    518. 

  518. 			const struct nfs4_state *state,
    519. 

  519. 			const struct nfs_closeargs *args,
    520. 

  520. 			const struct nfs_closeres *res,
    521. 

  521. 			int error
    522. 

  522. 		),
    523. 

  523. 

  524. 		TP_ARGS(state, args, res, error),
    525. 

  525. 

  526. 		TP_STRUCT__entry(
    527. 

  527. 			__field(dev_t, dev)
    528. 

  528. 			__field(u32, fhandle)
    529. 

  529. 			__field(u64, fileid)
    530. 

  530. 			__field(unsigned int, fmode)
    531. 

  531. 			__field(int, error)
    532. 

  532. 			__field(int, stateid_seq)
    533. 

  533. 			__field(u32, stateid_hash)
    534. 

  534. 		),
    535. 

  535. 

  536. 		TP_fast_assign(
    537. 

  537. 			const struct inode *inode = state->inode;
    538. 

  538. 

  539. 			__entry->dev = inode->i_sb->s_dev;
    540. 

  540. 			__entry->fileid = NFS_FILEID(inode);
    541. 

  541. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    542. 

  542. 			__entry->fmode = (__force unsigned int)state->state;
    543. 

  543. 			__entry->error = error;
    544. 

  544. 			__entry->stateid_seq =
    545. 

  545. 				be32_to_cpu(args->stateid.seqid);
    546. 

  546. 			__entry->stateid_hash =
    547. 

  547. 				nfs_stateid_hash(&args->stateid);
    548. 

  548. 		),
    549. 

  549. 

  550. 		TP_printk(
    551. 

  551. 			"error=%d (%s) fmode=%s fileid=%02x:%02x:%llu "
    552. 

  552. 			"fhandle=0x%08x openstateid=%d:0x%08x",
    553. 

  553. 			__entry->error,
    554. 

  554. 			show_nfsv4_errors(__entry->error),
    555. 

  555. 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
    556. 

  556. 					  "closed",
    557. 

  557. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    558. 

  558. 			(unsigned long long)__entry->fileid,
    559. 

  559. 			__entry->fhandle,
    560. 

  560. 			__entry->stateid_seq, __entry->stateid_hash
    561. 

  561. 		)
    562. 

  562. );
    563. 

  563. 

  564. #define show_lock_cmd(type) \
    565. 

  565. 	__print_symbolic((int)type, \
    566. 

  566. 		{ F_GETLK, "GETLK" }, \
    567. 

  567. 		{ F_SETLK, "SETLK" }, \
    568. 

  568. 		{ F_SETLKW, "SETLKW" })
    569. 

  569. #define show_lock_type(type) \
    570. 

  570. 	__print_symbolic((int)type, \
    571. 

  571. 		{ F_RDLCK, "RDLCK" }, \
    572. 

  572. 		{ F_WRLCK, "WRLCK" }, \
    573. 

  573. 		{ F_UNLCK, "UNLCK" })
    574. 

  574. 

  575. DECLARE_EVENT_CLASS(nfs4_lock_event,
    576. 

  576. 		TP_PROTO(
    577. 

  577. 			const struct file_lock *request,
    578. 

  578. 			const struct nfs4_state *state,
    579. 

  579. 			int cmd,
    580. 

  580. 			int error
    581. 

  581. 		),
    582. 

  582. 

  583. 		TP_ARGS(request, state, cmd, error),
    584. 

  584. 

  585. 		TP_STRUCT__entry(
    586. 

  586. 			__field(int, error)
    587. 

  587. 			__field(int, cmd)
    588. 

  588. 			__field(char, type)
    589. 

  589. 			__field(loff_t, start)
    590. 

  590. 			__field(loff_t, end)
    591. 

  591. 			__field(dev_t, dev)
    592. 

  592. 			__field(u32, fhandle)
    593. 

  593. 			__field(u64, fileid)
    594. 

  594. 			__field(int, stateid_seq)
    595. 

  595. 			__field(u32, stateid_hash)
    596. 

  596. 		),
    597. 

  597. 

  598. 		TP_fast_assign(
    599. 

  599. 			const struct inode *inode = state->inode;
    600. 

  600. 

  601. 			__entry->error = error;
    602. 

  602. 			__entry->cmd = cmd;
    603. 

  603. 			__entry->type = request->fl_type;
    604. 

  604. 			__entry->start = request->fl_start;
    605. 

  605. 			__entry->end = request->fl_end;
    606. 

  606. 			__entry->dev = inode->i_sb->s_dev;
    607. 

  607. 			__entry->fileid = NFS_FILEID(inode);
    608. 

  608. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    609. 

  609. 			__entry->stateid_seq =
    610. 

  610. 				be32_to_cpu(state->stateid.seqid);
    611. 

  611. 			__entry->stateid_hash =
    612. 

  612. 				nfs_stateid_hash(&state->stateid);
    613. 

  613. 		),
    614. 

  614. 

  615. 		TP_printk(
    616. 

  616. 			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
    617. 

  617. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    618. 

  618. 			"stateid=%d:0x%08x",
    619. 

  619. 			__entry->error,
    620. 

  620. 			show_nfsv4_errors(__entry->error),
    621. 

  621. 			show_lock_cmd(__entry->cmd),
    622. 

  622. 			show_lock_type(__entry->type),
    623. 

  623. 			(long long)__entry->start,
    624. 

  624. 			(long long)__entry->end,
    625. 

  625. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    626. 

  626. 			(unsigned long long)__entry->fileid,
    627. 

  627. 			__entry->fhandle,
    628. 

  628. 			__entry->stateid_seq, __entry->stateid_hash
    629. 

  629. 		)
    630. 

  630. );
    631. 

  631. 

  632. #define DEFINE_NFS4_LOCK_EVENT(name) \
    633. 

  633. 	DEFINE_EVENT(nfs4_lock_event, name, \
    634. 

  634. 			TP_PROTO( \
    635. 

  635. 				const struct file_lock *request, \
    636. 

  636. 				const struct nfs4_state *state, \
    637. 

  637. 				int cmd, \
    638. 

  638. 				int error \
    639. 

  639. 			), \
    640. 

  640. 			TP_ARGS(request, state, cmd, error))
    641. 

  641. DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
    642. 

  642. DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
    643. 

  643. 

  644. TRACE_EVENT(nfs4_set_lock,
    645. 

  645. 		TP_PROTO(
    646. 

  646. 			const struct file_lock *request,
    647. 

  647. 			const struct nfs4_state *state,
    648. 

  648. 			const nfs4_stateid *lockstateid,
    649. 

  649. 			int cmd,
    650. 

  650. 			int error
    651. 

  651. 		),
    652. 

  652. 

  653. 		TP_ARGS(request, state, lockstateid, cmd, error),
    654. 

  654. 

  655. 		TP_STRUCT__entry(
    656. 

  656. 			__field(int, error)
    657. 

  657. 			__field(int, cmd)
    658. 

  658. 			__field(char, type)
    659. 

  659. 			__field(loff_t, start)
    660. 

  660. 			__field(loff_t, end)
    661. 

  661. 			__field(dev_t, dev)
    662. 

  662. 			__field(u32, fhandle)
    663. 

  663. 			__field(u64, fileid)
    664. 

  664. 			__field(int, stateid_seq)
    665. 

  665. 			__field(u32, stateid_hash)
    666. 

  666. 			__field(int, lockstateid_seq)
    667. 

  667. 			__field(u32, lockstateid_hash)
    668. 

  668. 		),
    669. 

  669. 

  670. 		TP_fast_assign(
    671. 

  671. 			const struct inode *inode = state->inode;
    672. 

  672. 

  673. 			__entry->error = error;
    674. 

  674. 			__entry->cmd = cmd;
    675. 

  675. 			__entry->type = request->fl_type;
    676. 

  676. 			__entry->start = request->fl_start;
    677. 

  677. 			__entry->end = request->fl_end;
    678. 

  678. 			__entry->dev = inode->i_sb->s_dev;
    679. 

  679. 			__entry->fileid = NFS_FILEID(inode);
    680. 

  680. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    681. 

  681. 			__entry->stateid_seq =
    682. 

  682. 				be32_to_cpu(state->stateid.seqid);
    683. 

  683. 			__entry->stateid_hash =
    684. 

  684. 				nfs_stateid_hash(&state->stateid);
    685. 

  685. 			__entry->lockstateid_seq =
    686. 

  686. 				be32_to_cpu(lockstateid->seqid);
    687. 

  687. 			__entry->lockstateid_hash =
    688. 

  688. 				nfs_stateid_hash(lockstateid);
    689. 

  689. 		),
    690. 

  690. 

  691. 		TP_printk(
    692. 

  692. 			"error=%d (%s) cmd=%s:%s range=%lld:%lld "
    693. 

  693. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    694. 

  694. 			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
    695. 

  695. 			__entry->error,
    696. 

  696. 			show_nfsv4_errors(__entry->error),
    697. 

  697. 			show_lock_cmd(__entry->cmd),
    698. 

  698. 			show_lock_type(__entry->type),
    699. 

  699. 			(long long)__entry->start,
    700. 

  700. 			(long long)__entry->end,
    701. 

  701. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    702. 

  702. 			(unsigned long long)__entry->fileid,
    703. 

  703. 			__entry->fhandle,
    704. 

  704. 			__entry->stateid_seq, __entry->stateid_hash,
    705. 

  705. 			__entry->lockstateid_seq, __entry->lockstateid_hash
    706. 

  706. 		)
    707. 

  707. );
    708. 

  708. 

  709. DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
    710. 

  710. 		TP_PROTO(
    711. 

  711. 			const struct inode *inode,
    712. 

  712. 			fmode_t fmode
    713. 

  713. 		),
    714. 

  714. 

  715. 		TP_ARGS(inode, fmode),
    716. 

  716. 

  717. 		TP_STRUCT__entry(
    718. 

  718. 			__field(dev_t, dev)
    719. 

  719. 			__field(u32, fhandle)
    720. 

  720. 			__field(u64, fileid)
    721. 

  721. 			__field(unsigned int, fmode)
    722. 

  722. 		),
    723. 

  723. 

  724. 		TP_fast_assign(
    725. 

  725. 			__entry->dev = inode->i_sb->s_dev;
    726. 

  726. 			__entry->fileid = NFS_FILEID(inode);
    727. 

  727. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    728. 

  728. 			__entry->fmode = (__force unsigned int)fmode;
    729. 

  729. 		),
    730. 

  730. 

  731. 		TP_printk(
    732. 

  732. 			"fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
    733. 

  733. 			show_fmode_flags(__entry->fmode),
    734. 

  734. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    735. 

  735. 			(unsigned long long)__entry->fileid,
    736. 

  736. 			__entry->fhandle
    737. 

  737. 		)
    738. 

  738. );
    739. 

  739. #define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
    740. 

  740. 	DEFINE_EVENT(nfs4_set_delegation_event, name, \
    741. 

  741. 			TP_PROTO( \
    742. 

  742. 				const struct inode *inode, \
    743. 

  743. 				fmode_t fmode \
    744. 

  744. 			), \
    745. 

  745. 			TP_ARGS(inode, fmode))
    746. 

  746. DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
    747. 

  747. DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
    748. 

  748. 

  749. TRACE_EVENT(nfs4_delegreturn_exit,
    750. 

  750. 		TP_PROTO(
    751. 

  751. 			const struct nfs4_delegreturnargs *args,
    752. 

  752. 			const struct nfs4_delegreturnres *res,
    753. 

  753. 			int error
    754. 

  754. 		),
    755. 

  755. 

  756. 		TP_ARGS(args, res, error),
    757. 

  757. 

  758. 		TP_STRUCT__entry(
    759. 

  759. 			__field(dev_t, dev)
    760. 

  760. 			__field(u32, fhandle)
    761. 

  761. 			__field(int, error)
    762. 

  762. 			__field(int, stateid_seq)
    763. 

  763. 			__field(u32, stateid_hash)
    764. 

  764. 		),
    765. 

  765. 

  766. 		TP_fast_assign(
    767. 

  767. 			__entry->dev = res->server->s_dev;
    768. 

  768. 			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
    769. 

  769. 			__entry->error = error;
    770. 

  770. 			__entry->stateid_seq =
    771. 

  771. 				be32_to_cpu(args->stateid->seqid);
    772. 

  772. 			__entry->stateid_hash =
    773. 

  773. 				nfs_stateid_hash(args->stateid);
    774. 

  774. 		),
    775. 

  775. 

  776. 		TP_printk(
    777. 

  777. 			"error=%d (%s) dev=%02x:%02x fhandle=0x%08x "
    778. 

  778. 			"stateid=%d:0x%08x",
    779. 

  779. 			__entry->error,
    780. 

  780. 			show_nfsv4_errors(__entry->error),
    781. 

  781. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    782. 

  782. 			__entry->fhandle,
    783. 

  783. 			__entry->stateid_seq, __entry->stateid_hash
    784. 

  784. 		)
    785. 

  785. );
    786. 

  786. 

  787. #ifdef CONFIG_NFS_V4_1
    788. 

  788. DECLARE_EVENT_CLASS(nfs4_test_stateid_event,
    789. 

  789. 		TP_PROTO(
    790. 

  790. 			const struct nfs4_state *state,
    791. 

  791. 			const struct nfs4_lock_state *lsp,
    792. 

  792. 			int error
    793. 

  793. 		),
    794. 

  794. 

  795. 		TP_ARGS(state, lsp, error),
    796. 

  796. 

  797. 		TP_STRUCT__entry(
    798. 

  798. 			__field(int, error)
    799. 

  799. 			__field(dev_t, dev)
    800. 

  800. 			__field(u32, fhandle)
    801. 

  801. 			__field(u64, fileid)
    802. 

  802. 			__field(int, stateid_seq)
    803. 

  803. 			__field(u32, stateid_hash)
    804. 

  804. 		),
    805. 

  805. 

  806. 		TP_fast_assign(
    807. 

  807. 			const struct inode *inode = state->inode;
    808. 

  808. 

  809. 			__entry->error = error;
    810. 

  810. 			__entry->dev = inode->i_sb->s_dev;
    811. 

  811. 			__entry->fileid = NFS_FILEID(inode);
    812. 

  812. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    813. 

  813. 			__entry->stateid_seq =
    814. 

  814. 				be32_to_cpu(state->stateid.seqid);
    815. 

  815. 			__entry->stateid_hash =
    816. 

  816. 				nfs_stateid_hash(&state->stateid);
    817. 

  817. 		),
    818. 

  818. 

  819. 		TP_printk(
    820. 

  820. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    821. 

  821. 			"stateid=%d:0x%08x",
    822. 

  822. 			__entry->error,
    823. 

  823. 			show_nfsv4_errors(__entry->error),
    824. 

  824. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    825. 

  825. 			(unsigned long long)__entry->fileid,
    826. 

  826. 			__entry->fhandle,
    827. 

  827. 			__entry->stateid_seq, __entry->stateid_hash
    828. 

  828. 		)
    829. 

  829. );
    830. 

  830. 

  831. #define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
    832. 

  832. 	DEFINE_EVENT(nfs4_test_stateid_event, name, \
    833. 

  833. 			TP_PROTO( \
    834. 

  834. 				const struct nfs4_state *state, \
    835. 

  835. 				const struct nfs4_lock_state *lsp, \
    836. 

  836. 				int error \
    837. 

  837. 			), \
    838. 

  838. 			TP_ARGS(state, lsp, error))
    839. 

  839. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid);
    840. 

  840. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid);
    841. 

  841. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid);
    842. 

  842. #endif /* CONFIG_NFS_V4_1 */
    843. 

  843. 

  844. DECLARE_EVENT_CLASS(nfs4_lookup_event,
    845. 

  845. 		TP_PROTO(
    846. 

  846. 			const struct inode *dir,
    847. 

  847. 			const struct qstr *name,
    848. 

  848. 			int error
    849. 

  849. 		),
    850. 

  850. 

  851. 		TP_ARGS(dir, name, error),
    852. 

  852. 

  853. 		TP_STRUCT__entry(
    854. 

  854. 			__field(dev_t, dev)
    855. 

  855. 			__field(int, error)
    856. 

  856. 			__field(u64, dir)
    857. 

  857. 			__string(name, name->name)
    858. 

  858. 		),
    859. 

  859. 

  860. 		TP_fast_assign(
    861. 

  861. 			__entry->dev = dir->i_sb->s_dev;
    862. 

  862. 			__entry->dir = NFS_FILEID(dir);
    863. 

  863. 			__entry->error = error;
    864. 

  864. 			__assign_str(name, name->name);
    865. 

  865. 		),
    866. 

  866. 

  867. 		TP_printk(
    868. 

  868. 			"error=%d (%s) name=%02x:%02x:%llu/%s",
    869. 

  869. 			__entry->error,
    870. 

  870. 			show_nfsv4_errors(__entry->error),
    871. 

  871. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    872. 

  872. 			(unsigned long long)__entry->dir,
    873. 

  873. 			__get_str(name)
    874. 

  874. 		)
    875. 

  875. );
    876. 

  876. 

  877. #define DEFINE_NFS4_LOOKUP_EVENT(name) \
    878. 

  878. 	DEFINE_EVENT(nfs4_lookup_event, name, \
    879. 

  879. 			TP_PROTO( \
    880. 

  880. 				const struct inode *dir, \
    881. 

  881. 				const struct qstr *name, \
    882. 

  882. 				int error \
    883. 

  883. 			), \
    884. 

  884. 			TP_ARGS(dir, name, error))
    885. 

  885. 

  886. DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
    887. 

  887. DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
    888. 

  888. DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
    889. 

  889. DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
    890. 

  890. DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
    891. 

  891. DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
    892. 

  892. DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
    893. 

  893. 

  894. TRACE_EVENT(nfs4_rename,
    895. 

  895. 		TP_PROTO(
    896. 

  896. 			const struct inode *olddir,
    897. 

  897. 			const struct qstr *oldname,
    898. 

  898. 			const struct inode *newdir,
    899. 

  899. 			const struct qstr *newname,
    900. 

  900. 			int error
    901. 

  901. 		),
    902. 

  902. 

  903. 		TP_ARGS(olddir, oldname, newdir, newname, error),
    904. 

  904. 

  905. 		TP_STRUCT__entry(
    906. 

  906. 			__field(dev_t, dev)
    907. 

  907. 			__field(int, error)
    908. 

  908. 			__field(u64, olddir)
    909. 

  909. 			__string(oldname, oldname->name)
    910. 

  910. 			__field(u64, newdir)
    911. 

  911. 			__string(newname, newname->name)
    912. 

  912. 		),
    913. 

  913. 

  914. 		TP_fast_assign(
    915. 

  915. 			__entry->dev = olddir->i_sb->s_dev;
    916. 

  916. 			__entry->olddir = NFS_FILEID(olddir);
    917. 

  917. 			__entry->newdir = NFS_FILEID(newdir);
    918. 

  918. 			__entry->error = error;
    919. 

  919. 			__assign_str(oldname, oldname->name);
    920. 

  920. 			__assign_str(newname, newname->name);
    921. 

  921. 		),
    922. 

  922. 

  923. 		TP_printk(
    924. 

  924. 			"error=%d (%s) oldname=%02x:%02x:%llu/%s "
    925. 

  925. 			"newname=%02x:%02x:%llu/%s",
    926. 

  926. 			__entry->error,
    927. 

  927. 			show_nfsv4_errors(__entry->error),
    928. 

  928. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    929. 

  929. 			(unsigned long long)__entry->olddir,
    930. 

  930. 			__get_str(oldname),
    931. 

  931. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    932. 

  932. 			(unsigned long long)__entry->newdir,
    933. 

  933. 			__get_str(newname)
    934. 

  934. 		)
    935. 

  935. );
    936. 

  936. 

  937. DECLARE_EVENT_CLASS(nfs4_inode_event,
    938. 

  938. 		TP_PROTO(
    939. 

  939. 			const struct inode *inode,
    940. 

  940. 			int error
    941. 

  941. 		),
    942. 

  942. 

  943. 		TP_ARGS(inode, error),
    944. 

  944. 

  945. 		TP_STRUCT__entry(
    946. 

  946. 			__field(dev_t, dev)
    947. 

  947. 			__field(u32, fhandle)
    948. 

  948. 			__field(u64, fileid)
    949. 

  949. 			__field(int, error)
    950. 

  950. 		),
    951. 

  951. 

  952. 		TP_fast_assign(
    953. 

  953. 			__entry->dev = inode->i_sb->s_dev;
    954. 

  954. 			__entry->fileid = NFS_FILEID(inode);
    955. 

  955. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    956. 

  956. 			__entry->error = error;
    957. 

  957. 		),
    958. 

  958. 

  959. 		TP_printk(
    960. 

  960. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
    961. 

  961. 			__entry->error,
    962. 

  962. 			show_nfsv4_errors(__entry->error),
    963. 

  963. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    964. 

  964. 			(unsigned long long)__entry->fileid,
    965. 

  965. 			__entry->fhandle
    966. 

  966. 		)
    967. 

  967. );
    968. 

  968. 

  969. #define DEFINE_NFS4_INODE_EVENT(name) \
    970. 

  970. 	DEFINE_EVENT(nfs4_inode_event, name, \
    971. 

  971. 			TP_PROTO( \
    972. 

  972. 				const struct inode *inode, \
    973. 

  973. 				int error \
    974. 

  974. 			), \
    975. 

  975. 			TP_ARGS(inode, error))
    976. 

  976. 

  977. DEFINE_NFS4_INODE_EVENT(nfs4_access);
    978. 

  978. DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
    979. 

  979. DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
    980. 

  980. DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
    981. 

  981. DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
    982. 

  982. #ifdef CONFIG_NFS_V4_SECURITY_LABEL
    983. 

  983. DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
    984. 

  984. DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
    985. 

  985. #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
    986. 

  986. 

  987. DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,
    988. 

  988. 		TP_PROTO(
    989. 

  989. 			const struct inode *inode,
    990. 

  990. 			const nfs4_stateid *stateid,
    991. 

  991. 			int error
    992. 

  992. 		),
    993. 

  993. 

  994. 		TP_ARGS(inode, stateid, error),
    995. 

  995. 

  996. 		TP_STRUCT__entry(
    997. 

  997. 			__field(dev_t, dev)
    998. 

  998. 			__field(u32, fhandle)
    999. 

  999. 			__field(u64, fileid)
    1000. 

  1000. 			__field(int, error)
    1001. 

  1001. 			__field(int, stateid_seq)
    1002. 

  1002. 			__field(u32, stateid_hash)
    1003. 

  1003. 		),
    1004. 

  1004. 

  1005. 		TP_fast_assign(
    1006. 

  1006. 			__entry->dev = inode->i_sb->s_dev;
    1007. 

  1007. 			__entry->fileid = NFS_FILEID(inode);
    1008. 

  1008. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1009. 

  1009. 			__entry->error = error;
    1010. 

  1010. 			__entry->stateid_seq =
    1011. 

  1011. 				be32_to_cpu(stateid->seqid);
    1012. 

  1012. 			__entry->stateid_hash =
    1013. 

  1013. 				nfs_stateid_hash(stateid);
    1014. 

  1014. 		),
    1015. 

  1015. 

  1016. 		TP_printk(
    1017. 

  1017. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1018. 

  1018. 			"stateid=%d:0x%08x",
    1019. 

  1019. 			__entry->error,
    1020. 

  1020. 			show_nfsv4_errors(__entry->error),
    1021. 

  1021. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1022. 

  1022. 			(unsigned long long)__entry->fileid,
    1023. 

  1023. 			__entry->fhandle,
    1024. 

  1024. 			__entry->stateid_seq, __entry->stateid_hash
    1025. 

  1025. 		)
    1026. 

  1026. );
    1027. 

  1027. 

  1028. #define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
    1029. 

  1029. 	DEFINE_EVENT(nfs4_inode_stateid_event, name, \
    1030. 

  1030. 			TP_PROTO( \
    1031. 

  1031. 				const struct inode *inode, \
    1032. 

  1032. 				const nfs4_stateid *stateid, \
    1033. 

  1033. 				int error \
    1034. 

  1034. 			), \
    1035. 

  1035. 			TP_ARGS(inode, stateid, error))
    1036. 

  1036. 

  1037. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);
    1038. 

  1038. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
    1039. 

  1039. 

  1040. DECLARE_EVENT_CLASS(nfs4_getattr_event,
    1041. 

  1041. 		TP_PROTO(
    1042. 

  1042. 			const struct nfs_server *server,
    1043. 

  1043. 			const struct nfs_fh *fhandle,
    1044. 

  1044. 			const struct nfs_fattr *fattr,
    1045. 

  1045. 			int error
    1046. 

  1046. 		),
    1047. 

  1047. 

  1048. 		TP_ARGS(server, fhandle, fattr, error),
    1049. 

  1049. 

  1050. 		TP_STRUCT__entry(
    1051. 

  1051. 			__field(dev_t, dev)
    1052. 

  1052. 			__field(u32, fhandle)
    1053. 

  1053. 			__field(u64, fileid)
    1054. 

  1054. 			__field(unsigned int, valid)
    1055. 

  1055. 			__field(int, error)
    1056. 

  1056. 		),
    1057. 

  1057. 

  1058. 		TP_fast_assign(
    1059. 

  1059. 			__entry->dev = server->s_dev;
    1060. 

  1060. 			__entry->valid = fattr->valid;
    1061. 

  1061. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1062. 

  1062. 			__entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
    1063. 

  1063. 			__entry->error = error;
    1064. 

  1064. 		),
    1065. 

  1065. 

  1066. 		TP_printk(
    1067. 

  1067. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1068. 

  1068. 			"valid=%s",
    1069. 

  1069. 			__entry->error,
    1070. 

  1070. 			show_nfsv4_errors(__entry->error),
    1071. 

  1071. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1072. 

  1072. 			(unsigned long long)__entry->fileid,
    1073. 

  1073. 			__entry->fhandle,
    1074. 

  1074. 			show_nfs_fattr_flags(__entry->valid)
    1075. 

  1075. 		)
    1076. 

  1076. );
    1077. 

  1077. 

  1078. #define DEFINE_NFS4_GETATTR_EVENT(name) \
    1079. 

  1079. 	DEFINE_EVENT(nfs4_getattr_event, name, \
    1080. 

  1080. 			TP_PROTO( \
    1081. 

  1081. 				const struct nfs_server *server, \
    1082. 

  1082. 				const struct nfs_fh *fhandle, \
    1083. 

  1083. 				const struct nfs_fattr *fattr, \
    1084. 

  1084. 				int error \
    1085. 

  1085. 			), \
    1086. 

  1086. 			TP_ARGS(server, fhandle, fattr, error))
    1087. 

  1087. DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
    1088. 

  1088. DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
    1089. 

  1089. DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
    1090. 

  1090. 

  1091. DECLARE_EVENT_CLASS(nfs4_inode_callback_event,
    1092. 

  1092. 		TP_PROTO(
    1093. 

  1093. 			const struct nfs_client *clp,
    1094. 

  1094. 			const struct nfs_fh *fhandle,
    1095. 

  1095. 			const struct inode *inode,
    1096. 

  1096. 			int error
    1097. 

  1097. 		),
    1098. 

  1098. 

  1099. 		TP_ARGS(clp, fhandle, inode, error),
    1100. 

  1100. 

  1101. 		TP_STRUCT__entry(
    1102. 

  1102. 			__field(int, error)
    1103. 

  1103. 			__field(dev_t, dev)
    1104. 

  1104. 			__field(u32, fhandle)
    1105. 

  1105. 			__field(u64, fileid)
    1106. 

  1106. 			__string(dstaddr, clp ?
    1107. 

  1107. 				rpc_peeraddr2str(clp->cl_rpcclient,
    1108. 

  1108. 					RPC_DISPLAY_ADDR) : "unknown")
    1109. 

  1109. 		),
    1110. 

  1110. 

  1111. 		TP_fast_assign(
    1112. 

  1112. 			__entry->error = error;
    1113. 

  1113. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1114. 

  1114. 			if (inode != NULL) {
    1115. 

  1115. 				__entry->fileid = NFS_FILEID(inode);
    1116. 

  1116. 				__entry->dev = inode->i_sb->s_dev;
    1117. 

  1117. 			} else {
    1118. 

  1118. 				__entry->fileid = 0;
    1119. 

  1119. 				__entry->dev = 0;
    1120. 

  1120. 			}
    1121. 

  1121. 			__assign_str(dstaddr, clp ?
    1122. 

  1122. 				rpc_peeraddr2str(clp->cl_rpcclient,
    1123. 

  1123. 					RPC_DISPLAY_ADDR) : "unknown")
    1124. 

  1124. 		),
    1125. 

  1125. 

  1126. 		TP_printk(
    1127. 

  1127. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1128. 

  1128. 			"dstaddr=%s",
    1129. 

  1129. 			__entry->error,
    1130. 

  1130. 			show_nfsv4_errors(__entry->error),
    1131. 

  1131. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1132. 

  1132. 			(unsigned long long)__entry->fileid,
    1133. 

  1133. 			__entry->fhandle,
    1134. 

  1134. 			__get_str(dstaddr)
    1135. 

  1135. 		)
    1136. 

  1136. );
    1137. 

  1137. 

  1138. #define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
    1139. 

  1139. 	DEFINE_EVENT(nfs4_inode_callback_event, name, \
    1140. 

  1140. 			TP_PROTO( \
    1141. 

  1141. 				const struct nfs_client *clp, \
    1142. 

  1142. 				const struct nfs_fh *fhandle, \
    1143. 

  1143. 				const struct inode *inode, \
    1144. 

  1144. 				int error \
    1145. 

  1145. 			), \
    1146. 

  1146. 			TP_ARGS(clp, fhandle, inode, error))
    1147. 

  1147. DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr);
    1148. 

  1148. 

  1149. DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,
    1150. 

  1150. 		TP_PROTO(
    1151. 

  1151. 			const struct nfs_client *clp,
    1152. 

  1152. 			const struct nfs_fh *fhandle,
    1153. 

  1153. 			const struct inode *inode,
    1154. 

  1154. 			const nfs4_stateid *stateid,
    1155. 

  1155. 			int error
    1156. 

  1156. 		),
    1157. 

  1157. 

  1158. 		TP_ARGS(clp, fhandle, inode, stateid, error),
    1159. 

  1159. 

  1160. 		TP_STRUCT__entry(
    1161. 

  1161. 			__field(int, error)
    1162. 

  1162. 			__field(dev_t, dev)
    1163. 

  1163. 			__field(u32, fhandle)
    1164. 

  1164. 			__field(u64, fileid)
    1165. 

  1165. 			__string(dstaddr, clp ?
    1166. 

  1166. 				rpc_peeraddr2str(clp->cl_rpcclient,
    1167. 

  1167. 					RPC_DISPLAY_ADDR) : "unknown")
    1168. 

  1168. 			__field(int, stateid_seq)
    1169. 

  1169. 			__field(u32, stateid_hash)
    1170. 

  1170. 		),
    1171. 

  1171. 

  1172. 		TP_fast_assign(
    1173. 

  1173. 			__entry->error = error;
    1174. 

  1174. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1175. 

  1175. 			if (inode != NULL) {
    1176. 

  1176. 				__entry->fileid = NFS_FILEID(inode);
    1177. 

  1177. 				__entry->dev = inode->i_sb->s_dev;
    1178. 

  1178. 			} else {
    1179. 

  1179. 				__entry->fileid = 0;
    1180. 

  1180. 				__entry->dev = 0;
    1181. 

  1181. 			}
    1182. 

  1182. 			__assign_str(dstaddr, clp ?
    1183. 

  1183. 				rpc_peeraddr2str(clp->cl_rpcclient,
    1184. 

  1184. 					RPC_DISPLAY_ADDR) : "unknown")
    1185. 

  1185. 			__entry->stateid_seq =
    1186. 

  1186. 				be32_to_cpu(stateid->seqid);
    1187. 

  1187. 			__entry->stateid_hash =
    1188. 

  1188. 				nfs_stateid_hash(stateid);
    1189. 

  1189. 		),
    1190. 

  1190. 

  1191. 		TP_printk(
    1192. 

  1192. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1193. 

  1193. 			"stateid=%d:0x%08x dstaddr=%s",
    1194. 

  1194. 			__entry->error,
    1195. 

  1195. 			show_nfsv4_errors(__entry->error),
    1196. 

  1196. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1197. 

  1197. 			(unsigned long long)__entry->fileid,
    1198. 

  1198. 			__entry->fhandle,
    1199. 

  1199. 			__entry->stateid_seq, __entry->stateid_hash,
    1200. 

  1200. 			__get_str(dstaddr)
    1201. 

  1201. 		)
    1202. 

  1202. );
    1203. 

  1203. 

  1204. #define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
    1205. 

  1205. 	DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
    1206. 

  1206. 			TP_PROTO( \
    1207. 

  1207. 				const struct nfs_client *clp, \
    1208. 

  1208. 				const struct nfs_fh *fhandle, \
    1209. 

  1209. 				const struct inode *inode, \
    1210. 

  1210. 				const nfs4_stateid *stateid, \
    1211. 

  1211. 				int error \
    1212. 

  1212. 			), \
    1213. 

  1213. 			TP_ARGS(clp, fhandle, inode, stateid, error))
    1214. 

  1214. DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall);
    1215. 

  1215. DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file);
    1216. 

  1216. 

  1217. DECLARE_EVENT_CLASS(nfs4_idmap_event,
    1218. 

  1218. 		TP_PROTO(
    1219. 

  1219. 			const char *name,
    1220. 

  1220. 			int len,
    1221. 

  1221. 			u32 id,
    1222. 

  1222. 			int error
    1223. 

  1223. 		),
    1224. 

  1224. 

  1225. 		TP_ARGS(name, len, id, error),
    1226. 

  1226. 

  1227. 		TP_STRUCT__entry(
    1228. 

  1228. 			__field(int, error)
    1229. 

  1229. 			__field(u32, id)
    1230. 

  1230. 			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
    1231. 

  1231. 		),
    1232. 

  1232. 

  1233. 		TP_fast_assign(
    1234. 

  1234. 			if (len < 0)
    1235. 

  1235. 				len = 0;
    1236. 

  1236. 			__entry->error = error < 0 ? error : 0;
    1237. 

  1237. 			__entry->id = id;
    1238. 

  1238. 			memcpy(__get_str(name), name, len);
    1239. 

  1239. 			__get_str(name)[len] = 0;
    1240. 

  1240. 		),
    1241. 

  1241. 

  1242. 		TP_printk(
    1243. 

  1243. 			"error=%d id=%u name=%s",
    1244. 

  1244. 			__entry->error,
    1245. 

  1245. 			__entry->id,
    1246. 

  1246. 			__get_str(name)
    1247. 

  1247. 		)
    1248. 

  1248. );
    1249. 

  1249. #define DEFINE_NFS4_IDMAP_EVENT(name) \
    1250. 

  1250. 	DEFINE_EVENT(nfs4_idmap_event, name, \
    1251. 

  1251. 			TP_PROTO( \
    1252. 

  1252. 				const char *name, \
    1253. 

  1253. 				int len, \
    1254. 

  1254. 				u32 id, \
    1255. 

  1255. 				int error \
    1256. 

  1256. 			), \
    1257. 

  1257. 			TP_ARGS(name, len, id, error))
    1258. 

  1258. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
    1259. 

  1259. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
    1260. 

  1260. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
    1261. 

  1261. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
    1262. 

  1262. 

  1263. DECLARE_EVENT_CLASS(nfs4_read_event,
    1264. 

  1264. 		TP_PROTO(
    1265. 

  1265. 			const struct nfs_pgio_header *hdr,
    1266. 

  1266. 			int error
    1267. 

  1267. 		),
    1268. 

  1268. 

  1269. 		TP_ARGS(hdr, error),
    1270. 

  1270. 

  1271. 		TP_STRUCT__entry(
    1272. 

  1272. 			__field(dev_t, dev)
    1273. 

  1273. 			__field(u32, fhandle)
    1274. 

  1274. 			__field(u64, fileid)
    1275. 

  1275. 			__field(loff_t, offset)
    1276. 

  1276. 			__field(size_t, count)
    1277. 

  1277. 			__field(int, error)
    1278. 

  1278. 			__field(int, stateid_seq)
    1279. 

  1279. 			__field(u32, stateid_hash)
    1280. 

  1280. 		),
    1281. 

  1281. 

  1282. 		TP_fast_assign(
    1283. 

  1283. 			const struct inode *inode = hdr->inode;
    1284. 

  1284. 			const struct nfs4_state *state =
    1285. 

  1285. 				hdr->args.context->state;
    1286. 

  1286. 			__entry->dev = inode->i_sb->s_dev;
    1287. 

  1287. 			__entry->fileid = NFS_FILEID(inode);
    1288. 

  1288. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1289. 

  1289. 			__entry->offset = hdr->args.offset;
    1290. 

  1290. 			__entry->count = hdr->args.count;
    1291. 

  1291. 			__entry->error = error;
    1292. 

  1292. 			__entry->stateid_seq =
    1293. 

  1293. 				be32_to_cpu(state->stateid.seqid);
    1294. 

  1294. 			__entry->stateid_hash =
    1295. 

  1295. 				nfs_stateid_hash(&state->stateid);
    1296. 

  1296. 		),
    1297. 

  1297. 

  1298. 		TP_printk(
    1299. 

  1299. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1300. 

  1300. 			"offset=%lld count=%zu stateid=%d:0x%08x",
    1301. 

  1301. 			__entry->error,
    1302. 

  1302. 			show_nfsv4_errors(__entry->error),
    1303. 

  1303. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1304. 

  1304. 			(unsigned long long)__entry->fileid,
    1305. 

  1305. 			__entry->fhandle,
    1306. 

  1306. 			(long long)__entry->offset,
    1307. 

  1307. 			__entry->count,
    1308. 

  1308. 			__entry->stateid_seq, __entry->stateid_hash
    1309. 

  1309. 		)
    1310. 

  1310. );
    1311. 

  1311. #define DEFINE_NFS4_READ_EVENT(name) \
    1312. 

  1312. 	DEFINE_EVENT(nfs4_read_event, name, \
    1313. 

  1313. 			TP_PROTO( \
    1314. 

  1314. 				const struct nfs_pgio_header *hdr, \
    1315. 

  1315. 				int error \
    1316. 

  1316. 			), \
    1317. 

  1317. 			TP_ARGS(hdr, error))
    1318. 

  1318. DEFINE_NFS4_READ_EVENT(nfs4_read);
    1319. 

  1319. #ifdef CONFIG_NFS_V4_1
    1320. 

  1320. DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read);
    1321. 

  1321. #endif /* CONFIG_NFS_V4_1 */
    1322. 

  1322. 

  1323. DECLARE_EVENT_CLASS(nfs4_write_event,
    1324. 

  1324. 		TP_PROTO(
    1325. 

  1325. 			const struct nfs_pgio_header *hdr,
    1326. 

  1326. 			int error
    1327. 

  1327. 		),
    1328. 

  1328. 

  1329. 		TP_ARGS(hdr, error),
    1330. 

  1330. 

  1331. 		TP_STRUCT__entry(
    1332. 

  1332. 			__field(dev_t, dev)
    1333. 

  1333. 			__field(u32, fhandle)
    1334. 

  1334. 			__field(u64, fileid)
    1335. 

  1335. 			__field(loff_t, offset)
    1336. 

  1336. 			__field(size_t, count)
    1337. 

  1337. 			__field(int, error)
    1338. 

  1338. 			__field(int, stateid_seq)
    1339. 

  1339. 			__field(u32, stateid_hash)
    1340. 

  1340. 		),
    1341. 

  1341. 

  1342. 		TP_fast_assign(
    1343. 

  1343. 			const struct inode *inode = hdr->inode;
    1344. 

  1344. 			const struct nfs4_state *state =
    1345. 

  1345. 				hdr->args.context->state;
    1346. 

  1346. 			__entry->dev = inode->i_sb->s_dev;
    1347. 

  1347. 			__entry->fileid = NFS_FILEID(inode);
    1348. 

  1348. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1349. 

  1349. 			__entry->offset = hdr->args.offset;
    1350. 

  1350. 			__entry->count = hdr->args.count;
    1351. 

  1351. 			__entry->error = error;
    1352. 

  1352. 			__entry->stateid_seq =
    1353. 

  1353. 				be32_to_cpu(state->stateid.seqid);
    1354. 

  1354. 			__entry->stateid_hash =
    1355. 

  1355. 				nfs_stateid_hash(&state->stateid);
    1356. 

  1356. 		),
    1357. 

  1357. 

  1358. 		TP_printk(
    1359. 

  1359. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1360. 

  1360. 			"offset=%lld count=%zu stateid=%d:0x%08x",
    1361. 

  1361. 			__entry->error,
    1362. 

  1362. 			show_nfsv4_errors(__entry->error),
    1363. 

  1363. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1364. 

  1364. 			(unsigned long long)__entry->fileid,
    1365. 

  1365. 			__entry->fhandle,
    1366. 

  1366. 			(long long)__entry->offset,
    1367. 

  1367. 			__entry->count,
    1368. 

  1368. 			__entry->stateid_seq, __entry->stateid_hash
    1369. 

  1369. 		)
    1370. 

  1370. );
    1371. 

  1371. 

  1372. #define DEFINE_NFS4_WRITE_EVENT(name) \
    1373. 

  1373. 	DEFINE_EVENT(nfs4_write_event, name, \
    1374. 

  1374. 			TP_PROTO( \
    1375. 

  1375. 				const struct nfs_pgio_header *hdr, \
    1376. 

  1376. 				int error \
    1377. 

  1377. 			), \
    1378. 

  1378. 			TP_ARGS(hdr, error))
    1379. 

  1379. DEFINE_NFS4_WRITE_EVENT(nfs4_write);
    1380. 

  1380. #ifdef CONFIG_NFS_V4_1
    1381. 

  1381. DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write);
    1382. 

  1382. #endif /* CONFIG_NFS_V4_1 */
    1383. 

  1383. 

  1384. DECLARE_EVENT_CLASS(nfs4_commit_event,
    1385. 

  1385. 		TP_PROTO(
    1386. 

  1386. 			const struct nfs_commit_data *data,
    1387. 

  1387. 			int error
    1388. 

  1388. 		),
    1389. 

  1389. 

  1390. 		TP_ARGS(data, error),
    1391. 

  1391. 

  1392. 		TP_STRUCT__entry(
    1393. 

  1393. 			__field(dev_t, dev)
    1394. 

  1394. 			__field(u32, fhandle)
    1395. 

  1395. 			__field(u64, fileid)
    1396. 

  1396. 			__field(loff_t, offset)
    1397. 

  1397. 			__field(size_t, count)
    1398. 

  1398. 			__field(int, error)
    1399. 

  1399. 		),
    1400. 

  1400. 

  1401. 		TP_fast_assign(
    1402. 

  1402. 			const struct inode *inode = data->inode;
    1403. 

  1403. 			__entry->dev = inode->i_sb->s_dev;
    1404. 

  1404. 			__entry->fileid = NFS_FILEID(inode);
    1405. 

  1405. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1406. 

  1406. 			__entry->offset = data->args.offset;
    1407. 

  1407. 			__entry->count = data->args.count;
    1408. 

  1408. 			__entry->error = error;
    1409. 

  1409. 		),
    1410. 

  1410. 

  1411. 		TP_printk(
    1412. 

  1412. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1413. 

  1413. 			"offset=%lld count=%zu",
    1414. 

  1414. 			__entry->error,
    1415. 

  1415. 			show_nfsv4_errors(__entry->error),
    1416. 

  1416. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1417. 

  1417. 			(unsigned long long)__entry->fileid,
    1418. 

  1418. 			__entry->fhandle,
    1419. 

  1419. 			(long long)__entry->offset,
    1420. 

  1420. 			__entry->count
    1421. 

  1421. 		)
    1422. 

  1422. );
    1423. 

  1423. #define DEFINE_NFS4_COMMIT_EVENT(name) \
    1424. 

  1424. 	DEFINE_EVENT(nfs4_commit_event, name, \
    1425. 

  1425. 			TP_PROTO( \
    1426. 

  1426. 				const struct nfs_commit_data *data, \
    1427. 

  1427. 				int error \
    1428. 

  1428. 			), \
    1429. 

  1429. 			TP_ARGS(data, error))
    1430. 

  1430. DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);
    1431. 

  1431. #ifdef CONFIG_NFS_V4_1
    1432. 

  1432. DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds);
    1433. 

  1433. 

  1434. #define show_pnfs_iomode(iomode) \
    1435. 

  1435. 	__print_symbolic(iomode, \
    1436. 

  1436. 		{ IOMODE_READ, "READ" }, \
    1437. 

  1437. 		{ IOMODE_RW, "RW" }, \
    1438. 

  1438. 		{ IOMODE_ANY, "ANY" })
    1439. 

  1439. 

  1440. TRACE_EVENT(nfs4_layoutget,
    1441. 

  1441. 		TP_PROTO(
    1442. 

  1442. 			const struct nfs_open_context *ctx,
    1443. 

  1443. 			const struct pnfs_layout_range *args,
    1444. 

  1444. 			const struct pnfs_layout_range *res,
    1445. 

  1445. 			const nfs4_stateid *layout_stateid,
    1446. 

  1446. 			int error
    1447. 

  1447. 		),
    1448. 

  1448. 

  1449. 		TP_ARGS(ctx, args, res, layout_stateid, error),
    1450. 

  1450. 

  1451. 		TP_STRUCT__entry(
    1452. 

  1452. 			__field(dev_t, dev)
    1453. 

  1453. 			__field(u32, fhandle)
    1454. 

  1454. 			__field(u64, fileid)
    1455. 

  1455. 			__field(u32, iomode)
    1456. 

  1456. 			__field(u64, offset)
    1457. 

  1457. 			__field(u64, count)
    1458. 

  1458. 			__field(int, error)
    1459. 

  1459. 			__field(int, stateid_seq)
    1460. 

  1460. 			__field(u32, stateid_hash)
    1461. 

  1461. 			__field(int, layoutstateid_seq)
    1462. 

  1462. 			__field(u32, layoutstateid_hash)
    1463. 

  1463. 		),
    1464. 

  1464. 

  1465. 		TP_fast_assign(
    1466. 

  1466. 			const struct inode *inode = d_inode(ctx->dentry);
    1467. 

  1467. 			const struct nfs4_state *state = ctx->state;
    1468. 

  1468. 			__entry->dev = inode->i_sb->s_dev;
    1469. 

  1469. 			__entry->fileid = NFS_FILEID(inode);
    1470. 

  1470. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1471. 

  1471. 			__entry->iomode = args->iomode;
    1472. 

  1472. 			__entry->offset = args->offset;
    1473. 

  1473. 			__entry->count = args->length;
    1474. 

  1474. 			__entry->error = error;
    1475. 

  1475. 			__entry->stateid_seq =
    1476. 

  1476. 				be32_to_cpu(state->stateid.seqid);
    1477. 

  1477. 			__entry->stateid_hash =
    1478. 

  1478. 				nfs_stateid_hash(&state->stateid);
    1479. 

  1479. 			if (!error) {
    1480. 

  1480. 				__entry->layoutstateid_seq =
    1481. 

  1481. 				be32_to_cpu(layout_stateid->seqid);
    1482. 

  1482. 				__entry->layoutstateid_hash =
    1483. 

  1483. 				nfs_stateid_hash(layout_stateid);
    1484. 

  1484. 			} else {
    1485. 

  1485. 				__entry->layoutstateid_seq = 0;
    1486. 

  1486. 				__entry->layoutstateid_hash = 0;
    1487. 

  1487. 			}
    1488. 

  1488. 		),
    1489. 

  1489. 

  1490. 		TP_printk(
    1491. 

  1491. 			"error=%d (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1492. 

  1492. 			"iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
    1493. 

  1493. 			"layoutstateid=%d:0x%08x",
    1494. 

  1494. 			__entry->error,
    1495. 

  1495. 			show_nfsv4_errors(__entry->error),
    1496. 

  1496. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1497. 

  1497. 			(unsigned long long)__entry->fileid,
    1498. 

  1498. 			__entry->fhandle,
    1499. 

  1499. 			show_pnfs_iomode(__entry->iomode),
    1500. 

  1500. 			(unsigned long long)__entry->offset,
    1501. 

  1501. 			(unsigned long long)__entry->count,
    1502. 

  1502. 			__entry->stateid_seq, __entry->stateid_hash,
    1503. 

  1503. 			__entry->layoutstateid_seq, __entry->layoutstateid_hash
    1504. 

  1504. 		)
    1505. 

  1505. );
    1506. 

  1506. 

  1507. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
    1508. 

  1508. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
    1509. 

  1509. DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close);
    1510. 

  1510. 

  1511. #define show_pnfs_update_layout_reason(reason)				\
    1512. 

  1512. 	__print_symbolic(reason,					\
    1513. 

  1513. 		{ PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" },		\
    1514. 

  1514. 		{ PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" },		\
    1515. 

  1515. 		{ PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" },	\
    1516. 

  1516. 		{ PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" },		\
    1517. 

  1517. 		{ PNFS_UPDATE_LAYOUT_NOMEM, "nomem" },			\
    1518. 

  1518. 		{ PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" },	\
    1519. 

  1519. 		{ PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" },	\
    1520. 

  1520. 		{ PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" },	\
    1521. 

  1521. 		{ PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" },		\
    1522. 

  1522. 		{ PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" },	\
    1523. 

  1523. 		{ PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" },	\
    1524. 

  1524. 		{ PNFS_UPDATE_LAYOUT_RETRY, "retrying" },	\
    1525. 

  1525. 		{ PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" })
    1526. 

  1526. 

  1527. TRACE_EVENT(pnfs_update_layout,
    1528. 

  1528. 		TP_PROTO(struct inode *inode,
    1529. 

  1529. 			loff_t pos,
    1530. 

  1530. 			u64 count,
    1531. 

  1531. 			enum pnfs_iomode iomode,
    1532. 

  1532. 			struct pnfs_layout_hdr *lo,
    1533. 

  1533. 			struct pnfs_layout_segment *lseg,
    1534. 

  1534. 			enum pnfs_update_layout_reason reason
    1535. 

  1535. 		),
    1536. 

  1536. 		TP_ARGS(inode, pos, count, iomode, lo, lseg, reason),
    1537. 

  1537. 		TP_STRUCT__entry(
    1538. 

  1538. 			__field(dev_t, dev)
    1539. 

  1539. 			__field(u64, fileid)
    1540. 

  1540. 			__field(u32, fhandle)
    1541. 

  1541. 			__field(loff_t, pos)
    1542. 

  1542. 			__field(u64, count)
    1543. 

  1543. 			__field(enum pnfs_iomode, iomode)
    1544. 

  1544. 			__field(int, layoutstateid_seq)
    1545. 

  1545. 			__field(u32, layoutstateid_hash)
    1546. 

  1546. 			__field(long, lseg)
    1547. 

  1547. 			__field(enum pnfs_update_layout_reason, reason)
    1548. 

  1548. 		),
    1549. 

  1549. 		TP_fast_assign(
    1550. 

  1550. 			__entry->dev = inode->i_sb->s_dev;
    1551. 

  1551. 			__entry->fileid = NFS_FILEID(inode);
    1552. 

  1552. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1553. 

  1553. 			__entry->pos = pos;
    1554. 

  1554. 			__entry->count = count;
    1555. 

  1555. 			__entry->iomode = iomode;
    1556. 

  1556. 			__entry->reason = reason;
    1557. 

  1557. 			if (lo != NULL) {
    1558. 

  1558. 				__entry->layoutstateid_seq =
    1559. 

  1559. 				be32_to_cpu(lo->plh_stateid.seqid);
    1560. 

  1560. 				__entry->layoutstateid_hash =
    1561. 

  1561. 				nfs_stateid_hash(&lo->plh_stateid);
    1562. 

  1562. 			} else {
    1563. 

  1563. 				__entry->layoutstateid_seq = 0;
    1564. 

  1564. 				__entry->layoutstateid_hash = 0;
    1565. 

  1565. 			}
    1566. 

  1566. 			__entry->lseg = (long)lseg;
    1567. 

  1567. 		),
    1568. 

  1568. 		TP_printk(
    1569. 

  1569. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    1570. 

  1570. 			"iomode=%s pos=%llu count=%llu "
    1571. 

  1571. 			"layoutstateid=%d:0x%08x lseg=0x%lx (%s)",
    1572. 

  1572. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1573. 

  1573. 			(unsigned long long)__entry->fileid,
    1574. 

  1574. 			__entry->fhandle,
    1575. 

  1575. 			show_pnfs_iomode(__entry->iomode),
    1576. 

  1576. 			(unsigned long long)__entry->pos,
    1577. 

  1577. 			(unsigned long long)__entry->count,
    1578. 

  1578. 			__entry->layoutstateid_seq, __entry->layoutstateid_hash,
    1579. 

  1579. 			__entry->lseg,
    1580. 

  1580. 			show_pnfs_update_layout_reason(__entry->reason)
    1581. 

  1581. 		)
    1582. 

  1582. );
    1583. 

  1583. 

  1584. #endif /* CONFIG_NFS_V4_1 */
    1585. 

  1585. 

  1586. #endif /* _TRACE_NFS4_H */
    1587. 

  1587. 

  1588. #undef TRACE_INCLUDE_PATH
    1589. 

  1589. #define TRACE_INCLUDE_PATH .
    1590. 

  1590. #define TRACE_INCLUDE_FILE nfs4trace
    1591. 

  1591. /* This part must be outside protection */
    1592. 

  1592. #include <trace/define_trace.h>
    1593. 

  1593.