1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (c) 2014 Christoph Hellwig. 4 */ 5 #undef TRACE_SYSTEM 6 #define TRACE_SYSTEM nfsd 7 8 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 9 #define _NFSD_TRACE_H 10 11 #include <linux/tracepoint.h> 12 #include <linux/sunrpc/clnt.h> 13 #include <linux/sunrpc/xprt.h> 14 #include <trace/misc/fs.h> 15 #include <trace/misc/nfs.h> 16 #include <trace/misc/sunrpc.h> 17 18 #include "export.h" 19 #include "nfsfh.h" 20 #include "xdr4.h" 21 22 #define NFSD_TRACE_PROC_CALL_FIELDS(r) \ 23 __field(unsigned int, netns_ino) \ 24 __field(u32, xid) \ 25 __sockaddr(server, (r)->rq_xprt->xpt_locallen) \ 26 __sockaddr(client, (r)->rq_xprt->xpt_remotelen) 27 28 #define NFSD_TRACE_PROC_CALL_ASSIGNMENTS(r) \ 29 do { \ 30 struct svc_xprt *xprt = (r)->rq_xprt; \ 31 __entry->netns_ino = SVC_NET(r)->ns.inum; \ 32 __entry->xid = be32_to_cpu((r)->rq_xid); \ 33 __assign_sockaddr(server, &xprt->xpt_local, \ 34 xprt->xpt_locallen); \ 35 __assign_sockaddr(client, &xprt->xpt_remote, \ 36 xprt->xpt_remotelen); \ 37 } while (0) 38 39 #define NFSD_TRACE_PROC_RES_FIELDS(r) \ 40 __field(unsigned int, netns_ino) \ 41 __field(u32, xid) \ 42 __field(unsigned long, status) \ 43 __sockaddr(server, (r)->rq_xprt->xpt_locallen) \ 44 __sockaddr(client, (r)->rq_xprt->xpt_remotelen) 45 46 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(r, error) \ 47 do { \ 48 struct svc_xprt *xprt = (r)->rq_xprt; \ 49 __entry->netns_ino = SVC_NET(r)->ns.inum; \ 50 __entry->xid = be32_to_cpu((r)->rq_xid); \ 51 __entry->status = be32_to_cpu(error); \ 52 __assign_sockaddr(server, &xprt->xpt_local, \ 53 xprt->xpt_locallen); \ 54 __assign_sockaddr(client, &xprt->xpt_remote, \ 55 xprt->xpt_remotelen); \ 56 } while (0); 57 58 DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 59 TP_PROTO( 60 const struct svc_rqst *rqstp 61 ), 62 TP_ARGS(rqstp), 63 TP_STRUCT__entry( 64 __field(unsigned int, netns_ino) 65 __field(u32, xid) 66 __field(u32, vers) 67 __field(u32, proc) 68 __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 69 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 70 ), 71 TP_fast_assign( 72 const struct svc_xprt *xprt = rqstp->rq_xprt; 73 74 __entry->netns_ino = xprt->xpt_net->ns.inum; 75 __entry->xid = be32_to_cpu(rqstp->rq_xid); 76 __entry->vers = rqstp->rq_vers; 77 __entry->proc = rqstp->rq_proc; 78 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 79 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 80 ), 81 TP_printk("xid=0x%08x vers=%u proc=%u", 82 __entry->xid, __entry->vers, __entry->proc 83 ) 84 ); 85 86 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 87 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 88 TP_PROTO(const struct svc_rqst *rqstp), \ 89 TP_ARGS(rqstp)) 90 91 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 92 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 93 94 #define show_nfsd_may_flags(x) \ 95 __print_flags(x, "|", \ 96 { NFSD_MAY_EXEC, "EXEC" }, \ 97 { NFSD_MAY_WRITE, "WRITE" }, \ 98 { NFSD_MAY_READ, "READ" }, \ 99 { NFSD_MAY_SATTR, "SATTR" }, \ 100 { NFSD_MAY_TRUNC, "TRUNC" }, \ 101 { NFSD_MAY_NLM, "NLM" }, \ 102 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 103 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 104 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 105 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 106 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 107 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 108 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }, \ 109 { NFSD_MAY_LOCALIO, "LOCALIO" }) 110 111 TRACE_EVENT(nfsd_compound, 112 TP_PROTO( 113 const struct svc_rqst *rqst, 114 const char *tag, 115 u32 taglen, 116 u32 opcnt 117 ), 118 TP_ARGS(rqst, tag, taglen, opcnt), 119 TP_STRUCT__entry( 120 __field(u32, xid) 121 __field(u32, opcnt) 122 __string_len(tag, tag, taglen) 123 ), 124 TP_fast_assign( 125 __entry->xid = be32_to_cpu(rqst->rq_xid); 126 __entry->opcnt = opcnt; 127 __assign_str(tag); 128 ), 129 TP_printk("xid=0x%08x opcnt=%u tag=%s", 130 __entry->xid, __entry->opcnt, __get_str(tag) 131 ) 132 ) 133 134 TRACE_EVENT(nfsd_compound_status, 135 TP_PROTO(u32 args_opcnt, 136 u32 resp_opcnt, 137 __be32 status, 138 const char *name), 139 TP_ARGS(args_opcnt, resp_opcnt, status, name), 140 TP_STRUCT__entry( 141 __field(u32, args_opcnt) 142 __field(u32, resp_opcnt) 143 __field(int, status) 144 __string(name, name) 145 ), 146 TP_fast_assign( 147 __entry->args_opcnt = args_opcnt; 148 __entry->resp_opcnt = resp_opcnt; 149 __entry->status = be32_to_cpu(status); 150 __assign_str(name); 151 ), 152 TP_printk("op=%u/%u %s status=%d", 153 __entry->resp_opcnt, __entry->args_opcnt, 154 __get_str(name), __entry->status) 155 ) 156 157 TRACE_EVENT(nfsd_compound_decode_err, 158 TP_PROTO( 159 const struct svc_rqst *rqstp, 160 u32 args_opcnt, 161 u32 resp_opcnt, 162 u32 opnum, 163 __be32 status 164 ), 165 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 166 TP_STRUCT__entry( 167 NFSD_TRACE_PROC_RES_FIELDS(rqstp) 168 169 __field(u32, args_opcnt) 170 __field(u32, resp_opcnt) 171 __field(u32, opnum) 172 ), 173 TP_fast_assign( 174 NFSD_TRACE_PROC_RES_ASSIGNMENTS(rqstp, status) 175 176 __entry->args_opcnt = args_opcnt; 177 __entry->resp_opcnt = resp_opcnt; 178 __entry->opnum = opnum; 179 ), 180 TP_printk("op=%u/%u opnum=%u status=%lu", 181 __entry->resp_opcnt, __entry->args_opcnt, 182 __entry->opnum, __entry->status) 183 ); 184 185 DECLARE_EVENT_CLASS(nfsd_compound_err_class, 186 TP_PROTO( 187 const struct svc_rqst *rqstp, 188 u32 opnum, 189 __be32 status 190 ), 191 TP_ARGS(rqstp, opnum, status), 192 TP_STRUCT__entry( 193 NFSD_TRACE_PROC_RES_FIELDS(rqstp) 194 195 __field(u32, opnum) 196 ), 197 TP_fast_assign( 198 NFSD_TRACE_PROC_RES_ASSIGNMENTS(rqstp, status) 199 200 __entry->opnum = opnum; 201 ), 202 TP_printk("opnum=%u status=%lu", 203 __entry->opnum, __entry->status) 204 ); 205 206 #define DEFINE_NFSD_COMPOUND_ERR_EVENT(name) \ 207 DEFINE_EVENT(nfsd_compound_err_class, nfsd_compound_##name##_err, \ 208 TP_PROTO( \ 209 const struct svc_rqst *rqstp, \ 210 u32 opnum, \ 211 __be32 status \ 212 ), \ 213 TP_ARGS(rqstp, opnum, status)) 214 215 DEFINE_NFSD_COMPOUND_ERR_EVENT(op); 216 DEFINE_NFSD_COMPOUND_ERR_EVENT(encode); 217 218 #define show_fs_file_type(x) \ 219 __print_symbolic(x, \ 220 { S_IFLNK, "LNK" }, \ 221 { S_IFREG, "REG" }, \ 222 { S_IFDIR, "DIR" }, \ 223 { S_IFCHR, "CHR" }, \ 224 { S_IFBLK, "BLK" }, \ 225 { S_IFIFO, "FIFO" }, \ 226 { S_IFSOCK, "SOCK" }) 227 228 TRACE_EVENT_CONDITION(nfsd_fh_verify, 229 TP_PROTO( 230 const struct svc_rqst *rqstp, 231 const struct svc_fh *fhp, 232 umode_t type, 233 int access 234 ), 235 TP_ARGS(rqstp, fhp, type, access), 236 TP_CONDITION(rqstp != NULL), 237 TP_STRUCT__entry( 238 __field(unsigned int, netns_ino) 239 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 240 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 241 __field(u32, xid) 242 __field(u32, fh_hash) 243 __field(const void *, inode) 244 __field(unsigned long, type) 245 __field(unsigned long, access) 246 ), 247 TP_fast_assign( 248 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 249 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 250 rqstp->rq_xprt->xpt_locallen); 251 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 252 rqstp->rq_xprt->xpt_remotelen); 253 __entry->xid = be32_to_cpu(rqstp->rq_xid); 254 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 255 __entry->inode = d_inode(fhp->fh_dentry); 256 __entry->type = type; 257 __entry->access = access; 258 ), 259 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 260 __entry->xid, __entry->fh_hash, 261 show_fs_file_type(__entry->type), 262 show_nfsd_may_flags(__entry->access) 263 ) 264 ); 265 266 TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 267 TP_PROTO( 268 const struct svc_rqst *rqstp, 269 const struct svc_fh *fhp, 270 umode_t type, 271 int access, 272 __be32 error 273 ), 274 TP_ARGS(rqstp, fhp, type, access, error), 275 TP_CONDITION(rqstp != NULL && error), 276 TP_STRUCT__entry( 277 __field(unsigned int, netns_ino) 278 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 279 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 280 __field(u32, xid) 281 __field(u32, fh_hash) 282 __field(const void *, inode) 283 __field(unsigned long, type) 284 __field(unsigned long, access) 285 __field(int, error) 286 ), 287 TP_fast_assign( 288 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 289 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 290 rqstp->rq_xprt->xpt_locallen); 291 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 292 rqstp->rq_xprt->xpt_remotelen); 293 __entry->xid = be32_to_cpu(rqstp->rq_xid); 294 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 295 if (fhp->fh_dentry) 296 __entry->inode = d_inode(fhp->fh_dentry); 297 else 298 __entry->inode = NULL; 299 __entry->type = type; 300 __entry->access = access; 301 __entry->error = be32_to_cpu(error); 302 ), 303 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 304 __entry->xid, __entry->fh_hash, 305 show_fs_file_type(__entry->type), 306 show_nfsd_may_flags(__entry->access), 307 __entry->error 308 ) 309 ); 310 311 DECLARE_EVENT_CLASS(nfsd_fh_err_class, 312 TP_PROTO(struct svc_rqst *rqstp, 313 struct svc_fh *fhp, 314 int status), 315 TP_ARGS(rqstp, fhp, status), 316 TP_STRUCT__entry( 317 __field(u32, xid) 318 __field(u32, fh_hash) 319 __field(int, status) 320 ), 321 TP_fast_assign( 322 __entry->xid = be32_to_cpu(rqstp->rq_xid); 323 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 324 __entry->status = status; 325 ), 326 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 327 __entry->xid, __entry->fh_hash, 328 __entry->status) 329 ) 330 331 #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 332 DEFINE_EVENT_CONDITION(nfsd_fh_err_class, nfsd_##name, \ 333 TP_PROTO(struct svc_rqst *rqstp, \ 334 struct svc_fh *fhp, \ 335 int status), \ 336 TP_ARGS(rqstp, fhp, status), \ 337 TP_CONDITION(rqstp != NULL)) 338 339 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 340 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 341 342 TRACE_EVENT(nfsd_exp_find_key, 343 TP_PROTO(const struct svc_expkey *key, 344 int status), 345 TP_ARGS(key, status), 346 TP_STRUCT__entry( 347 __field(u8, fsidtype) 348 __array(u32, fsid, 6) 349 __string(auth_domain, key->ek_client->name) 350 __field(int, status) 351 ), 352 TP_fast_assign( 353 __entry->fsidtype = key->ek_fsidtype; 354 memcpy(__entry->fsid, key->ek_fsid, 4*6); 355 __assign_str(auth_domain); 356 __entry->status = status; 357 ), 358 TP_printk("fsid=%x::%s domain=%s status=%d", 359 __entry->fsidtype, 360 __print_array(__entry->fsid, 6, 4), 361 __get_str(auth_domain), 362 __entry->status 363 ) 364 ); 365 366 TRACE_EVENT(nfsd_expkey_update, 367 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 368 TP_ARGS(key, exp_path), 369 TP_STRUCT__entry( 370 __field(u8, fsidtype) 371 __array(u32, fsid, 6) 372 __string(auth_domain, key->ek_client->name) 373 __string(path, exp_path) 374 __field(bool, cache) 375 ), 376 TP_fast_assign( 377 __entry->fsidtype = key->ek_fsidtype; 378 memcpy(__entry->fsid, key->ek_fsid, 4*6); 379 __assign_str(auth_domain); 380 __assign_str(path); 381 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 382 ), 383 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 384 __entry->fsidtype, 385 __print_array(__entry->fsid, 6, 4), 386 __get_str(auth_domain), 387 __get_str(path), 388 __entry->cache ? "pos" : "neg" 389 ) 390 ); 391 392 TRACE_EVENT(nfsd_exp_get_by_name, 393 TP_PROTO(const struct svc_export *key, 394 int status), 395 TP_ARGS(key, status), 396 TP_STRUCT__entry( 397 __string(path, key->ex_path.dentry->d_name.name) 398 __string(auth_domain, key->ex_client->name) 399 __field(int, status) 400 ), 401 TP_fast_assign( 402 __assign_str(path); 403 __assign_str(auth_domain); 404 __entry->status = status; 405 ), 406 TP_printk("path=%s domain=%s status=%d", 407 __get_str(path), 408 __get_str(auth_domain), 409 __entry->status 410 ) 411 ); 412 413 TRACE_EVENT(nfsd_export_update, 414 TP_PROTO(const struct svc_export *key), 415 TP_ARGS(key), 416 TP_STRUCT__entry( 417 __string(path, key->ex_path.dentry->d_name.name) 418 __string(auth_domain, key->ex_client->name) 419 __field(bool, cache) 420 ), 421 TP_fast_assign( 422 __assign_str(path); 423 __assign_str(auth_domain); 424 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 425 ), 426 TP_printk("path=%s domain=%s cache=%s", 427 __get_str(path), 428 __get_str(auth_domain), 429 __entry->cache ? "pos" : "neg" 430 ) 431 ); 432 433 DECLARE_EVENT_CLASS(nfsd_io_class, 434 TP_PROTO(struct svc_rqst *rqstp, 435 struct svc_fh *fhp, 436 u64 offset, 437 u32 len), 438 TP_ARGS(rqstp, fhp, offset, len), 439 TP_STRUCT__entry( 440 __field(u32, xid) 441 __field(u32, fh_hash) 442 __field(u64, offset) 443 __field(u32, len) 444 ), 445 TP_fast_assign( 446 __entry->xid = be32_to_cpu(rqstp->rq_xid); 447 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 448 __entry->offset = offset; 449 __entry->len = len; 450 ), 451 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 452 __entry->xid, __entry->fh_hash, 453 __entry->offset, __entry->len) 454 ) 455 456 #define DEFINE_NFSD_IO_EVENT(name) \ 457 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 458 TP_PROTO(struct svc_rqst *rqstp, \ 459 struct svc_fh *fhp, \ 460 u64 offset, \ 461 u32 len), \ 462 TP_ARGS(rqstp, fhp, offset, len)) 463 464 DEFINE_NFSD_IO_EVENT(read_start); 465 DEFINE_NFSD_IO_EVENT(read_splice); 466 DEFINE_NFSD_IO_EVENT(read_vector); 467 DEFINE_NFSD_IO_EVENT(read_io_done); 468 DEFINE_NFSD_IO_EVENT(read_done); 469 DEFINE_NFSD_IO_EVENT(write_start); 470 DEFINE_NFSD_IO_EVENT(write_opened); 471 DEFINE_NFSD_IO_EVENT(write_io_done); 472 DEFINE_NFSD_IO_EVENT(write_done); 473 DEFINE_NFSD_IO_EVENT(commit_start); 474 DEFINE_NFSD_IO_EVENT(commit_done); 475 476 DECLARE_EVENT_CLASS(nfsd_err_class, 477 TP_PROTO(struct svc_rqst *rqstp, 478 struct svc_fh *fhp, 479 loff_t offset, 480 int status), 481 TP_ARGS(rqstp, fhp, offset, status), 482 TP_STRUCT__entry( 483 __field(u32, xid) 484 __field(u32, fh_hash) 485 __field(loff_t, offset) 486 __field(int, status) 487 ), 488 TP_fast_assign( 489 __entry->xid = be32_to_cpu(rqstp->rq_xid); 490 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 491 __entry->offset = offset; 492 __entry->status = status; 493 ), 494 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 495 __entry->xid, __entry->fh_hash, 496 __entry->offset, __entry->status) 497 ) 498 499 #define DEFINE_NFSD_ERR_EVENT(name) \ 500 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 501 TP_PROTO(struct svc_rqst *rqstp, \ 502 struct svc_fh *fhp, \ 503 loff_t offset, \ 504 int len), \ 505 TP_ARGS(rqstp, fhp, offset, len)) 506 507 DEFINE_NFSD_ERR_EVENT(read_err); 508 DEFINE_NFSD_ERR_EVENT(write_err); 509 510 TRACE_EVENT(nfsd_dirent, 511 TP_PROTO(struct svc_fh *fhp, 512 u64 ino, 513 const char *name, 514 int namlen), 515 TP_ARGS(fhp, ino, name, namlen), 516 TP_STRUCT__entry( 517 __field(u32, fh_hash) 518 __field(u64, ino) 519 __string_len(name, name, namlen) 520 ), 521 TP_fast_assign( 522 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 523 __entry->ino = ino; 524 __assign_str(name); 525 ), 526 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 527 __entry->fh_hash, __entry->ino, __get_str(name) 528 ) 529 ) 530 531 DECLARE_EVENT_CLASS(nfsd_copy_err_class, 532 TP_PROTO(struct svc_rqst *rqstp, 533 struct svc_fh *src_fhp, 534 loff_t src_offset, 535 struct svc_fh *dst_fhp, 536 loff_t dst_offset, 537 u64 count, 538 int status), 539 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 540 TP_STRUCT__entry( 541 __field(u32, xid) 542 __field(u32, src_fh_hash) 543 __field(loff_t, src_offset) 544 __field(u32, dst_fh_hash) 545 __field(loff_t, dst_offset) 546 __field(u64, count) 547 __field(int, status) 548 ), 549 TP_fast_assign( 550 __entry->xid = be32_to_cpu(rqstp->rq_xid); 551 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 552 __entry->src_offset = src_offset; 553 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 554 __entry->dst_offset = dst_offset; 555 __entry->count = count; 556 __entry->status = status; 557 ), 558 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 559 "dst_fh_hash=0x%08x dst_offset=%lld " 560 "count=%llu status=%d", 561 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 562 __entry->dst_fh_hash, __entry->dst_offset, 563 (unsigned long long)__entry->count, 564 __entry->status) 565 ) 566 567 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 568 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 569 TP_PROTO(struct svc_rqst *rqstp, \ 570 struct svc_fh *src_fhp, \ 571 loff_t src_offset, \ 572 struct svc_fh *dst_fhp, \ 573 loff_t dst_offset, \ 574 u64 count, \ 575 int status), \ 576 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 577 count, status)) 578 579 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 580 581 #include "state.h" 582 #include "filecache.h" 583 #include "vfs.h" 584 585 TRACE_EVENT(nfsd_delegret_wakeup, 586 TP_PROTO( 587 const struct svc_rqst *rqstp, 588 const struct inode *inode, 589 long timeo 590 ), 591 TP_ARGS(rqstp, inode, timeo), 592 TP_STRUCT__entry( 593 __field(u32, xid) 594 __field(const void *, inode) 595 __field(long, timeo) 596 ), 597 TP_fast_assign( 598 __entry->xid = be32_to_cpu(rqstp->rq_xid); 599 __entry->inode = inode; 600 __entry->timeo = timeo; 601 ), 602 TP_printk("xid=0x%08x inode=%p%s", 603 __entry->xid, __entry->inode, 604 __entry->timeo == 0 ? " (timed out)" : "" 605 ) 606 ); 607 608 DECLARE_EVENT_CLASS(nfsd_stateid_class, 609 TP_PROTO(stateid_t *stp), 610 TP_ARGS(stp), 611 TP_STRUCT__entry( 612 __field(u32, cl_boot) 613 __field(u32, cl_id) 614 __field(u32, si_id) 615 __field(u32, si_generation) 616 ), 617 TP_fast_assign( 618 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 619 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 620 __entry->si_id = stp->si_opaque.so_id; 621 __entry->si_generation = stp->si_generation; 622 ), 623 TP_printk("client %08x:%08x stateid %08x:%08x", 624 __entry->cl_boot, 625 __entry->cl_id, 626 __entry->si_id, 627 __entry->si_generation) 628 ) 629 630 #define DEFINE_STATEID_EVENT(name) \ 631 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 632 TP_PROTO(stateid_t *stp), \ 633 TP_ARGS(stp)) 634 635 DEFINE_STATEID_EVENT(layoutstate_alloc); 636 DEFINE_STATEID_EVENT(layoutstate_unhash); 637 DEFINE_STATEID_EVENT(layoutstate_free); 638 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 639 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 640 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 641 DEFINE_STATEID_EVENT(layout_recall); 642 DEFINE_STATEID_EVENT(layout_recall_done); 643 DEFINE_STATEID_EVENT(layout_recall_fail); 644 DEFINE_STATEID_EVENT(layout_recall_release); 645 646 DEFINE_STATEID_EVENT(open); 647 DEFINE_STATEID_EVENT(deleg_read); 648 DEFINE_STATEID_EVENT(deleg_write); 649 DEFINE_STATEID_EVENT(deleg_return); 650 651 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 652 TP_PROTO(u32 seqid, const stateid_t *stp), 653 TP_ARGS(seqid, stp), 654 TP_STRUCT__entry( 655 __field(u32, seqid) 656 __field(u32, cl_boot) 657 __field(u32, cl_id) 658 __field(u32, si_id) 659 __field(u32, si_generation) 660 ), 661 TP_fast_assign( 662 __entry->seqid = seqid; 663 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 664 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 665 __entry->si_id = stp->si_opaque.so_id; 666 __entry->si_generation = stp->si_generation; 667 ), 668 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 669 __entry->seqid, __entry->cl_boot, __entry->cl_id, 670 __entry->si_id, __entry->si_generation) 671 ) 672 673 #define DEFINE_STATESEQID_EVENT(name) \ 674 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 675 TP_PROTO(u32 seqid, const stateid_t *stp), \ 676 TP_ARGS(seqid, stp)) 677 678 DEFINE_STATESEQID_EVENT(preprocess); 679 DEFINE_STATESEQID_EVENT(open_confirm); 680 681 #define show_stid_type(x) \ 682 __print_flags(x, "|", \ 683 { SC_TYPE_OPEN, "OPEN" }, \ 684 { SC_TYPE_LOCK, "LOCK" }, \ 685 { SC_TYPE_DELEG, "DELEG" }, \ 686 { SC_TYPE_LAYOUT, "LAYOUT" }) 687 688 #define show_stid_status(x) \ 689 __print_flags(x, "|", \ 690 { SC_STATUS_CLOSED, "CLOSED" }, \ 691 { SC_STATUS_REVOKED, "REVOKED" }, \ 692 { SC_STATUS_ADMIN_REVOKED, "ADMIN_REVOKED" }) 693 694 DECLARE_EVENT_CLASS(nfsd_stid_class, 695 TP_PROTO( 696 const struct nfs4_stid *stid 697 ), 698 TP_ARGS(stid), 699 TP_STRUCT__entry( 700 __field(unsigned long, sc_type) 701 __field(unsigned long, sc_status) 702 __field(int, sc_count) 703 __field(u32, cl_boot) 704 __field(u32, cl_id) 705 __field(u32, si_id) 706 __field(u32, si_generation) 707 ), 708 TP_fast_assign( 709 const stateid_t *stp = &stid->sc_stateid; 710 711 __entry->sc_type = stid->sc_type; 712 __entry->sc_status = stid->sc_status; 713 __entry->sc_count = refcount_read(&stid->sc_count); 714 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 715 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 716 __entry->si_id = stp->si_opaque.so_id; 717 __entry->si_generation = stp->si_generation; 718 ), 719 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s state=%s", 720 __entry->cl_boot, __entry->cl_id, 721 __entry->si_id, __entry->si_generation, 722 __entry->sc_count, show_stid_type(__entry->sc_type), 723 show_stid_status(__entry->sc_status) 724 ) 725 ); 726 727 #define DEFINE_STID_EVENT(name) \ 728 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 729 TP_PROTO(const struct nfs4_stid *stid), \ 730 TP_ARGS(stid)) 731 732 DEFINE_STID_EVENT(revoke); 733 734 TRACE_EVENT(nfsd_stateowner_replay, 735 TP_PROTO( 736 u32 opnum, 737 const struct nfs4_replay *rp 738 ), 739 TP_ARGS(opnum, rp), 740 TP_STRUCT__entry( 741 __field(unsigned long, status) 742 __field(u32, opnum) 743 ), 744 TP_fast_assign( 745 __entry->status = be32_to_cpu(rp->rp_status); 746 __entry->opnum = opnum; 747 ), 748 TP_printk("opnum=%u status=%lu", 749 __entry->opnum, __entry->status) 750 ); 751 752 TRACE_EVENT_CONDITION(nfsd_seq4_status, 753 TP_PROTO( 754 const struct svc_rqst *rqstp, 755 const struct nfsd4_sequence *sequence 756 ), 757 TP_ARGS(rqstp, sequence), 758 TP_CONDITION(sequence->status_flags), 759 TP_STRUCT__entry( 760 __field(unsigned int, netns_ino) 761 __field(u32, xid) 762 __field(u32, cl_boot) 763 __field(u32, cl_id) 764 __field(u32, seqno) 765 __field(u32, reserved) 766 __field(unsigned long, status_flags) 767 ), 768 TP_fast_assign( 769 const struct nfsd4_sessionid *sid = 770 (struct nfsd4_sessionid *)&sequence->sessionid; 771 772 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 773 __entry->xid = be32_to_cpu(rqstp->rq_xid); 774 __entry->cl_boot = sid->clientid.cl_boot; 775 __entry->cl_id = sid->clientid.cl_id; 776 __entry->seqno = sid->sequence; 777 __entry->reserved = sid->reserved; 778 __entry->status_flags = sequence->status_flags; 779 ), 780 TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s", 781 __entry->xid, __entry->cl_boot, __entry->cl_id, 782 __entry->seqno, __entry->reserved, 783 show_nfs4_seq4_status(__entry->status_flags) 784 ) 785 ); 786 787 DECLARE_EVENT_CLASS(nfsd_cs_slot_class, 788 TP_PROTO( 789 const struct nfs4_client *clp, 790 const struct nfsd4_create_session *cs 791 ), 792 TP_ARGS(clp, cs), 793 TP_STRUCT__entry( 794 __field(u32, seqid) 795 __field(u32, slot_seqid) 796 __field(u32, cl_boot) 797 __field(u32, cl_id) 798 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 799 ), 800 TP_fast_assign( 801 const struct nfsd4_clid_slot *slot = &clp->cl_cs_slot; 802 803 __entry->cl_boot = clp->cl_clientid.cl_boot; 804 __entry->cl_id = clp->cl_clientid.cl_id; 805 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 806 clp->cl_cb_conn.cb_addrlen); 807 __entry->seqid = cs->seqid; 808 __entry->slot_seqid = slot->sl_seqid; 809 ), 810 TP_printk("addr=%pISpc client %08x:%08x seqid=%u slot_seqid=%u", 811 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 812 __entry->seqid, __entry->slot_seqid 813 ) 814 ); 815 816 #define DEFINE_CS_SLOT_EVENT(name) \ 817 DEFINE_EVENT(nfsd_cs_slot_class, nfsd_##name, \ 818 TP_PROTO( \ 819 const struct nfs4_client *clp, \ 820 const struct nfsd4_create_session *cs \ 821 ), \ 822 TP_ARGS(clp, cs)) 823 824 DEFINE_CS_SLOT_EVENT(slot_seqid_conf); 825 DEFINE_CS_SLOT_EVENT(slot_seqid_unconf); 826 827 #define show_nfs_slot_flags(val) \ 828 __print_flags(val, "|", \ 829 { NFSD4_SLOT_INUSE, "INUSE" }, \ 830 { NFSD4_SLOT_CACHETHIS, "CACHETHIS" }, \ 831 { NFSD4_SLOT_INITIALIZED, "INITIALIZED" }, \ 832 { NFSD4_SLOT_CACHED, "CACHED" }, \ 833 { NFSD4_SLOT_REUSED, "REUSED" }) 834 835 TRACE_EVENT(nfsd_slot_seqid_sequence, 836 TP_PROTO( 837 const struct nfs4_client *clp, 838 const struct nfsd4_sequence *seq, 839 const struct nfsd4_slot *slot 840 ), 841 TP_ARGS(clp, seq, slot), 842 TP_STRUCT__entry( 843 __field(u32, seqid) 844 __field(u32, slot_seqid) 845 __field(u32, slot_index) 846 __field(unsigned long, slot_flags) 847 __field(u32, cl_boot) 848 __field(u32, cl_id) 849 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 850 ), 851 TP_fast_assign( 852 __entry->cl_boot = clp->cl_clientid.cl_boot; 853 __entry->cl_id = clp->cl_clientid.cl_id; 854 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 855 clp->cl_cb_conn.cb_addrlen); 856 __entry->seqid = seq->seqid; 857 __entry->slot_seqid = slot->sl_seqid; 858 __entry->slot_index = seq->slotid; 859 __entry->slot_flags = slot->sl_flags; 860 ), 861 TP_printk("addr=%pISpc client %08x:%08x idx=%u seqid=%u slot_seqid=%u flags=%s", 862 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 863 __entry->slot_index, __entry->seqid, __entry->slot_seqid, 864 show_nfs_slot_flags(__entry->slot_flags) 865 ) 866 ); 867 868 DECLARE_EVENT_CLASS(nfsd_clientid_class, 869 TP_PROTO(const clientid_t *clid), 870 TP_ARGS(clid), 871 TP_STRUCT__entry( 872 __field(u32, cl_boot) 873 __field(u32, cl_id) 874 ), 875 TP_fast_assign( 876 __entry->cl_boot = clid->cl_boot; 877 __entry->cl_id = clid->cl_id; 878 ), 879 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 880 ) 881 882 #define DEFINE_CLIENTID_EVENT(name) \ 883 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 884 TP_PROTO(const clientid_t *clid), \ 885 TP_ARGS(clid)) 886 887 DEFINE_CLIENTID_EVENT(expire_unconf); 888 DEFINE_CLIENTID_EVENT(reclaim_complete); 889 DEFINE_CLIENTID_EVENT(confirmed); 890 DEFINE_CLIENTID_EVENT(destroyed); 891 DEFINE_CLIENTID_EVENT(admin_expired); 892 DEFINE_CLIENTID_EVENT(replaced); 893 DEFINE_CLIENTID_EVENT(purged); 894 DEFINE_CLIENTID_EVENT(renew); 895 DEFINE_CLIENTID_EVENT(stale); 896 897 TRACE_EVENT(nfsd_mark_client_expired, 898 TP_PROTO( 899 const struct nfs4_client *clp, 900 int cl_rpc_users 901 ), 902 TP_ARGS(clp, cl_rpc_users), 903 TP_STRUCT__entry( 904 __field(int, cl_rpc_users) 905 __field(u32, cl_boot) 906 __field(u32, cl_id) 907 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 908 ), 909 TP_fast_assign( 910 __entry->cl_rpc_users = cl_rpc_users; 911 __entry->cl_boot = clp->cl_clientid.cl_boot; 912 __entry->cl_id = clp->cl_clientid.cl_id; 913 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 914 clp->cl_cb_conn.cb_addrlen) 915 ), 916 TP_printk("addr=%pISpc client %08x:%08x cl_rpc_users=%d", 917 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 918 __entry->cl_rpc_users) 919 ); 920 921 DECLARE_EVENT_CLASS(nfsd_net_class, 922 TP_PROTO(const struct nfsd_net *nn), 923 TP_ARGS(nn), 924 TP_STRUCT__entry( 925 __field(unsigned long long, boot_time) 926 ), 927 TP_fast_assign( 928 __entry->boot_time = nn->boot_time; 929 ), 930 TP_printk("boot_time=%16llx", __entry->boot_time) 931 ) 932 933 #define DEFINE_NET_EVENT(name) \ 934 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 935 TP_PROTO(const struct nfsd_net *nn), \ 936 TP_ARGS(nn)) 937 938 DEFINE_NET_EVENT(grace_start); 939 DEFINE_NET_EVENT(grace_complete); 940 941 TRACE_EVENT(nfsd_writeverf_reset, 942 TP_PROTO( 943 const struct nfsd_net *nn, 944 const struct svc_rqst *rqstp, 945 int error 946 ), 947 TP_ARGS(nn, rqstp, error), 948 TP_STRUCT__entry( 949 __field(unsigned long long, boot_time) 950 __field(u32, xid) 951 __field(int, error) 952 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 953 ), 954 TP_fast_assign( 955 __entry->boot_time = nn->boot_time; 956 __entry->xid = be32_to_cpu(rqstp->rq_xid); 957 __entry->error = error; 958 959 /* avoid seqlock inside TP_fast_assign */ 960 memcpy(__entry->verifier, nn->writeverf, 961 NFS4_VERIFIER_SIZE); 962 ), 963 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 964 __entry->boot_time, __entry->xid, __entry->error, 965 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 966 ) 967 ); 968 969 TRACE_EVENT(nfsd_clid_cred_mismatch, 970 TP_PROTO( 971 const struct nfs4_client *clp, 972 const struct svc_rqst *rqstp 973 ), 974 TP_ARGS(clp, rqstp), 975 TP_STRUCT__entry( 976 __field(u32, cl_boot) 977 __field(u32, cl_id) 978 __field(unsigned long, cl_flavor) 979 __field(unsigned long, new_flavor) 980 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 981 ), 982 TP_fast_assign( 983 __entry->cl_boot = clp->cl_clientid.cl_boot; 984 __entry->cl_id = clp->cl_clientid.cl_id; 985 __entry->cl_flavor = clp->cl_cred.cr_flavor; 986 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 987 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 988 rqstp->rq_xprt->xpt_remotelen); 989 ), 990 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 991 __entry->cl_boot, __entry->cl_id, 992 show_nfsd_authflavor(__entry->cl_flavor), 993 show_nfsd_authflavor(__entry->new_flavor), 994 __get_sockaddr(addr) 995 ) 996 ) 997 998 TRACE_EVENT(nfsd_clid_verf_mismatch, 999 TP_PROTO( 1000 const struct nfs4_client *clp, 1001 const struct svc_rqst *rqstp, 1002 const nfs4_verifier *verf 1003 ), 1004 TP_ARGS(clp, rqstp, verf), 1005 TP_STRUCT__entry( 1006 __field(u32, cl_boot) 1007 __field(u32, cl_id) 1008 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 1009 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 1010 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 1011 ), 1012 TP_fast_assign( 1013 __entry->cl_boot = clp->cl_clientid.cl_boot; 1014 __entry->cl_id = clp->cl_clientid.cl_id; 1015 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 1016 NFS4_VERIFIER_SIZE); 1017 memcpy(__entry->new_verifier, (void *)verf, 1018 NFS4_VERIFIER_SIZE); 1019 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 1020 rqstp->rq_xprt->xpt_remotelen); 1021 ), 1022 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 1023 __entry->cl_boot, __entry->cl_id, 1024 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 1025 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 1026 __get_sockaddr(addr) 1027 ) 1028 ); 1029 1030 DECLARE_EVENT_CLASS(nfsd_clid_class, 1031 TP_PROTO(const struct nfs4_client *clp), 1032 TP_ARGS(clp), 1033 TP_STRUCT__entry( 1034 __field(u32, cl_boot) 1035 __field(u32, cl_id) 1036 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1037 __field(unsigned long, flavor) 1038 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 1039 __string_len(name, clp->cl_name.data, clp->cl_name.len) 1040 ), 1041 TP_fast_assign( 1042 __entry->cl_boot = clp->cl_clientid.cl_boot; 1043 __entry->cl_id = clp->cl_clientid.cl_id; 1044 memcpy(__entry->addr, &clp->cl_addr, 1045 sizeof(struct sockaddr_in6)); 1046 __entry->flavor = clp->cl_cred.cr_flavor; 1047 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 1048 NFS4_VERIFIER_SIZE); 1049 __assign_str(name); 1050 ), 1051 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 1052 __entry->addr, __get_str(name), 1053 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 1054 show_nfsd_authflavor(__entry->flavor), 1055 __entry->cl_boot, __entry->cl_id) 1056 ); 1057 1058 #define DEFINE_CLID_EVENT(name) \ 1059 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 1060 TP_PROTO(const struct nfs4_client *clp), \ 1061 TP_ARGS(clp)) 1062 1063 DEFINE_CLID_EVENT(fresh); 1064 DEFINE_CLID_EVENT(confirmed_r); 1065 1066 /* 1067 * from fs/nfsd/filecache.h 1068 */ 1069 #define show_nf_flags(val) \ 1070 __print_flags(val, "|", \ 1071 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 1072 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 1073 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 1074 { 1 << NFSD_FILE_RECENT, "RECENT" }, \ 1075 { 1 << NFSD_FILE_GC, "GC" }) 1076 1077 DECLARE_EVENT_CLASS(nfsd_file_class, 1078 TP_PROTO(struct nfsd_file *nf), 1079 TP_ARGS(nf), 1080 TP_STRUCT__entry( 1081 __field(void *, nf_inode) 1082 __field(int, nf_ref) 1083 __field(unsigned long, nf_flags) 1084 __field(unsigned char, nf_may) 1085 __field(struct file *, nf_file) 1086 ), 1087 TP_fast_assign( 1088 __entry->nf_inode = nf->nf_inode; 1089 __entry->nf_ref = refcount_read(&nf->nf_ref); 1090 __entry->nf_flags = nf->nf_flags; 1091 __entry->nf_may = nf->nf_may; 1092 __entry->nf_file = nf->nf_file; 1093 ), 1094 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 1095 __entry->nf_inode, 1096 __entry->nf_ref, 1097 show_nf_flags(__entry->nf_flags), 1098 show_nfsd_may_flags(__entry->nf_may), 1099 __entry->nf_file) 1100 ) 1101 1102 #define DEFINE_NFSD_FILE_EVENT(name) \ 1103 DEFINE_EVENT(nfsd_file_class, name, \ 1104 TP_PROTO(struct nfsd_file *nf), \ 1105 TP_ARGS(nf)) 1106 1107 DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 1108 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 1109 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 1110 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 1111 1112 TRACE_EVENT(nfsd_file_alloc, 1113 TP_PROTO( 1114 const struct nfsd_file *nf 1115 ), 1116 TP_ARGS(nf), 1117 TP_STRUCT__entry( 1118 __field(const void *, nf_inode) 1119 __field(unsigned long, nf_flags) 1120 __field(unsigned long, nf_may) 1121 __field(unsigned int, nf_ref) 1122 ), 1123 TP_fast_assign( 1124 __entry->nf_inode = nf->nf_inode; 1125 __entry->nf_flags = nf->nf_flags; 1126 __entry->nf_ref = refcount_read(&nf->nf_ref); 1127 __entry->nf_may = nf->nf_may; 1128 ), 1129 TP_printk("inode=%p ref=%u flags=%s may=%s", 1130 __entry->nf_inode, __entry->nf_ref, 1131 show_nf_flags(__entry->nf_flags), 1132 show_nfsd_may_flags(__entry->nf_may) 1133 ) 1134 ); 1135 1136 TRACE_EVENT(nfsd_file_get_dio_attrs, 1137 TP_PROTO( 1138 const struct inode *inode, 1139 const struct kstat *stat 1140 ), 1141 TP_ARGS(inode, stat), 1142 TP_STRUCT__entry( 1143 __field(const void *, inode) 1144 __field(unsigned long, mask) 1145 __field(u32, mem_align) 1146 __field(u32, offset_align) 1147 __field(u32, read_offset_align) 1148 ), 1149 TP_fast_assign( 1150 __entry->inode = inode; 1151 __entry->mask = stat->result_mask; 1152 __entry->mem_align = stat->dio_mem_align; 1153 __entry->offset_align = stat->dio_offset_align; 1154 __entry->read_offset_align = stat->dio_read_offset_align; 1155 ), 1156 TP_printk("inode=%p flags=%s mem_align=%u offset_align=%u read_offset_align=%u", 1157 __entry->inode, show_statx_mask(__entry->mask), 1158 __entry->mem_align, __entry->offset_align, 1159 __entry->read_offset_align 1160 ) 1161 ); 1162 1163 TRACE_EVENT(nfsd_file_acquire, 1164 TP_PROTO( 1165 const struct svc_rqst *rqstp, 1166 const struct inode *inode, 1167 unsigned int may_flags, 1168 const struct nfsd_file *nf, 1169 __be32 status 1170 ), 1171 1172 TP_ARGS(rqstp, inode, may_flags, nf, status), 1173 1174 TP_STRUCT__entry( 1175 __field(u32, xid) 1176 __field(const void *, inode) 1177 __field(unsigned long, may_flags) 1178 __field(unsigned int, nf_ref) 1179 __field(unsigned long, nf_flags) 1180 __field(unsigned long, nf_may) 1181 __field(const void *, nf_file) 1182 __field(u32, status) 1183 ), 1184 1185 TP_fast_assign( 1186 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1187 __entry->inode = inode; 1188 __entry->may_flags = may_flags; 1189 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 1190 __entry->nf_flags = nf ? nf->nf_flags : 0; 1191 __entry->nf_may = nf ? nf->nf_may : 0; 1192 __entry->nf_file = nf ? nf->nf_file : NULL; 1193 __entry->status = be32_to_cpu(status); 1194 ), 1195 1196 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 1197 __entry->xid, __entry->inode, 1198 show_nfsd_may_flags(__entry->may_flags), 1199 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1200 show_nfsd_may_flags(__entry->nf_may), 1201 __entry->nf_file, __entry->status 1202 ) 1203 ); 1204 1205 TRACE_EVENT(nfsd_file_insert_err, 1206 TP_PROTO( 1207 const struct svc_rqst *rqstp, 1208 const struct inode *inode, 1209 unsigned int may_flags, 1210 long error 1211 ), 1212 TP_ARGS(rqstp, inode, may_flags, error), 1213 TP_STRUCT__entry( 1214 __field(u32, xid) 1215 __field(const void *, inode) 1216 __field(unsigned long, may_flags) 1217 __field(long, error) 1218 ), 1219 TP_fast_assign( 1220 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1221 __entry->inode = inode; 1222 __entry->may_flags = may_flags; 1223 __entry->error = error; 1224 ), 1225 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1226 __entry->xid, __entry->inode, 1227 show_nfsd_may_flags(__entry->may_flags), 1228 __entry->error 1229 ) 1230 ); 1231 1232 TRACE_EVENT(nfsd_file_cons_err, 1233 TP_PROTO( 1234 const struct svc_rqst *rqstp, 1235 const struct inode *inode, 1236 unsigned int may_flags, 1237 const struct nfsd_file *nf 1238 ), 1239 TP_ARGS(rqstp, inode, may_flags, nf), 1240 TP_STRUCT__entry( 1241 __field(u32, xid) 1242 __field(const void *, inode) 1243 __field(unsigned long, may_flags) 1244 __field(unsigned int, nf_ref) 1245 __field(unsigned long, nf_flags) 1246 __field(unsigned long, nf_may) 1247 __field(const void *, nf_file) 1248 ), 1249 TP_fast_assign( 1250 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1251 __entry->inode = inode; 1252 __entry->may_flags = may_flags; 1253 __entry->nf_ref = refcount_read(&nf->nf_ref); 1254 __entry->nf_flags = nf->nf_flags; 1255 __entry->nf_may = nf->nf_may; 1256 __entry->nf_file = nf->nf_file; 1257 ), 1258 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1259 __entry->xid, __entry->inode, 1260 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1261 show_nf_flags(__entry->nf_flags), 1262 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1263 ) 1264 ); 1265 1266 DECLARE_EVENT_CLASS(nfsd_file_open_class, 1267 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1268 TP_ARGS(nf, status), 1269 TP_STRUCT__entry( 1270 __field(void *, nf_inode) /* cannot be dereferenced */ 1271 __field(int, nf_ref) 1272 __field(unsigned long, nf_flags) 1273 __field(unsigned long, nf_may) 1274 __field(void *, nf_file) /* cannot be dereferenced */ 1275 ), 1276 TP_fast_assign( 1277 __entry->nf_inode = nf->nf_inode; 1278 __entry->nf_ref = refcount_read(&nf->nf_ref); 1279 __entry->nf_flags = nf->nf_flags; 1280 __entry->nf_may = nf->nf_may; 1281 __entry->nf_file = nf->nf_file; 1282 ), 1283 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1284 __entry->nf_inode, 1285 __entry->nf_ref, 1286 show_nf_flags(__entry->nf_flags), 1287 show_nfsd_may_flags(__entry->nf_may), 1288 __entry->nf_file) 1289 ) 1290 1291 #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1292 DEFINE_EVENT(nfsd_file_open_class, name, \ 1293 TP_PROTO( \ 1294 const struct nfsd_file *nf, \ 1295 __be32 status \ 1296 ), \ 1297 TP_ARGS(nf, status)) 1298 1299 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1300 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1301 1302 TRACE_EVENT(nfsd_file_is_cached, 1303 TP_PROTO( 1304 const struct inode *inode, 1305 int found 1306 ), 1307 TP_ARGS(inode, found), 1308 TP_STRUCT__entry( 1309 __field(const struct inode *, inode) 1310 __field(int, found) 1311 ), 1312 TP_fast_assign( 1313 __entry->inode = inode; 1314 __entry->found = found; 1315 ), 1316 TP_printk("inode=%p is %scached", 1317 __entry->inode, 1318 __entry->found ? "" : "not " 1319 ) 1320 ); 1321 1322 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1323 TP_PROTO(struct inode *inode, u32 mask), 1324 TP_ARGS(inode, mask), 1325 TP_STRUCT__entry( 1326 __field(struct inode *, inode) 1327 __field(unsigned int, nlink) 1328 __field(umode_t, mode) 1329 __field(u32, mask) 1330 ), 1331 TP_fast_assign( 1332 __entry->inode = inode; 1333 __entry->nlink = inode->i_nlink; 1334 __entry->mode = inode->i_mode; 1335 __entry->mask = mask; 1336 ), 1337 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1338 __entry->nlink, __entry->mode, __entry->mask) 1339 ); 1340 1341 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1342 TP_PROTO( 1343 const struct nfsd_file *nf 1344 ), 1345 TP_ARGS(nf), 1346 TP_STRUCT__entry( 1347 __field(void *, nf_inode) 1348 __field(void *, nf_file) 1349 __field(int, nf_ref) 1350 __field(unsigned long, nf_flags) 1351 ), 1352 TP_fast_assign( 1353 __entry->nf_inode = nf->nf_inode; 1354 __entry->nf_file = nf->nf_file; 1355 __entry->nf_ref = refcount_read(&nf->nf_ref); 1356 __entry->nf_flags = nf->nf_flags; 1357 ), 1358 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1359 __entry->nf_inode, __entry->nf_ref, 1360 show_nf_flags(__entry->nf_flags), 1361 __entry->nf_file 1362 ) 1363 ); 1364 1365 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1366 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1367 TP_PROTO( \ 1368 const struct nfsd_file *nf \ 1369 ), \ 1370 TP_ARGS(nf)) 1371 1372 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1373 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1374 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1375 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1376 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1377 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_aged); 1378 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1379 1380 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1381 TP_PROTO( 1382 unsigned long removed, 1383 unsigned long remaining 1384 ), 1385 TP_ARGS(removed, remaining), 1386 TP_STRUCT__entry( 1387 __field(unsigned long, removed) 1388 __field(unsigned long, remaining) 1389 ), 1390 TP_fast_assign( 1391 __entry->removed = removed; 1392 __entry->remaining = remaining; 1393 ), 1394 TP_printk("%lu entries removed, %lu remaining", 1395 __entry->removed, __entry->remaining) 1396 ); 1397 1398 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1399 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1400 TP_PROTO( \ 1401 unsigned long removed, \ 1402 unsigned long remaining \ 1403 ), \ 1404 TP_ARGS(removed, remaining)) 1405 1406 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1407 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1408 1409 TRACE_EVENT(nfsd_file_close, 1410 TP_PROTO( 1411 const struct inode *inode 1412 ), 1413 TP_ARGS(inode), 1414 TP_STRUCT__entry( 1415 __field(const void *, inode) 1416 ), 1417 TP_fast_assign( 1418 __entry->inode = inode; 1419 ), 1420 TP_printk("inode=%p", 1421 __entry->inode 1422 ) 1423 ); 1424 1425 #include "cache.h" 1426 1427 TRACE_DEFINE_ENUM(RC_DROPIT); 1428 TRACE_DEFINE_ENUM(RC_REPLY); 1429 TRACE_DEFINE_ENUM(RC_DOIT); 1430 1431 #define show_drc_retval(x) \ 1432 __print_symbolic(x, \ 1433 { RC_DROPIT, "DROPIT" }, \ 1434 { RC_REPLY, "REPLY" }, \ 1435 { RC_DOIT, "DOIT" }) 1436 1437 TRACE_EVENT(nfsd_drc_found, 1438 TP_PROTO( 1439 const struct nfsd_net *nn, 1440 const struct svc_rqst *rqstp, 1441 int result 1442 ), 1443 TP_ARGS(nn, rqstp, result), 1444 TP_STRUCT__entry( 1445 __field(unsigned long long, boot_time) 1446 __field(unsigned long, result) 1447 __field(u32, xid) 1448 ), 1449 TP_fast_assign( 1450 __entry->boot_time = nn->boot_time; 1451 __entry->result = result; 1452 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1453 ), 1454 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1455 __entry->boot_time, __entry->xid, 1456 show_drc_retval(__entry->result)) 1457 1458 ); 1459 1460 TRACE_EVENT(nfsd_drc_mismatch, 1461 TP_PROTO( 1462 const struct nfsd_net *nn, 1463 const struct nfsd_cacherep *key, 1464 const struct nfsd_cacherep *rp 1465 ), 1466 TP_ARGS(nn, key, rp), 1467 TP_STRUCT__entry( 1468 __field(unsigned long long, boot_time) 1469 __field(u32, xid) 1470 __field(u32, cached) 1471 __field(u32, ingress) 1472 ), 1473 TP_fast_assign( 1474 __entry->boot_time = nn->boot_time; 1475 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1476 __entry->cached = (__force u32)key->c_key.k_csum; 1477 __entry->ingress = (__force u32)rp->c_key.k_csum; 1478 ), 1479 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1480 __entry->boot_time, __entry->xid, __entry->cached, 1481 __entry->ingress) 1482 ); 1483 1484 TRACE_EVENT(nfsd_cb_args, 1485 TP_PROTO( 1486 const struct nfs4_client *clp, 1487 const struct nfs4_cb_conn *conn 1488 ), 1489 TP_ARGS(clp, conn), 1490 TP_STRUCT__entry( 1491 __field(u32, cl_boot) 1492 __field(u32, cl_id) 1493 __field(u32, prog) 1494 __field(u32, ident) 1495 __sockaddr(addr, conn->cb_addrlen) 1496 ), 1497 TP_fast_assign( 1498 __entry->cl_boot = clp->cl_clientid.cl_boot; 1499 __entry->cl_id = clp->cl_clientid.cl_id; 1500 __entry->prog = conn->cb_prog; 1501 __entry->ident = conn->cb_ident; 1502 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1503 ), 1504 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1505 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1506 __entry->prog, __entry->ident) 1507 ); 1508 1509 TRACE_EVENT(nfsd_cb_nodelegs, 1510 TP_PROTO(const struct nfs4_client *clp), 1511 TP_ARGS(clp), 1512 TP_STRUCT__entry( 1513 __field(u32, cl_boot) 1514 __field(u32, cl_id) 1515 ), 1516 TP_fast_assign( 1517 __entry->cl_boot = clp->cl_clientid.cl_boot; 1518 __entry->cl_id = clp->cl_clientid.cl_id; 1519 ), 1520 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1521 ) 1522 1523 #define show_cb_state(val) \ 1524 __print_symbolic(val, \ 1525 { NFSD4_CB_UP, "UP" }, \ 1526 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1527 { NFSD4_CB_DOWN, "DOWN" }, \ 1528 { NFSD4_CB_FAULT, "FAULT"}) 1529 1530 DECLARE_EVENT_CLASS(nfsd_cb_class, 1531 TP_PROTO(const struct nfs4_client *clp), 1532 TP_ARGS(clp), 1533 TP_STRUCT__entry( 1534 __field(unsigned long, state) 1535 __field(u32, cl_boot) 1536 __field(u32, cl_id) 1537 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1538 ), 1539 TP_fast_assign( 1540 __entry->state = clp->cl_cb_state; 1541 __entry->cl_boot = clp->cl_clientid.cl_boot; 1542 __entry->cl_id = clp->cl_clientid.cl_id; 1543 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1544 clp->cl_cb_conn.cb_addrlen) 1545 ), 1546 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1547 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1548 show_cb_state(__entry->state)) 1549 ); 1550 1551 #define DEFINE_NFSD_CB_EVENT(name) \ 1552 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1553 TP_PROTO(const struct nfs4_client *clp), \ 1554 TP_ARGS(clp)) 1555 1556 DEFINE_NFSD_CB_EVENT(start); 1557 DEFINE_NFSD_CB_EVENT(new_state); 1558 DEFINE_NFSD_CB_EVENT(probe); 1559 DEFINE_NFSD_CB_EVENT(lost); 1560 DEFINE_NFSD_CB_EVENT(shutdown); 1561 DEFINE_NFSD_CB_EVENT(rpc_prepare); 1562 DEFINE_NFSD_CB_EVENT(rpc_done); 1563 DEFINE_NFSD_CB_EVENT(rpc_release); 1564 1565 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1566 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1567 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1568 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1569 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1570 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1571 1572 #define show_nfsd_authflavor(val) \ 1573 __print_symbolic(val, \ 1574 { RPC_AUTH_NULL, "none" }, \ 1575 { RPC_AUTH_UNIX, "sys" }, \ 1576 { RPC_AUTH_GSS, "gss" }, \ 1577 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1578 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1579 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1580 1581 TRACE_EVENT(nfsd_cb_setup, 1582 TP_PROTO(const struct nfs4_client *clp, 1583 const char *netid, 1584 rpc_authflavor_t authflavor 1585 ), 1586 TP_ARGS(clp, netid, authflavor), 1587 TP_STRUCT__entry( 1588 __field(u32, cl_boot) 1589 __field(u32, cl_id) 1590 __field(unsigned long, authflavor) 1591 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1592 __string(netid, netid) 1593 ), 1594 TP_fast_assign( 1595 __entry->cl_boot = clp->cl_clientid.cl_boot; 1596 __entry->cl_id = clp->cl_clientid.cl_id; 1597 __assign_str(netid); 1598 __entry->authflavor = authflavor; 1599 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1600 clp->cl_cb_conn.cb_addrlen) 1601 ), 1602 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1603 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1604 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1605 ); 1606 1607 TRACE_EVENT(nfsd_cb_setup_err, 1608 TP_PROTO( 1609 const struct nfs4_client *clp, 1610 long error 1611 ), 1612 TP_ARGS(clp, error), 1613 TP_STRUCT__entry( 1614 __field(long, error) 1615 __field(u32, cl_boot) 1616 __field(u32, cl_id) 1617 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1618 ), 1619 TP_fast_assign( 1620 __entry->error = error; 1621 __entry->cl_boot = clp->cl_clientid.cl_boot; 1622 __entry->cl_id = clp->cl_clientid.cl_id; 1623 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1624 clp->cl_cb_conn.cb_addrlen) 1625 ), 1626 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1627 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1628 __entry->error) 1629 ); 1630 1631 /* Not a real opcode, but there is no 0 operation. */ 1632 #define _CB_NULL 0 1633 1634 #define show_nfsd_cb_opcode(val) \ 1635 __print_symbolic(val, \ 1636 { _CB_NULL, "CB_NULL" }, \ 1637 { OP_CB_GETATTR, "CB_GETATTR" }, \ 1638 { OP_CB_RECALL, "CB_RECALL" }, \ 1639 { OP_CB_LAYOUTRECALL, "CB_LAYOUTRECALL" }, \ 1640 { OP_CB_RECALL_ANY, "CB_RECALL_ANY" }, \ 1641 { OP_CB_NOTIFY_LOCK, "CB_NOTIFY_LOCK" }, \ 1642 { OP_CB_OFFLOAD, "CB_OFFLOAD" }) 1643 1644 DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class, 1645 TP_PROTO( 1646 const struct nfs4_client *clp, 1647 const struct nfsd4_callback *cb 1648 ), 1649 TP_ARGS(clp, cb), 1650 TP_STRUCT__entry( 1651 __field(u32, cl_boot) 1652 __field(u32, cl_id) 1653 __field(const void *, cb) 1654 __field(unsigned long, opcode) 1655 __field(bool, need_restart) 1656 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1657 ), 1658 TP_fast_assign( 1659 __entry->cl_boot = clp->cl_clientid.cl_boot; 1660 __entry->cl_id = clp->cl_clientid.cl_id; 1661 __entry->cb = cb; 1662 __entry->opcode = cb->cb_ops ? cb->cb_ops->opcode : _CB_NULL; 1663 __entry->need_restart = test_bit(NFSD4_CALLBACK_REQUEUE, &cb->cb_flags); 1664 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1665 clp->cl_cb_conn.cb_addrlen) 1666 ), 1667 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s opcode=%s", 1668 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, __entry->cb, 1669 __entry->need_restart ? " (need restart)" : " (first try)", 1670 show_nfsd_cb_opcode(__entry->opcode) 1671 ) 1672 ); 1673 1674 #define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \ 1675 DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \ 1676 TP_PROTO( \ 1677 const struct nfs4_client *clp, \ 1678 const struct nfsd4_callback *cb \ 1679 ), \ 1680 TP_ARGS(clp, cb)) 1681 1682 DEFINE_NFSD_CB_LIFETIME_EVENT(queue); 1683 DEFINE_NFSD_CB_LIFETIME_EVENT(destroy); 1684 DEFINE_NFSD_CB_LIFETIME_EVENT(restart); 1685 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update); 1686 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown); 1687 1688 TRACE_EVENT(nfsd_cb_seq_status, 1689 TP_PROTO( 1690 const struct rpc_task *task, 1691 const struct nfsd4_callback *cb 1692 ), 1693 TP_ARGS(task, cb), 1694 TP_STRUCT__entry( 1695 __field(unsigned int, task_id) 1696 __field(unsigned int, client_id) 1697 __field(u32, cl_boot) 1698 __field(u32, cl_id) 1699 __field(u32, seqno) 1700 __field(u32, reserved) 1701 __field(int, tk_status) 1702 __field(int, seq_status) 1703 ), 1704 TP_fast_assign( 1705 const struct nfs4_client *clp = cb->cb_clp; 1706 const struct nfsd4_session *session = clp->cl_cb_session; 1707 const struct nfsd4_sessionid *sid = 1708 (struct nfsd4_sessionid *)&session->se_sessionid; 1709 1710 __entry->task_id = task->tk_pid; 1711 __entry->client_id = task->tk_client ? 1712 task->tk_client->cl_clid : -1; 1713 __entry->cl_boot = sid->clientid.cl_boot; 1714 __entry->cl_id = sid->clientid.cl_id; 1715 __entry->seqno = sid->sequence; 1716 __entry->reserved = sid->reserved; 1717 __entry->tk_status = task->tk_status; 1718 __entry->seq_status = cb->cb_seq_status; 1719 ), 1720 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1721 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d", 1722 __entry->task_id, __entry->client_id, 1723 __entry->cl_boot, __entry->cl_id, 1724 __entry->seqno, __entry->reserved, 1725 __entry->tk_status, __entry->seq_status 1726 ) 1727 ); 1728 1729 TRACE_EVENT(nfsd_cb_free_slot, 1730 TP_PROTO( 1731 const struct rpc_task *task, 1732 const struct nfsd4_callback *cb 1733 ), 1734 TP_ARGS(task, cb), 1735 TP_STRUCT__entry( 1736 __field(unsigned int, task_id) 1737 __field(unsigned int, client_id) 1738 __field(u32, cl_boot) 1739 __field(u32, cl_id) 1740 __field(u32, seqno) 1741 __field(u32, reserved) 1742 __field(u32, slot_seqno) 1743 ), 1744 TP_fast_assign( 1745 const struct nfs4_client *clp = cb->cb_clp; 1746 const struct nfsd4_session *session = clp->cl_cb_session; 1747 const struct nfsd4_sessionid *sid = 1748 (struct nfsd4_sessionid *)&session->se_sessionid; 1749 1750 __entry->task_id = task->tk_pid; 1751 __entry->client_id = task->tk_client ? 1752 task->tk_client->cl_clid : -1; 1753 __entry->cl_boot = sid->clientid.cl_boot; 1754 __entry->cl_id = sid->clientid.cl_id; 1755 __entry->seqno = sid->sequence; 1756 __entry->reserved = sid->reserved; 1757 __entry->slot_seqno = session->se_cb_seq_nr[cb->cb_held_slot]; 1758 ), 1759 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1760 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u", 1761 __entry->task_id, __entry->client_id, 1762 __entry->cl_boot, __entry->cl_id, 1763 __entry->seqno, __entry->reserved, 1764 __entry->slot_seqno 1765 ) 1766 ); 1767 1768 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1769 TP_PROTO( 1770 const struct nfs4_stid *stid 1771 ), 1772 TP_ARGS(stid), 1773 TP_CONDITION(stid->sc_client), 1774 TP_STRUCT__entry( 1775 __field(u32, cl_boot) 1776 __field(u32, cl_id) 1777 __field(u32, si_id) 1778 __field(u32, si_generation) 1779 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1780 ), 1781 TP_fast_assign( 1782 const stateid_t *stp = &stid->sc_stateid; 1783 const struct nfs4_client *clp = stid->sc_client; 1784 1785 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1786 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1787 __entry->si_id = stp->si_opaque.so_id; 1788 __entry->si_generation = stp->si_generation; 1789 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1790 clp->cl_cb_conn.cb_addrlen) 1791 ), 1792 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1793 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1794 __entry->si_id, __entry->si_generation) 1795 ); 1796 1797 TRACE_EVENT(nfsd_cb_notify_lock, 1798 TP_PROTO( 1799 const struct nfs4_lockowner *lo, 1800 const struct nfsd4_blocked_lock *nbl 1801 ), 1802 TP_ARGS(lo, nbl), 1803 TP_STRUCT__entry( 1804 __field(u32, cl_boot) 1805 __field(u32, cl_id) 1806 __field(u32, fh_hash) 1807 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1808 ), 1809 TP_fast_assign( 1810 const struct nfs4_client *clp = lo->lo_owner.so_client; 1811 1812 __entry->cl_boot = clp->cl_clientid.cl_boot; 1813 __entry->cl_id = clp->cl_clientid.cl_id; 1814 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1815 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1816 clp->cl_cb_conn.cb_addrlen) 1817 ), 1818 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1819 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1820 __entry->fh_hash) 1821 ); 1822 1823 TRACE_EVENT(nfsd_cb_offload, 1824 TP_PROTO( 1825 const struct nfs4_client *clp, 1826 const stateid_t *stp, 1827 const struct knfsd_fh *fh, 1828 u64 count, 1829 __be32 status 1830 ), 1831 TP_ARGS(clp, stp, fh, count, status), 1832 TP_STRUCT__entry( 1833 __field(u32, cl_boot) 1834 __field(u32, cl_id) 1835 __field(u32, si_id) 1836 __field(u32, si_generation) 1837 __field(u32, fh_hash) 1838 __field(int, status) 1839 __field(u64, count) 1840 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1841 ), 1842 TP_fast_assign( 1843 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1844 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1845 __entry->si_id = stp->si_opaque.so_id; 1846 __entry->si_generation = stp->si_generation; 1847 __entry->fh_hash = knfsd_fh_hash(fh); 1848 __entry->status = be32_to_cpu(status); 1849 __entry->count = count; 1850 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1851 clp->cl_cb_conn.cb_addrlen) 1852 ), 1853 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1854 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1855 __entry->si_id, __entry->si_generation, 1856 __entry->fh_hash, __entry->count, __entry->status) 1857 ); 1858 1859 TRACE_EVENT(nfsd_cb_recall_any, 1860 TP_PROTO( 1861 const struct nfsd4_cb_recall_any *ra 1862 ), 1863 TP_ARGS(ra), 1864 TP_STRUCT__entry( 1865 __field(u32, cl_boot) 1866 __field(u32, cl_id) 1867 __field(u32, keep) 1868 __field(unsigned long, bmval0) 1869 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1870 ), 1871 TP_fast_assign( 1872 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1873 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1874 __entry->keep = ra->ra_keep; 1875 __entry->bmval0 = ra->ra_bmval[0]; 1876 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1877 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1878 ), 1879 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1880 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1881 __entry->keep, show_rca_mask(__entry->bmval0) 1882 ) 1883 ); 1884 1885 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1886 TP_PROTO( 1887 const stateid_t *stp, 1888 const struct rpc_task *task 1889 ), 1890 TP_ARGS(stp, task), 1891 TP_STRUCT__entry( 1892 __field(u32, cl_boot) 1893 __field(u32, cl_id) 1894 __field(u32, si_id) 1895 __field(u32, si_generation) 1896 __field(int, status) 1897 ), 1898 TP_fast_assign( 1899 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1900 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1901 __entry->si_id = stp->si_opaque.so_id; 1902 __entry->si_generation = stp->si_generation; 1903 __entry->status = task->tk_status; 1904 ), 1905 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1906 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1907 __entry->si_generation, __entry->status 1908 ) 1909 ); 1910 1911 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1912 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1913 TP_PROTO( \ 1914 const stateid_t *stp, \ 1915 const struct rpc_task *task \ 1916 ), \ 1917 TP_ARGS(stp, task)) 1918 1919 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1920 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1921 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1922 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1923 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_getattr_done); 1924 1925 TRACE_EVENT(nfsd_cb_recall_any_done, 1926 TP_PROTO( 1927 const struct nfsd4_callback *cb, 1928 const struct rpc_task *task 1929 ), 1930 TP_ARGS(cb, task), 1931 TP_STRUCT__entry( 1932 __field(u32, cl_boot) 1933 __field(u32, cl_id) 1934 __field(int, status) 1935 ), 1936 TP_fast_assign( 1937 __entry->status = task->tk_status; 1938 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1939 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1940 ), 1941 TP_printk("client %08x:%08x status=%d", 1942 __entry->cl_boot, __entry->cl_id, __entry->status 1943 ) 1944 ); 1945 1946 TRACE_EVENT(nfsd_ctl_unlock_ip, 1947 TP_PROTO( 1948 const struct net *net, 1949 const char *address 1950 ), 1951 TP_ARGS(net, address), 1952 TP_STRUCT__entry( 1953 __field(unsigned int, netns_ino) 1954 __string(address, address) 1955 ), 1956 TP_fast_assign( 1957 __entry->netns_ino = net->ns.inum; 1958 __assign_str(address); 1959 ), 1960 TP_printk("address=%s", 1961 __get_str(address) 1962 ) 1963 ); 1964 1965 TRACE_EVENT(nfsd_ctl_unlock_fs, 1966 TP_PROTO( 1967 const struct net *net, 1968 const char *path 1969 ), 1970 TP_ARGS(net, path), 1971 TP_STRUCT__entry( 1972 __field(unsigned int, netns_ino) 1973 __string(path, path) 1974 ), 1975 TP_fast_assign( 1976 __entry->netns_ino = net->ns.inum; 1977 __assign_str(path); 1978 ), 1979 TP_printk("path=%s", 1980 __get_str(path) 1981 ) 1982 ); 1983 1984 TRACE_EVENT(nfsd_ctl_filehandle, 1985 TP_PROTO( 1986 const struct net *net, 1987 const char *domain, 1988 const char *path, 1989 int maxsize 1990 ), 1991 TP_ARGS(net, domain, path, maxsize), 1992 TP_STRUCT__entry( 1993 __field(unsigned int, netns_ino) 1994 __field(int, maxsize) 1995 __string(domain, domain) 1996 __string(path, path) 1997 ), 1998 TP_fast_assign( 1999 __entry->netns_ino = net->ns.inum; 2000 __entry->maxsize = maxsize; 2001 __assign_str(domain); 2002 __assign_str(path); 2003 ), 2004 TP_printk("domain=%s path=%s maxsize=%d", 2005 __get_str(domain), __get_str(path), __entry->maxsize 2006 ) 2007 ); 2008 2009 TRACE_EVENT(nfsd_ctl_threads, 2010 TP_PROTO( 2011 const struct net *net, 2012 int newthreads 2013 ), 2014 TP_ARGS(net, newthreads), 2015 TP_STRUCT__entry( 2016 __field(unsigned int, netns_ino) 2017 __field(int, newthreads) 2018 ), 2019 TP_fast_assign( 2020 __entry->netns_ino = net->ns.inum; 2021 __entry->newthreads = newthreads; 2022 ), 2023 TP_printk("newthreads=%d", 2024 __entry->newthreads 2025 ) 2026 ); 2027 2028 TRACE_EVENT(nfsd_ctl_pool_threads, 2029 TP_PROTO( 2030 const struct net *net, 2031 int pool, 2032 int nrthreads 2033 ), 2034 TP_ARGS(net, pool, nrthreads), 2035 TP_STRUCT__entry( 2036 __field(unsigned int, netns_ino) 2037 __field(int, pool) 2038 __field(int, nrthreads) 2039 ), 2040 TP_fast_assign( 2041 __entry->netns_ino = net->ns.inum; 2042 __entry->pool = pool; 2043 __entry->nrthreads = nrthreads; 2044 ), 2045 TP_printk("pool=%d nrthreads=%d", 2046 __entry->pool, __entry->nrthreads 2047 ) 2048 ); 2049 2050 TRACE_EVENT(nfsd_ctl_version, 2051 TP_PROTO( 2052 const struct net *net, 2053 const char *mesg 2054 ), 2055 TP_ARGS(net, mesg), 2056 TP_STRUCT__entry( 2057 __field(unsigned int, netns_ino) 2058 __string(mesg, mesg) 2059 ), 2060 TP_fast_assign( 2061 __entry->netns_ino = net->ns.inum; 2062 __assign_str(mesg); 2063 ), 2064 TP_printk("%s", 2065 __get_str(mesg) 2066 ) 2067 ); 2068 2069 TRACE_EVENT(nfsd_ctl_ports_addfd, 2070 TP_PROTO( 2071 const struct net *net, 2072 int fd 2073 ), 2074 TP_ARGS(net, fd), 2075 TP_STRUCT__entry( 2076 __field(unsigned int, netns_ino) 2077 __field(int, fd) 2078 ), 2079 TP_fast_assign( 2080 __entry->netns_ino = net->ns.inum; 2081 __entry->fd = fd; 2082 ), 2083 TP_printk("fd=%d", 2084 __entry->fd 2085 ) 2086 ); 2087 2088 TRACE_EVENT(nfsd_ctl_ports_addxprt, 2089 TP_PROTO( 2090 const struct net *net, 2091 const char *transport, 2092 int port 2093 ), 2094 TP_ARGS(net, transport, port), 2095 TP_STRUCT__entry( 2096 __field(unsigned int, netns_ino) 2097 __field(int, port) 2098 __string(transport, transport) 2099 ), 2100 TP_fast_assign( 2101 __entry->netns_ino = net->ns.inum; 2102 __entry->port = port; 2103 __assign_str(transport); 2104 ), 2105 TP_printk("transport=%s port=%d", 2106 __get_str(transport), __entry->port 2107 ) 2108 ); 2109 2110 TRACE_EVENT(nfsd_ctl_maxblksize, 2111 TP_PROTO( 2112 const struct net *net, 2113 int bsize 2114 ), 2115 TP_ARGS(net, bsize), 2116 TP_STRUCT__entry( 2117 __field(unsigned int, netns_ino) 2118 __field(int, bsize) 2119 ), 2120 TP_fast_assign( 2121 __entry->netns_ino = net->ns.inum; 2122 __entry->bsize = bsize; 2123 ), 2124 TP_printk("bsize=%d", 2125 __entry->bsize 2126 ) 2127 ); 2128 2129 TRACE_EVENT(nfsd_ctl_time, 2130 TP_PROTO( 2131 const struct net *net, 2132 const char *name, 2133 size_t namelen, 2134 int time 2135 ), 2136 TP_ARGS(net, name, namelen, time), 2137 TP_STRUCT__entry( 2138 __field(unsigned int, netns_ino) 2139 __field(int, time) 2140 __string_len(name, name, namelen) 2141 ), 2142 TP_fast_assign( 2143 __entry->netns_ino = net->ns.inum; 2144 __entry->time = time; 2145 __assign_str(name); 2146 ), 2147 TP_printk("file=%s time=%d", 2148 __get_str(name), __entry->time 2149 ) 2150 ); 2151 2152 TRACE_EVENT(nfsd_ctl_recoverydir, 2153 TP_PROTO( 2154 const struct net *net, 2155 const char *recdir 2156 ), 2157 TP_ARGS(net, recdir), 2158 TP_STRUCT__entry( 2159 __field(unsigned int, netns_ino) 2160 __string(recdir, recdir) 2161 ), 2162 TP_fast_assign( 2163 __entry->netns_ino = net->ns.inum; 2164 __assign_str(recdir); 2165 ), 2166 TP_printk("recdir=%s", 2167 __get_str(recdir) 2168 ) 2169 ); 2170 2171 TRACE_EVENT(nfsd_end_grace, 2172 TP_PROTO( 2173 const struct net *net 2174 ), 2175 TP_ARGS(net), 2176 TP_STRUCT__entry( 2177 __field(unsigned int, netns_ino) 2178 ), 2179 TP_fast_assign( 2180 __entry->netns_ino = net->ns.inum; 2181 ), 2182 TP_printk("nn=%d", __entry->netns_ino 2183 ) 2184 ); 2185 2186 DECLARE_EVENT_CLASS(nfsd_copy_class, 2187 TP_PROTO( 2188 const struct nfsd4_copy *copy 2189 ), 2190 TP_ARGS(copy), 2191 TP_STRUCT__entry( 2192 __field(bool, intra) 2193 __field(bool, async) 2194 __field(u32, src_cl_boot) 2195 __field(u32, src_cl_id) 2196 __field(u32, src_so_id) 2197 __field(u32, src_si_generation) 2198 __field(u32, dst_cl_boot) 2199 __field(u32, dst_cl_id) 2200 __field(u32, dst_so_id) 2201 __field(u32, dst_si_generation) 2202 __field(u32, cb_cl_boot) 2203 __field(u32, cb_cl_id) 2204 __field(u32, cb_so_id) 2205 __field(u32, cb_si_generation) 2206 __field(u64, src_cp_pos) 2207 __field(u64, dst_cp_pos) 2208 __field(u64, cp_count) 2209 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2210 ), 2211 TP_fast_assign( 2212 const stateid_t *src_stp = ©->cp_src_stateid; 2213 const stateid_t *dst_stp = ©->cp_dst_stateid; 2214 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2215 2216 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2217 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2218 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2219 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2220 __entry->src_so_id = src_stp->si_opaque.so_id; 2221 __entry->src_si_generation = src_stp->si_generation; 2222 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2223 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2224 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2225 __entry->dst_si_generation = dst_stp->si_generation; 2226 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2227 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2228 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2229 __entry->cb_si_generation = cb_stp->si_generation; 2230 __entry->src_cp_pos = copy->cp_src_pos; 2231 __entry->dst_cp_pos = copy->cp_dst_pos; 2232 __entry->cp_count = copy->cp_count; 2233 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2234 sizeof(struct sockaddr_in6)); 2235 ), 2236 TP_printk("client=%pISpc intra=%d async=%d " 2237 "src_client %08x:%08x src_stateid %08x:%08x " 2238 "dst_client %08x:%08x dst_stateid %08x:%08x " 2239 "cb_client %08x:%08x cb_stateid %08x:%08x " 2240 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2241 __get_sockaddr(addr), __entry->intra, __entry->async, 2242 __entry->src_cl_boot, __entry->src_cl_id, 2243 __entry->src_so_id, __entry->src_si_generation, 2244 __entry->dst_cl_boot, __entry->dst_cl_id, 2245 __entry->dst_so_id, __entry->dst_si_generation, 2246 __entry->cb_cl_boot, __entry->cb_cl_id, 2247 __entry->cb_so_id, __entry->cb_si_generation, 2248 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2249 ) 2250 ); 2251 2252 #define DEFINE_COPY_EVENT(name) \ 2253 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \ 2254 TP_PROTO(const struct nfsd4_copy *copy), \ 2255 TP_ARGS(copy)) 2256 2257 DEFINE_COPY_EVENT(inter); 2258 DEFINE_COPY_EVENT(intra); 2259 DEFINE_COPY_EVENT(async); 2260 2261 TRACE_EVENT(nfsd_copy_done, 2262 TP_PROTO( 2263 const struct nfsd4_copy *copy, 2264 __be32 status 2265 ), 2266 TP_ARGS(copy, status), 2267 TP_STRUCT__entry( 2268 __field(int, status) 2269 __field(bool, intra) 2270 __field(bool, async) 2271 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2272 ), 2273 TP_fast_assign( 2274 __entry->status = be32_to_cpu(status); 2275 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2276 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2277 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2278 sizeof(struct sockaddr_in6)); 2279 ), 2280 TP_printk("addr=%pISpc status=%d intra=%d async=%d", 2281 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async 2282 ) 2283 ); 2284 2285 DECLARE_EVENT_CLASS(nfsd_copy_async_done_class, 2286 TP_PROTO( 2287 const struct nfsd4_copy *copy 2288 ), 2289 TP_ARGS(copy), 2290 TP_STRUCT__entry( 2291 __field(int, status) 2292 __field(bool, intra) 2293 __field(bool, async) 2294 __field(u32, src_cl_boot) 2295 __field(u32, src_cl_id) 2296 __field(u32, src_so_id) 2297 __field(u32, src_si_generation) 2298 __field(u32, dst_cl_boot) 2299 __field(u32, dst_cl_id) 2300 __field(u32, dst_so_id) 2301 __field(u32, dst_si_generation) 2302 __field(u32, cb_cl_boot) 2303 __field(u32, cb_cl_id) 2304 __field(u32, cb_so_id) 2305 __field(u32, cb_si_generation) 2306 __field(u64, src_cp_pos) 2307 __field(u64, dst_cp_pos) 2308 __field(u64, cp_count) 2309 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2310 ), 2311 TP_fast_assign( 2312 const stateid_t *src_stp = ©->cp_src_stateid; 2313 const stateid_t *dst_stp = ©->cp_dst_stateid; 2314 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2315 2316 __entry->status = be32_to_cpu(copy->nfserr); 2317 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2318 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2319 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2320 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2321 __entry->src_so_id = src_stp->si_opaque.so_id; 2322 __entry->src_si_generation = src_stp->si_generation; 2323 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2324 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2325 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2326 __entry->dst_si_generation = dst_stp->si_generation; 2327 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2328 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2329 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2330 __entry->cb_si_generation = cb_stp->si_generation; 2331 __entry->src_cp_pos = copy->cp_src_pos; 2332 __entry->dst_cp_pos = copy->cp_dst_pos; 2333 __entry->cp_count = copy->cp_count; 2334 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2335 sizeof(struct sockaddr_in6)); 2336 ), 2337 TP_printk("client=%pISpc status=%d intra=%d async=%d " 2338 "src_client %08x:%08x src_stateid %08x:%08x " 2339 "dst_client %08x:%08x dst_stateid %08x:%08x " 2340 "cb_client %08x:%08x cb_stateid %08x:%08x " 2341 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2342 __get_sockaddr(addr), 2343 __entry->status, __entry->intra, __entry->async, 2344 __entry->src_cl_boot, __entry->src_cl_id, 2345 __entry->src_so_id, __entry->src_si_generation, 2346 __entry->dst_cl_boot, __entry->dst_cl_id, 2347 __entry->dst_so_id, __entry->dst_si_generation, 2348 __entry->cb_cl_boot, __entry->cb_cl_id, 2349 __entry->cb_so_id, __entry->cb_si_generation, 2350 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2351 ) 2352 ); 2353 2354 #define DEFINE_COPY_ASYNC_DONE_EVENT(name) \ 2355 DEFINE_EVENT(nfsd_copy_async_done_class, \ 2356 nfsd_copy_async_##name, \ 2357 TP_PROTO(const struct nfsd4_copy *copy), \ 2358 TP_ARGS(copy)) 2359 2360 DEFINE_COPY_ASYNC_DONE_EVENT(done); 2361 DEFINE_COPY_ASYNC_DONE_EVENT(cancel); 2362 2363 TRACE_EVENT(nfsd_vfs_setattr, 2364 TP_PROTO( 2365 const struct svc_rqst *rqstp, 2366 const struct svc_fh *fhp, 2367 const struct iattr *iap, 2368 const struct timespec64 *guardtime 2369 ), 2370 TP_ARGS(rqstp, fhp, iap, guardtime), 2371 TP_STRUCT__entry( 2372 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2373 __field(u32, fh_hash) 2374 __field(s64, gtime_tv_sec) 2375 __field(u32, gtime_tv_nsec) 2376 __field(unsigned int, ia_valid) 2377 __field(loff_t, ia_size) 2378 __field(uid_t, ia_uid) 2379 __field(gid_t, ia_gid) 2380 __field(umode_t, ia_mode) 2381 ), 2382 TP_fast_assign( 2383 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2384 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2385 __entry->gtime_tv_sec = guardtime ? guardtime->tv_sec : 0; 2386 __entry->gtime_tv_nsec = guardtime ? guardtime->tv_nsec : 0; 2387 __entry->ia_valid = iap->ia_valid; 2388 __entry->ia_size = iap->ia_size; 2389 __entry->ia_uid = __kuid_val(iap->ia_uid); 2390 __entry->ia_gid = __kgid_val(iap->ia_gid); 2391 __entry->ia_mode = iap->ia_mode; 2392 ), 2393 TP_printk( 2394 "xid=0x%08x fh_hash=0x%08x ia_valid=%s ia_size=%llu ia_mode=0%o ia_uid=%u ia_gid=%u guard_time=%lld.%u", 2395 __entry->xid, __entry->fh_hash, show_ia_valid_flags(__entry->ia_valid), 2396 __entry->ia_size, __entry->ia_mode, __entry->ia_uid, __entry->ia_gid, 2397 __entry->gtime_tv_sec, __entry->gtime_tv_nsec 2398 ) 2399 ) 2400 2401 TRACE_EVENT(nfsd_vfs_lookup, 2402 TP_PROTO( 2403 const struct svc_rqst *rqstp, 2404 const struct svc_fh *fhp, 2405 const char *name, 2406 unsigned int len 2407 ), 2408 TP_ARGS(rqstp, fhp, name, len), 2409 TP_STRUCT__entry( 2410 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2411 __field(u32, fh_hash) 2412 __string_len(name, name, len) 2413 ), 2414 TP_fast_assign( 2415 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2416 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2417 __assign_str(name); 2418 ), 2419 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s", 2420 __entry->xid, __entry->fh_hash, __get_str(name) 2421 ) 2422 ); 2423 2424 TRACE_EVENT(nfsd_vfs_create, 2425 TP_PROTO( 2426 const struct svc_rqst *rqstp, 2427 const struct svc_fh *fhp, 2428 umode_t type, 2429 const char *name, 2430 unsigned int len 2431 ), 2432 TP_ARGS(rqstp, fhp, type, name, len), 2433 TP_STRUCT__entry( 2434 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2435 __field(u32, fh_hash) 2436 __field(umode_t, type) 2437 __string_len(name, name, len) 2438 ), 2439 TP_fast_assign( 2440 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2441 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2442 __entry->type = type; 2443 __assign_str(name); 2444 ), 2445 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s name=%s", 2446 __entry->xid, __entry->fh_hash, 2447 show_fs_file_type(__entry->type), __get_str(name) 2448 ) 2449 ); 2450 2451 TRACE_EVENT(nfsd_vfs_symlink, 2452 TP_PROTO( 2453 const struct svc_rqst *rqstp, 2454 const struct svc_fh *fhp, 2455 const char *name, 2456 unsigned int namelen, 2457 const char *target 2458 ), 2459 TP_ARGS(rqstp, fhp, name, namelen, target), 2460 TP_STRUCT__entry( 2461 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2462 __field(u32, fh_hash) 2463 __string_len(name, name, namelen) 2464 __string(target, target) 2465 ), 2466 TP_fast_assign( 2467 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2468 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2469 __assign_str(name); 2470 __assign_str(target); 2471 ), 2472 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s target=%s", 2473 __entry->xid, __entry->fh_hash, 2474 __get_str(name), __get_str(target) 2475 ) 2476 ); 2477 2478 TRACE_EVENT(nfsd_vfs_link, 2479 TP_PROTO( 2480 const struct svc_rqst *rqstp, 2481 const struct svc_fh *sfhp, 2482 const struct svc_fh *tfhp, 2483 const char *name, 2484 unsigned int namelen 2485 ), 2486 TP_ARGS(rqstp, sfhp, tfhp, name, namelen), 2487 TP_STRUCT__entry( 2488 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2489 __field(u32, sfh_hash) 2490 __field(u32, tfh_hash) 2491 __string_len(name, name, namelen) 2492 ), 2493 TP_fast_assign( 2494 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2495 __entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle); 2496 __entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle); 2497 __assign_str(name); 2498 ), 2499 TP_printk("xid=0x%08x src_fh=0x%08x tgt_fh=0x%08x name=%s", 2500 __entry->xid, __entry->sfh_hash, __entry->tfh_hash, 2501 __get_str(name) 2502 ) 2503 ); 2504 2505 TRACE_EVENT(nfsd_vfs_unlink, 2506 TP_PROTO( 2507 const struct svc_rqst *rqstp, 2508 const struct svc_fh *fhp, 2509 const char *name, 2510 unsigned int len 2511 ), 2512 TP_ARGS(rqstp, fhp, name, len), 2513 TP_STRUCT__entry( 2514 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2515 __field(u32, fh_hash) 2516 __string_len(name, name, len) 2517 ), 2518 TP_fast_assign( 2519 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2520 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2521 __assign_str(name); 2522 ), 2523 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s", 2524 __entry->xid, __entry->fh_hash, 2525 __get_str(name) 2526 ) 2527 ); 2528 2529 TRACE_EVENT(nfsd_vfs_rename, 2530 TP_PROTO( 2531 const struct svc_rqst *rqstp, 2532 const struct svc_fh *sfhp, 2533 const struct svc_fh *tfhp, 2534 const char *source, 2535 unsigned int sourcelen, 2536 const char *target, 2537 unsigned int targetlen 2538 ), 2539 TP_ARGS(rqstp, sfhp, tfhp, source, sourcelen, target, targetlen), 2540 TP_STRUCT__entry( 2541 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2542 __field(u32, sfh_hash) 2543 __field(u32, tfh_hash) 2544 __string_len(source, source, sourcelen) 2545 __string_len(target, target, targetlen) 2546 ), 2547 TP_fast_assign( 2548 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2549 __entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle); 2550 __entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle); 2551 __assign_str(source); 2552 __assign_str(target); 2553 ), 2554 TP_printk("xid=0x%08x sfh_hash=0x%08x tfh_hash=0x%08x source=%s target=%s", 2555 __entry->xid, __entry->sfh_hash, __entry->tfh_hash, 2556 __get_str(source), __get_str(target) 2557 ) 2558 ); 2559 2560 TRACE_EVENT(nfsd_vfs_readdir, 2561 TP_PROTO( 2562 const struct svc_rqst *rqstp, 2563 const struct svc_fh *fhp, 2564 u32 count, 2565 u64 offset 2566 ), 2567 TP_ARGS(rqstp, fhp, count, offset), 2568 TP_STRUCT__entry( 2569 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2570 __field(u32, fh_hash) 2571 __field(u32, count) 2572 __field(u64, offset) 2573 ), 2574 TP_fast_assign( 2575 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2576 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2577 __entry->count = count; 2578 __entry->offset = offset; 2579 ), 2580 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu count=%u", 2581 __entry->xid, __entry->fh_hash, 2582 __entry->offset, __entry->count 2583 ) 2584 ); 2585 2586 DECLARE_EVENT_CLASS(nfsd_vfs_getattr_class, 2587 TP_PROTO( 2588 const struct svc_rqst *rqstp, 2589 const struct svc_fh *fhp 2590 ), 2591 TP_ARGS(rqstp, fhp), 2592 TP_STRUCT__entry( 2593 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2594 __field(u32, fh_hash) 2595 ), 2596 TP_fast_assign( 2597 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2598 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2599 ), 2600 TP_printk("xid=0x%08x fh_hash=0x%08x", 2601 __entry->xid, __entry->fh_hash 2602 ) 2603 ); 2604 2605 #define DEFINE_NFSD_VFS_GETATTR_EVENT(__name) \ 2606 DEFINE_EVENT(nfsd_vfs_getattr_class, __name, \ 2607 TP_PROTO( \ 2608 const struct svc_rqst *rqstp, \ 2609 const struct svc_fh *fhp \ 2610 ), \ 2611 TP_ARGS(rqstp, fhp)) 2612 2613 DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_getattr); 2614 DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_statfs); 2615 2616 #endif /* _NFSD_TRACE_H */ 2617 2618 #undef TRACE_INCLUDE_PATH 2619 #define TRACE_INCLUDE_PATH . 2620 #define TRACE_INCLUDE_FILE trace 2621 #include <trace/define_trace.h> 2622