PageRenderTime 37ms CodeModel.GetById 17ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/nfs/nfs4trace.h

http://github.com/torvalds/linux
C Header | 2276 lines | 2052 code | 219 blank | 5 comment | 19 complexity | e136e8e29766f5b0eeb0923bbd18cff7 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /* SPDX-License-Identifier: GPL-2.0 */
    2. 

  2. /*
    3. 

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

  4.  */
    5. 

  5. #undef TRACE_SYSTEM
    6. 

  6. #define TRACE_SYSTEM nfs4
    7. 

  7. 

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

  9. #define _TRACE_NFS4_H
    10. 

  10. 

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

  12. 

  13. TRACE_DEFINE_ENUM(EPERM);
    14. 

  14. TRACE_DEFINE_ENUM(ENOENT);
    15. 

  15. TRACE_DEFINE_ENUM(EIO);
    16. 

  16. TRACE_DEFINE_ENUM(ENXIO);
    17. 

  17. TRACE_DEFINE_ENUM(EACCES);
    18. 

  18. TRACE_DEFINE_ENUM(EEXIST);
    19. 

  19. TRACE_DEFINE_ENUM(EXDEV);
    20. 

  20. TRACE_DEFINE_ENUM(ENOTDIR);
    21. 

  21. TRACE_DEFINE_ENUM(EISDIR);
    22. 

  22. TRACE_DEFINE_ENUM(EFBIG);
    23. 

  23. TRACE_DEFINE_ENUM(ENOSPC);
    24. 

  24. TRACE_DEFINE_ENUM(EROFS);
    25. 

  25. TRACE_DEFINE_ENUM(EMLINK);
    26. 

  26. TRACE_DEFINE_ENUM(ENAMETOOLONG);
    27. 

  27. TRACE_DEFINE_ENUM(ENOTEMPTY);
    28. 

  28. TRACE_DEFINE_ENUM(EDQUOT);
    29. 

  29. TRACE_DEFINE_ENUM(ESTALE);
    30. 

  30. TRACE_DEFINE_ENUM(EBADHANDLE);
    31. 

  31. TRACE_DEFINE_ENUM(EBADCOOKIE);
    32. 

  32. TRACE_DEFINE_ENUM(ENOTSUPP);
    33. 

  33. TRACE_DEFINE_ENUM(ETOOSMALL);
    34. 

  34. TRACE_DEFINE_ENUM(EREMOTEIO);
    35. 

  35. TRACE_DEFINE_ENUM(EBADTYPE);
    36. 

  36. TRACE_DEFINE_ENUM(EAGAIN);
    37. 

  37. TRACE_DEFINE_ENUM(ELOOP);
    38. 

  38. TRACE_DEFINE_ENUM(EOPNOTSUPP);
    39. 

  39. TRACE_DEFINE_ENUM(EDEADLK);
    40. 

  40. TRACE_DEFINE_ENUM(ENOMEM);
    41. 

  41. TRACE_DEFINE_ENUM(EKEYEXPIRED);
    42. 

  42. TRACE_DEFINE_ENUM(ETIMEDOUT);
    43. 

  43. TRACE_DEFINE_ENUM(ERESTARTSYS);
    44. 

  44. TRACE_DEFINE_ENUM(ECONNREFUSED);
    45. 

  45. TRACE_DEFINE_ENUM(ECONNRESET);
    46. 

  46. TRACE_DEFINE_ENUM(ENETUNREACH);
    47. 

  47. TRACE_DEFINE_ENUM(EHOSTUNREACH);
    48. 

  48. TRACE_DEFINE_ENUM(EHOSTDOWN);
    49. 

  49. TRACE_DEFINE_ENUM(EPIPE);
    50. 

  50. TRACE_DEFINE_ENUM(EPFNOSUPPORT);
    51. 

  51. TRACE_DEFINE_ENUM(EPROTONOSUPPORT);
    52. 

  52. 

  53. TRACE_DEFINE_ENUM(NFS4_OK);
    54. 

  54. TRACE_DEFINE_ENUM(NFS4ERR_ACCESS);
    55. 

  55. TRACE_DEFINE_ENUM(NFS4ERR_ATTRNOTSUPP);
    56. 

  56. TRACE_DEFINE_ENUM(NFS4ERR_ADMIN_REVOKED);
    57. 

  57. TRACE_DEFINE_ENUM(NFS4ERR_BACK_CHAN_BUSY);
    58. 

  58. TRACE_DEFINE_ENUM(NFS4ERR_BADCHAR);
    59. 

  59. TRACE_DEFINE_ENUM(NFS4ERR_BADHANDLE);
    60. 

  60. TRACE_DEFINE_ENUM(NFS4ERR_BADIOMODE);
    61. 

  61. TRACE_DEFINE_ENUM(NFS4ERR_BADLAYOUT);
    62. 

  62. TRACE_DEFINE_ENUM(NFS4ERR_BADLABEL);
    63. 

  63. TRACE_DEFINE_ENUM(NFS4ERR_BADNAME);
    64. 

  64. TRACE_DEFINE_ENUM(NFS4ERR_BADOWNER);
    65. 

  65. TRACE_DEFINE_ENUM(NFS4ERR_BADSESSION);
    66. 

  66. TRACE_DEFINE_ENUM(NFS4ERR_BADSLOT);
    67. 

  67. TRACE_DEFINE_ENUM(NFS4ERR_BADTYPE);
    68. 

  68. TRACE_DEFINE_ENUM(NFS4ERR_BADXDR);
    69. 

  69. TRACE_DEFINE_ENUM(NFS4ERR_BAD_COOKIE);
    70. 

  70. TRACE_DEFINE_ENUM(NFS4ERR_BAD_HIGH_SLOT);
    71. 

  71. TRACE_DEFINE_ENUM(NFS4ERR_BAD_RANGE);
    72. 

  72. TRACE_DEFINE_ENUM(NFS4ERR_BAD_SEQID);
    73. 

  73. TRACE_DEFINE_ENUM(NFS4ERR_BAD_SESSION_DIGEST);
    74. 

  74. TRACE_DEFINE_ENUM(NFS4ERR_BAD_STATEID);
    75. 

  75. TRACE_DEFINE_ENUM(NFS4ERR_CB_PATH_DOWN);
    76. 

  76. TRACE_DEFINE_ENUM(NFS4ERR_CLID_INUSE);
    77. 

  77. TRACE_DEFINE_ENUM(NFS4ERR_CLIENTID_BUSY);
    78. 

  78. TRACE_DEFINE_ENUM(NFS4ERR_COMPLETE_ALREADY);
    79. 

  79. TRACE_DEFINE_ENUM(NFS4ERR_CONN_NOT_BOUND_TO_SESSION);
    80. 

  80. TRACE_DEFINE_ENUM(NFS4ERR_DEADLOCK);
    81. 

  81. TRACE_DEFINE_ENUM(NFS4ERR_DEADSESSION);
    82. 

  82. TRACE_DEFINE_ENUM(NFS4ERR_DELAY);
    83. 

  83. TRACE_DEFINE_ENUM(NFS4ERR_DELEG_ALREADY_WANTED);
    84. 

  84. TRACE_DEFINE_ENUM(NFS4ERR_DELEG_REVOKED);
    85. 

  85. TRACE_DEFINE_ENUM(NFS4ERR_DENIED);
    86. 

  86. TRACE_DEFINE_ENUM(NFS4ERR_DIRDELEG_UNAVAIL);
    87. 

  87. TRACE_DEFINE_ENUM(NFS4ERR_DQUOT);
    88. 

  88. TRACE_DEFINE_ENUM(NFS4ERR_ENCR_ALG_UNSUPP);
    89. 

  89. TRACE_DEFINE_ENUM(NFS4ERR_EXIST);
    90. 

  90. TRACE_DEFINE_ENUM(NFS4ERR_EXPIRED);
    91. 

  91. TRACE_DEFINE_ENUM(NFS4ERR_FBIG);
    92. 

  92. TRACE_DEFINE_ENUM(NFS4ERR_FHEXPIRED);
    93. 

  93. TRACE_DEFINE_ENUM(NFS4ERR_FILE_OPEN);
    94. 

  94. TRACE_DEFINE_ENUM(NFS4ERR_GRACE);
    95. 

  95. TRACE_DEFINE_ENUM(NFS4ERR_HASH_ALG_UNSUPP);
    96. 

  96. TRACE_DEFINE_ENUM(NFS4ERR_INVAL);
    97. 

  97. TRACE_DEFINE_ENUM(NFS4ERR_IO);
    98. 

  98. TRACE_DEFINE_ENUM(NFS4ERR_ISDIR);
    99. 

  99. TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTTRYLATER);
    100. 

  100. TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTUNAVAILABLE);
    101. 

  101. TRACE_DEFINE_ENUM(NFS4ERR_LEASE_MOVED);
    102. 

  102. TRACE_DEFINE_ENUM(NFS4ERR_LOCKED);
    103. 

  103. TRACE_DEFINE_ENUM(NFS4ERR_LOCKS_HELD);
    104. 

  104. TRACE_DEFINE_ENUM(NFS4ERR_LOCK_RANGE);
    105. 

  105. TRACE_DEFINE_ENUM(NFS4ERR_MINOR_VERS_MISMATCH);
    106. 

  106. TRACE_DEFINE_ENUM(NFS4ERR_MLINK);
    107. 

  107. TRACE_DEFINE_ENUM(NFS4ERR_MOVED);
    108. 

  108. TRACE_DEFINE_ENUM(NFS4ERR_NAMETOOLONG);
    109. 

  109. TRACE_DEFINE_ENUM(NFS4ERR_NOENT);
    110. 

  110. TRACE_DEFINE_ENUM(NFS4ERR_NOFILEHANDLE);
    111. 

  111. TRACE_DEFINE_ENUM(NFS4ERR_NOMATCHING_LAYOUT);
    112. 

  112. TRACE_DEFINE_ENUM(NFS4ERR_NOSPC);
    113. 

  113. TRACE_DEFINE_ENUM(NFS4ERR_NOTDIR);
    114. 

  114. TRACE_DEFINE_ENUM(NFS4ERR_NOTEMPTY);
    115. 

  115. TRACE_DEFINE_ENUM(NFS4ERR_NOTSUPP);
    116. 

  116. TRACE_DEFINE_ENUM(NFS4ERR_NOT_ONLY_OP);
    117. 

  117. TRACE_DEFINE_ENUM(NFS4ERR_NOT_SAME);
    118. 

  118. TRACE_DEFINE_ENUM(NFS4ERR_NO_GRACE);
    119. 

  119. TRACE_DEFINE_ENUM(NFS4ERR_NXIO);
    120. 

  120. TRACE_DEFINE_ENUM(NFS4ERR_OLD_STATEID);
    121. 

  121. TRACE_DEFINE_ENUM(NFS4ERR_OPENMODE);
    122. 

  122. TRACE_DEFINE_ENUM(NFS4ERR_OP_ILLEGAL);
    123. 

  123. TRACE_DEFINE_ENUM(NFS4ERR_OP_NOT_IN_SESSION);
    124. 

  124. TRACE_DEFINE_ENUM(NFS4ERR_PERM);
    125. 

  125. TRACE_DEFINE_ENUM(NFS4ERR_PNFS_IO_HOLE);
    126. 

  126. TRACE_DEFINE_ENUM(NFS4ERR_PNFS_NO_LAYOUT);
    127. 

  127. TRACE_DEFINE_ENUM(NFS4ERR_RECALLCONFLICT);
    128. 

  128. TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_BAD);
    129. 

  129. TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_CONFLICT);
    130. 

  130. TRACE_DEFINE_ENUM(NFS4ERR_REJECT_DELEG);
    131. 

  131. TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG);
    132. 

  132. TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG_TO_CACHE);
    133. 

  133. TRACE_DEFINE_ENUM(NFS4ERR_REQ_TOO_BIG);
    134. 

  134. TRACE_DEFINE_ENUM(NFS4ERR_RESOURCE);
    135. 

  135. TRACE_DEFINE_ENUM(NFS4ERR_RESTOREFH);
    136. 

  136. TRACE_DEFINE_ENUM(NFS4ERR_RETRY_UNCACHED_REP);
    137. 

  137. TRACE_DEFINE_ENUM(NFS4ERR_RETURNCONFLICT);
    138. 

  138. TRACE_DEFINE_ENUM(NFS4ERR_ROFS);
    139. 

  139. TRACE_DEFINE_ENUM(NFS4ERR_SAME);
    140. 

  140. TRACE_DEFINE_ENUM(NFS4ERR_SHARE_DENIED);
    141. 

  141. TRACE_DEFINE_ENUM(NFS4ERR_SEQUENCE_POS);
    142. 

  142. TRACE_DEFINE_ENUM(NFS4ERR_SEQ_FALSE_RETRY);
    143. 

  143. TRACE_DEFINE_ENUM(NFS4ERR_SEQ_MISORDERED);
    144. 

  144. TRACE_DEFINE_ENUM(NFS4ERR_SERVERFAULT);
    145. 

  145. TRACE_DEFINE_ENUM(NFS4ERR_STALE);
    146. 

  146. TRACE_DEFINE_ENUM(NFS4ERR_STALE_CLIENTID);
    147. 

  147. TRACE_DEFINE_ENUM(NFS4ERR_STALE_STATEID);
    148. 

  148. TRACE_DEFINE_ENUM(NFS4ERR_SYMLINK);
    149. 

  149. TRACE_DEFINE_ENUM(NFS4ERR_TOOSMALL);
    150. 

  150. TRACE_DEFINE_ENUM(NFS4ERR_TOO_MANY_OPS);
    151. 

  151. TRACE_DEFINE_ENUM(NFS4ERR_UNKNOWN_LAYOUTTYPE);
    152. 

  152. TRACE_DEFINE_ENUM(NFS4ERR_UNSAFE_COMPOUND);
    153. 

  153. TRACE_DEFINE_ENUM(NFS4ERR_WRONGSEC);
    154. 

  154. TRACE_DEFINE_ENUM(NFS4ERR_WRONG_CRED);
    155. 

  155. TRACE_DEFINE_ENUM(NFS4ERR_WRONG_TYPE);
    156. 

  156. TRACE_DEFINE_ENUM(NFS4ERR_XDEV);
    157. 

  157. 

  158. TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_MDS);
    159. 

  159. TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_PNFS);
    160. 

  160. 

  161. #define show_nfsv4_errors(error) \
    162. 

  162. 	__print_symbolic(error, \
    163. 

  163. 		{ NFS4_OK, "OK" }, \
    164. 

  164. 		/* Mapped by nfs4_stat_to_errno() */ \
    165. 

  165. 		{ EPERM, "EPERM" }, \
    166. 

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

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

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

  169. 		{ EACCES, "EACCES" }, \
    170. 

  170. 		{ EEXIST, "EEXIST" }, \
    171. 

  171. 		{ EXDEV, "EXDEV" }, \
    172. 

  172. 		{ ENOTDIR, "ENOTDIR" }, \
    173. 

  173. 		{ EISDIR, "EISDIR" }, \
    174. 

  174. 		{ EFBIG, "EFBIG" }, \
    175. 

  175. 		{ ENOSPC, "ENOSPC" }, \
    176. 

  176. 		{ EROFS, "EROFS" }, \
    177. 

  177. 		{ EMLINK, "EMLINK" }, \
    178. 

  178. 		{ ENAMETOOLONG, "ENAMETOOLONG" }, \
    179. 

  179. 		{ ENOTEMPTY, "ENOTEMPTY" }, \
    180. 

  180. 		{ EDQUOT, "EDQUOT" }, \
    181. 

  181. 		{ ESTALE, "ESTALE" }, \
    182. 

  182. 		{ EBADHANDLE, "EBADHANDLE" }, \
    183. 

  183. 		{ EBADCOOKIE, "EBADCOOKIE" }, \
    184. 

  184. 		{ ENOTSUPP, "ENOTSUPP" }, \
    185. 

  185. 		{ ETOOSMALL, "ETOOSMALL" }, \
    186. 

  186. 		{ EREMOTEIO, "EREMOTEIO" }, \
    187. 

  187. 		{ EBADTYPE, "EBADTYPE" }, \
    188. 

  188. 		{ EAGAIN, "EAGAIN" }, \
    189. 

  189. 		{ ELOOP, "ELOOP" }, \
    190. 

  190. 		{ EOPNOTSUPP, "EOPNOTSUPP" }, \
    191. 

  191. 		{ EDEADLK, "EDEADLK" }, \
    192. 

  192. 		/* RPC errors */ \
    193. 

  193. 		{ ENOMEM, "ENOMEM" }, \
    194. 

  194. 		{ EKEYEXPIRED, "EKEYEXPIRED" }, \
    195. 

  195. 		{ ETIMEDOUT, "ETIMEDOUT" }, \
    196. 

  196. 		{ ERESTARTSYS, "ERESTARTSYS" }, \
    197. 

  197. 		{ ECONNREFUSED, "ECONNREFUSED" }, \
    198. 

  198. 		{ ECONNRESET, "ECONNRESET" }, \
    199. 

  199. 		{ ENETUNREACH, "ENETUNREACH" }, \
    200. 

  200. 		{ EHOSTUNREACH, "EHOSTUNREACH" }, \
    201. 

  201. 		{ EHOSTDOWN, "EHOSTDOWN" }, \
    202. 

  202. 		{ EPIPE, "EPIPE" }, \
    203. 

  203. 		{ EPFNOSUPPORT, "EPFNOSUPPORT" }, \
    204. 

  204. 		{ EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \
    205. 

  205. 		/* NFSv4 native errors */ \
    206. 

  206. 		{ NFS4ERR_ACCESS, "ACCESS" }, \
    207. 

  207. 		{ NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
    208. 

  208. 		{ NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \
    209. 

  209. 		{ NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \
    210. 

  210. 		{ NFS4ERR_BADCHAR, "BADCHAR" }, \
    211. 

  211. 		{ NFS4ERR_BADHANDLE, "BADHANDLE" }, \
    212. 

  212. 		{ NFS4ERR_BADIOMODE, "BADIOMODE" }, \
    213. 

  213. 		{ NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \
    214. 

  214. 		{ NFS4ERR_BADLABEL, "BADLABEL" }, \
    215. 

  215. 		{ NFS4ERR_BADNAME, "BADNAME" }, \
    216. 

  216. 		{ NFS4ERR_BADOWNER, "BADOWNER" }, \
    217. 

  217. 		{ NFS4ERR_BADSESSION, "BADSESSION" }, \
    218. 

  218. 		{ NFS4ERR_BADSLOT, "BADSLOT" }, \
    219. 

  219. 		{ NFS4ERR_BADTYPE, "BADTYPE" }, \
    220. 

  220. 		{ NFS4ERR_BADXDR, "BADXDR" }, \
    221. 

  221. 		{ NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \
    222. 

  222. 		{ NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \
    223. 

  223. 		{ NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \
    224. 

  224. 		{ NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \
    225. 

  225. 		{ NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \
    226. 

  226. 		{ NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \
    227. 

  227. 		{ NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
    228. 

  228. 		{ NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \
    229. 

  229. 		{ NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \
    230. 

  230. 		{ NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \
    231. 

  231. 		{ NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \
    232. 

  232. 			"CONN_NOT_BOUND_TO_SESSION" }, \
    233. 

  233. 		{ NFS4ERR_DEADLOCK, "DEADLOCK" }, \
    234. 

  234. 		{ NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \
    235. 

  235. 		{ NFS4ERR_DELAY, "DELAY" }, \
    236. 

  236. 		{ NFS4ERR_DELEG_ALREADY_WANTED, \
    237. 

  237. 			"DELEG_ALREADY_WANTED" }, \
    238. 

  238. 		{ NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \
    239. 

  239. 		{ NFS4ERR_DENIED, "DENIED" }, \
    240. 

  240. 		{ NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \
    241. 

  241. 		{ NFS4ERR_DQUOT, "DQUOT" }, \
    242. 

  242. 		{ NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \
    243. 

  243. 		{ NFS4ERR_EXIST, "EXIST" }, \
    244. 

  244. 		{ NFS4ERR_EXPIRED, "EXPIRED" }, \
    245. 

  245. 		{ NFS4ERR_FBIG, "FBIG" }, \
    246. 

  246. 		{ NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \
    247. 

  247. 		{ NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \
    248. 

  248. 		{ NFS4ERR_GRACE, "GRACE" }, \
    249. 

  249. 		{ NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \
    250. 

  250. 		{ NFS4ERR_INVAL, "INVAL" }, \
    251. 

  251. 		{ NFS4ERR_IO, "IO" }, \
    252. 

  252. 		{ NFS4ERR_ISDIR, "ISDIR" }, \
    253. 

  253. 		{ NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \
    254. 

  254. 		{ NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \
    255. 

  255. 		{ NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \
    256. 

  256. 		{ NFS4ERR_LOCKED, "LOCKED" }, \
    257. 

  257. 		{ NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \
    258. 

  258. 		{ NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \
    259. 

  259. 		{ NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \
    260. 

  260. 		{ NFS4ERR_MLINK, "MLINK" }, \
    261. 

  261. 		{ NFS4ERR_MOVED, "MOVED" }, \
    262. 

  262. 		{ NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \
    263. 

  263. 		{ NFS4ERR_NOENT, "NOENT" }, \
    264. 

  264. 		{ NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \
    265. 

  265. 		{ NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \
    266. 

  266. 		{ NFS4ERR_NOSPC, "NOSPC" }, \
    267. 

  267. 		{ NFS4ERR_NOTDIR, "NOTDIR" }, \
    268. 

  268. 		{ NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \
    269. 

  269. 		{ NFS4ERR_NOTSUPP, "NOTSUPP" }, \
    270. 

  270. 		{ NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \
    271. 

  271. 		{ NFS4ERR_NOT_SAME, "NOT_SAME" }, \
    272. 

  272. 		{ NFS4ERR_NO_GRACE, "NO_GRACE" }, \
    273. 

  273. 		{ NFS4ERR_NXIO, "NXIO" }, \
    274. 

  274. 		{ NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \
    275. 

  275. 		{ NFS4ERR_OPENMODE, "OPENMODE" }, \
    276. 

  276. 		{ NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \
    277. 

  277. 		{ NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \
    278. 

  278. 		{ NFS4ERR_PERM, "PERM" }, \
    279. 

  279. 		{ NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \
    280. 

  280. 		{ NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \
    281. 

  281. 		{ NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \
    282. 

  282. 		{ NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \
    283. 

  283. 		{ NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \
    284. 

  284. 		{ NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \
    285. 

  285. 		{ NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \
    286. 

  286. 		{ NFS4ERR_REP_TOO_BIG_TO_CACHE, \
    287. 

  287. 			"REP_TOO_BIG_TO_CACHE" }, \
    288. 

  288. 		{ NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \
    289. 

  289. 		{ NFS4ERR_RESOURCE, "RESOURCE" }, \
    290. 

  290. 		{ NFS4ERR_RESTOREFH, "RESTOREFH" }, \
    291. 

  291. 		{ NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \
    292. 

  292. 		{ NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \
    293. 

  293. 		{ NFS4ERR_ROFS, "ROFS" }, \
    294. 

  294. 		{ NFS4ERR_SAME, "SAME" }, \
    295. 

  295. 		{ NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \
    296. 

  296. 		{ NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \
    297. 

  297. 		{ NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \
    298. 

  298. 		{ NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \
    299. 

  299. 		{ NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \
    300. 

  300. 		{ NFS4ERR_STALE, "STALE" }, \
    301. 

  301. 		{ NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \
    302. 

  302. 		{ NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \
    303. 

  303. 		{ NFS4ERR_SYMLINK, "SYMLINK" }, \
    304. 

  304. 		{ NFS4ERR_TOOSMALL, "TOOSMALL" }, \
    305. 

  305. 		{ NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \
    306. 

  306. 		{ NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \
    307. 

  307. 		{ NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \
    308. 

  308. 		{ NFS4ERR_WRONGSEC, "WRONGSEC" }, \
    309. 

  309. 		{ NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \
    310. 

  310. 		{ NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \
    311. 

  311. 		{ NFS4ERR_XDEV, "XDEV" }, \
    312. 

  312. 		/* ***** Internal to Linux NFS client ***** */ \
    313. 

  313. 		{ NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \
    314. 

  314. 		{ NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" })
    315. 

  315. 

  316. #define show_open_flags(flags) \
    317. 

  317. 	__print_flags(flags, "|", \
    318. 

  318. 		{ O_CREAT, "O_CREAT" }, \
    319. 

  319. 		{ O_EXCL, "O_EXCL" }, \
    320. 

  320. 		{ O_TRUNC, "O_TRUNC" }, \
    321. 

  321. 		{ O_DIRECT, "O_DIRECT" })
    322. 

  322. 

  323. #define show_fmode_flags(mode) \
    324. 

  324. 	__print_flags(mode, "|", \
    325. 

  325. 		{ ((__force unsigned long)FMODE_READ), "READ" }, \
    326. 

  326. 		{ ((__force unsigned long)FMODE_WRITE), "WRITE" }, \
    327. 

  327. 		{ ((__force unsigned long)FMODE_EXEC), "EXEC" })
    328. 

  328. 

  329. #define show_nfs_fattr_flags(valid) \
    330. 

  330. 	__print_flags((unsigned long)valid, "|", \
    331. 

  331. 		{ NFS_ATTR_FATTR_TYPE, "TYPE" }, \
    332. 

  332. 		{ NFS_ATTR_FATTR_MODE, "MODE" }, \
    333. 

  333. 		{ NFS_ATTR_FATTR_NLINK, "NLINK" }, \
    334. 

  334. 		{ NFS_ATTR_FATTR_OWNER, "OWNER" }, \
    335. 

  335. 		{ NFS_ATTR_FATTR_GROUP, "GROUP" }, \
    336. 

  336. 		{ NFS_ATTR_FATTR_RDEV, "RDEV" }, \
    337. 

  337. 		{ NFS_ATTR_FATTR_SIZE, "SIZE" }, \
    338. 

  338. 		{ NFS_ATTR_FATTR_FSID, "FSID" }, \
    339. 

  339. 		{ NFS_ATTR_FATTR_FILEID, "FILEID" }, \
    340. 

  340. 		{ NFS_ATTR_FATTR_ATIME, "ATIME" }, \
    341. 

  341. 		{ NFS_ATTR_FATTR_MTIME, "MTIME" }, \
    342. 

  342. 		{ NFS_ATTR_FATTR_CTIME, "CTIME" }, \
    343. 

  343. 		{ NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
    344. 

  344. 		{ NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
    345. 

  345. 		{ NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" })
    346. 

  346. 

  347. DECLARE_EVENT_CLASS(nfs4_clientid_event,
    348. 

  348. 		TP_PROTO(
    349. 

  349. 			const struct nfs_client *clp,
    350. 

  350. 			int error
    351. 

  351. 		),
    352. 

  352. 

  353. 		TP_ARGS(clp, error),
    354. 

  354. 

  355. 		TP_STRUCT__entry(
    356. 

  356. 			__string(dstaddr, clp->cl_hostname)
    357. 

  357. 			__field(unsigned long, error)
    358. 

  358. 		),
    359. 

  359. 

  360. 		TP_fast_assign(
    361. 

  361. 			__entry->error = error < 0 ? -error : 0;
    362. 

  362. 			__assign_str(dstaddr, clp->cl_hostname);
    363. 

  363. 		),
    364. 

  364. 

  365. 		TP_printk(
    366. 

  366. 			"error=%ld (%s) dstaddr=%s",
    367. 

  367. 			-__entry->error,
    368. 

  368. 			show_nfsv4_errors(__entry->error),
    369. 

  369. 			__get_str(dstaddr)
    370. 

  370. 		)
    371. 

  371. );
    372. 

  372. #define DEFINE_NFS4_CLIENTID_EVENT(name) \
    373. 

  373. 	DEFINE_EVENT(nfs4_clientid_event, name,	 \
    374. 

  374. 			TP_PROTO( \
    375. 

  375. 				const struct nfs_client *clp, \
    376. 

  376. 				int error \
    377. 

  377. 			), \
    378. 

  378. 			TP_ARGS(clp, error))
    379. 

  379. DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
    380. 

  380. DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
    381. 

  381. DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew);
    382. 

  382. DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async);
    383. 

  383. #ifdef CONFIG_NFS_V4_1
    384. 

  384. DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
    385. 

  385. DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
    386. 

  386. DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
    387. 

  387. DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
    388. 

  388. DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
    389. 

  389. DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence);
    390. 

  390. DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete);
    391. 

  391. 

  392. #define show_nfs4_sequence_status_flags(status) \
    393. 

  393. 	__print_flags((unsigned long)status, "|", \
    394. 

  394. 		{ SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \
    395. 

  395. 		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \
    396. 

  396. 			"CB_GSS_CONTEXTS_EXPIRING" }, \
    397. 

  397. 		{ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \
    398. 

  398. 			"CB_GSS_CONTEXTS_EXPIRED" }, \
    399. 

  399. 		{ SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \
    400. 

  400. 			"EXPIRED_ALL_STATE_REVOKED" }, \
    401. 

  401. 		{ SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \
    402. 

  402. 			"EXPIRED_SOME_STATE_REVOKED" }, \
    403. 

  403. 		{ SEQ4_STATUS_ADMIN_STATE_REVOKED, \
    404. 

  404. 			"ADMIN_STATE_REVOKED" }, \
    405. 

  405. 		{ SEQ4_STATUS_RECALLABLE_STATE_REVOKED,	 \
    406. 

  406. 			"RECALLABLE_STATE_REVOKED" }, \
    407. 

  407. 		{ SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \
    408. 

  408. 		{ SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \
    409. 

  409. 			"RESTART_RECLAIM_NEEDED" }, \
    410. 

  410. 		{ SEQ4_STATUS_CB_PATH_DOWN_SESSION, \
    411. 

  411. 			"CB_PATH_DOWN_SESSION" }, \
    412. 

  412. 		{ SEQ4_STATUS_BACKCHANNEL_FAULT, \
    413. 

  413. 			"BACKCHANNEL_FAULT" })
    414. 

  414. 

  415. TRACE_EVENT(nfs4_sequence_done,
    416. 

  416. 		TP_PROTO(
    417. 

  417. 			const struct nfs4_session *session,
    418. 

  418. 			const struct nfs4_sequence_res *res
    419. 

  419. 		),
    420. 

  420. 		TP_ARGS(session, res),
    421. 

  421. 

  422. 		TP_STRUCT__entry(
    423. 

  423. 			__field(unsigned int, session)
    424. 

  424. 			__field(unsigned int, slot_nr)
    425. 

  425. 			__field(unsigned int, seq_nr)
    426. 

  426. 			__field(unsigned int, highest_slotid)
    427. 

  427. 			__field(unsigned int, target_highest_slotid)
    428. 

  428. 			__field(unsigned int, status_flags)
    429. 

  429. 			__field(unsigned long, error)
    430. 

  430. 		),
    431. 

  431. 

  432. 		TP_fast_assign(
    433. 

  433. 			const struct nfs4_slot *sr_slot = res->sr_slot;
    434. 

  434. 			__entry->session = nfs_session_id_hash(&session->sess_id);
    435. 

  435. 			__entry->slot_nr = sr_slot->slot_nr;
    436. 

  436. 			__entry->seq_nr = sr_slot->seq_nr;
    437. 

  437. 			__entry->highest_slotid = res->sr_highest_slotid;
    438. 

  438. 			__entry->target_highest_slotid =
    439. 

  439. 					res->sr_target_highest_slotid;
    440. 

  440. 			__entry->status_flags = res->sr_status_flags;
    441. 

  441. 			__entry->error = res->sr_status < 0 ?
    442. 

  442. 					-res->sr_status : 0;
    443. 

  443. 		),
    444. 

  444. 		TP_printk(
    445. 

  445. 			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
    446. 

  446. 			"highest_slotid=%u target_highest_slotid=%u "
    447. 

  447. 			"status_flags=%u (%s)",
    448. 

  448. 			-__entry->error,
    449. 

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

  450. 			__entry->session,
    451. 

  451. 			__entry->slot_nr,
    452. 

  452. 			__entry->seq_nr,
    453. 

  453. 			__entry->highest_slotid,
    454. 

  454. 			__entry->target_highest_slotid,
    455. 

  455. 			__entry->status_flags,
    456. 

  456. 			show_nfs4_sequence_status_flags(__entry->status_flags)
    457. 

  457. 		)
    458. 

  458. );
    459. 

  459. 

  460. struct cb_sequenceargs;
    461. 

  461. struct cb_sequenceres;
    462. 

  462. 

  463. TRACE_EVENT(nfs4_cb_sequence,
    464. 

  464. 		TP_PROTO(
    465. 

  465. 			const struct cb_sequenceargs *args,
    466. 

  466. 			const struct cb_sequenceres *res,
    467. 

  467. 			__be32 status
    468. 

  468. 		),
    469. 

  469. 		TP_ARGS(args, res, status),
    470. 

  470. 

  471. 		TP_STRUCT__entry(
    472. 

  472. 			__field(unsigned int, session)
    473. 

  473. 			__field(unsigned int, slot_nr)
    474. 

  474. 			__field(unsigned int, seq_nr)
    475. 

  475. 			__field(unsigned int, highest_slotid)
    476. 

  476. 			__field(unsigned int, cachethis)
    477. 

  477. 			__field(unsigned long, error)
    478. 

  478. 		),
    479. 

  479. 

  480. 		TP_fast_assign(
    481. 

  481. 			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
    482. 

  482. 			__entry->slot_nr = args->csa_slotid;
    483. 

  483. 			__entry->seq_nr = args->csa_sequenceid;
    484. 

  484. 			__entry->highest_slotid = args->csa_highestslotid;
    485. 

  485. 			__entry->cachethis = args->csa_cachethis;
    486. 

  486. 			__entry->error = be32_to_cpu(status);
    487. 

  487. 		),
    488. 

  488. 

  489. 		TP_printk(
    490. 

  490. 			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
    491. 

  491. 			"highest_slotid=%u",
    492. 

  492. 			-__entry->error,
    493. 

  493. 			show_nfsv4_errors(__entry->error),
    494. 

  494. 			__entry->session,
    495. 

  495. 			__entry->slot_nr,
    496. 

  496. 			__entry->seq_nr,
    497. 

  497. 			__entry->highest_slotid
    498. 

  498. 		)
    499. 

  499. );
    500. 

  500. 

  501. TRACE_EVENT(nfs4_cb_seqid_err,
    502. 

  502. 		TP_PROTO(
    503. 

  503. 			const struct cb_sequenceargs *args,
    504. 

  504. 			__be32 status
    505. 

  505. 		),
    506. 

  506. 		TP_ARGS(args, status),
    507. 

  507. 

  508. 		TP_STRUCT__entry(
    509. 

  509. 			__field(unsigned int, session)
    510. 

  510. 			__field(unsigned int, slot_nr)
    511. 

  511. 			__field(unsigned int, seq_nr)
    512. 

  512. 			__field(unsigned int, highest_slotid)
    513. 

  513. 			__field(unsigned int, cachethis)
    514. 

  514. 			__field(unsigned long, error)
    515. 

  515. 		),
    516. 

  516. 

  517. 		TP_fast_assign(
    518. 

  518. 			__entry->session = nfs_session_id_hash(&args->csa_sessionid);
    519. 

  519. 			__entry->slot_nr = args->csa_slotid;
    520. 

  520. 			__entry->seq_nr = args->csa_sequenceid;
    521. 

  521. 			__entry->highest_slotid = args->csa_highestslotid;
    522. 

  522. 			__entry->cachethis = args->csa_cachethis;
    523. 

  523. 			__entry->error = be32_to_cpu(status);
    524. 

  524. 		),
    525. 

  525. 

  526. 		TP_printk(
    527. 

  527. 			"error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
    528. 

  528. 			"highest_slotid=%u",
    529. 

  529. 			-__entry->error,
    530. 

  530. 			show_nfsv4_errors(__entry->error),
    531. 

  531. 			__entry->session,
    532. 

  532. 			__entry->slot_nr,
    533. 

  533. 			__entry->seq_nr,
    534. 

  534. 			__entry->highest_slotid
    535. 

  535. 		)
    536. 

  536. );
    537. 

  537. 

  538. #endif /* CONFIG_NFS_V4_1 */
    539. 

  539. 

  540. TRACE_EVENT(nfs4_setup_sequence,
    541. 

  541. 		TP_PROTO(
    542. 

  542. 			const struct nfs4_session *session,
    543. 

  543. 			const struct nfs4_sequence_args *args
    544. 

  544. 		),
    545. 

  545. 		TP_ARGS(session, args),
    546. 

  546. 

  547. 		TP_STRUCT__entry(
    548. 

  548. 			__field(unsigned int, session)
    549. 

  549. 			__field(unsigned int, slot_nr)
    550. 

  550. 			__field(unsigned int, seq_nr)
    551. 

  551. 			__field(unsigned int, highest_used_slotid)
    552. 

  552. 		),
    553. 

  553. 

  554. 		TP_fast_assign(
    555. 

  555. 			const struct nfs4_slot *sa_slot = args->sa_slot;
    556. 

  556. 			__entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0;
    557. 

  557. 			__entry->slot_nr = sa_slot->slot_nr;
    558. 

  558. 			__entry->seq_nr = sa_slot->seq_nr;
    559. 

  559. 			__entry->highest_used_slotid =
    560. 

  560. 					sa_slot->table->highest_used_slotid;
    561. 

  561. 		),
    562. 

  562. 		TP_printk(
    563. 

  563. 			"session=0x%08x slot_nr=%u seq_nr=%u "
    564. 

  564. 			"highest_used_slotid=%u",
    565. 

  565. 			__entry->session,
    566. 

  566. 			__entry->slot_nr,
    567. 

  567. 			__entry->seq_nr,
    568. 

  568. 			__entry->highest_used_slotid
    569. 

  569. 		)
    570. 

  570. );
    571. 

  571. 

  572. TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING);
    573. 

  573. TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE);
    574. 

  574. TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED);
    575. 

  575. TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT);
    576. 

  576. TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE);
    577. 

  577. TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN);
    578. 

  578. TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET);
    579. 

  579. TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM);
    580. 

  580. TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH);
    581. 

  581. TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE);
    582. 

  582. TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION);
    583. 

  583. TRACE_DEFINE_ENUM(NFS4CLNT_MOVED);
    584. 

  584. TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED);
    585. 

  585. TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED);
    586. 

  586. TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER);
    587. 

  587. TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
    588. 

  588. TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
    589. 

  589. TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
    590. 

  590. 

  591. #define show_nfs4_clp_state(state) \
    592. 

  592. 	__print_flags(state, "|", \
    593. 

  593. 		{ NFS4CLNT_MANAGER_RUNNING,	"MANAGER_RUNNING" }, \
    594. 

  594. 		{ NFS4CLNT_CHECK_LEASE,		"CHECK_LEASE" }, \
    595. 

  595. 		{ NFS4CLNT_LEASE_EXPIRED,	"LEASE_EXPIRED" }, \
    596. 

  596. 		{ NFS4CLNT_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
    597. 

  597. 		{ NFS4CLNT_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
    598. 

  598. 		{ NFS4CLNT_DELEGRETURN,		"DELEGRETURN" }, \
    599. 

  599. 		{ NFS4CLNT_SESSION_RESET,	"SESSION_RESET" }, \
    600. 

  600. 		{ NFS4CLNT_LEASE_CONFIRM,	"LEASE_CONFIRM" }, \
    601. 

  601. 		{ NFS4CLNT_SERVER_SCOPE_MISMATCH, \
    602. 

  602. 						"SERVER_SCOPE_MISMATCH" }, \
    603. 

  603. 		{ NFS4CLNT_PURGE_STATE,		"PURGE_STATE" }, \
    604. 

  604. 		{ NFS4CLNT_BIND_CONN_TO_SESSION, \
    605. 

  605. 						"BIND_CONN_TO_SESSION" }, \
    606. 

  606. 		{ NFS4CLNT_MOVED,		"MOVED" }, \
    607. 

  607. 		{ NFS4CLNT_LEASE_MOVED,		"LEASE_MOVED" }, \
    608. 

  608. 		{ NFS4CLNT_DELEGATION_EXPIRED,	"DELEGATION_EXPIRED" }, \
    609. 

  609. 		{ NFS4CLNT_RUN_MANAGER,		"RUN_MANAGER" }, \
    610. 

  610. 		{ NFS4CLNT_RECALL_RUNNING,	"RECALL_RUNNING" }, \
    611. 

  611. 		{ NFS4CLNT_RECALL_ANY_LAYOUT_READ, "RECALL_ANY_LAYOUT_READ" }, \
    612. 

  612. 		{ NFS4CLNT_RECALL_ANY_LAYOUT_RW, "RECALL_ANY_LAYOUT_RW" })
    613. 

  613. 

  614. TRACE_EVENT(nfs4_state_mgr,
    615. 

  615. 		TP_PROTO(
    616. 

  616. 			const struct nfs_client *clp
    617. 

  617. 		),
    618. 

  618. 

  619. 		TP_ARGS(clp),
    620. 

  620. 

  621. 		TP_STRUCT__entry(
    622. 

  622. 			__field(unsigned long, state)
    623. 

  623. 			__string(hostname, clp->cl_hostname)
    624. 

  624. 		),
    625. 

  625. 

  626. 		TP_fast_assign(
    627. 

  627. 			__entry->state = clp->cl_state;
    628. 

  628. 			__assign_str(hostname, clp->cl_hostname)
    629. 

  629. 		),
    630. 

  630. 

  631. 		TP_printk(
    632. 

  632. 			"hostname=%s clp state=%s", __get_str(hostname),
    633. 

  633. 			show_nfs4_clp_state(__entry->state)
    634. 

  634. 		)
    635. 

  635. )
    636. 

  636. 

  637. TRACE_EVENT(nfs4_state_mgr_failed,
    638. 

  638. 		TP_PROTO(
    639. 

  639. 			const struct nfs_client *clp,
    640. 

  640. 			const char *section,
    641. 

  641. 			int status
    642. 

  642. 		),
    643. 

  643. 

  644. 		TP_ARGS(clp, section, status),
    645. 

  645. 

  646. 		TP_STRUCT__entry(
    647. 

  647. 			__field(unsigned long, error)
    648. 

  648. 			__field(unsigned long, state)
    649. 

  649. 			__string(hostname, clp->cl_hostname)
    650. 

  650. 			__string(section, section)
    651. 

  651. 		),
    652. 

  652. 

  653. 		TP_fast_assign(
    654. 

  654. 			__entry->error = status < 0 ? -status : 0;
    655. 

  655. 			__entry->state = clp->cl_state;
    656. 

  656. 			__assign_str(hostname, clp->cl_hostname);
    657. 

  657. 			__assign_str(section, section);
    658. 

  658. 		),
    659. 

  659. 

  660. 		TP_printk(
    661. 

  661. 			"hostname=%s clp state=%s error=%ld (%s) section=%s",
    662. 

  662. 			__get_str(hostname),
    663. 

  663. 			show_nfs4_clp_state(__entry->state), -__entry->error,
    664. 

  664. 			show_nfsv4_errors(__entry->error), __get_str(section)
    665. 

  665. 

  666. 		)
    667. 

  667. )
    668. 

  668. 

  669. TRACE_EVENT(nfs4_xdr_status,
    670. 

  670. 		TP_PROTO(
    671. 

  671. 			const struct xdr_stream *xdr,
    672. 

  672. 			u32 op,
    673. 

  673. 			u32 error
    674. 

  674. 		),
    675. 

  675. 

  676. 		TP_ARGS(xdr, op, error),
    677. 

  677. 

  678. 		TP_STRUCT__entry(
    679. 

  679. 			__field(unsigned int, task_id)
    680. 

  680. 			__field(unsigned int, client_id)
    681. 

  681. 			__field(u32, xid)
    682. 

  682. 			__field(u32, op)
    683. 

  683. 			__field(unsigned long, error)
    684. 

  684. 		),
    685. 

  685. 

  686. 		TP_fast_assign(
    687. 

  687. 			const struct rpc_rqst *rqstp = xdr->rqst;
    688. 

  688. 			const struct rpc_task *task = rqstp->rq_task;
    689. 

  689. 

  690. 			__entry->task_id = task->tk_pid;
    691. 

  691. 			__entry->client_id = task->tk_client->cl_clid;
    692. 

  692. 			__entry->xid = be32_to_cpu(rqstp->rq_xid);
    693. 

  693. 			__entry->op = op;
    694. 

  694. 			__entry->error = error;
    695. 

  695. 		),
    696. 

  696. 

  697. 		TP_printk(
    698. 

  698. 			"task:%u@%d xid=0x%08x error=%ld (%s) operation=%u",
    699. 

  699. 			__entry->task_id, __entry->client_id, __entry->xid,
    700. 

  700. 			-__entry->error, show_nfsv4_errors(__entry->error),
    701. 

  701. 			__entry->op
    702. 

  702. 		)
    703. 

  703. );
    704. 

  704. 

  705. DECLARE_EVENT_CLASS(nfs4_cb_error_class,
    706. 

  706. 		TP_PROTO(
    707. 

  707. 			__be32 xid,
    708. 

  708. 			u32 cb_ident
    709. 

  709. 		),
    710. 

  710. 

  711. 		TP_ARGS(xid, cb_ident),
    712. 

  712. 

  713. 		TP_STRUCT__entry(
    714. 

  714. 			__field(u32, xid)
    715. 

  715. 			__field(u32, cbident)
    716. 

  716. 		),
    717. 

  717. 

  718. 		TP_fast_assign(
    719. 

  719. 			__entry->xid = be32_to_cpu(xid);
    720. 

  720. 			__entry->cbident = cb_ident;
    721. 

  721. 		),
    722. 

  722. 

  723. 		TP_printk(
    724. 

  724. 			"xid=0x%08x cb_ident=0x%08x",
    725. 

  725. 			__entry->xid, __entry->cbident
    726. 

  726. 		)
    727. 

  727. );
    728. 

  728. 

  729. #define DEFINE_CB_ERROR_EVENT(name) \
    730. 

  730. 	DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
    731. 

  731. 			TP_PROTO( \
    732. 

  732. 				__be32 xid, \
    733. 

  733. 				u32 cb_ident \
    734. 

  734. 			), \
    735. 

  735. 			TP_ARGS(xid, cb_ident))
    736. 

  736. 

  737. DEFINE_CB_ERROR_EVENT(no_clp);
    738. 

  738. DEFINE_CB_ERROR_EVENT(badprinc);
    739. 

  739. 

  740. DECLARE_EVENT_CLASS(nfs4_open_event,
    741. 

  741. 		TP_PROTO(
    742. 

  742. 			const struct nfs_open_context *ctx,
    743. 

  743. 			int flags,
    744. 

  744. 			int error
    745. 

  745. 		),
    746. 

  746. 

  747. 		TP_ARGS(ctx, flags, error),
    748. 

  748. 

  749. 		TP_STRUCT__entry(
    750. 

  750. 			__field(unsigned long, error)
    751. 

  751. 			__field(unsigned int, flags)
    752. 

  752. 			__field(unsigned int, fmode)
    753. 

  753. 			__field(dev_t, dev)
    754. 

  754. 			__field(u32, fhandle)
    755. 

  755. 			__field(u64, fileid)
    756. 

  756. 			__field(u64, dir)
    757. 

  757. 			__string(name, ctx->dentry->d_name.name)
    758. 

  758. 			__field(int, stateid_seq)
    759. 

  759. 			__field(u32, stateid_hash)
    760. 

  760. 			__field(int, openstateid_seq)
    761. 

  761. 			__field(u32, openstateid_hash)
    762. 

  762. 		),
    763. 

  763. 

  764. 		TP_fast_assign(
    765. 

  765. 			const struct nfs4_state *state = ctx->state;
    766. 

  766. 			const struct inode *inode = NULL;
    767. 

  767. 

  768. 			__entry->error = -error;
    769. 

  769. 			__entry->flags = flags;
    770. 

  770. 			__entry->fmode = (__force unsigned int)ctx->mode;
    771. 

  771. 			__entry->dev = ctx->dentry->d_sb->s_dev;
    772. 

  772. 			if (!IS_ERR_OR_NULL(state)) {
    773. 

  773. 				inode = state->inode;
    774. 

  774. 				__entry->stateid_seq =
    775. 

  775. 					be32_to_cpu(state->stateid.seqid);
    776. 

  776. 				__entry->stateid_hash =
    777. 

  777. 					nfs_stateid_hash(&state->stateid);
    778. 

  778. 				__entry->openstateid_seq =
    779. 

  779. 					be32_to_cpu(state->open_stateid.seqid);
    780. 

  780. 				__entry->openstateid_hash =
    781. 

  781. 					nfs_stateid_hash(&state->open_stateid);
    782. 

  782. 			} else {
    783. 

  783. 				__entry->stateid_seq = 0;
    784. 

  784. 				__entry->stateid_hash = 0;
    785. 

  785. 				__entry->openstateid_seq = 0;
    786. 

  786. 				__entry->openstateid_hash = 0;
    787. 

  787. 			}
    788. 

  788. 			if (inode != NULL) {
    789. 

  789. 				__entry->fileid = NFS_FILEID(inode);
    790. 

  790. 				__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    791. 

  791. 			} else {
    792. 

  792. 				__entry->fileid = 0;
    793. 

  793. 				__entry->fhandle = 0;
    794. 

  794. 			}
    795. 

  795. 			__entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
    796. 

  796. 			__assign_str(name, ctx->dentry->d_name.name);
    797. 

  797. 		),
    798. 

  798. 

  799. 		TP_printk(
    800. 

  800. 			"error=%ld (%s) flags=%d (%s) fmode=%s "
    801. 

  801. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    802. 

  802. 			"name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
    803. 

  803. 			"openstateid=%d:0x%08x",
    804. 

  804. 			 -__entry->error,
    805. 

  805. 			 show_nfsv4_errors(__entry->error),
    806. 

  806. 			 __entry->flags,
    807. 

  807. 			 show_open_flags(__entry->flags),
    808. 

  808. 			 show_fmode_flags(__entry->fmode),
    809. 

  809. 			 MAJOR(__entry->dev), MINOR(__entry->dev),
    810. 

  810. 			 (unsigned long long)__entry->fileid,
    811. 

  811. 			 __entry->fhandle,
    812. 

  812. 			 MAJOR(__entry->dev), MINOR(__entry->dev),
    813. 

  813. 			 (unsigned long long)__entry->dir,
    814. 

  814. 			 __get_str(name),
    815. 

  815. 			 __entry->stateid_seq, __entry->stateid_hash,
    816. 

  816. 			 __entry->openstateid_seq, __entry->openstateid_hash
    817. 

  817. 		)
    818. 

  818. );
    819. 

  819. 

  820. #define DEFINE_NFS4_OPEN_EVENT(name) \
    821. 

  821. 	DEFINE_EVENT(nfs4_open_event, name, \
    822. 

  822. 			TP_PROTO( \
    823. 

  823. 				const struct nfs_open_context *ctx, \
    824. 

  824. 				int flags, \
    825. 

  825. 				int error \
    826. 

  826. 			), \
    827. 

  827. 			TP_ARGS(ctx, flags, error))
    828. 

  828. DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
    829. 

  829. DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
    830. 

  830. DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
    831. 

  831. 

  832. TRACE_EVENT(nfs4_cached_open,
    833. 

  833. 		TP_PROTO(
    834. 

  834. 			const struct nfs4_state *state
    835. 

  835. 		),
    836. 

  836. 		TP_ARGS(state),
    837. 

  837. 		TP_STRUCT__entry(
    838. 

  838. 			__field(dev_t, dev)
    839. 

  839. 			__field(u32, fhandle)
    840. 

  840. 			__field(u64, fileid)
    841. 

  841. 			__field(unsigned int, fmode)
    842. 

  842. 			__field(int, stateid_seq)
    843. 

  843. 			__field(u32, stateid_hash)
    844. 

  844. 		),
    845. 

  845. 

  846. 		TP_fast_assign(
    847. 

  847. 			const struct inode *inode = state->inode;
    848. 

  848. 

  849. 			__entry->dev = inode->i_sb->s_dev;
    850. 

  850. 			__entry->fileid = NFS_FILEID(inode);
    851. 

  851. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    852. 

  852. 			__entry->fmode = (__force unsigned int)state->state;
    853. 

  853. 			__entry->stateid_seq =
    854. 

  854. 				be32_to_cpu(state->stateid.seqid);
    855. 

  855. 			__entry->stateid_hash =
    856. 

  856. 				nfs_stateid_hash(&state->stateid);
    857. 

  857. 		),
    858. 

  858. 

  859. 		TP_printk(
    860. 

  860. 			"fmode=%s fileid=%02x:%02x:%llu "
    861. 

  861. 			"fhandle=0x%08x stateid=%d:0x%08x",
    862. 

  862. 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
    863. 

  863. 					  "closed",
    864. 

  864. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    865. 

  865. 			(unsigned long long)__entry->fileid,
    866. 

  866. 			__entry->fhandle,
    867. 

  867. 			__entry->stateid_seq, __entry->stateid_hash
    868. 

  868. 		)
    869. 

  869. );
    870. 

  870. 

  871. TRACE_EVENT(nfs4_close,
    872. 

  872. 		TP_PROTO(
    873. 

  873. 			const struct nfs4_state *state,
    874. 

  874. 			const struct nfs_closeargs *args,
    875. 

  875. 			const struct nfs_closeres *res,
    876. 

  876. 			int error
    877. 

  877. 		),
    878. 

  878. 

  879. 		TP_ARGS(state, args, res, error),
    880. 

  880. 

  881. 		TP_STRUCT__entry(
    882. 

  882. 			__field(dev_t, dev)
    883. 

  883. 			__field(u32, fhandle)
    884. 

  884. 			__field(u64, fileid)
    885. 

  885. 			__field(unsigned int, fmode)
    886. 

  886. 			__field(unsigned long, error)
    887. 

  887. 			__field(int, stateid_seq)
    888. 

  888. 			__field(u32, stateid_hash)
    889. 

  889. 		),
    890. 

  890. 

  891. 		TP_fast_assign(
    892. 

  892. 			const struct inode *inode = state->inode;
    893. 

  893. 

  894. 			__entry->dev = inode->i_sb->s_dev;
    895. 

  895. 			__entry->fileid = NFS_FILEID(inode);
    896. 

  896. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    897. 

  897. 			__entry->fmode = (__force unsigned int)state->state;
    898. 

  898. 			__entry->error = error < 0 ? -error : 0;
    899. 

  899. 			__entry->stateid_seq =
    900. 

  900. 				be32_to_cpu(args->stateid.seqid);
    901. 

  901. 			__entry->stateid_hash =
    902. 

  902. 				nfs_stateid_hash(&args->stateid);
    903. 

  903. 		),
    904. 

  904. 

  905. 		TP_printk(
    906. 

  906. 			"error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
    907. 

  907. 			"fhandle=0x%08x openstateid=%d:0x%08x",
    908. 

  908. 			-__entry->error,
    909. 

  909. 			show_nfsv4_errors(__entry->error),
    910. 

  910. 			__entry->fmode ?  show_fmode_flags(__entry->fmode) :
    911. 

  911. 					  "closed",
    912. 

  912. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    913. 

  913. 			(unsigned long long)__entry->fileid,
    914. 

  914. 			__entry->fhandle,
    915. 

  915. 			__entry->stateid_seq, __entry->stateid_hash
    916. 

  916. 		)
    917. 

  917. );
    918. 

  918. 

  919. TRACE_DEFINE_ENUM(F_GETLK);
    920. 

  920. TRACE_DEFINE_ENUM(F_SETLK);
    921. 

  921. TRACE_DEFINE_ENUM(F_SETLKW);
    922. 

  922. TRACE_DEFINE_ENUM(F_RDLCK);
    923. 

  923. TRACE_DEFINE_ENUM(F_WRLCK);
    924. 

  924. TRACE_DEFINE_ENUM(F_UNLCK);
    925. 

  925. 

  926. #define show_lock_cmd(type) \
    927. 

  927. 	__print_symbolic((int)type, \
    928. 

  928. 		{ F_GETLK, "GETLK" }, \
    929. 

  929. 		{ F_SETLK, "SETLK" }, \
    930. 

  930. 		{ F_SETLKW, "SETLKW" })
    931. 

  931. #define show_lock_type(type) \
    932. 

  932. 	__print_symbolic((int)type, \
    933. 

  933. 		{ F_RDLCK, "RDLCK" }, \
    934. 

  934. 		{ F_WRLCK, "WRLCK" }, \
    935. 

  935. 		{ F_UNLCK, "UNLCK" })
    936. 

  936. 

  937. DECLARE_EVENT_CLASS(nfs4_lock_event,
    938. 

  938. 		TP_PROTO(
    939. 

  939. 			const struct file_lock *request,
    940. 

  940. 			const struct nfs4_state *state,
    941. 

  941. 			int cmd,
    942. 

  942. 			int error
    943. 

  943. 		),
    944. 

  944. 

  945. 		TP_ARGS(request, state, cmd, error),
    946. 

  946. 

  947. 		TP_STRUCT__entry(
    948. 

  948. 			__field(unsigned long, error)
    949. 

  949. 			__field(int, cmd)
    950. 

  950. 			__field(char, type)
    951. 

  951. 			__field(loff_t, start)
    952. 

  952. 			__field(loff_t, end)
    953. 

  953. 			__field(dev_t, dev)
    954. 

  954. 			__field(u32, fhandle)
    955. 

  955. 			__field(u64, fileid)
    956. 

  956. 			__field(int, stateid_seq)
    957. 

  957. 			__field(u32, stateid_hash)
    958. 

  958. 		),
    959. 

  959. 

  960. 		TP_fast_assign(
    961. 

  961. 			const struct inode *inode = state->inode;
    962. 

  962. 

  963. 			__entry->error = error < 0 ? -error : 0;
    964. 

  964. 			__entry->cmd = cmd;
    965. 

  965. 			__entry->type = request->fl_type;
    966. 

  966. 			__entry->start = request->fl_start;
    967. 

  967. 			__entry->end = request->fl_end;
    968. 

  968. 			__entry->dev = inode->i_sb->s_dev;
    969. 

  969. 			__entry->fileid = NFS_FILEID(inode);
    970. 

  970. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    971. 

  971. 			__entry->stateid_seq =
    972. 

  972. 				be32_to_cpu(state->stateid.seqid);
    973. 

  973. 			__entry->stateid_hash =
    974. 

  974. 				nfs_stateid_hash(&state->stateid);
    975. 

  975. 		),
    976. 

  976. 

  977. 		TP_printk(
    978. 

  978. 			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
    979. 

  979. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    980. 

  980. 			"stateid=%d:0x%08x",
    981. 

  981. 			-__entry->error,
    982. 

  982. 			show_nfsv4_errors(__entry->error),
    983. 

  983. 			show_lock_cmd(__entry->cmd),
    984. 

  984. 			show_lock_type(__entry->type),
    985. 

  985. 			(long long)__entry->start,
    986. 

  986. 			(long long)__entry->end,
    987. 

  987. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    988. 

  988. 			(unsigned long long)__entry->fileid,
    989. 

  989. 			__entry->fhandle,
    990. 

  990. 			__entry->stateid_seq, __entry->stateid_hash
    991. 

  991. 		)
    992. 

  992. );
    993. 

  993. 

  994. #define DEFINE_NFS4_LOCK_EVENT(name) \
    995. 

  995. 	DEFINE_EVENT(nfs4_lock_event, name, \
    996. 

  996. 			TP_PROTO( \
    997. 

  997. 				const struct file_lock *request, \
    998. 

  998. 				const struct nfs4_state *state, \
    999. 

  999. 				int cmd, \
    1000. 

  1000. 				int error \
    1001. 

  1001. 			), \
    1002. 

  1002. 			TP_ARGS(request, state, cmd, error))
    1003. 

  1003. DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
    1004. 

  1004. DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
    1005. 

  1005. 

  1006. TRACE_EVENT(nfs4_set_lock,
    1007. 

  1007. 		TP_PROTO(
    1008. 

  1008. 			const struct file_lock *request,
    1009. 

  1009. 			const struct nfs4_state *state,
    1010. 

  1010. 			const nfs4_stateid *lockstateid,
    1011. 

  1011. 			int cmd,
    1012. 

  1012. 			int error
    1013. 

  1013. 		),
    1014. 

  1014. 

  1015. 		TP_ARGS(request, state, lockstateid, cmd, error),
    1016. 

  1016. 

  1017. 		TP_STRUCT__entry(
    1018. 

  1018. 			__field(unsigned long, error)
    1019. 

  1019. 			__field(int, cmd)
    1020. 

  1020. 			__field(char, type)
    1021. 

  1021. 			__field(loff_t, start)
    1022. 

  1022. 			__field(loff_t, end)
    1023. 

  1023. 			__field(dev_t, dev)
    1024. 

  1024. 			__field(u32, fhandle)
    1025. 

  1025. 			__field(u64, fileid)
    1026. 

  1026. 			__field(int, stateid_seq)
    1027. 

  1027. 			__field(u32, stateid_hash)
    1028. 

  1028. 			__field(int, lockstateid_seq)
    1029. 

  1029. 			__field(u32, lockstateid_hash)
    1030. 

  1030. 		),
    1031. 

  1031. 

  1032. 		TP_fast_assign(
    1033. 

  1033. 			const struct inode *inode = state->inode;
    1034. 

  1034. 

  1035. 			__entry->error = error < 0 ? -error : 0;
    1036. 

  1036. 			__entry->cmd = cmd;
    1037. 

  1037. 			__entry->type = request->fl_type;
    1038. 

  1038. 			__entry->start = request->fl_start;
    1039. 

  1039. 			__entry->end = request->fl_end;
    1040. 

  1040. 			__entry->dev = inode->i_sb->s_dev;
    1041. 

  1041. 			__entry->fileid = NFS_FILEID(inode);
    1042. 

  1042. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1043. 

  1043. 			__entry->stateid_seq =
    1044. 

  1044. 				be32_to_cpu(state->stateid.seqid);
    1045. 

  1045. 			__entry->stateid_hash =
    1046. 

  1046. 				nfs_stateid_hash(&state->stateid);
    1047. 

  1047. 			__entry->lockstateid_seq =
    1048. 

  1048. 				be32_to_cpu(lockstateid->seqid);
    1049. 

  1049. 			__entry->lockstateid_hash =
    1050. 

  1050. 				nfs_stateid_hash(lockstateid);
    1051. 

  1051. 		),
    1052. 

  1052. 

  1053. 		TP_printk(
    1054. 

  1054. 			"error=%ld (%s) cmd=%s:%s range=%lld:%lld "
    1055. 

  1055. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    1056. 

  1056. 			"stateid=%d:0x%08x lockstateid=%d:0x%08x",
    1057. 

  1057. 			-__entry->error,
    1058. 

  1058. 			show_nfsv4_errors(__entry->error),
    1059. 

  1059. 			show_lock_cmd(__entry->cmd),
    1060. 

  1060. 			show_lock_type(__entry->type),
    1061. 

  1061. 			(long long)__entry->start,
    1062. 

  1062. 			(long long)__entry->end,
    1063. 

  1063. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1064. 

  1064. 			(unsigned long long)__entry->fileid,
    1065. 

  1065. 			__entry->fhandle,
    1066. 

  1066. 			__entry->stateid_seq, __entry->stateid_hash,
    1067. 

  1067. 			__entry->lockstateid_seq, __entry->lockstateid_hash
    1068. 

  1068. 		)
    1069. 

  1069. );
    1070. 

  1070. 

  1071. TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
    1072. 

  1072. TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
    1073. 

  1073. TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
    1074. 

  1074. TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
    1075. 

  1075. TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
    1076. 

  1076. TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
    1077. 

  1077. TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
    1078. 

  1078. TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
    1079. 

  1079. TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
    1080. 

  1080. TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
    1081. 

  1081. TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
    1082. 

  1082. TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
    1083. 

  1083. TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
    1084. 

  1084. TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
    1085. 

  1085. TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
    1086. 

  1086. 

  1087. #define show_nfs4_state_flags(flags) \
    1088. 

  1088. 	__print_flags(flags, "|", \
    1089. 

  1089. 		{ LK_STATE_IN_USE,		"IN_USE" }, \
    1090. 

  1090. 		{ NFS_DELEGATED_STATE,		"DELEGATED" }, \
    1091. 

  1091. 		{ NFS_OPEN_STATE,		"OPEN" }, \
    1092. 

  1092. 		{ NFS_O_RDONLY_STATE,		"O_RDONLY" }, \
    1093. 

  1093. 		{ NFS_O_WRONLY_STATE,		"O_WRONLY" }, \
    1094. 

  1094. 		{ NFS_O_RDWR_STATE,		"O_RDWR" }, \
    1095. 

  1095. 		{ NFS_STATE_RECLAIM_REBOOT,	"RECLAIM_REBOOT" }, \
    1096. 

  1096. 		{ NFS_STATE_RECLAIM_NOGRACE,	"RECLAIM_NOGRACE" }, \
    1097. 

  1097. 		{ NFS_STATE_POSIX_LOCKS,	"POSIX_LOCKS" }, \
    1098. 

  1098. 		{ NFS_STATE_RECOVERY_FAILED,	"RECOVERY_FAILED" }, \
    1099. 

  1099. 		{ NFS_STATE_MAY_NOTIFY_LOCK,	"MAY_NOTIFY_LOCK" }, \
    1100. 

  1100. 		{ NFS_STATE_CHANGE_WAIT,	"CHANGE_WAIT" }, \
    1101. 

  1101. 		{ NFS_CLNT_DST_SSC_COPY_STATE,	"CLNT_DST_SSC_COPY" }, \
    1102. 

  1102. 		{ NFS_CLNT_SRC_SSC_COPY_STATE,	"CLNT_SRC_SSC_COPY" }, \
    1103. 

  1103. 		{ NFS_SRV_SSC_COPY_STATE,	"SRV_SSC_COPY" })
    1104. 

  1104. 

  1105. #define show_nfs4_lock_flags(flags) \
    1106. 

  1106. 	__print_flags(flags, "|", \
    1107. 

  1107. 		{ BIT(NFS_LOCK_INITIALIZED),	"INITIALIZED" }, \
    1108. 

  1108. 		{ BIT(NFS_LOCK_LOST),		"LOST" })
    1109. 

  1109. 

  1110. TRACE_EVENT(nfs4_state_lock_reclaim,
    1111. 

  1111. 		TP_PROTO(
    1112. 

  1112. 			const struct nfs4_state *state,
    1113. 

  1113. 			const struct nfs4_lock_state *lock
    1114. 

  1114. 		),
    1115. 

  1115. 

  1116. 		TP_ARGS(state, lock),
    1117. 

  1117. 

  1118. 		TP_STRUCT__entry(
    1119. 

  1119. 			__field(dev_t, dev)
    1120. 

  1120. 			__field(u32, fhandle)
    1121. 

  1121. 			__field(u64, fileid)
    1122. 

  1122. 			__field(unsigned long, state_flags)
    1123. 

  1123. 			__field(unsigned long, lock_flags)
    1124. 

  1124. 			__field(int, stateid_seq)
    1125. 

  1125. 			__field(u32, stateid_hash)
    1126. 

  1126. 		),
    1127. 

  1127. 

  1128. 		TP_fast_assign(
    1129. 

  1129. 			const struct inode *inode = state->inode;
    1130. 

  1130. 

  1131. 			__entry->dev = inode->i_sb->s_dev;
    1132. 

  1132. 			__entry->fileid = NFS_FILEID(inode);
    1133. 

  1133. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1134. 

  1134. 			__entry->state_flags = state->flags;
    1135. 

  1135. 			__entry->lock_flags = lock->ls_flags;
    1136. 

  1136. 			__entry->stateid_seq =
    1137. 

  1137. 				be32_to_cpu(state->stateid.seqid);
    1138. 

  1138. 			__entry->stateid_hash =
    1139. 

  1139. 				nfs_stateid_hash(&state->stateid);
    1140. 

  1140. 		),
    1141. 

  1141. 

  1142. 		TP_printk(
    1143. 

  1143. 			"fileid=%02x:%02x:%llu fhandle=0x%08x "
    1144. 

  1144. 			"stateid=%d:0x%08x state_flags=%s lock_flags=%s",
    1145. 

  1145. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1146. 

  1146. 			(unsigned long long)__entry->fileid, __entry->fhandle,
    1147. 

  1147. 			__entry->stateid_seq, __entry->stateid_hash,
    1148. 

  1148. 			show_nfs4_state_flags(__entry->state_flags),
    1149. 

  1149. 			show_nfs4_lock_flags(__entry->lock_flags)
    1150. 

  1150. 		)
    1151. 

  1151. )
    1152. 

  1152. 

  1153. DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
    1154. 

  1154. 		TP_PROTO(
    1155. 

  1155. 			const struct inode *inode,
    1156. 

  1156. 			fmode_t fmode
    1157. 

  1157. 		),
    1158. 

  1158. 

  1159. 		TP_ARGS(inode, fmode),
    1160. 

  1160. 

  1161. 		TP_STRUCT__entry(
    1162. 

  1162. 			__field(dev_t, dev)
    1163. 

  1163. 			__field(u32, fhandle)
    1164. 

  1164. 			__field(u64, fileid)
    1165. 

  1165. 			__field(unsigned int, fmode)
    1166. 

  1166. 		),
    1167. 

  1167. 

  1168. 		TP_fast_assign(
    1169. 

  1169. 			__entry->dev = inode->i_sb->s_dev;
    1170. 

  1170. 			__entry->fileid = NFS_FILEID(inode);
    1171. 

  1171. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1172. 

  1172. 			__entry->fmode = (__force unsigned int)fmode;
    1173. 

  1173. 		),
    1174. 

  1174. 

  1175. 		TP_printk(
    1176. 

  1176. 			"fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
    1177. 

  1177. 			show_fmode_flags(__entry->fmode),
    1178. 

  1178. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1179. 

  1179. 			(unsigned long long)__entry->fileid,
    1180. 

  1180. 			__entry->fhandle
    1181. 

  1181. 		)
    1182. 

  1182. );
    1183. 

  1183. #define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
    1184. 

  1184. 	DEFINE_EVENT(nfs4_set_delegation_event, name, \
    1185. 

  1185. 			TP_PROTO( \
    1186. 

  1186. 				const struct inode *inode, \
    1187. 

  1187. 				fmode_t fmode \
    1188. 

  1188. 			), \
    1189. 

  1189. 			TP_ARGS(inode, fmode))
    1190. 

  1190. DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
    1191. 

  1191. DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
    1192. 

  1192. 

  1193. TRACE_EVENT(nfs4_delegreturn_exit,
    1194. 

  1194. 		TP_PROTO(
    1195. 

  1195. 			const struct nfs4_delegreturnargs *args,
    1196. 

  1196. 			const struct nfs4_delegreturnres *res,
    1197. 

  1197. 			int error
    1198. 

  1198. 		),
    1199. 

  1199. 

  1200. 		TP_ARGS(args, res, error),
    1201. 

  1201. 

  1202. 		TP_STRUCT__entry(
    1203. 

  1203. 			__field(dev_t, dev)
    1204. 

  1204. 			__field(u32, fhandle)
    1205. 

  1205. 			__field(unsigned long, error)
    1206. 

  1206. 			__field(int, stateid_seq)
    1207. 

  1207. 			__field(u32, stateid_hash)
    1208. 

  1208. 		),
    1209. 

  1209. 

  1210. 		TP_fast_assign(
    1211. 

  1211. 			__entry->dev = res->server->s_dev;
    1212. 

  1212. 			__entry->fhandle = nfs_fhandle_hash(args->fhandle);
    1213. 

  1213. 			__entry->error = error < 0 ? -error : 0;
    1214. 

  1214. 			__entry->stateid_seq =
    1215. 

  1215. 				be32_to_cpu(args->stateid->seqid);
    1216. 

  1216. 			__entry->stateid_hash =
    1217. 

  1217. 				nfs_stateid_hash(args->stateid);
    1218. 

  1218. 		),
    1219. 

  1219. 

  1220. 		TP_printk(
    1221. 

  1221. 			"error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
    1222. 

  1222. 			"stateid=%d:0x%08x",
    1223. 

  1223. 			-__entry->error,
    1224. 

  1224. 			show_nfsv4_errors(__entry->error),
    1225. 

  1225. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1226. 

  1226. 			__entry->fhandle,
    1227. 

  1227. 			__entry->stateid_seq, __entry->stateid_hash
    1228. 

  1228. 		)
    1229. 

  1229. );
    1230. 

  1230. 

  1231. #ifdef CONFIG_NFS_V4_1
    1232. 

  1232. DECLARE_EVENT_CLASS(nfs4_test_stateid_event,
    1233. 

  1233. 		TP_PROTO(
    1234. 

  1234. 			const struct nfs4_state *state,
    1235. 

  1235. 			const struct nfs4_lock_state *lsp,
    1236. 

  1236. 			int error
    1237. 

  1237. 		),
    1238. 

  1238. 

  1239. 		TP_ARGS(state, lsp, error),
    1240. 

  1240. 

  1241. 		TP_STRUCT__entry(
    1242. 

  1242. 			__field(unsigned long, error)
    1243. 

  1243. 			__field(dev_t, dev)
    1244. 

  1244. 			__field(u32, fhandle)
    1245. 

  1245. 			__field(u64, fileid)
    1246. 

  1246. 			__field(int, stateid_seq)
    1247. 

  1247. 			__field(u32, stateid_hash)
    1248. 

  1248. 		),
    1249. 

  1249. 

  1250. 		TP_fast_assign(
    1251. 

  1251. 			const struct inode *inode = state->inode;
    1252. 

  1252. 

  1253. 			__entry->error = error < 0 ? -error : 0;
    1254. 

  1254. 			__entry->dev = inode->i_sb->s_dev;
    1255. 

  1255. 			__entry->fileid = NFS_FILEID(inode);
    1256. 

  1256. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1257. 

  1257. 			__entry->stateid_seq =
    1258. 

  1258. 				be32_to_cpu(state->stateid.seqid);
    1259. 

  1259. 			__entry->stateid_hash =
    1260. 

  1260. 				nfs_stateid_hash(&state->stateid);
    1261. 

  1261. 		),
    1262. 

  1262. 

  1263. 		TP_printk(
    1264. 

  1264. 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1265. 

  1265. 			"stateid=%d:0x%08x",
    1266. 

  1266. 			-__entry->error,
    1267. 

  1267. 			show_nfsv4_errors(__entry->error),
    1268. 

  1268. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1269. 

  1269. 			(unsigned long long)__entry->fileid,
    1270. 

  1270. 			__entry->fhandle,
    1271. 

  1271. 			__entry->stateid_seq, __entry->stateid_hash
    1272. 

  1272. 		)
    1273. 

  1273. );
    1274. 

  1274. 

  1275. #define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
    1276. 

  1276. 	DEFINE_EVENT(nfs4_test_stateid_event, name, \
    1277. 

  1277. 			TP_PROTO( \
    1278. 

  1278. 				const struct nfs4_state *state, \
    1279. 

  1279. 				const struct nfs4_lock_state *lsp, \
    1280. 

  1280. 				int error \
    1281. 

  1281. 			), \
    1282. 

  1282. 			TP_ARGS(state, lsp, error))
    1283. 

  1283. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid);
    1284. 

  1284. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid);
    1285. 

  1285. DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid);
    1286. 

  1286. #endif /* CONFIG_NFS_V4_1 */
    1287. 

  1287. 

  1288. DECLARE_EVENT_CLASS(nfs4_lookup_event,
    1289. 

  1289. 		TP_PROTO(
    1290. 

  1290. 			const struct inode *dir,
    1291. 

  1291. 			const struct qstr *name,
    1292. 

  1292. 			int error
    1293. 

  1293. 		),
    1294. 

  1294. 

  1295. 		TP_ARGS(dir, name, error),
    1296. 

  1296. 

  1297. 		TP_STRUCT__entry(
    1298. 

  1298. 			__field(dev_t, dev)
    1299. 

  1299. 			__field(unsigned long, error)
    1300. 

  1300. 			__field(u64, dir)
    1301. 

  1301. 			__string(name, name->name)
    1302. 

  1302. 		),
    1303. 

  1303. 

  1304. 		TP_fast_assign(
    1305. 

  1305. 			__entry->dev = dir->i_sb->s_dev;
    1306. 

  1306. 			__entry->dir = NFS_FILEID(dir);
    1307. 

  1307. 			__entry->error = -error;
    1308. 

  1308. 			__assign_str(name, name->name);
    1309. 

  1309. 		),
    1310. 

  1310. 

  1311. 		TP_printk(
    1312. 

  1312. 			"error=%ld (%s) name=%02x:%02x:%llu/%s",
    1313. 

  1313. 			-__entry->error,
    1314. 

  1314. 			show_nfsv4_errors(__entry->error),
    1315. 

  1315. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1316. 

  1316. 			(unsigned long long)__entry->dir,
    1317. 

  1317. 			__get_str(name)
    1318. 

  1318. 		)
    1319. 

  1319. );
    1320. 

  1320. 

  1321. #define DEFINE_NFS4_LOOKUP_EVENT(name) \
    1322. 

  1322. 	DEFINE_EVENT(nfs4_lookup_event, name, \
    1323. 

  1323. 			TP_PROTO( \
    1324. 

  1324. 				const struct inode *dir, \
    1325. 

  1325. 				const struct qstr *name, \
    1326. 

  1326. 				int error \
    1327. 

  1327. 			), \
    1328. 

  1328. 			TP_ARGS(dir, name, error))
    1329. 

  1329. 

  1330. DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
    1331. 

  1331. DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
    1332. 

  1332. DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
    1333. 

  1333. DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
    1334. 

  1334. DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
    1335. 

  1335. DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
    1336. 

  1336. DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
    1337. 

  1337. 

  1338. TRACE_EVENT(nfs4_lookupp,
    1339. 

  1339. 		TP_PROTO(
    1340. 

  1340. 			const struct inode *inode,
    1341. 

  1341. 			int error
    1342. 

  1342. 		),
    1343. 

  1343. 

  1344. 		TP_ARGS(inode, error),
    1345. 

  1345. 

  1346. 		TP_STRUCT__entry(
    1347. 

  1347. 			__field(dev_t, dev)
    1348. 

  1348. 			__field(u64, ino)
    1349. 

  1349. 			__field(unsigned long, error)
    1350. 

  1350. 		),
    1351. 

  1351. 

  1352. 		TP_fast_assign(
    1353. 

  1353. 			__entry->dev = inode->i_sb->s_dev;
    1354. 

  1354. 			__entry->ino = NFS_FILEID(inode);
    1355. 

  1355. 			__entry->error = error < 0 ? -error : 0;
    1356. 

  1356. 		),
    1357. 

  1357. 

  1358. 		TP_printk(
    1359. 

  1359. 			"error=%ld (%s) inode=%02x:%02x:%llu",
    1360. 

  1360. 			-__entry->error,
    1361. 

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

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

  1363. 			(unsigned long long)__entry->ino
    1364. 

  1364. 		)
    1365. 

  1365. );
    1366. 

  1366. 

  1367. TRACE_EVENT(nfs4_rename,
    1368. 

  1368. 		TP_PROTO(
    1369. 

  1369. 			const struct inode *olddir,
    1370. 

  1370. 			const struct qstr *oldname,
    1371. 

  1371. 			const struct inode *newdir,
    1372. 

  1372. 			const struct qstr *newname,
    1373. 

  1373. 			int error
    1374. 

  1374. 		),
    1375. 

  1375. 

  1376. 		TP_ARGS(olddir, oldname, newdir, newname, error),
    1377. 

  1377. 

  1378. 		TP_STRUCT__entry(
    1379. 

  1379. 			__field(dev_t, dev)
    1380. 

  1380. 			__field(unsigned long, error)
    1381. 

  1381. 			__field(u64, olddir)
    1382. 

  1382. 			__string(oldname, oldname->name)
    1383. 

  1383. 			__field(u64, newdir)
    1384. 

  1384. 			__string(newname, newname->name)
    1385. 

  1385. 		),
    1386. 

  1386. 

  1387. 		TP_fast_assign(
    1388. 

  1388. 			__entry->dev = olddir->i_sb->s_dev;
    1389. 

  1389. 			__entry->olddir = NFS_FILEID(olddir);
    1390. 

  1390. 			__entry->newdir = NFS_FILEID(newdir);
    1391. 

  1391. 			__entry->error = error < 0 ? -error : 0;
    1392. 

  1392. 			__assign_str(oldname, oldname->name);
    1393. 

  1393. 			__assign_str(newname, newname->name);
    1394. 

  1394. 		),
    1395. 

  1395. 

  1396. 		TP_printk(
    1397. 

  1397. 			"error=%ld (%s) oldname=%02x:%02x:%llu/%s "
    1398. 

  1398. 			"newname=%02x:%02x:%llu/%s",
    1399. 

  1399. 			-__entry->error,
    1400. 

  1400. 			show_nfsv4_errors(__entry->error),
    1401. 

  1401. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1402. 

  1402. 			(unsigned long long)__entry->olddir,
    1403. 

  1403. 			__get_str(oldname),
    1404. 

  1404. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1405. 

  1405. 			(unsigned long long)__entry->newdir,
    1406. 

  1406. 			__get_str(newname)
    1407. 

  1407. 		)
    1408. 

  1408. );
    1409. 

  1409. 

  1410. DECLARE_EVENT_CLASS(nfs4_inode_event,
    1411. 

  1411. 		TP_PROTO(
    1412. 

  1412. 			const struct inode *inode,
    1413. 

  1413. 			int error
    1414. 

  1414. 		),
    1415. 

  1415. 

  1416. 		TP_ARGS(inode, error),
    1417. 

  1417. 

  1418. 		TP_STRUCT__entry(
    1419. 

  1419. 			__field(dev_t, dev)
    1420. 

  1420. 			__field(u32, fhandle)
    1421. 

  1421. 			__field(u64, fileid)
    1422. 

  1422. 			__field(unsigned long, error)
    1423. 

  1423. 		),
    1424. 

  1424. 

  1425. 		TP_fast_assign(
    1426. 

  1426. 			__entry->dev = inode->i_sb->s_dev;
    1427. 

  1427. 			__entry->fileid = NFS_FILEID(inode);
    1428. 

  1428. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1429. 

  1429. 			__entry->error = error < 0 ? -error : 0;
    1430. 

  1430. 		),
    1431. 

  1431. 

  1432. 		TP_printk(
    1433. 

  1433. 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
    1434. 

  1434. 			-__entry->error,
    1435. 

  1435. 			show_nfsv4_errors(__entry->error),
    1436. 

  1436. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1437. 

  1437. 			(unsigned long long)__entry->fileid,
    1438. 

  1438. 			__entry->fhandle
    1439. 

  1439. 		)
    1440. 

  1440. );
    1441. 

  1441. 

  1442. #define DEFINE_NFS4_INODE_EVENT(name) \
    1443. 

  1443. 	DEFINE_EVENT(nfs4_inode_event, name, \
    1444. 

  1444. 			TP_PROTO( \
    1445. 

  1445. 				const struct inode *inode, \
    1446. 

  1446. 				int error \
    1447. 

  1447. 			), \
    1448. 

  1448. 			TP_ARGS(inode, error))
    1449. 

  1449. 

  1450. DEFINE_NFS4_INODE_EVENT(nfs4_access);
    1451. 

  1451. DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
    1452. 

  1452. DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
    1453. 

  1453. DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
    1454. 

  1454. DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
    1455. 

  1455. #ifdef CONFIG_NFS_V4_SECURITY_LABEL
    1456. 

  1456. DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
    1457. 

  1457. DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
    1458. 

  1458. #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
    1459. 

  1459. 

  1460. DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,
    1461. 

  1461. 		TP_PROTO(
    1462. 

  1462. 			const struct inode *inode,
    1463. 

  1463. 			const nfs4_stateid *stateid,
    1464. 

  1464. 			int error
    1465. 

  1465. 		),
    1466. 

  1466. 

  1467. 		TP_ARGS(inode, stateid, error),
    1468. 

  1468. 

  1469. 		TP_STRUCT__entry(
    1470. 

  1470. 			__field(dev_t, dev)
    1471. 

  1471. 			__field(u32, fhandle)
    1472. 

  1472. 			__field(u64, fileid)
    1473. 

  1473. 			__field(unsigned long, error)
    1474. 

  1474. 			__field(int, stateid_seq)
    1475. 

  1475. 			__field(u32, stateid_hash)
    1476. 

  1476. 		),
    1477. 

  1477. 

  1478. 		TP_fast_assign(
    1479. 

  1479. 			__entry->dev = inode->i_sb->s_dev;
    1480. 

  1480. 			__entry->fileid = NFS_FILEID(inode);
    1481. 

  1481. 			__entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
    1482. 

  1482. 			__entry->error = error < 0 ? -error : 0;
    1483. 

  1483. 			__entry->stateid_seq =
    1484. 

  1484. 				be32_to_cpu(stateid->seqid);
    1485. 

  1485. 			__entry->stateid_hash =
    1486. 

  1486. 				nfs_stateid_hash(stateid);
    1487. 

  1487. 		),
    1488. 

  1488. 

  1489. 		TP_printk(
    1490. 

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

  1491. 			"stateid=%d:0x%08x",
    1492. 

  1492. 			-__entry->error,
    1493. 

  1493. 			show_nfsv4_errors(__entry->error),
    1494. 

  1494. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1495. 

  1495. 			(unsigned long long)__entry->fileid,
    1496. 

  1496. 			__entry->fhandle,
    1497. 

  1497. 			__entry->stateid_seq, __entry->stateid_hash
    1498. 

  1498. 		)
    1499. 

  1499. );
    1500. 

  1500. 

  1501. #define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
    1502. 

  1502. 	DEFINE_EVENT(nfs4_inode_stateid_event, name, \
    1503. 

  1503. 			TP_PROTO( \
    1504. 

  1504. 				const struct inode *inode, \
    1505. 

  1505. 				const nfs4_stateid *stateid, \
    1506. 

  1506. 				int error \
    1507. 

  1507. 			), \
    1508. 

  1508. 			TP_ARGS(inode, stateid, error))
    1509. 

  1509. 

  1510. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);
    1511. 

  1511. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
    1512. 

  1512. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
    1513. 

  1513. DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
    1514. 

  1514. 

  1515. DECLARE_EVENT_CLASS(nfs4_getattr_event,
    1516. 

  1516. 		TP_PROTO(
    1517. 

  1517. 			const struct nfs_server *server,
    1518. 

  1518. 			const struct nfs_fh *fhandle,
    1519. 

  1519. 			const struct nfs_fattr *fattr,
    1520. 

  1520. 			int error
    1521. 

  1521. 		),
    1522. 

  1522. 

  1523. 		TP_ARGS(server, fhandle, fattr, error),
    1524. 

  1524. 

  1525. 		TP_STRUCT__entry(
    1526. 

  1526. 			__field(dev_t, dev)
    1527. 

  1527. 			__field(u32, fhandle)
    1528. 

  1528. 			__field(u64, fileid)
    1529. 

  1529. 			__field(unsigned int, valid)
    1530. 

  1530. 			__field(unsigned long, error)
    1531. 

  1531. 		),
    1532. 

  1532. 

  1533. 		TP_fast_assign(
    1534. 

  1534. 			__entry->dev = server->s_dev;
    1535. 

  1535. 			__entry->valid = fattr->valid;
    1536. 

  1536. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1537. 

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

  1538. 			__entry->error = error < 0 ? -error : 0;
    1539. 

  1539. 		),
    1540. 

  1540. 

  1541. 		TP_printk(
    1542. 

  1542. 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1543. 

  1543. 			"valid=%s",
    1544. 

  1544. 			-__entry->error,
    1545. 

  1545. 			show_nfsv4_errors(__entry->error),
    1546. 

  1546. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1547. 

  1547. 			(unsigned long long)__entry->fileid,
    1548. 

  1548. 			__entry->fhandle,
    1549. 

  1549. 			show_nfs_fattr_flags(__entry->valid)
    1550. 

  1550. 		)
    1551. 

  1551. );
    1552. 

  1552. 

  1553. #define DEFINE_NFS4_GETATTR_EVENT(name) \
    1554. 

  1554. 	DEFINE_EVENT(nfs4_getattr_event, name, \
    1555. 

  1555. 			TP_PROTO( \
    1556. 

  1556. 				const struct nfs_server *server, \
    1557. 

  1557. 				const struct nfs_fh *fhandle, \
    1558. 

  1558. 				const struct nfs_fattr *fattr, \
    1559. 

  1559. 				int error \
    1560. 

  1560. 			), \
    1561. 

  1561. 			TP_ARGS(server, fhandle, fattr, error))
    1562. 

  1562. DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
    1563. 

  1563. DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
    1564. 

  1564. DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
    1565. 

  1565. 

  1566. DECLARE_EVENT_CLASS(nfs4_inode_callback_event,
    1567. 

  1567. 		TP_PROTO(
    1568. 

  1568. 			const struct nfs_client *clp,
    1569. 

  1569. 			const struct nfs_fh *fhandle,
    1570. 

  1570. 			const struct inode *inode,
    1571. 

  1571. 			int error
    1572. 

  1572. 		),
    1573. 

  1573. 

  1574. 		TP_ARGS(clp, fhandle, inode, error),
    1575. 

  1575. 

  1576. 		TP_STRUCT__entry(
    1577. 

  1577. 			__field(unsigned long, error)
    1578. 

  1578. 			__field(dev_t, dev)
    1579. 

  1579. 			__field(u32, fhandle)
    1580. 

  1580. 			__field(u64, fileid)
    1581. 

  1581. 			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
    1582. 

  1582. 		),
    1583. 

  1583. 

  1584. 		TP_fast_assign(
    1585. 

  1585. 			__entry->error = error < 0 ? -error : 0;
    1586. 

  1586. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1587. 

  1587. 			if (!IS_ERR_OR_NULL(inode)) {
    1588. 

  1588. 				__entry->fileid = NFS_FILEID(inode);
    1589. 

  1589. 				__entry->dev = inode->i_sb->s_dev;
    1590. 

  1590. 			} else {
    1591. 

  1591. 				__entry->fileid = 0;
    1592. 

  1592. 				__entry->dev = 0;
    1593. 

  1593. 			}
    1594. 

  1594. 			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
    1595. 

  1595. 		),
    1596. 

  1596. 

  1597. 		TP_printk(
    1598. 

  1598. 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1599. 

  1599. 			"dstaddr=%s",
    1600. 

  1600. 			-__entry->error,
    1601. 

  1601. 			show_nfsv4_errors(__entry->error),
    1602. 

  1602. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1603. 

  1603. 			(unsigned long long)__entry->fileid,
    1604. 

  1604. 			__entry->fhandle,
    1605. 

  1605. 			__get_str(dstaddr)
    1606. 

  1606. 		)
    1607. 

  1607. );
    1608. 

  1608. 

  1609. #define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
    1610. 

  1610. 	DEFINE_EVENT(nfs4_inode_callback_event, name, \
    1611. 

  1611. 			TP_PROTO( \
    1612. 

  1612. 				const struct nfs_client *clp, \
    1613. 

  1613. 				const struct nfs_fh *fhandle, \
    1614. 

  1614. 				const struct inode *inode, \
    1615. 

  1615. 				int error \
    1616. 

  1616. 			), \
    1617. 

  1617. 			TP_ARGS(clp, fhandle, inode, error))
    1618. 

  1618. DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr);
    1619. 

  1619. 

  1620. DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,
    1621. 

  1621. 		TP_PROTO(
    1622. 

  1622. 			const struct nfs_client *clp,
    1623. 

  1623. 			const struct nfs_fh *fhandle,
    1624. 

  1624. 			const struct inode *inode,
    1625. 

  1625. 			const nfs4_stateid *stateid,
    1626. 

  1626. 			int error
    1627. 

  1627. 		),
    1628. 

  1628. 

  1629. 		TP_ARGS(clp, fhandle, inode, stateid, error),
    1630. 

  1630. 

  1631. 		TP_STRUCT__entry(
    1632. 

  1632. 			__field(unsigned long, error)
    1633. 

  1633. 			__field(dev_t, dev)
    1634. 

  1634. 			__field(u32, fhandle)
    1635. 

  1635. 			__field(u64, fileid)
    1636. 

  1636. 			__string(dstaddr, clp ? clp->cl_hostname : "unknown")
    1637. 

  1637. 			__field(int, stateid_seq)
    1638. 

  1638. 			__field(u32, stateid_hash)
    1639. 

  1639. 		),
    1640. 

  1640. 

  1641. 		TP_fast_assign(
    1642. 

  1642. 			__entry->error = error < 0 ? -error : 0;
    1643. 

  1643. 			__entry->fhandle = nfs_fhandle_hash(fhandle);
    1644. 

  1644. 			if (!IS_ERR_OR_NULL(inode)) {
    1645. 

  1645. 				__entry->fileid = NFS_FILEID(inode);
    1646. 

  1646. 				__entry->dev = inode->i_sb->s_dev;
    1647. 

  1647. 			} else {
    1648. 

  1648. 				__entry->fileid = 0;
    1649. 

  1649. 				__entry->dev = 0;
    1650. 

  1650. 			}
    1651. 

  1651. 			__assign_str(dstaddr, clp ? clp->cl_hostname : "unknown")
    1652. 

  1652. 			__entry->stateid_seq =
    1653. 

  1653. 				be32_to_cpu(stateid->seqid);
    1654. 

  1654. 			__entry->stateid_hash =
    1655. 

  1655. 				nfs_stateid_hash(stateid);
    1656. 

  1656. 		),
    1657. 

  1657. 

  1658. 		TP_printk(
    1659. 

  1659. 			"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
    1660. 

  1660. 			"stateid=%d:0x%08x dstaddr=%s",
    1661. 

  1661. 			-__entry->error,
    1662. 

  1662. 			show_nfsv4_errors(__entry->error),
    1663. 

  1663. 			MAJOR(__entry->dev), MINOR(__entry->dev),
    1664. 

  1664. 			(unsigned long long)__entry->fileid,
    1665. 

  1665. 			__entry->fhandle,
    1666. 

  1666. 			__entry->stateid_seq, __entry->stateid_hash,
    1667. 

  1667. 			__get_str(dstaddr)
    1668. 

  1668. 		)
    1669. 

  1669. );
    1670. 

  1670. 

  1671. #define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
    1672. 

  1672. 	DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
    1673. 

  1673. 			TP_PROTO( \
    1674. 

  1674. 				const struct nfs_client *clp, \
    1675. 

  1675. 				const struct nfs_fh *fhandle, \
    1676. 

  1676. 				const struct inode *inode, \
    1677. 

  1677. 				const nfs4_stateid *stateid, \
    1678. 

  1678. 				int error \
    1679. 

  1679. 			), \
    1680. 

  1680. 			TP_ARGS(clp, fhandle, inode, stateid, error))
    1681. 

  1681. DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall);
    1682. 

  1682. DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file);
    1683. 

  1683. 

  1684. DECLARE_EVENT_CLASS(nfs4_idmap_event,
    1685. 

  1685. 		TP_PROTO(
    1686. 

  1686. 			const char *name,
    1687. 

  1687. 			int len,
    1688. 

  1688. 			u32 id,
    1689. 

  1689. 			int error
    1690. 

  1690. 		),
    1691. 

  1691. 

  1692. 		TP_ARGS(name, len, id, error),
    1693. 

  1693. 

  1694. 		TP_STRUCT__entry(
    1695. 

  1695. 			__field(unsigned long, error)
    1696. 

  1696. 			__field(u32, id)
    1697. 

  1697. 			__dynamic_array(char, name, len > 0 ? len + 1 : 1)
    1698. 

  1698. 		),
    1699. 

  1699. 

  1700. 		TP_fast_assign(
    1701. 

  1701. 			if (len < 0)
    1702. 

  1702. 				len = 0;
    1703. 

  1703. 			__entry->error = error < 0 ? error : 0;
    1704. 

  1704. 			__entry->id = id;
    1705. 

  1705. 			memcpy(__get_str(name), name, len);
    1706. 

  1706. 			__get_str(name)[len] = 0;
    1707. 

  1707. 		),
    1708. 

  1708. 

  1709. 		TP_printk(
    1710. 

  1710. 			"error=%ld (%s) id=%u name=%s",
    1711. 

  1711. 			-__entry->error, show_nfsv4_errors(__entry->error),
    1712. 

  1712. 			__entry->id,
    1713. 

  1713. 			__get_str(name)
    1714. 

  1714. 		)
    1715. 

  1715. );
    1716. 

  1716. #define DEFINE_NFS4_IDMAP_EVENT(name) \
    1717. 

  1717. 	DEFINE_EVENT(nfs4_idmap_event, name, \
    1718. 

  1718. 			TP_PROTO( \
    1719. 

  1719. 				const char *name, \
    1720. 

  1720. 				int len, \
    1721. 

  1721. 				u32 id, \
    1722. 

  1722. 				int error \
    1723. 

  1723. 			), \
    1724. 

  1724. 			TP_ARGS(name, len, id, error))
    1725. 

  1725. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
    1726. 

  1726. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
    1727. 

  1727. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
    1728. 

  1728. DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
    1729. 

  1729. 

  1730. DECLARE_EVENT_CLASS(nfs4_read_event,
    1731. 

  1731. 		TP_PROTO(
    1732. 

  1732. 			const struct nfs_pgio_header *hdr,
    1733. 

  1733. 			int error
    1734. 

  1734. 		),
    1735. 

  1735. 

  1736. 		TP_ARGS(hdr, error),
    1737. 

  1737. 

  1738. 		TP_STRUCT__entry(
    1739. 

  1739. 			__field(dev_t, dev)
    1740. 

  1740. 			__field(u32, fhandle)
    1741. 

  1741. 			__field(u64, fileid)
    1742. 

  1742. 			__field(loff_t, offset)
    1743. 

  1743. 			__field(u32, arg_count)
    1744. 

  1744. 			__field(u32, res_count)
    1745. 

  1745. 			__field(unsigned long, error)
    1746. 

  1746. 			__field(int, stateid_seq)
    1747. 

  1747. 			__field(u32, stateid_hash)
    1748. 

  1748. 		),
    1749. 

  1749. 

  1750. 		TP_fast_assign(
    1751. 

  1751. 			const struct inode *inode = hdr->inode;
    1752. 

  1752. 			const struct nfs_inode *nfsi = NFS_I(inode);
    1753. 

  1753. 			const struct nfs_fh *fh = hdr->args.fh ?
    1754. 

  1754. 						  hdr->args.fh : &nfsi->fh;
    1755. 

  1755. 			const struct nfs4_state *state =
    1756. 

  1756. 				hdr->args.context->state;
    1757. 

  1757. 

  1758. 			__entry->dev = inode->i_sb->s_dev;
    1759. 

  1759. 			__entry->fileid = nfsi->fileid;
    1760. 

  1760. 			__entry->fhandle = nfs_fhandle_hash(fh);
    1761. 

  1761. 			__entry->offset = hdr->args.offset;
    1762. 

  1762. 			__entry->arg_count = hdr->args.count;
    1763. 

  1763. 			__entry->res_count = hdr…
    1764.

Large files files are truncated, but you can click here to view the full file