1/* SPDX-License-Identifier: GPL-2.0 */ 2/* 3 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com> 4 */ 5#undef TRACE_SYSTEM 6#define TRACE_SYSTEM nfs4 7 8#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ) 9#define _TRACE_NFS4_H 10 11#include <linux/tracepoint.h> 12 13TRACE_DEFINE_ENUM(EPERM); 14TRACE_DEFINE_ENUM(ENOENT); 15TRACE_DEFINE_ENUM(EIO); 16TRACE_DEFINE_ENUM(ENXIO); 17TRACE_DEFINE_ENUM(EACCES); 18TRACE_DEFINE_ENUM(EEXIST); 19TRACE_DEFINE_ENUM(EXDEV); 20TRACE_DEFINE_ENUM(ENOTDIR); 21TRACE_DEFINE_ENUM(EISDIR); 22TRACE_DEFINE_ENUM(EFBIG); 23TRACE_DEFINE_ENUM(ENOSPC); 24TRACE_DEFINE_ENUM(EROFS); 25TRACE_DEFINE_ENUM(EMLINK); 26TRACE_DEFINE_ENUM(ENAMETOOLONG); 27TRACE_DEFINE_ENUM(ENOTEMPTY); 28TRACE_DEFINE_ENUM(EDQUOT); 29TRACE_DEFINE_ENUM(ESTALE); 30TRACE_DEFINE_ENUM(EBADHANDLE); 31TRACE_DEFINE_ENUM(EBADCOOKIE); 32TRACE_DEFINE_ENUM(ENOTSUPP); 33TRACE_DEFINE_ENUM(ETOOSMALL); 34TRACE_DEFINE_ENUM(EREMOTEIO); 35TRACE_DEFINE_ENUM(EBADTYPE); 36TRACE_DEFINE_ENUM(EAGAIN); 37TRACE_DEFINE_ENUM(ELOOP); 38TRACE_DEFINE_ENUM(EOPNOTSUPP); 39TRACE_DEFINE_ENUM(EDEADLK); 40TRACE_DEFINE_ENUM(ENOMEM); 41TRACE_DEFINE_ENUM(EKEYEXPIRED); 42TRACE_DEFINE_ENUM(ETIMEDOUT); 43TRACE_DEFINE_ENUM(ERESTARTSYS); 44TRACE_DEFINE_ENUM(ECONNREFUSED); 45TRACE_DEFINE_ENUM(ECONNRESET); 46TRACE_DEFINE_ENUM(ENETUNREACH); 47TRACE_DEFINE_ENUM(EHOSTUNREACH); 48TRACE_DEFINE_ENUM(EHOSTDOWN); 49TRACE_DEFINE_ENUM(EPIPE); 50TRACE_DEFINE_ENUM(EPFNOSUPPORT); 51TRACE_DEFINE_ENUM(EPROTONOSUPPORT); 52 53TRACE_DEFINE_ENUM(NFS4_OK); 54TRACE_DEFINE_ENUM(NFS4ERR_ACCESS); 55TRACE_DEFINE_ENUM(NFS4ERR_ATTRNOTSUPP); 56TRACE_DEFINE_ENUM(NFS4ERR_ADMIN_REVOKED); 57TRACE_DEFINE_ENUM(NFS4ERR_BACK_CHAN_BUSY); 58TRACE_DEFINE_ENUM(NFS4ERR_BADCHAR); 59TRACE_DEFINE_ENUM(NFS4ERR_BADHANDLE); 60TRACE_DEFINE_ENUM(NFS4ERR_BADIOMODE); 61TRACE_DEFINE_ENUM(NFS4ERR_BADLAYOUT); 62TRACE_DEFINE_ENUM(NFS4ERR_BADLABEL); 63TRACE_DEFINE_ENUM(NFS4ERR_BADNAME); 64TRACE_DEFINE_ENUM(NFS4ERR_BADOWNER); 65TRACE_DEFINE_ENUM(NFS4ERR_BADSESSION); 66TRACE_DEFINE_ENUM(NFS4ERR_BADSLOT); 67TRACE_DEFINE_ENUM(NFS4ERR_BADTYPE); 68TRACE_DEFINE_ENUM(NFS4ERR_BADXDR); 69TRACE_DEFINE_ENUM(NFS4ERR_BAD_COOKIE); 70TRACE_DEFINE_ENUM(NFS4ERR_BAD_HIGH_SLOT); 71TRACE_DEFINE_ENUM(NFS4ERR_BAD_RANGE); 72TRACE_DEFINE_ENUM(NFS4ERR_BAD_SEQID); 73TRACE_DEFINE_ENUM(NFS4ERR_BAD_SESSION_DIGEST); 74TRACE_DEFINE_ENUM(NFS4ERR_BAD_STATEID); 75TRACE_DEFINE_ENUM(NFS4ERR_CB_PATH_DOWN); 76TRACE_DEFINE_ENUM(NFS4ERR_CLID_INUSE); 77TRACE_DEFINE_ENUM(NFS4ERR_CLIENTID_BUSY); 78TRACE_DEFINE_ENUM(NFS4ERR_COMPLETE_ALREADY); 79TRACE_DEFINE_ENUM(NFS4ERR_CONN_NOT_BOUND_TO_SESSION); 80TRACE_DEFINE_ENUM(NFS4ERR_DEADLOCK); 81TRACE_DEFINE_ENUM(NFS4ERR_DEADSESSION); 82TRACE_DEFINE_ENUM(NFS4ERR_DELAY); 83TRACE_DEFINE_ENUM(NFS4ERR_DELEG_ALREADY_WANTED); 84TRACE_DEFINE_ENUM(NFS4ERR_DELEG_REVOKED); 85TRACE_DEFINE_ENUM(NFS4ERR_DENIED); 86TRACE_DEFINE_ENUM(NFS4ERR_DIRDELEG_UNAVAIL); 87TRACE_DEFINE_ENUM(NFS4ERR_DQUOT); 88TRACE_DEFINE_ENUM(NFS4ERR_ENCR_ALG_UNSUPP); 89TRACE_DEFINE_ENUM(NFS4ERR_EXIST); 90TRACE_DEFINE_ENUM(NFS4ERR_EXPIRED); 91TRACE_DEFINE_ENUM(NFS4ERR_FBIG); 92TRACE_DEFINE_ENUM(NFS4ERR_FHEXPIRED); 93TRACE_DEFINE_ENUM(NFS4ERR_FILE_OPEN); 94TRACE_DEFINE_ENUM(NFS4ERR_GRACE); 95TRACE_DEFINE_ENUM(NFS4ERR_HASH_ALG_UNSUPP); 96TRACE_DEFINE_ENUM(NFS4ERR_INVAL); 97TRACE_DEFINE_ENUM(NFS4ERR_IO); 98TRACE_DEFINE_ENUM(NFS4ERR_ISDIR); 99TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTTRYLATER); 100TRACE_DEFINE_ENUM(NFS4ERR_LAYOUTUNAVAILABLE); 101TRACE_DEFINE_ENUM(NFS4ERR_LEASE_MOVED); 102TRACE_DEFINE_ENUM(NFS4ERR_LOCKED); 103TRACE_DEFINE_ENUM(NFS4ERR_LOCKS_HELD); 104TRACE_DEFINE_ENUM(NFS4ERR_LOCK_RANGE); 105TRACE_DEFINE_ENUM(NFS4ERR_MINOR_VERS_MISMATCH); 106TRACE_DEFINE_ENUM(NFS4ERR_MLINK); 107TRACE_DEFINE_ENUM(NFS4ERR_MOVED); 108TRACE_DEFINE_ENUM(NFS4ERR_NAMETOOLONG); 109TRACE_DEFINE_ENUM(NFS4ERR_NOENT); 110TRACE_DEFINE_ENUM(NFS4ERR_NOFILEHANDLE); 111TRACE_DEFINE_ENUM(NFS4ERR_NOMATCHING_LAYOUT); 112TRACE_DEFINE_ENUM(NFS4ERR_NOSPC); 113TRACE_DEFINE_ENUM(NFS4ERR_NOTDIR); 114TRACE_DEFINE_ENUM(NFS4ERR_NOTEMPTY); 115TRACE_DEFINE_ENUM(NFS4ERR_NOTSUPP); 116TRACE_DEFINE_ENUM(NFS4ERR_NOT_ONLY_OP); 117TRACE_DEFINE_ENUM(NFS4ERR_NOT_SAME); 118TRACE_DEFINE_ENUM(NFS4ERR_NO_GRACE); 119TRACE_DEFINE_ENUM(NFS4ERR_NXIO); 120TRACE_DEFINE_ENUM(NFS4ERR_OLD_STATEID); 121TRACE_DEFINE_ENUM(NFS4ERR_OPENMODE); 122TRACE_DEFINE_ENUM(NFS4ERR_OP_ILLEGAL); 123TRACE_DEFINE_ENUM(NFS4ERR_OP_NOT_IN_SESSION); 124TRACE_DEFINE_ENUM(NFS4ERR_PERM); 125TRACE_DEFINE_ENUM(NFS4ERR_PNFS_IO_HOLE); 126TRACE_DEFINE_ENUM(NFS4ERR_PNFS_NO_LAYOUT); 127TRACE_DEFINE_ENUM(NFS4ERR_RECALLCONFLICT); 128TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_BAD); 129TRACE_DEFINE_ENUM(NFS4ERR_RECLAIM_CONFLICT); 130TRACE_DEFINE_ENUM(NFS4ERR_REJECT_DELEG); 131TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG); 132TRACE_DEFINE_ENUM(NFS4ERR_REP_TOO_BIG_TO_CACHE); 133TRACE_DEFINE_ENUM(NFS4ERR_REQ_TOO_BIG); 134TRACE_DEFINE_ENUM(NFS4ERR_RESOURCE); 135TRACE_DEFINE_ENUM(NFS4ERR_RESTOREFH); 136TRACE_DEFINE_ENUM(NFS4ERR_RETRY_UNCACHED_REP); 137TRACE_DEFINE_ENUM(NFS4ERR_RETURNCONFLICT); 138TRACE_DEFINE_ENUM(NFS4ERR_ROFS); 139TRACE_DEFINE_ENUM(NFS4ERR_SAME); 140TRACE_DEFINE_ENUM(NFS4ERR_SHARE_DENIED); 141TRACE_DEFINE_ENUM(NFS4ERR_SEQUENCE_POS); 142TRACE_DEFINE_ENUM(NFS4ERR_SEQ_FALSE_RETRY); 143TRACE_DEFINE_ENUM(NFS4ERR_SEQ_MISORDERED); 144TRACE_DEFINE_ENUM(NFS4ERR_SERVERFAULT); 145TRACE_DEFINE_ENUM(NFS4ERR_STALE); 146TRACE_DEFINE_ENUM(NFS4ERR_STALE_CLIENTID); 147TRACE_DEFINE_ENUM(NFS4ERR_STALE_STATEID); 148TRACE_DEFINE_ENUM(NFS4ERR_SYMLINK); 149TRACE_DEFINE_ENUM(NFS4ERR_TOOSMALL); 150TRACE_DEFINE_ENUM(NFS4ERR_TOO_MANY_OPS); 151TRACE_DEFINE_ENUM(NFS4ERR_UNKNOWN_LAYOUTTYPE); 152TRACE_DEFINE_ENUM(NFS4ERR_UNSAFE_COMPOUND); 153TRACE_DEFINE_ENUM(NFS4ERR_WRONGSEC); 154TRACE_DEFINE_ENUM(NFS4ERR_WRONG_CRED); 155TRACE_DEFINE_ENUM(NFS4ERR_WRONG_TYPE); 156TRACE_DEFINE_ENUM(NFS4ERR_XDEV); 157 158TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_MDS); 159TRACE_DEFINE_ENUM(NFS4ERR_RESET_TO_PNFS); 160 161#define show_nfsv4_errors(error) \ 162 __print_symbolic(error, \ 163 { NFS4_OK, "OK" }, \ 164 /* Mapped by nfs4_stat_to_errno() */ \ 165 { EPERM, "EPERM" }, \ 166 { ENOENT, "ENOENT" }, \ 167 { EIO, "EIO" }, \ 168 { ENXIO, "ENXIO" }, \ 169 { EACCES, "EACCES" }, \ 170 { EEXIST, "EEXIST" }, \ 171 { EXDEV, "EXDEV" }, \ 172 { ENOTDIR, "ENOTDIR" }, \ 173 { EISDIR, "EISDIR" }, \ 174 { EFBIG, "EFBIG" }, \ 175 { ENOSPC, "ENOSPC" }, \ 176 { EROFS, "EROFS" }, \ 177 { EMLINK, "EMLINK" }, \ 178 { ENAMETOOLONG, "ENAMETOOLONG" }, \ 179 { ENOTEMPTY, "ENOTEMPTY" }, \ 180 { EDQUOT, "EDQUOT" }, \ 181 { ESTALE, "ESTALE" }, \ 182 { EBADHANDLE, "EBADHANDLE" }, \ 183 { EBADCOOKIE, "EBADCOOKIE" }, \ 184 { ENOTSUPP, "ENOTSUPP" }, \ 185 { ETOOSMALL, "ETOOSMALL" }, \ 186 { EREMOTEIO, "EREMOTEIO" }, \ 187 { EBADTYPE, "EBADTYPE" }, \ 188 { EAGAIN, "EAGAIN" }, \ 189 { ELOOP, "ELOOP" }, \ 190 { EOPNOTSUPP, "EOPNOTSUPP" }, \ 191 { EDEADLK, "EDEADLK" }, \ 192 /* RPC errors */ \ 193 { ENOMEM, "ENOMEM" }, \ 194 { EKEYEXPIRED, "EKEYEXPIRED" }, \ 195 { ETIMEDOUT, "ETIMEDOUT" }, \ 196 { ERESTARTSYS, "ERESTARTSYS" }, \ 197 { ECONNREFUSED, "ECONNREFUSED" }, \ 198 { ECONNRESET, "ECONNRESET" }, \ 199 { ENETUNREACH, "ENETUNREACH" }, \ 200 { EHOSTUNREACH, "EHOSTUNREACH" }, \ 201 { EHOSTDOWN, "EHOSTDOWN" }, \ 202 { EPIPE, "EPIPE" }, \ 203 { EPFNOSUPPORT, "EPFNOSUPPORT" }, \ 204 { EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \ 205 /* NFSv4 native errors */ \ 206 { NFS4ERR_ACCESS, "ACCESS" }, \ 207 { NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \ 208 { NFS4ERR_ADMIN_REVOKED, "ADMIN_REVOKED" }, \ 209 { NFS4ERR_BACK_CHAN_BUSY, "BACK_CHAN_BUSY" }, \ 210 { NFS4ERR_BADCHAR, "BADCHAR" }, \ 211 { NFS4ERR_BADHANDLE, "BADHANDLE" }, \ 212 { NFS4ERR_BADIOMODE, "BADIOMODE" }, \ 213 { NFS4ERR_BADLAYOUT, "BADLAYOUT" }, \ 214 { NFS4ERR_BADLABEL, "BADLABEL" }, \ 215 { NFS4ERR_BADNAME, "BADNAME" }, \ 216 { NFS4ERR_BADOWNER, "BADOWNER" }, \ 217 { NFS4ERR_BADSESSION, "BADSESSION" }, \ 218 { NFS4ERR_BADSLOT, "BADSLOT" }, \ 219 { NFS4ERR_BADTYPE, "BADTYPE" }, \ 220 { NFS4ERR_BADXDR, "BADXDR" }, \ 221 { NFS4ERR_BAD_COOKIE, "BAD_COOKIE" }, \ 222 { NFS4ERR_BAD_HIGH_SLOT, "BAD_HIGH_SLOT" }, \ 223 { NFS4ERR_BAD_RANGE, "BAD_RANGE" }, \ 224 { NFS4ERR_BAD_SEQID, "BAD_SEQID" }, \ 225 { NFS4ERR_BAD_SESSION_DIGEST, "BAD_SESSION_DIGEST" }, \ 226 { NFS4ERR_BAD_STATEID, "BAD_STATEID" }, \ 227 { NFS4ERR_CB_PATH_DOWN, "CB_PATH_DOWN" }, \ 228 { NFS4ERR_CLID_INUSE, "CLID_INUSE" }, \ 229 { NFS4ERR_CLIENTID_BUSY, "CLIENTID_BUSY" }, \ 230 { NFS4ERR_COMPLETE_ALREADY, "COMPLETE_ALREADY" }, \ 231 { NFS4ERR_CONN_NOT_BOUND_TO_SESSION, \ 232 "CONN_NOT_BOUND_TO_SESSION" }, \ 233 { NFS4ERR_DEADLOCK, "DEADLOCK" }, \ 234 { NFS4ERR_DEADSESSION, "DEAD_SESSION" }, \ 235 { NFS4ERR_DELAY, "DELAY" }, \ 236 { NFS4ERR_DELEG_ALREADY_WANTED, \ 237 "DELEG_ALREADY_WANTED" }, \ 238 { NFS4ERR_DELEG_REVOKED, "DELEG_REVOKED" }, \ 239 { NFS4ERR_DENIED, "DENIED" }, \ 240 { NFS4ERR_DIRDELEG_UNAVAIL, "DIRDELEG_UNAVAIL" }, \ 241 { NFS4ERR_DQUOT, "DQUOT" }, \ 242 { NFS4ERR_ENCR_ALG_UNSUPP, "ENCR_ALG_UNSUPP" }, \ 243 { NFS4ERR_EXIST, "EXIST" }, \ 244 { NFS4ERR_EXPIRED, "EXPIRED" }, \ 245 { NFS4ERR_FBIG, "FBIG" }, \ 246 { NFS4ERR_FHEXPIRED, "FHEXPIRED" }, \ 247 { NFS4ERR_FILE_OPEN, "FILE_OPEN" }, \ 248 { NFS4ERR_GRACE, "GRACE" }, \ 249 { NFS4ERR_HASH_ALG_UNSUPP, "HASH_ALG_UNSUPP" }, \ 250 { NFS4ERR_INVAL, "INVAL" }, \ 251 { NFS4ERR_IO, "IO" }, \ 252 { NFS4ERR_ISDIR, "ISDIR" }, \ 253 { NFS4ERR_LAYOUTTRYLATER, "LAYOUTTRYLATER" }, \ 254 { NFS4ERR_LAYOUTUNAVAILABLE, "LAYOUTUNAVAILABLE" }, \ 255 { NFS4ERR_LEASE_MOVED, "LEASE_MOVED" }, \ 256 { NFS4ERR_LOCKED, "LOCKED" }, \ 257 { NFS4ERR_LOCKS_HELD, "LOCKS_HELD" }, \ 258 { NFS4ERR_LOCK_RANGE, "LOCK_RANGE" }, \ 259 { NFS4ERR_MINOR_VERS_MISMATCH, "MINOR_VERS_MISMATCH" }, \ 260 { NFS4ERR_MLINK, "MLINK" }, \ 261 { NFS4ERR_MOVED, "MOVED" }, \ 262 { NFS4ERR_NAMETOOLONG, "NAMETOOLONG" }, \ 263 { NFS4ERR_NOENT, "NOENT" }, \ 264 { NFS4ERR_NOFILEHANDLE, "NOFILEHANDLE" }, \ 265 { NFS4ERR_NOMATCHING_LAYOUT, "NOMATCHING_LAYOUT" }, \ 266 { NFS4ERR_NOSPC, "NOSPC" }, \ 267 { NFS4ERR_NOTDIR, "NOTDIR" }, \ 268 { NFS4ERR_NOTEMPTY, "NOTEMPTY" }, \ 269 { NFS4ERR_NOTSUPP, "NOTSUPP" }, \ 270 { NFS4ERR_NOT_ONLY_OP, "NOT_ONLY_OP" }, \ 271 { NFS4ERR_NOT_SAME, "NOT_SAME" }, \ 272 { NFS4ERR_NO_GRACE, "NO_GRACE" }, \ 273 { NFS4ERR_NXIO, "NXIO" }, \ 274 { NFS4ERR_OLD_STATEID, "OLD_STATEID" }, \ 275 { NFS4ERR_OPENMODE, "OPENMODE" }, \ 276 { NFS4ERR_OP_ILLEGAL, "OP_ILLEGAL" }, \ 277 { NFS4ERR_OP_NOT_IN_SESSION, "OP_NOT_IN_SESSION" }, \ 278 { NFS4ERR_PERM, "PERM" }, \ 279 { NFS4ERR_PNFS_IO_HOLE, "PNFS_IO_HOLE" }, \ 280 { NFS4ERR_PNFS_NO_LAYOUT, "PNFS_NO_LAYOUT" }, \ 281 { NFS4ERR_RECALLCONFLICT, "RECALLCONFLICT" }, \ 282 { NFS4ERR_RECLAIM_BAD, "RECLAIM_BAD" }, \ 283 { NFS4ERR_RECLAIM_CONFLICT, "RECLAIM_CONFLICT" }, \ 284 { NFS4ERR_REJECT_DELEG, "REJECT_DELEG" }, \ 285 { NFS4ERR_REP_TOO_BIG, "REP_TOO_BIG" }, \ 286 { NFS4ERR_REP_TOO_BIG_TO_CACHE, \ 287 "REP_TOO_BIG_TO_CACHE" }, \ 288 { NFS4ERR_REQ_TOO_BIG, "REQ_TOO_BIG" }, \ 289 { NFS4ERR_RESOURCE, "RESOURCE" }, \ 290 { NFS4ERR_RESTOREFH, "RESTOREFH" }, \ 291 { NFS4ERR_RETRY_UNCACHED_REP, "RETRY_UNCACHED_REP" }, \ 292 { NFS4ERR_RETURNCONFLICT, "RETURNCONFLICT" }, \ 293 { NFS4ERR_ROFS, "ROFS" }, \ 294 { NFS4ERR_SAME, "SAME" }, \ 295 { NFS4ERR_SHARE_DENIED, "SHARE_DENIED" }, \ 296 { NFS4ERR_SEQUENCE_POS, "SEQUENCE_POS" }, \ 297 { NFS4ERR_SEQ_FALSE_RETRY, "SEQ_FALSE_RETRY" }, \ 298 { NFS4ERR_SEQ_MISORDERED, "SEQ_MISORDERED" }, \ 299 { NFS4ERR_SERVERFAULT, "SERVERFAULT" }, \ 300 { NFS4ERR_STALE, "STALE" }, \ 301 { NFS4ERR_STALE_CLIENTID, "STALE_CLIENTID" }, \ 302 { NFS4ERR_STALE_STATEID, "STALE_STATEID" }, \ 303 { NFS4ERR_SYMLINK, "SYMLINK" }, \ 304 { NFS4ERR_TOOSMALL, "TOOSMALL" }, \ 305 { NFS4ERR_TOO_MANY_OPS, "TOO_MANY_OPS" }, \ 306 { NFS4ERR_UNKNOWN_LAYOUTTYPE, "UNKNOWN_LAYOUTTYPE" }, \ 307 { NFS4ERR_UNSAFE_COMPOUND, "UNSAFE_COMPOUND" }, \ 308 { NFS4ERR_WRONGSEC, "WRONGSEC" }, \ 309 { NFS4ERR_WRONG_CRED, "WRONG_CRED" }, \ 310 { NFS4ERR_WRONG_TYPE, "WRONG_TYPE" }, \ 311 { NFS4ERR_XDEV, "XDEV" }, \ 312 /* ***** Internal to Linux NFS client ***** */ \ 313 { NFS4ERR_RESET_TO_MDS, "RESET_TO_MDS" }, \ 314 { NFS4ERR_RESET_TO_PNFS, "RESET_TO_PNFS" }) 315 316#define show_open_flags(flags) \ 317 __print_flags(flags, "|", \ 318 { O_CREAT, "O_CREAT" }, \ 319 { O_EXCL, "O_EXCL" }, \ 320 { O_TRUNC, "O_TRUNC" }, \ 321 { O_DIRECT, "O_DIRECT" }) 322 323#define show_fmode_flags(mode) \ 324 __print_flags(mode, "|", \ 325 { ((__force unsigned long)FMODE_READ), "READ" }, \ 326 { ((__force unsigned long)FMODE_WRITE), "WRITE" }, \ 327 { ((__force unsigned long)FMODE_EXEC), "EXEC" }) 328 329#define show_nfs_fattr_flags(valid) \ 330 __print_flags((unsigned long)valid, "|", \ 331 { NFS_ATTR_FATTR_TYPE, "TYPE" }, \ 332 { NFS_ATTR_FATTR_MODE, "MODE" }, \ 333 { NFS_ATTR_FATTR_NLINK, "NLINK" }, \ 334 { NFS_ATTR_FATTR_OWNER, "OWNER" }, \ 335 { NFS_ATTR_FATTR_GROUP, "GROUP" }, \ 336 { NFS_ATTR_FATTR_RDEV, "RDEV" }, \ 337 { NFS_ATTR_FATTR_SIZE, "SIZE" }, \ 338 { NFS_ATTR_FATTR_FSID, "FSID" }, \ 339 { NFS_ATTR_FATTR_FILEID, "FILEID" }, \ 340 { NFS_ATTR_FATTR_ATIME, "ATIME" }, \ 341 { NFS_ATTR_FATTR_MTIME, "MTIME" }, \ 342 { NFS_ATTR_FATTR_CTIME, "CTIME" }, \ 343 { NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \ 344 { NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \ 345 { NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" }) 346 347DECLARE_EVENT_CLASS(nfs4_clientid_event, 348 TP_PROTO( 349 const struct nfs_client *clp, 350 int error 351 ), 352 353 TP_ARGS(clp, error), 354 355 TP_STRUCT__entry( 356 __string(dstaddr, clp->cl_hostname) 357 __field(unsigned long, error) 358 ), 359 360 TP_fast_assign( 361 __entry->error = error < 0 ? -error : 0; 362 __assign_str(dstaddr, clp->cl_hostname); 363 ), 364 365 TP_printk( 366 "error=%ld (%s) dstaddr=%s", 367 -__entry->error, 368 show_nfsv4_errors(__entry->error), 369 __get_str(dstaddr) 370 ) 371); 372#define DEFINE_NFS4_CLIENTID_EVENT(name) \ 373 DEFINE_EVENT(nfs4_clientid_event, name, \ 374 TP_PROTO( \ 375 const struct nfs_client *clp, \ 376 int error \ 377 ), \ 378 TP_ARGS(clp, error)) 379DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid); 380DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm); 381DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew); 382DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async); 383#ifdef CONFIG_NFS_V4_1 384DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id); 385DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session); 386DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session); 387DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid); 388DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session); 389DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence); 390DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete); 391 392#define show_nfs4_sequence_status_flags(status) \ 393 __print_flags((unsigned long)status, "|", \ 394 { SEQ4_STATUS_CB_PATH_DOWN, "CB_PATH_DOWN" }, \ 395 { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING, \ 396 "CB_GSS_CONTEXTS_EXPIRING" }, \ 397 { SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED, \ 398 "CB_GSS_CONTEXTS_EXPIRED" }, \ 399 { SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED, \ 400 "EXPIRED_ALL_STATE_REVOKED" }, \ 401 { SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED, \ 402 "EXPIRED_SOME_STATE_REVOKED" }, \ 403 { SEQ4_STATUS_ADMIN_STATE_REVOKED, \ 404 "ADMIN_STATE_REVOKED" }, \ 405 { SEQ4_STATUS_RECALLABLE_STATE_REVOKED, \ 406 "RECALLABLE_STATE_REVOKED" }, \ 407 { SEQ4_STATUS_LEASE_MOVED, "LEASE_MOVED" }, \ 408 { SEQ4_STATUS_RESTART_RECLAIM_NEEDED, \ 409 "RESTART_RECLAIM_NEEDED" }, \ 410 { SEQ4_STATUS_CB_PATH_DOWN_SESSION, \ 411 "CB_PATH_DOWN_SESSION" }, \ 412 { SEQ4_STATUS_BACKCHANNEL_FAULT, \ 413 "BACKCHANNEL_FAULT" }) 414 415TRACE_EVENT(nfs4_sequence_done, 416 TP_PROTO( 417 const struct nfs4_session *session, 418 const struct nfs4_sequence_res *res 419 ), 420 TP_ARGS(session, res), 421 422 TP_STRUCT__entry( 423 __field(unsigned int, session) 424 __field(unsigned int, slot_nr) 425 __field(unsigned int, seq_nr) 426 __field(unsigned int, highest_slotid) 427 __field(unsigned int, target_highest_slotid) 428 __field(unsigned int, status_flags) 429 __field(unsigned long, error) 430 ), 431 432 TP_fast_assign( 433 const struct nfs4_slot *sr_slot = res->sr_slot; 434 __entry->session = nfs_session_id_hash(&session->sess_id); 435 __entry->slot_nr = sr_slot->slot_nr; 436 __entry->seq_nr = sr_slot->seq_nr; 437 __entry->highest_slotid = res->sr_highest_slotid; 438 __entry->target_highest_slotid = 439 res->sr_target_highest_slotid; 440 __entry->status_flags = res->sr_status_flags; 441 __entry->error = res->sr_status < 0 ? 442 -res->sr_status : 0; 443 ), 444 TP_printk( 445 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " 446 "highest_slotid=%u target_highest_slotid=%u " 447 "status_flags=%u (%s)", 448 -__entry->error, 449 show_nfsv4_errors(__entry->error), 450 __entry->session, 451 __entry->slot_nr, 452 __entry->seq_nr, 453 __entry->highest_slotid, 454 __entry->target_highest_slotid, 455 __entry->status_flags, 456 show_nfs4_sequence_status_flags(__entry->status_flags) 457 ) 458); 459 460struct cb_sequenceargs; 461struct cb_sequenceres; 462 463TRACE_EVENT(nfs4_cb_sequence, 464 TP_PROTO( 465 const struct cb_sequenceargs *args, 466 const struct cb_sequenceres *res, 467 __be32 status 468 ), 469 TP_ARGS(args, res, status), 470 471 TP_STRUCT__entry( 472 __field(unsigned int, session) 473 __field(unsigned int, slot_nr) 474 __field(unsigned int, seq_nr) 475 __field(unsigned int, highest_slotid) 476 __field(unsigned int, cachethis) 477 __field(unsigned long, error) 478 ), 479 480 TP_fast_assign( 481 __entry->session = nfs_session_id_hash(&args->csa_sessionid); 482 __entry->slot_nr = args->csa_slotid; 483 __entry->seq_nr = args->csa_sequenceid; 484 __entry->highest_slotid = args->csa_highestslotid; 485 __entry->cachethis = args->csa_cachethis; 486 __entry->error = be32_to_cpu(status); 487 ), 488 489 TP_printk( 490 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " 491 "highest_slotid=%u", 492 -__entry->error, 493 show_nfsv4_errors(__entry->error), 494 __entry->session, 495 __entry->slot_nr, 496 __entry->seq_nr, 497 __entry->highest_slotid 498 ) 499); 500 501TRACE_EVENT(nfs4_cb_seqid_err, 502 TP_PROTO( 503 const struct cb_sequenceargs *args, 504 __be32 status 505 ), 506 TP_ARGS(args, status), 507 508 TP_STRUCT__entry( 509 __field(unsigned int, session) 510 __field(unsigned int, slot_nr) 511 __field(unsigned int, seq_nr) 512 __field(unsigned int, highest_slotid) 513 __field(unsigned int, cachethis) 514 __field(unsigned long, error) 515 ), 516 517 TP_fast_assign( 518 __entry->session = nfs_session_id_hash(&args->csa_sessionid); 519 __entry->slot_nr = args->csa_slotid; 520 __entry->seq_nr = args->csa_sequenceid; 521 __entry->highest_slotid = args->csa_highestslotid; 522 __entry->cachethis = args->csa_cachethis; 523 __entry->error = be32_to_cpu(status); 524 ), 525 526 TP_printk( 527 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u " 528 "highest_slotid=%u", 529 -__entry->error, 530 show_nfsv4_errors(__entry->error), 531 __entry->session, 532 __entry->slot_nr, 533 __entry->seq_nr, 534 __entry->highest_slotid 535 ) 536); 537 538#endif /* CONFIG_NFS_V4_1 */ 539 540TRACE_EVENT(nfs4_setup_sequence, 541 TP_PROTO( 542 const struct nfs4_session *session, 543 const struct nfs4_sequence_args *args 544 ), 545 TP_ARGS(session, args), 546 547 TP_STRUCT__entry( 548 __field(unsigned int, session) 549 __field(unsigned int, slot_nr) 550 __field(unsigned int, seq_nr) 551 __field(unsigned int, highest_used_slotid) 552 ), 553 554 TP_fast_assign( 555 const struct nfs4_slot *sa_slot = args->sa_slot; 556 __entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0; 557 __entry->slot_nr = sa_slot->slot_nr; 558 __entry->seq_nr = sa_slot->seq_nr; 559 __entry->highest_used_slotid = 560 sa_slot->table->highest_used_slotid; 561 ), 562 TP_printk( 563 "session=0x%08x slot_nr=%u seq_nr=%u " 564 "highest_used_slotid=%u", 565 __entry->session, 566 __entry->slot_nr, 567 __entry->seq_nr, 568 __entry->highest_used_slotid 569 ) 570); 571 572TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING); 573TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE); 574TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED); 575TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT); 576TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE); 577TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN); 578TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET); 579TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM); 580TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH); 581TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE); 582TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION); 583TRACE_DEFINE_ENUM(NFS4CLNT_MOVED); 584TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED); 585TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED); 586TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER); 587TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_AVAILABLE); 588TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING); 589TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ); 590TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW); 591TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN_DELAYED); 592 593#define show_nfs4_clp_state(state) \ 594 __print_flags(state, "|", \ 595 { BIT(NFS4CLNT_MANAGER_RUNNING), "MANAGER_RUNNING" }, \ 596 { BIT(NFS4CLNT_CHECK_LEASE), "CHECK_LEASE" }, \ 597 { BIT(NFS4CLNT_LEASE_EXPIRED), "LEASE_EXPIRED" }, \ 598 { BIT(NFS4CLNT_RECLAIM_REBOOT), "RECLAIM_REBOOT" }, \ 599 { BIT(NFS4CLNT_RECLAIM_NOGRACE), "RECLAIM_NOGRACE" }, \ 600 { BIT(NFS4CLNT_DELEGRETURN), "DELEGRETURN" }, \ 601 { BIT(NFS4CLNT_SESSION_RESET), "SESSION_RESET" }, \ 602 { BIT(NFS4CLNT_LEASE_CONFIRM), "LEASE_CONFIRM" }, \ 603 { BIT(NFS4CLNT_SERVER_SCOPE_MISMATCH), "SERVER_SCOPE_MISMATCH" }, \ 604 { BIT(NFS4CLNT_PURGE_STATE), "PURGE_STATE" }, \ 605 { BIT(NFS4CLNT_BIND_CONN_TO_SESSION), "BIND_CONN_TO_SESSION" }, \ 606 { BIT(NFS4CLNT_MOVED), "MOVED" }, \ 607 { BIT(NFS4CLNT_LEASE_MOVED), "LEASE_MOVED" }, \ 608 { BIT(NFS4CLNT_DELEGATION_EXPIRED), "DELEGATION_EXPIRED" }, \ 609 { BIT(NFS4CLNT_RUN_MANAGER), "RUN_MANAGER" }, \ 610 { BIT(NFS4CLNT_MANAGER_AVAILABLE), "MANAGER_AVAILABLE" }, \ 611 { BIT(NFS4CLNT_RECALL_RUNNING), "RECALL_RUNNING" }, \ 612 { BIT(NFS4CLNT_RECALL_ANY_LAYOUT_READ), "RECALL_ANY_LAYOUT_READ" }, \ 613 { BIT(NFS4CLNT_RECALL_ANY_LAYOUT_RW), "RECALL_ANY_LAYOUT_RW" }, \ 614 { BIT(NFS4CLNT_DELEGRETURN_DELAYED), "DELERETURN_DELAYED" }) 615 616TRACE_EVENT(nfs4_state_mgr, 617 TP_PROTO( 618 const struct nfs_client *clp 619 ), 620 621 TP_ARGS(clp), 622 623 TP_STRUCT__entry( 624 __field(unsigned long, state) 625 __string(hostname, clp->cl_hostname) 626 ), 627 628 TP_fast_assign( 629 __entry->state = clp->cl_state; 630 __assign_str(hostname, clp->cl_hostname) 631 ), 632 633 TP_printk( 634 "hostname=%s clp state=%s", __get_str(hostname), 635 show_nfs4_clp_state(__entry->state) 636 ) 637) 638 639TRACE_EVENT(nfs4_state_mgr_failed, 640 TP_PROTO( 641 const struct nfs_client *clp, 642 const char *section, 643 int status 644 ), 645 646 TP_ARGS(clp, section, status), 647 648 TP_STRUCT__entry( 649 __field(unsigned long, error) 650 __field(unsigned long, state) 651 __string(hostname, clp->cl_hostname) 652 __string(section, section) 653 ), 654 655 TP_fast_assign( 656 __entry->error = status < 0 ? -status : 0; 657 __entry->state = clp->cl_state; 658 __assign_str(hostname, clp->cl_hostname); 659 __assign_str(section, section); 660 ), 661 662 TP_printk( 663 "hostname=%s clp state=%s error=%ld (%s) section=%s", 664 __get_str(hostname), 665 show_nfs4_clp_state(__entry->state), -__entry->error, 666 show_nfsv4_errors(__entry->error), __get_str(section) 667 668 ) 669) 670 671TRACE_EVENT(nfs4_xdr_status, 672 TP_PROTO( 673 const struct xdr_stream *xdr, 674 u32 op, 675 u32 error 676 ), 677 678 TP_ARGS(xdr, op, error), 679 680 TP_STRUCT__entry( 681 __field(unsigned int, task_id) 682 __field(unsigned int, client_id) 683 __field(u32, xid) 684 __field(u32, op) 685 __field(unsigned long, error) 686 ), 687 688 TP_fast_assign( 689 const struct rpc_rqst *rqstp = xdr->rqst; 690 const struct rpc_task *task = rqstp->rq_task; 691 692 __entry->task_id = task->tk_pid; 693 __entry->client_id = task->tk_client->cl_clid; 694 __entry->xid = be32_to_cpu(rqstp->rq_xid); 695 __entry->op = op; 696 __entry->error = error; 697 ), 698 699 TP_printk( 700 "task:%u@%d xid=0x%08x error=%ld (%s) operation=%u", 701 __entry->task_id, __entry->client_id, __entry->xid, 702 -__entry->error, show_nfsv4_errors(__entry->error), 703 __entry->op 704 ) 705); 706 707DECLARE_EVENT_CLASS(nfs4_cb_error_class, 708 TP_PROTO( 709 __be32 xid, 710 u32 cb_ident 711 ), 712 713 TP_ARGS(xid, cb_ident), 714 715 TP_STRUCT__entry( 716 __field(u32, xid) 717 __field(u32, cbident) 718 ), 719 720 TP_fast_assign( 721 __entry->xid = be32_to_cpu(xid); 722 __entry->cbident = cb_ident; 723 ), 724 725 TP_printk( 726 "xid=0x%08x cb_ident=0x%08x", 727 __entry->xid, __entry->cbident 728 ) 729); 730 731#define DEFINE_CB_ERROR_EVENT(name) \ 732 DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \ 733 TP_PROTO( \ 734 __be32 xid, \ 735 u32 cb_ident \ 736 ), \ 737 TP_ARGS(xid, cb_ident)) 738 739DEFINE_CB_ERROR_EVENT(no_clp); 740DEFINE_CB_ERROR_EVENT(badprinc); 741 742DECLARE_EVENT_CLASS(nfs4_open_event, 743 TP_PROTO( 744 const struct nfs_open_context *ctx, 745 int flags, 746 int error 747 ), 748 749 TP_ARGS(ctx, flags, error), 750 751 TP_STRUCT__entry( 752 __field(unsigned long, error) 753 __field(unsigned int, flags) 754 __field(unsigned int, fmode) 755 __field(dev_t, dev) 756 __field(u32, fhandle) 757 __field(u64, fileid) 758 __field(u64, dir) 759 __string(name, ctx->dentry->d_name.name) 760 __field(int, stateid_seq) 761 __field(u32, stateid_hash) 762 __field(int, openstateid_seq) 763 __field(u32, openstateid_hash) 764 ), 765 766 TP_fast_assign( 767 const struct nfs4_state *state = ctx->state; 768 const struct inode *inode = NULL; 769 770 __entry->error = -error; 771 __entry->flags = flags; 772 __entry->fmode = (__force unsigned int)ctx->mode; 773 __entry->dev = ctx->dentry->d_sb->s_dev; 774 if (!IS_ERR_OR_NULL(state)) { 775 inode = state->inode; 776 __entry->stateid_seq = 777 be32_to_cpu(state->stateid.seqid); 778 __entry->stateid_hash = 779 nfs_stateid_hash(&state->stateid); 780 __entry->openstateid_seq = 781 be32_to_cpu(state->open_stateid.seqid); 782 __entry->openstateid_hash = 783 nfs_stateid_hash(&state->open_stateid); 784 } else { 785 __entry->stateid_seq = 0; 786 __entry->stateid_hash = 0; 787 __entry->openstateid_seq = 0; 788 __entry->openstateid_hash = 0; 789 } 790 if (inode != NULL) { 791 __entry->fileid = NFS_FILEID(inode); 792 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 793 } else { 794 __entry->fileid = 0; 795 __entry->fhandle = 0; 796 } 797 __entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent)); 798 __assign_str(name, ctx->dentry->d_name.name); 799 ), 800 801 TP_printk( 802 "error=%ld (%s) flags=%d (%s) fmode=%s " 803 "fileid=%02x:%02x:%llu fhandle=0x%08x " 804 "name=%02x:%02x:%llu/%s stateid=%d:0x%08x " 805 "openstateid=%d:0x%08x", 806 -__entry->error, 807 show_nfsv4_errors(__entry->error), 808 __entry->flags, 809 show_open_flags(__entry->flags), 810 show_fmode_flags(__entry->fmode), 811 MAJOR(__entry->dev), MINOR(__entry->dev), 812 (unsigned long long)__entry->fileid, 813 __entry->fhandle, 814 MAJOR(__entry->dev), MINOR(__entry->dev), 815 (unsigned long long)__entry->dir, 816 __get_str(name), 817 __entry->stateid_seq, __entry->stateid_hash, 818 __entry->openstateid_seq, __entry->openstateid_hash 819 ) 820); 821 822#define DEFINE_NFS4_OPEN_EVENT(name) \ 823 DEFINE_EVENT(nfs4_open_event, name, \ 824 TP_PROTO( \ 825 const struct nfs_open_context *ctx, \ 826 int flags, \ 827 int error \ 828 ), \ 829 TP_ARGS(ctx, flags, error)) 830DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim); 831DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired); 832DEFINE_NFS4_OPEN_EVENT(nfs4_open_file); 833 834TRACE_EVENT(nfs4_cached_open, 835 TP_PROTO( 836 const struct nfs4_state *state 837 ), 838 TP_ARGS(state), 839 TP_STRUCT__entry( 840 __field(dev_t, dev) 841 __field(u32, fhandle) 842 __field(u64, fileid) 843 __field(unsigned int, fmode) 844 __field(int, stateid_seq) 845 __field(u32, stateid_hash) 846 ), 847 848 TP_fast_assign( 849 const struct inode *inode = state->inode; 850 851 __entry->dev = inode->i_sb->s_dev; 852 __entry->fileid = NFS_FILEID(inode); 853 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 854 __entry->fmode = (__force unsigned int)state->state; 855 __entry->stateid_seq = 856 be32_to_cpu(state->stateid.seqid); 857 __entry->stateid_hash = 858 nfs_stateid_hash(&state->stateid); 859 ), 860 861 TP_printk( 862 "fmode=%s fileid=%02x:%02x:%llu " 863 "fhandle=0x%08x stateid=%d:0x%08x", 864 __entry->fmode ? show_fmode_flags(__entry->fmode) : 865 "closed", 866 MAJOR(__entry->dev), MINOR(__entry->dev), 867 (unsigned long long)__entry->fileid, 868 __entry->fhandle, 869 __entry->stateid_seq, __entry->stateid_hash 870 ) 871); 872 873TRACE_EVENT(nfs4_close, 874 TP_PROTO( 875 const struct nfs4_state *state, 876 const struct nfs_closeargs *args, 877 const struct nfs_closeres *res, 878 int error 879 ), 880 881 TP_ARGS(state, args, res, error), 882 883 TP_STRUCT__entry( 884 __field(dev_t, dev) 885 __field(u32, fhandle) 886 __field(u64, fileid) 887 __field(unsigned int, fmode) 888 __field(unsigned long, error) 889 __field(int, stateid_seq) 890 __field(u32, stateid_hash) 891 ), 892 893 TP_fast_assign( 894 const struct inode *inode = state->inode; 895 896 __entry->dev = inode->i_sb->s_dev; 897 __entry->fileid = NFS_FILEID(inode); 898 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 899 __entry->fmode = (__force unsigned int)state->state; 900 __entry->error = error < 0 ? -error : 0; 901 __entry->stateid_seq = 902 be32_to_cpu(args->stateid.seqid); 903 __entry->stateid_hash = 904 nfs_stateid_hash(&args->stateid); 905 ), 906 907 TP_printk( 908 "error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu " 909 "fhandle=0x%08x openstateid=%d:0x%08x", 910 -__entry->error, 911 show_nfsv4_errors(__entry->error), 912 __entry->fmode ? show_fmode_flags(__entry->fmode) : 913 "closed", 914 MAJOR(__entry->dev), MINOR(__entry->dev), 915 (unsigned long long)__entry->fileid, 916 __entry->fhandle, 917 __entry->stateid_seq, __entry->stateid_hash 918 ) 919); 920 921TRACE_DEFINE_ENUM(F_GETLK); 922TRACE_DEFINE_ENUM(F_SETLK); 923TRACE_DEFINE_ENUM(F_SETLKW); 924TRACE_DEFINE_ENUM(F_RDLCK); 925TRACE_DEFINE_ENUM(F_WRLCK); 926TRACE_DEFINE_ENUM(F_UNLCK); 927 928#define show_lock_cmd(type) \ 929 __print_symbolic((int)type, \ 930 { F_GETLK, "GETLK" }, \ 931 { F_SETLK, "SETLK" }, \ 932 { F_SETLKW, "SETLKW" }) 933#define show_lock_type(type) \ 934 __print_symbolic((int)type, \ 935 { F_RDLCK, "RDLCK" }, \ 936 { F_WRLCK, "WRLCK" }, \ 937 { F_UNLCK, "UNLCK" }) 938 939DECLARE_EVENT_CLASS(nfs4_lock_event, 940 TP_PROTO( 941 const struct file_lock *request, 942 const struct nfs4_state *state, 943 int cmd, 944 int error 945 ), 946 947 TP_ARGS(request, state, cmd, error), 948 949 TP_STRUCT__entry( 950 __field(unsigned long, error) 951 __field(int, cmd) 952 __field(char, type) 953 __field(loff_t, start) 954 __field(loff_t, end) 955 __field(dev_t, dev) 956 __field(u32, fhandle) 957 __field(u64, fileid) 958 __field(int, stateid_seq) 959 __field(u32, stateid_hash) 960 ), 961 962 TP_fast_assign( 963 const struct inode *inode = state->inode; 964 965 __entry->error = error < 0 ? -error : 0; 966 __entry->cmd = cmd; 967 __entry->type = request->fl_type; 968 __entry->start = request->fl_start; 969 __entry->end = request->fl_end; 970 __entry->dev = inode->i_sb->s_dev; 971 __entry->fileid = NFS_FILEID(inode); 972 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 973 __entry->stateid_seq = 974 be32_to_cpu(state->stateid.seqid); 975 __entry->stateid_hash = 976 nfs_stateid_hash(&state->stateid); 977 ), 978 979 TP_printk( 980 "error=%ld (%s) cmd=%s:%s range=%lld:%lld " 981 "fileid=%02x:%02x:%llu fhandle=0x%08x " 982 "stateid=%d:0x%08x", 983 -__entry->error, 984 show_nfsv4_errors(__entry->error), 985 show_lock_cmd(__entry->cmd), 986 show_lock_type(__entry->type), 987 (long long)__entry->start, 988 (long long)__entry->end, 989 MAJOR(__entry->dev), MINOR(__entry->dev), 990 (unsigned long long)__entry->fileid, 991 __entry->fhandle, 992 __entry->stateid_seq, __entry->stateid_hash 993 ) 994); 995 996#define DEFINE_NFS4_LOCK_EVENT(name) \ 997 DEFINE_EVENT(nfs4_lock_event, name, \ 998 TP_PROTO( \ 999 const struct file_lock *request, \ 1000 const struct nfs4_state *state, \ 1001 int cmd, \ 1002 int error \ 1003 ), \ 1004 TP_ARGS(request, state, cmd, error)) 1005DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock); 1006DEFINE_NFS4_LOCK_EVENT(nfs4_unlock); 1007 1008TRACE_EVENT(nfs4_set_lock, 1009 TP_PROTO( 1010 const struct file_lock *request, 1011 const struct nfs4_state *state, 1012 const nfs4_stateid *lockstateid, 1013 int cmd, 1014 int error 1015 ), 1016 1017 TP_ARGS(request, state, lockstateid, cmd, error), 1018 1019 TP_STRUCT__entry( 1020 __field(unsigned long, error) 1021 __field(int, cmd) 1022 __field(char, type) 1023 __field(loff_t, start) 1024 __field(loff_t, end) 1025 __field(dev_t, dev) 1026 __field(u32, fhandle) 1027 __field(u64, fileid) 1028 __field(int, stateid_seq) 1029 __field(u32, stateid_hash) 1030 __field(int, lockstateid_seq) 1031 __field(u32, lockstateid_hash) 1032 ), 1033 1034 TP_fast_assign( 1035 const struct inode *inode = state->inode; 1036 1037 __entry->error = error < 0 ? -error : 0; 1038 __entry->cmd = cmd; 1039 __entry->type = request->fl_type; 1040 __entry->start = request->fl_start; 1041 __entry->end = request->fl_end; 1042 __entry->dev = inode->i_sb->s_dev; 1043 __entry->fileid = NFS_FILEID(inode); 1044 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1045 __entry->stateid_seq = 1046 be32_to_cpu(state->stateid.seqid); 1047 __entry->stateid_hash = 1048 nfs_stateid_hash(&state->stateid); 1049 __entry->lockstateid_seq = 1050 be32_to_cpu(lockstateid->seqid); 1051 __entry->lockstateid_hash = 1052 nfs_stateid_hash(lockstateid); 1053 ), 1054 1055 TP_printk( 1056 "error=%ld (%s) cmd=%s:%s range=%lld:%lld " 1057 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1058 "stateid=%d:0x%08x lockstateid=%d:0x%08x", 1059 -__entry->error, 1060 show_nfsv4_errors(__entry->error), 1061 show_lock_cmd(__entry->cmd), 1062 show_lock_type(__entry->type), 1063 (long long)__entry->start, 1064 (long long)__entry->end, 1065 MAJOR(__entry->dev), MINOR(__entry->dev), 1066 (unsigned long long)__entry->fileid, 1067 __entry->fhandle, 1068 __entry->stateid_seq, __entry->stateid_hash, 1069 __entry->lockstateid_seq, __entry->lockstateid_hash 1070 ) 1071); 1072 1073TRACE_DEFINE_ENUM(LK_STATE_IN_USE); 1074TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE); 1075TRACE_DEFINE_ENUM(NFS_OPEN_STATE); 1076TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE); 1077TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE); 1078TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE); 1079TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT); 1080TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE); 1081TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS); 1082TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED); 1083TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK); 1084TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT); 1085TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE); 1086TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE); 1087TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE); 1088 1089#define show_nfs4_state_flags(flags) \ 1090 __print_flags(flags, "|", \ 1091 { LK_STATE_IN_USE, "IN_USE" }, \ 1092 { NFS_DELEGATED_STATE, "DELEGATED" }, \ 1093 { NFS_OPEN_STATE, "OPEN" }, \ 1094 { NFS_O_RDONLY_STATE, "O_RDONLY" }, \ 1095 { NFS_O_WRONLY_STATE, "O_WRONLY" }, \ 1096 { NFS_O_RDWR_STATE, "O_RDWR" }, \ 1097 { NFS_STATE_RECLAIM_REBOOT, "RECLAIM_REBOOT" }, \ 1098 { NFS_STATE_RECLAIM_NOGRACE, "RECLAIM_NOGRACE" }, \ 1099 { NFS_STATE_POSIX_LOCKS, "POSIX_LOCKS" }, \ 1100 { NFS_STATE_RECOVERY_FAILED, "RECOVERY_FAILED" }, \ 1101 { NFS_STATE_MAY_NOTIFY_LOCK, "MAY_NOTIFY_LOCK" }, \ 1102 { NFS_STATE_CHANGE_WAIT, "CHANGE_WAIT" }, \ 1103 { NFS_CLNT_DST_SSC_COPY_STATE, "CLNT_DST_SSC_COPY" }, \ 1104 { NFS_CLNT_SRC_SSC_COPY_STATE, "CLNT_SRC_SSC_COPY" }, \ 1105 { NFS_SRV_SSC_COPY_STATE, "SRV_SSC_COPY" }) 1106 1107#define show_nfs4_lock_flags(flags) \ 1108 __print_flags(flags, "|", \ 1109 { BIT(NFS_LOCK_INITIALIZED), "INITIALIZED" }, \ 1110 { BIT(NFS_LOCK_LOST), "LOST" }) 1111 1112TRACE_EVENT(nfs4_state_lock_reclaim, 1113 TP_PROTO( 1114 const struct nfs4_state *state, 1115 const struct nfs4_lock_state *lock 1116 ), 1117 1118 TP_ARGS(state, lock), 1119 1120 TP_STRUCT__entry( 1121 __field(dev_t, dev) 1122 __field(u32, fhandle) 1123 __field(u64, fileid) 1124 __field(unsigned long, state_flags) 1125 __field(unsigned long, lock_flags) 1126 __field(int, stateid_seq) 1127 __field(u32, stateid_hash) 1128 ), 1129 1130 TP_fast_assign( 1131 const struct inode *inode = state->inode; 1132 1133 __entry->dev = inode->i_sb->s_dev; 1134 __entry->fileid = NFS_FILEID(inode); 1135 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1136 __entry->state_flags = state->flags; 1137 __entry->lock_flags = lock->ls_flags; 1138 __entry->stateid_seq = 1139 be32_to_cpu(state->stateid.seqid); 1140 __entry->stateid_hash = 1141 nfs_stateid_hash(&state->stateid); 1142 ), 1143 1144 TP_printk( 1145 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1146 "stateid=%d:0x%08x state_flags=%s lock_flags=%s", 1147 MAJOR(__entry->dev), MINOR(__entry->dev), 1148 (unsigned long long)__entry->fileid, __entry->fhandle, 1149 __entry->stateid_seq, __entry->stateid_hash, 1150 show_nfs4_state_flags(__entry->state_flags), 1151 show_nfs4_lock_flags(__entry->lock_flags) 1152 ) 1153) 1154 1155DECLARE_EVENT_CLASS(nfs4_set_delegation_event, 1156 TP_PROTO( 1157 const struct inode *inode, 1158 fmode_t fmode 1159 ), 1160 1161 TP_ARGS(inode, fmode), 1162 1163 TP_STRUCT__entry( 1164 __field(dev_t, dev) 1165 __field(u32, fhandle) 1166 __field(u64, fileid) 1167 __field(unsigned int, fmode) 1168 ), 1169 1170 TP_fast_assign( 1171 __entry->dev = inode->i_sb->s_dev; 1172 __entry->fileid = NFS_FILEID(inode); 1173 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1174 __entry->fmode = (__force unsigned int)fmode; 1175 ), 1176 1177 TP_printk( 1178 "fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x", 1179 show_fmode_flags(__entry->fmode), 1180 MAJOR(__entry->dev), MINOR(__entry->dev), 1181 (unsigned long long)__entry->fileid, 1182 __entry->fhandle 1183 ) 1184); 1185#define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \ 1186 DEFINE_EVENT(nfs4_set_delegation_event, name, \ 1187 TP_PROTO( \ 1188 const struct inode *inode, \ 1189 fmode_t fmode \ 1190 ), \ 1191 TP_ARGS(inode, fmode)) 1192DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation); 1193DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation); 1194 1195TRACE_EVENT(nfs4_delegreturn_exit, 1196 TP_PROTO( 1197 const struct nfs4_delegreturnargs *args, 1198 const struct nfs4_delegreturnres *res, 1199 int error 1200 ), 1201 1202 TP_ARGS(args, res, error), 1203 1204 TP_STRUCT__entry( 1205 __field(dev_t, dev) 1206 __field(u32, fhandle) 1207 __field(unsigned long, error) 1208 __field(int, stateid_seq) 1209 __field(u32, stateid_hash) 1210 ), 1211 1212 TP_fast_assign( 1213 __entry->dev = res->server->s_dev; 1214 __entry->fhandle = nfs_fhandle_hash(args->fhandle); 1215 __entry->error = error < 0 ? -error : 0; 1216 __entry->stateid_seq = 1217 be32_to_cpu(args->stateid->seqid); 1218 __entry->stateid_hash = 1219 nfs_stateid_hash(args->stateid); 1220 ), 1221 1222 TP_printk( 1223 "error=%ld (%s) dev=%02x:%02x fhandle=0x%08x " 1224 "stateid=%d:0x%08x", 1225 -__entry->error, 1226 show_nfsv4_errors(__entry->error), 1227 MAJOR(__entry->dev), MINOR(__entry->dev), 1228 __entry->fhandle, 1229 __entry->stateid_seq, __entry->stateid_hash 1230 ) 1231); 1232 1233#ifdef CONFIG_NFS_V4_1 1234DECLARE_EVENT_CLASS(nfs4_test_stateid_event, 1235 TP_PROTO( 1236 const struct nfs4_state *state, 1237 const struct nfs4_lock_state *lsp, 1238 int error 1239 ), 1240 1241 TP_ARGS(state, lsp, error), 1242 1243 TP_STRUCT__entry( 1244 __field(unsigned long, error) 1245 __field(dev_t, dev) 1246 __field(u32, fhandle) 1247 __field(u64, fileid) 1248 __field(int, stateid_seq) 1249 __field(u32, stateid_hash) 1250 ), 1251 1252 TP_fast_assign( 1253 const struct inode *inode = state->inode; 1254 1255 __entry->error = error < 0 ? -error : 0; 1256 __entry->dev = inode->i_sb->s_dev; 1257 __entry->fileid = NFS_FILEID(inode); 1258 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1259 __entry->stateid_seq = 1260 be32_to_cpu(state->stateid.seqid); 1261 __entry->stateid_hash = 1262 nfs_stateid_hash(&state->stateid); 1263 ), 1264 1265 TP_printk( 1266 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1267 "stateid=%d:0x%08x", 1268 -__entry->error, 1269 show_nfsv4_errors(__entry->error), 1270 MAJOR(__entry->dev), MINOR(__entry->dev), 1271 (unsigned long long)__entry->fileid, 1272 __entry->fhandle, 1273 __entry->stateid_seq, __entry->stateid_hash 1274 ) 1275); 1276 1277#define DEFINE_NFS4_TEST_STATEID_EVENT(name) \ 1278 DEFINE_EVENT(nfs4_test_stateid_event, name, \ 1279 TP_PROTO( \ 1280 const struct nfs4_state *state, \ 1281 const struct nfs4_lock_state *lsp, \ 1282 int error \ 1283 ), \ 1284 TP_ARGS(state, lsp, error)) 1285DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid); 1286DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid); 1287DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid); 1288#endif /* CONFIG_NFS_V4_1 */ 1289 1290DECLARE_EVENT_CLASS(nfs4_lookup_event, 1291 TP_PROTO( 1292 const struct inode *dir, 1293 const struct qstr *name, 1294 int error 1295 ), 1296 1297 TP_ARGS(dir, name, error), 1298 1299 TP_STRUCT__entry( 1300 __field(dev_t, dev) 1301 __field(unsigned long, error) 1302 __field(u64, dir) 1303 __string(name, name->name) 1304 ), 1305 1306 TP_fast_assign( 1307 __entry->dev = dir->i_sb->s_dev; 1308 __entry->dir = NFS_FILEID(dir); 1309 __entry->error = -error; 1310 __assign_str(name, name->name); 1311 ), 1312 1313 TP_printk( 1314 "error=%ld (%s) name=%02x:%02x:%llu/%s", 1315 -__entry->error, 1316 show_nfsv4_errors(__entry->error), 1317 MAJOR(__entry->dev), MINOR(__entry->dev), 1318 (unsigned long long)__entry->dir, 1319 __get_str(name) 1320 ) 1321); 1322 1323#define DEFINE_NFS4_LOOKUP_EVENT(name) \ 1324 DEFINE_EVENT(nfs4_lookup_event, name, \ 1325 TP_PROTO( \ 1326 const struct inode *dir, \ 1327 const struct qstr *name, \ 1328 int error \ 1329 ), \ 1330 TP_ARGS(dir, name, error)) 1331 1332DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup); 1333DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink); 1334DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir); 1335DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod); 1336DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove); 1337DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations); 1338DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo); 1339 1340TRACE_EVENT(nfs4_lookupp, 1341 TP_PROTO( 1342 const struct inode *inode, 1343 int error 1344 ), 1345 1346 TP_ARGS(inode, error), 1347 1348 TP_STRUCT__entry( 1349 __field(dev_t, dev) 1350 __field(u64, ino) 1351 __field(unsigned long, error) 1352 ), 1353 1354 TP_fast_assign( 1355 __entry->dev = inode->i_sb->s_dev; 1356 __entry->ino = NFS_FILEID(inode); 1357 __entry->error = error < 0 ? -error : 0; 1358 ), 1359 1360 TP_printk( 1361 "error=%ld (%s) inode=%02x:%02x:%llu", 1362 -__entry->error, 1363 show_nfsv4_errors(__entry->error), 1364 MAJOR(__entry->dev), MINOR(__entry->dev), 1365 (unsigned long long)__entry->ino 1366 ) 1367); 1368 1369TRACE_EVENT(nfs4_rename, 1370 TP_PROTO( 1371 const struct inode *olddir, 1372 const struct qstr *oldname, 1373 const struct inode *newdir, 1374 const struct qstr *newname, 1375 int error 1376 ), 1377 1378 TP_ARGS(olddir, oldname, newdir, newname, error), 1379 1380 TP_STRUCT__entry( 1381 __field(dev_t, dev) 1382 __field(unsigned long, error) 1383 __field(u64, olddir) 1384 __string(oldname, oldname->name) 1385 __field(u64, newdir) 1386 __string(newname, newname->name) 1387 ), 1388 1389 TP_fast_assign( 1390 __entry->dev = olddir->i_sb->s_dev; 1391 __entry->olddir = NFS_FILEID(olddir); 1392 __entry->newdir = NFS_FILEID(newdir); 1393 __entry->error = error < 0 ? -error : 0; 1394 __assign_str(oldname, oldname->name); 1395 __assign_str(newname, newname->name); 1396 ), 1397 1398 TP_printk( 1399 "error=%ld (%s) oldname=%02x:%02x:%llu/%s " 1400 "newname=%02x:%02x:%llu/%s", 1401 -__entry->error, 1402 show_nfsv4_errors(__entry->error), 1403 MAJOR(__entry->dev), MINOR(__entry->dev), 1404 (unsigned long long)__entry->olddir, 1405 __get_str(oldname), 1406 MAJOR(__entry->dev), MINOR(__entry->dev), 1407 (unsigned long long)__entry->newdir, 1408 __get_str(newname) 1409 ) 1410); 1411 1412DECLARE_EVENT_CLASS(nfs4_inode_event, 1413 TP_PROTO( 1414 const struct inode *inode, 1415 int error 1416 ), 1417 1418 TP_ARGS(inode, error), 1419 1420 TP_STRUCT__entry( 1421 __field(dev_t, dev) 1422 __field(u32, fhandle) 1423 __field(u64, fileid) 1424 __field(unsigned long, error) 1425 ), 1426 1427 TP_fast_assign( 1428 __entry->dev = inode->i_sb->s_dev; 1429 __entry->fileid = NFS_FILEID(inode); 1430 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1431 __entry->error = error < 0 ? -error : 0; 1432 ), 1433 1434 TP_printk( 1435 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x", 1436 -__entry->error, 1437 show_nfsv4_errors(__entry->error), 1438 MAJOR(__entry->dev), MINOR(__entry->dev), 1439 (unsigned long long)__entry->fileid, 1440 __entry->fhandle 1441 ) 1442); 1443 1444#define DEFINE_NFS4_INODE_EVENT(name) \ 1445 DEFINE_EVENT(nfs4_inode_event, name, \ 1446 TP_PROTO( \ 1447 const struct inode *inode, \ 1448 int error \ 1449 ), \ 1450 TP_ARGS(inode, error)) 1451 1452DEFINE_NFS4_INODE_EVENT(nfs4_access); 1453DEFINE_NFS4_INODE_EVENT(nfs4_readlink); 1454DEFINE_NFS4_INODE_EVENT(nfs4_readdir); 1455DEFINE_NFS4_INODE_EVENT(nfs4_get_acl); 1456DEFINE_NFS4_INODE_EVENT(nfs4_set_acl); 1457#ifdef CONFIG_NFS_V4_SECURITY_LABEL 1458DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label); 1459DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label); 1460#endif /* CONFIG_NFS_V4_SECURITY_LABEL */ 1461 1462DECLARE_EVENT_CLASS(nfs4_inode_stateid_event, 1463 TP_PROTO( 1464 const struct inode *inode, 1465 const nfs4_stateid *stateid, 1466 int error 1467 ), 1468 1469 TP_ARGS(inode, stateid, error), 1470 1471 TP_STRUCT__entry( 1472 __field(dev_t, dev) 1473 __field(u32, fhandle) 1474 __field(u64, fileid) 1475 __field(unsigned long, error) 1476 __field(int, stateid_seq) 1477 __field(u32, stateid_hash) 1478 ), 1479 1480 TP_fast_assign( 1481 __entry->dev = inode->i_sb->s_dev; 1482 __entry->fileid = NFS_FILEID(inode); 1483 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1484 __entry->error = error < 0 ? -error : 0; 1485 __entry->stateid_seq = 1486 be32_to_cpu(stateid->seqid); 1487 __entry->stateid_hash = 1488 nfs_stateid_hash(stateid); 1489 ), 1490 1491 TP_printk( 1492 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1493 "stateid=%d:0x%08x", 1494 -__entry->error, 1495 show_nfsv4_errors(__entry->error), 1496 MAJOR(__entry->dev), MINOR(__entry->dev), 1497 (unsigned long long)__entry->fileid, 1498 __entry->fhandle, 1499 __entry->stateid_seq, __entry->stateid_hash 1500 ) 1501); 1502 1503#define DEFINE_NFS4_INODE_STATEID_EVENT(name) \ 1504 DEFINE_EVENT(nfs4_inode_stateid_event, name, \ 1505 TP_PROTO( \ 1506 const struct inode *inode, \ 1507 const nfs4_stateid *stateid, \ 1508 int error \ 1509 ), \ 1510 TP_ARGS(inode, stateid, error)) 1511 1512DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr); 1513DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn); 1514DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update); 1515DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait); 1516DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait); 1517 1518DECLARE_EVENT_CLASS(nfs4_getattr_event, 1519 TP_PROTO( 1520 const struct nfs_server *server, 1521 const struct nfs_fh *fhandle, 1522 const struct nfs_fattr *fattr, 1523 int error 1524 ), 1525 1526 TP_ARGS(server, fhandle, fattr, error), 1527 1528 TP_STRUCT__entry( 1529 __field(dev_t, dev) 1530 __field(u32, fhandle) 1531 __field(u64, fileid) 1532 __field(unsigned int, valid) 1533 __field(unsigned long, error) 1534 ), 1535 1536 TP_fast_assign( 1537 __entry->dev = server->s_dev; 1538 __entry->valid = fattr->valid; 1539 __entry->fhandle = nfs_fhandle_hash(fhandle); 1540 __entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0; 1541 __entry->error = error < 0 ? -error : 0; 1542 ), 1543 1544 TP_printk( 1545 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1546 "valid=%s", 1547 -__entry->error, 1548 show_nfsv4_errors(__entry->error), 1549 MAJOR(__entry->dev), MINOR(__entry->dev), 1550 (unsigned long long)__entry->fileid, 1551 __entry->fhandle, 1552 show_nfs_fattr_flags(__entry->valid) 1553 ) 1554); 1555 1556#define DEFINE_NFS4_GETATTR_EVENT(name) \ 1557 DEFINE_EVENT(nfs4_getattr_event, name, \ 1558 TP_PROTO( \ 1559 const struct nfs_server *server, \ 1560 const struct nfs_fh *fhandle, \ 1561 const struct nfs_fattr *fattr, \ 1562 int error \ 1563 ), \ 1564 TP_ARGS(server, fhandle, fattr, error)) 1565DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr); 1566DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root); 1567DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo); 1568 1569DECLARE_EVENT_CLASS(nfs4_inode_callback_event, 1570 TP_PROTO( 1571 const struct nfs_client *clp, 1572 const struct nfs_fh *fhandle, 1573 const struct inode *inode, 1574 int error 1575 ), 1576 1577 TP_ARGS(clp, fhandle, inode, error), 1578 1579 TP_STRUCT__entry( 1580 __field(unsigned long, error) 1581 __field(dev_t, dev) 1582 __field(u32, fhandle) 1583 __field(u64, fileid) 1584 __string(dstaddr, clp ? clp->cl_hostname : "unknown") 1585 ), 1586 1587 TP_fast_assign( 1588 __entry->error = error < 0 ? -error : 0; 1589 __entry->fhandle = nfs_fhandle_hash(fhandle); 1590 if (!IS_ERR_OR_NULL(inode)) { 1591 __entry->fileid = NFS_FILEID(inode); 1592 __entry->dev = inode->i_sb->s_dev; 1593 } else { 1594 __entry->fileid = 0; 1595 __entry->dev = 0; 1596 } 1597 __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") 1598 ), 1599 1600 TP_printk( 1601 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1602 "dstaddr=%s", 1603 -__entry->error, 1604 show_nfsv4_errors(__entry->error), 1605 MAJOR(__entry->dev), MINOR(__entry->dev), 1606 (unsigned long long)__entry->fileid, 1607 __entry->fhandle, 1608 __get_str(dstaddr) 1609 ) 1610); 1611 1612#define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \ 1613 DEFINE_EVENT(nfs4_inode_callback_event, name, \ 1614 TP_PROTO( \ 1615 const struct nfs_client *clp, \ 1616 const struct nfs_fh *fhandle, \ 1617 const struct inode *inode, \ 1618 int error \ 1619 ), \ 1620 TP_ARGS(clp, fhandle, inode, error)) 1621DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr); 1622 1623DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, 1624 TP_PROTO( 1625 const struct nfs_client *clp, 1626 const struct nfs_fh *fhandle, 1627 const struct inode *inode, 1628 const nfs4_stateid *stateid, 1629 int error 1630 ), 1631 1632 TP_ARGS(clp, fhandle, inode, stateid, error), 1633 1634 TP_STRUCT__entry( 1635 __field(unsigned long, error) 1636 __field(dev_t, dev) 1637 __field(u32, fhandle) 1638 __field(u64, fileid) 1639 __string(dstaddr, clp ? clp->cl_hostname : "unknown") 1640 __field(int, stateid_seq) 1641 __field(u32, stateid_hash) 1642 ), 1643 1644 TP_fast_assign( 1645 __entry->error = error < 0 ? -error : 0; 1646 __entry->fhandle = nfs_fhandle_hash(fhandle); 1647 if (!IS_ERR_OR_NULL(inode)) { 1648 __entry->fileid = NFS_FILEID(inode); 1649 __entry->dev = inode->i_sb->s_dev; 1650 } else { 1651 __entry->fileid = 0; 1652 __entry->dev = 0; 1653 } 1654 __assign_str(dstaddr, clp ? clp->cl_hostname : "unknown") 1655 __entry->stateid_seq = 1656 be32_to_cpu(stateid->seqid); 1657 __entry->stateid_hash = 1658 nfs_stateid_hash(stateid); 1659 ), 1660 1661 TP_printk( 1662 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1663 "stateid=%d:0x%08x dstaddr=%s", 1664 -__entry->error, 1665 show_nfsv4_errors(__entry->error), 1666 MAJOR(__entry->dev), MINOR(__entry->dev), 1667 (unsigned long long)__entry->fileid, 1668 __entry->fhandle, 1669 __entry->stateid_seq, __entry->stateid_hash, 1670 __get_str(dstaddr) 1671 ) 1672); 1673 1674#define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \ 1675 DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \ 1676 TP_PROTO( \ 1677 const struct nfs_client *clp, \ 1678 const struct nfs_fh *fhandle, \ 1679 const struct inode *inode, \ 1680 const nfs4_stateid *stateid, \ 1681 int error \ 1682 ), \ 1683 TP_ARGS(clp, fhandle, inode, stateid, error)) 1684DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall); 1685DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file); 1686 1687DECLARE_EVENT_CLASS(nfs4_idmap_event, 1688 TP_PROTO( 1689 const char *name, 1690 int len, 1691 u32 id, 1692 int error 1693 ), 1694 1695 TP_ARGS(name, len, id, error), 1696 1697 TP_STRUCT__entry( 1698 __field(unsigned long, error) 1699 __field(u32, id) 1700 __dynamic_array(char, name, len > 0 ? len + 1 : 1) 1701 ), 1702 1703 TP_fast_assign( 1704 if (len < 0) 1705 len = 0; 1706 __entry->error = error < 0 ? error : 0; 1707 __entry->id = id; 1708 memcpy(__get_str(name), name, len); 1709 __get_str(name)[len] = 0; 1710 ), 1711 1712 TP_printk( 1713 "error=%ld (%s) id=%u name=%s", 1714 -__entry->error, show_nfsv4_errors(__entry->error), 1715 __entry->id, 1716 __get_str(name) 1717 ) 1718); 1719#define DEFINE_NFS4_IDMAP_EVENT(name) \ 1720 DEFINE_EVENT(nfs4_idmap_event, name, \ 1721 TP_PROTO( \ 1722 const char *name, \ 1723 int len, \ 1724 u32 id, \ 1725 int error \ 1726 ), \ 1727 TP_ARGS(name, len, id, error)) 1728DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid); 1729DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid); 1730DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name); 1731DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group); 1732 1733#ifdef CONFIG_NFS_V4_1 1734#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \ 1735 (lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0) 1736#else 1737#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0) 1738#endif 1739 1740DECLARE_EVENT_CLASS(nfs4_read_event, 1741 TP_PROTO( 1742 const struct nfs_pgio_header *hdr, 1743 int error 1744 ), 1745 1746 TP_ARGS(hdr, error), 1747 1748 TP_STRUCT__entry( 1749 __field(dev_t, dev) 1750 __field(u32, fhandle) 1751 __field(u64, fileid) 1752 __field(loff_t, offset) 1753 __field(u32, arg_count) 1754 __field(u32, res_count) 1755 __field(unsigned long, error) 1756 __field(int, stateid_seq) 1757 __field(u32, stateid_hash) 1758 __field(int, layoutstateid_seq) 1759 __field(u32, layoutstateid_hash) 1760 ), 1761 1762 TP_fast_assign( 1763 const struct inode *inode = hdr->inode; 1764 const struct nfs_inode *nfsi = NFS_I(inode); 1765 const struct nfs_fh *fh = hdr->args.fh ? 1766 hdr->args.fh : &nfsi->fh; 1767 const struct nfs4_state *state = 1768 hdr->args.context->state; 1769 const struct pnfs_layout_segment *lseg = hdr->lseg; 1770 1771 __entry->dev = inode->i_sb->s_dev; 1772 __entry->fileid = nfsi->fileid; 1773 __entry->fhandle = nfs_fhandle_hash(fh); 1774 __entry->offset = hdr->args.offset; 1775 __entry->arg_count = hdr->args.count; 1776 __entry->res_count = hdr->res.count; 1777 __entry->error = error < 0 ? -error : 0; 1778 __entry->stateid_seq = 1779 be32_to_cpu(state->stateid.seqid); 1780 __entry->stateid_hash = 1781 nfs_stateid_hash(&state->stateid); 1782 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1783 __entry->layoutstateid_hash = 1784 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1785 ), 1786 1787 TP_printk( 1788 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1789 "offset=%lld count=%u res=%u stateid=%d:0x%08x " 1790 "layoutstateid=%d:0x%08x", 1791 -__entry->error, 1792 show_nfsv4_errors(__entry->error), 1793 MAJOR(__entry->dev), MINOR(__entry->dev), 1794 (unsigned long long)__entry->fileid, 1795 __entry->fhandle, 1796 (long long)__entry->offset, 1797 __entry->arg_count, __entry->res_count, 1798 __entry->stateid_seq, __entry->stateid_hash, 1799 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1800 ) 1801); 1802#define DEFINE_NFS4_READ_EVENT(name) \ 1803 DEFINE_EVENT(nfs4_read_event, name, \ 1804 TP_PROTO( \ 1805 const struct nfs_pgio_header *hdr, \ 1806 int error \ 1807 ), \ 1808 TP_ARGS(hdr, error)) 1809DEFINE_NFS4_READ_EVENT(nfs4_read); 1810#ifdef CONFIG_NFS_V4_1 1811DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read); 1812#endif /* CONFIG_NFS_V4_1 */ 1813 1814DECLARE_EVENT_CLASS(nfs4_write_event, 1815 TP_PROTO( 1816 const struct nfs_pgio_header *hdr, 1817 int error 1818 ), 1819 1820 TP_ARGS(hdr, error), 1821 1822 TP_STRUCT__entry( 1823 __field(dev_t, dev) 1824 __field(u32, fhandle) 1825 __field(u64, fileid) 1826 __field(loff_t, offset) 1827 __field(u32, arg_count) 1828 __field(u32, res_count) 1829 __field(unsigned long, error) 1830 __field(int, stateid_seq) 1831 __field(u32, stateid_hash) 1832 __field(int, layoutstateid_seq) 1833 __field(u32, layoutstateid_hash) 1834 ), 1835 1836 TP_fast_assign( 1837 const struct inode *inode = hdr->inode; 1838 const struct nfs_inode *nfsi = NFS_I(inode); 1839 const struct nfs_fh *fh = hdr->args.fh ? 1840 hdr->args.fh : &nfsi->fh; 1841 const struct nfs4_state *state = 1842 hdr->args.context->state; 1843 const struct pnfs_layout_segment *lseg = hdr->lseg; 1844 1845 __entry->dev = inode->i_sb->s_dev; 1846 __entry->fileid = nfsi->fileid; 1847 __entry->fhandle = nfs_fhandle_hash(fh); 1848 __entry->offset = hdr->args.offset; 1849 __entry->arg_count = hdr->args.count; 1850 __entry->res_count = hdr->res.count; 1851 __entry->error = error < 0 ? -error : 0; 1852 __entry->stateid_seq = 1853 be32_to_cpu(state->stateid.seqid); 1854 __entry->stateid_hash = 1855 nfs_stateid_hash(&state->stateid); 1856 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1857 __entry->layoutstateid_hash = 1858 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1859 ), 1860 1861 TP_printk( 1862 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1863 "offset=%lld count=%u res=%u stateid=%d:0x%08x " 1864 "layoutstateid=%d:0x%08x", 1865 -__entry->error, 1866 show_nfsv4_errors(__entry->error), 1867 MAJOR(__entry->dev), MINOR(__entry->dev), 1868 (unsigned long long)__entry->fileid, 1869 __entry->fhandle, 1870 (long long)__entry->offset, 1871 __entry->arg_count, __entry->res_count, 1872 __entry->stateid_seq, __entry->stateid_hash, 1873 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1874 ) 1875); 1876 1877#define DEFINE_NFS4_WRITE_EVENT(name) \ 1878 DEFINE_EVENT(nfs4_write_event, name, \ 1879 TP_PROTO( \ 1880 const struct nfs_pgio_header *hdr, \ 1881 int error \ 1882 ), \ 1883 TP_ARGS(hdr, error)) 1884DEFINE_NFS4_WRITE_EVENT(nfs4_write); 1885#ifdef CONFIG_NFS_V4_1 1886DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write); 1887#endif /* CONFIG_NFS_V4_1 */ 1888 1889DECLARE_EVENT_CLASS(nfs4_commit_event, 1890 TP_PROTO( 1891 const struct nfs_commit_data *data, 1892 int error 1893 ), 1894 1895 TP_ARGS(data, error), 1896 1897 TP_STRUCT__entry( 1898 __field(dev_t, dev) 1899 __field(u32, fhandle) 1900 __field(u64, fileid) 1901 __field(unsigned long, error) 1902 __field(loff_t, offset) 1903 __field(u32, count) 1904 __field(int, layoutstateid_seq) 1905 __field(u32, layoutstateid_hash) 1906 ), 1907 1908 TP_fast_assign( 1909 const struct inode *inode = data->inode; 1910 const struct nfs_inode *nfsi = NFS_I(inode); 1911 const struct nfs_fh *fh = data->args.fh ? 1912 data->args.fh : &nfsi->fh; 1913 const struct pnfs_layout_segment *lseg = data->lseg; 1914 1915 __entry->dev = inode->i_sb->s_dev; 1916 __entry->fileid = nfsi->fileid; 1917 __entry->fhandle = nfs_fhandle_hash(fh); 1918 __entry->offset = data->args.offset; 1919 __entry->count = data->args.count; 1920 __entry->error = error < 0 ? -error : 0; 1921 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1922 __entry->layoutstateid_hash = 1923 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1924 ), 1925 1926 TP_printk( 1927 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1928 "offset=%lld count=%u layoutstateid=%d:0x%08x", 1929 -__entry->error, 1930 show_nfsv4_errors(__entry->error), 1931 MAJOR(__entry->dev), MINOR(__entry->dev), 1932 (unsigned long long)__entry->fileid, 1933 __entry->fhandle, 1934 (long long)__entry->offset, 1935 __entry->count, 1936 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1937 ) 1938); 1939#define DEFINE_NFS4_COMMIT_EVENT(name) \ 1940 DEFINE_EVENT(nfs4_commit_event, name, \ 1941 TP_PROTO( \ 1942 const struct nfs_commit_data *data, \ 1943 int error \ 1944 ), \ 1945 TP_ARGS(data, error)) 1946DEFINE_NFS4_COMMIT_EVENT(nfs4_commit); 1947#ifdef CONFIG_NFS_V4_1 1948DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds); 1949 1950TRACE_DEFINE_ENUM(IOMODE_READ); 1951TRACE_DEFINE_ENUM(IOMODE_RW); 1952TRACE_DEFINE_ENUM(IOMODE_ANY); 1953 1954#define show_pnfs_iomode(iomode) \ 1955 __print_symbolic(iomode, \ 1956 { IOMODE_READ, "READ" }, \ 1957 { IOMODE_RW, "RW" }, \ 1958 { IOMODE_ANY, "ANY" }) 1959 1960TRACE_EVENT(nfs4_layoutget, 1961 TP_PROTO( 1962 const struct nfs_open_context *ctx, 1963 const struct pnfs_layout_range *args, 1964 const struct pnfs_layout_range *res, 1965 const nfs4_stateid *layout_stateid, 1966 int error 1967 ), 1968 1969 TP_ARGS(ctx, args, res, layout_stateid, error), 1970 1971 TP_STRUCT__entry( 1972 __field(dev_t, dev) 1973 __field(u32, fhandle) 1974 __field(u64, fileid) 1975 __field(u32, iomode) 1976 __field(u64, offset) 1977 __field(u64, count) 1978 __field(unsigned long, error) 1979 __field(int, stateid_seq) 1980 __field(u32, stateid_hash) 1981 __field(int, layoutstateid_seq) 1982 __field(u32, layoutstateid_hash) 1983 ), 1984 1985 TP_fast_assign( 1986 const struct inode *inode = d_inode(ctx->dentry); 1987 const struct nfs4_state *state = ctx->state; 1988 __entry->dev = inode->i_sb->s_dev; 1989 __entry->fileid = NFS_FILEID(inode); 1990 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1991 __entry->iomode = args->iomode; 1992 __entry->offset = args->offset; 1993 __entry->count = args->length; 1994 __entry->error = error < 0 ? -error : 0; 1995 __entry->stateid_seq = 1996 be32_to_cpu(state->stateid.seqid); 1997 __entry->stateid_hash = 1998 nfs_stateid_hash(&state->stateid); 1999 if (!error) { 2000 __entry->layoutstateid_seq = 2001 be32_to_cpu(layout_stateid->seqid); 2002 __entry->layoutstateid_hash = 2003 nfs_stateid_hash(layout_stateid); 2004 } else { 2005 __entry->layoutstateid_seq = 0; 2006 __entry->layoutstateid_hash = 0; 2007 } 2008 ), 2009 2010 TP_printk( 2011 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2012 "iomode=%s offset=%llu count=%llu stateid=%d:0x%08x " 2013 "layoutstateid=%d:0x%08x", 2014 -__entry->error, 2015 show_nfsv4_errors(__entry->error), 2016 MAJOR(__entry->dev), MINOR(__entry->dev), 2017 (unsigned long long)__entry->fileid, 2018 __entry->fhandle, 2019 show_pnfs_iomode(__entry->iomode), 2020 (unsigned long long)__entry->offset, 2021 (unsigned long long)__entry->count, 2022 __entry->stateid_seq, __entry->stateid_hash, 2023 __entry->layoutstateid_seq, __entry->layoutstateid_hash 2024 ) 2025); 2026 2027DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit); 2028DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn); 2029DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close); 2030DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror); 2031DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats); 2032 2033TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN); 2034TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS); 2035TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN); 2036TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH); 2037TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM); 2038TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL); 2039TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL); 2040TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED); 2041TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN); 2042TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED); 2043TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN); 2044TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY); 2045TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET); 2046TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT); 2047 2048#define show_pnfs_update_layout_reason(reason) \ 2049 __print_symbolic(reason, \ 2050 { PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" }, \ 2051 { PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" }, \ 2052 { PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" }, \ 2053 { PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" }, \ 2054 { PNFS_UPDATE_LAYOUT_NOMEM, "nomem" }, \ 2055 { PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" }, \ 2056 { PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" }, \ 2057 { PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" }, \ 2058 { PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" }, \ 2059 { PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" }, \ 2060 { PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" }, \ 2061 { PNFS_UPDATE_LAYOUT_RETRY, "retrying" }, \ 2062 { PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \ 2063 { PNFS_UPDATE_LAYOUT_EXIT, "exit" }) 2064 2065TRACE_EVENT(pnfs_update_layout, 2066 TP_PROTO(struct inode *inode, 2067 loff_t pos, 2068 u64 count, 2069 enum pnfs_iomode iomode, 2070 struct pnfs_layout_hdr *lo, 2071 struct pnfs_layout_segment *lseg, 2072 enum pnfs_update_layout_reason reason 2073 ), 2074 TP_ARGS(inode, pos, count, iomode, lo, lseg, reason), 2075 TP_STRUCT__entry( 2076 __field(dev_t, dev) 2077 __field(u64, fileid) 2078 __field(u32, fhandle) 2079 __field(loff_t, pos) 2080 __field(u64, count) 2081 __field(enum pnfs_iomode, iomode) 2082 __field(int, layoutstateid_seq) 2083 __field(u32, layoutstateid_hash) 2084 __field(long, lseg) 2085 __field(enum pnfs_update_layout_reason, reason) 2086 ), 2087 TP_fast_assign( 2088 __entry->dev = inode->i_sb->s_dev; 2089 __entry->fileid = NFS_FILEID(inode); 2090 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 2091 __entry->pos = pos; 2092 __entry->count = count; 2093 __entry->iomode = iomode; 2094 __entry->reason = reason; 2095 if (lo != NULL) { 2096 __entry->layoutstateid_seq = 2097 be32_to_cpu(lo->plh_stateid.seqid); 2098 __entry->layoutstateid_hash = 2099 nfs_stateid_hash(&lo->plh_stateid); 2100 } else { 2101 __entry->layoutstateid_seq = 0; 2102 __entry->layoutstateid_hash = 0; 2103 } 2104 __entry->lseg = (long)lseg; 2105 ), 2106 TP_printk( 2107 "fileid=%02x:%02x:%llu fhandle=0x%08x " 2108 "iomode=%s pos=%llu count=%llu " 2109 "layoutstateid=%d:0x%08x lseg=0x%lx (%s)", 2110 MAJOR(__entry->dev), MINOR(__entry->dev), 2111 (unsigned long long)__entry->fileid, 2112 __entry->fhandle, 2113 show_pnfs_iomode(__entry->iomode), 2114 (unsigned long long)__entry->pos, 2115 (unsigned long long)__entry->count, 2116 __entry->layoutstateid_seq, __entry->layoutstateid_hash, 2117 __entry->lseg, 2118 show_pnfs_update_layout_reason(__entry->reason) 2119 ) 2120); 2121 2122DECLARE_EVENT_CLASS(pnfs_layout_event, 2123 TP_PROTO(struct inode *inode, 2124 loff_t pos, 2125 u64 count, 2126 enum pnfs_iomode iomode, 2127 struct pnfs_layout_hdr *lo, 2128 struct pnfs_layout_segment *lseg 2129 ), 2130 TP_ARGS(inode, pos, count, iomode, lo, lseg), 2131 TP_STRUCT__entry( 2132 __field(dev_t, dev) 2133 __field(u64, fileid) 2134 __field(u32, fhandle) 2135 __field(loff_t, pos) 2136 __field(u64, count) 2137 __field(enum pnfs_iomode, iomode) 2138 __field(int, layoutstateid_seq) 2139 __field(u32, layoutstateid_hash) 2140 __field(long, lseg) 2141 ), 2142 TP_fast_assign( 2143 __entry->dev = inode->i_sb->s_dev; 2144 __entry->fileid = NFS_FILEID(inode); 2145 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 2146 __entry->pos = pos; 2147 __entry->count = count; 2148 __entry->iomode = iomode; 2149 if (lo != NULL) { 2150 __entry->layoutstateid_seq = 2151 be32_to_cpu(lo->plh_stateid.seqid); 2152 __entry->layoutstateid_hash = 2153 nfs_stateid_hash(&lo->plh_stateid); 2154 } else { 2155 __entry->layoutstateid_seq = 0; 2156 __entry->layoutstateid_hash = 0; 2157 } 2158 __entry->lseg = (long)lseg; 2159 ), 2160 TP_printk( 2161 "fileid=%02x:%02x:%llu fhandle=0x%08x " 2162 "iomode=%s pos=%llu count=%llu " 2163 "layoutstateid=%d:0x%08x lseg=0x%lx", 2164 MAJOR(__entry->dev), MINOR(__entry->dev), 2165 (unsigned long long)__entry->fileid, 2166 __entry->fhandle, 2167 show_pnfs_iomode(__entry->iomode), 2168 (unsigned long long)__entry->pos, 2169 (unsigned long long)__entry->count, 2170 __entry->layoutstateid_seq, __entry->layoutstateid_hash, 2171 __entry->lseg 2172 ) 2173); 2174 2175#define DEFINE_PNFS_LAYOUT_EVENT(name) \ 2176 DEFINE_EVENT(pnfs_layout_event, name, \ 2177 TP_PROTO(struct inode *inode, \ 2178 loff_t pos, \ 2179 u64 count, \ 2180 enum pnfs_iomode iomode, \ 2181 struct pnfs_layout_hdr *lo, \ 2182 struct pnfs_layout_segment *lseg \ 2183 ), \ 2184 TP_ARGS(inode, pos, count, iomode, lo, lseg)) 2185 2186DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read); 2187DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write); 2188DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count); 2189DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done); 2190DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done); 2191DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist); 2192DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist); 2193 2194DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event, 2195 TP_PROTO( 2196 const struct nfs_pgio_header *hdr 2197 ), 2198 2199 TP_ARGS(hdr), 2200 2201 TP_STRUCT__entry( 2202 __field(unsigned long, error) 2203 __field(dev_t, dev) 2204 __field(u32, fhandle) 2205 __field(u64, fileid) 2206 __field(loff_t, offset) 2207 __field(u32, count) 2208 __field(int, stateid_seq) 2209 __field(u32, stateid_hash) 2210 __string(dstaddr, hdr->ds_clp ? 2211 rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient, 2212 RPC_DISPLAY_ADDR) : "unknown") 2213 ), 2214 2215 TP_fast_assign( 2216 const struct inode *inode = hdr->inode; 2217 2218 __entry->error = hdr->res.op_status; 2219 __entry->fhandle = nfs_fhandle_hash(hdr->args.fh); 2220 __entry->fileid = NFS_FILEID(inode); 2221 __entry->dev = inode->i_sb->s_dev; 2222 __entry->offset = hdr->args.offset; 2223 __entry->count = hdr->args.count; 2224 __entry->stateid_seq = 2225 be32_to_cpu(hdr->args.stateid.seqid); 2226 __entry->stateid_hash = 2227 nfs_stateid_hash(&hdr->args.stateid); 2228 __assign_str(dstaddr, hdr->ds_clp ? 2229 rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient, 2230 RPC_DISPLAY_ADDR) : "unknown"); 2231 ), 2232 2233 TP_printk( 2234 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2235 "offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s", 2236 -__entry->error, 2237 show_nfsv4_errors(__entry->error), 2238 MAJOR(__entry->dev), MINOR(__entry->dev), 2239 (unsigned long long)__entry->fileid, 2240 __entry->fhandle, 2241 __entry->offset, __entry->count, 2242 __entry->stateid_seq, __entry->stateid_hash, 2243 __get_str(dstaddr) 2244 ) 2245); 2246 2247#define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \ 2248 DEFINE_EVENT(nfs4_flexfiles_io_event, name, \ 2249 TP_PROTO( \ 2250 const struct nfs_pgio_header *hdr \ 2251 ), \ 2252 TP_ARGS(hdr)) 2253DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error); 2254DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error); 2255 2256TRACE_EVENT(ff_layout_commit_error, 2257 TP_PROTO( 2258 const struct nfs_commit_data *data 2259 ), 2260 2261 TP_ARGS(data), 2262 2263 TP_STRUCT__entry( 2264 __field(unsigned long, error) 2265 __field(dev_t, dev) 2266 __field(u32, fhandle) 2267 __field(u64, fileid) 2268 __field(loff_t, offset) 2269 __field(u32, count) 2270 __string(dstaddr, data->ds_clp ? 2271 rpc_peeraddr2str(data->ds_clp->cl_rpcclient, 2272 RPC_DISPLAY_ADDR) : "unknown") 2273 ), 2274 2275 TP_fast_assign( 2276 const struct inode *inode = data->inode; 2277 2278 __entry->error = data->res.op_status; 2279 __entry->fhandle = nfs_fhandle_hash(data->args.fh); 2280 __entry->fileid = NFS_FILEID(inode); 2281 __entry->dev = inode->i_sb->s_dev; 2282 __entry->offset = data->args.offset; 2283 __entry->count = data->args.count; 2284 __assign_str(dstaddr, data->ds_clp ? 2285 rpc_peeraddr2str(data->ds_clp->cl_rpcclient, 2286 RPC_DISPLAY_ADDR) : "unknown"); 2287 ), 2288 2289 TP_printk( 2290 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2291 "offset=%llu count=%u dstaddr=%s", 2292 -__entry->error, 2293 show_nfsv4_errors(__entry->error), 2294 MAJOR(__entry->dev), MINOR(__entry->dev), 2295 (unsigned long long)__entry->fileid, 2296 __entry->fhandle, 2297 __entry->offset, __entry->count, 2298 __get_str(dstaddr) 2299 ) 2300); 2301 2302 2303#endif /* CONFIG_NFS_V4_1 */ 2304 2305#endif /* _TRACE_NFS4_H */ 2306 2307#undef TRACE_INCLUDE_PATH 2308#define TRACE_INCLUDE_PATH . 2309#define TRACE_INCLUDE_FILE nfs4trace 2310/* This part must be outside protection */ 2311#include <trace/define_trace.h> 2312