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(int, 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(int, 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 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 1112 1113 TRACE_EVENT(nfsd_file_alloc, 1114 TP_PROTO( 1115 const struct nfsd_file *nf 1116 ), 1117 TP_ARGS(nf), 1118 TP_STRUCT__entry( 1119 __field(const void *, nf_inode) 1120 __field(unsigned long, nf_flags) 1121 __field(unsigned long, nf_may) 1122 __field(unsigned int, nf_ref) 1123 ), 1124 TP_fast_assign( 1125 __entry->nf_inode = nf->nf_inode; 1126 __entry->nf_flags = nf->nf_flags; 1127 __entry->nf_ref = refcount_read(&nf->nf_ref); 1128 __entry->nf_may = nf->nf_may; 1129 ), 1130 TP_printk("inode=%p ref=%u flags=%s may=%s", 1131 __entry->nf_inode, __entry->nf_ref, 1132 show_nf_flags(__entry->nf_flags), 1133 show_nfsd_may_flags(__entry->nf_may) 1134 ) 1135 ); 1136 1137 TRACE_EVENT(nfsd_file_acquire, 1138 TP_PROTO( 1139 const struct svc_rqst *rqstp, 1140 const struct inode *inode, 1141 unsigned int may_flags, 1142 const struct nfsd_file *nf, 1143 __be32 status 1144 ), 1145 1146 TP_ARGS(rqstp, inode, may_flags, nf, status), 1147 1148 TP_STRUCT__entry( 1149 __field(u32, xid) 1150 __field(const void *, inode) 1151 __field(unsigned long, may_flags) 1152 __field(unsigned int, nf_ref) 1153 __field(unsigned long, nf_flags) 1154 __field(unsigned long, nf_may) 1155 __field(const void *, nf_file) 1156 __field(u32, status) 1157 ), 1158 1159 TP_fast_assign( 1160 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1161 __entry->inode = inode; 1162 __entry->may_flags = may_flags; 1163 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 1164 __entry->nf_flags = nf ? nf->nf_flags : 0; 1165 __entry->nf_may = nf ? nf->nf_may : 0; 1166 __entry->nf_file = nf ? nf->nf_file : NULL; 1167 __entry->status = be32_to_cpu(status); 1168 ), 1169 1170 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 1171 __entry->xid, __entry->inode, 1172 show_nfsd_may_flags(__entry->may_flags), 1173 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1174 show_nfsd_may_flags(__entry->nf_may), 1175 __entry->nf_file, __entry->status 1176 ) 1177 ); 1178 1179 TRACE_EVENT(nfsd_file_insert_err, 1180 TP_PROTO( 1181 const struct svc_rqst *rqstp, 1182 const struct inode *inode, 1183 unsigned int may_flags, 1184 long error 1185 ), 1186 TP_ARGS(rqstp, inode, may_flags, error), 1187 TP_STRUCT__entry( 1188 __field(u32, xid) 1189 __field(const void *, inode) 1190 __field(unsigned long, may_flags) 1191 __field(long, error) 1192 ), 1193 TP_fast_assign( 1194 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1195 __entry->inode = inode; 1196 __entry->may_flags = may_flags; 1197 __entry->error = error; 1198 ), 1199 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1200 __entry->xid, __entry->inode, 1201 show_nfsd_may_flags(__entry->may_flags), 1202 __entry->error 1203 ) 1204 ); 1205 1206 TRACE_EVENT(nfsd_file_cons_err, 1207 TP_PROTO( 1208 const struct svc_rqst *rqstp, 1209 const struct inode *inode, 1210 unsigned int may_flags, 1211 const struct nfsd_file *nf 1212 ), 1213 TP_ARGS(rqstp, inode, may_flags, nf), 1214 TP_STRUCT__entry( 1215 __field(u32, xid) 1216 __field(const void *, inode) 1217 __field(unsigned long, may_flags) 1218 __field(unsigned int, nf_ref) 1219 __field(unsigned long, nf_flags) 1220 __field(unsigned long, nf_may) 1221 __field(const void *, nf_file) 1222 ), 1223 TP_fast_assign( 1224 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1225 __entry->inode = inode; 1226 __entry->may_flags = may_flags; 1227 __entry->nf_ref = refcount_read(&nf->nf_ref); 1228 __entry->nf_flags = nf->nf_flags; 1229 __entry->nf_may = nf->nf_may; 1230 __entry->nf_file = nf->nf_file; 1231 ), 1232 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1233 __entry->xid, __entry->inode, 1234 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1235 show_nf_flags(__entry->nf_flags), 1236 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1237 ) 1238 ); 1239 1240 DECLARE_EVENT_CLASS(nfsd_file_open_class, 1241 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1242 TP_ARGS(nf, status), 1243 TP_STRUCT__entry( 1244 __field(void *, nf_inode) /* cannot be dereferenced */ 1245 __field(int, nf_ref) 1246 __field(unsigned long, nf_flags) 1247 __field(unsigned long, nf_may) 1248 __field(void *, nf_file) /* cannot be dereferenced */ 1249 ), 1250 TP_fast_assign( 1251 __entry->nf_inode = nf->nf_inode; 1252 __entry->nf_ref = refcount_read(&nf->nf_ref); 1253 __entry->nf_flags = nf->nf_flags; 1254 __entry->nf_may = nf->nf_may; 1255 __entry->nf_file = nf->nf_file; 1256 ), 1257 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1258 __entry->nf_inode, 1259 __entry->nf_ref, 1260 show_nf_flags(__entry->nf_flags), 1261 show_nfsd_may_flags(__entry->nf_may), 1262 __entry->nf_file) 1263 ) 1264 1265 #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1266 DEFINE_EVENT(nfsd_file_open_class, name, \ 1267 TP_PROTO( \ 1268 const struct nfsd_file *nf, \ 1269 __be32 status \ 1270 ), \ 1271 TP_ARGS(nf, status)) 1272 1273 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1274 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1275 1276 TRACE_EVENT(nfsd_file_is_cached, 1277 TP_PROTO( 1278 const struct inode *inode, 1279 int found 1280 ), 1281 TP_ARGS(inode, found), 1282 TP_STRUCT__entry( 1283 __field(const struct inode *, inode) 1284 __field(int, found) 1285 ), 1286 TP_fast_assign( 1287 __entry->inode = inode; 1288 __entry->found = found; 1289 ), 1290 TP_printk("inode=%p is %scached", 1291 __entry->inode, 1292 __entry->found ? "" : "not " 1293 ) 1294 ); 1295 1296 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1297 TP_PROTO(struct inode *inode, u32 mask), 1298 TP_ARGS(inode, mask), 1299 TP_STRUCT__entry( 1300 __field(struct inode *, inode) 1301 __field(unsigned int, nlink) 1302 __field(umode_t, mode) 1303 __field(u32, mask) 1304 ), 1305 TP_fast_assign( 1306 __entry->inode = inode; 1307 __entry->nlink = inode->i_nlink; 1308 __entry->mode = inode->i_mode; 1309 __entry->mask = mask; 1310 ), 1311 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1312 __entry->nlink, __entry->mode, __entry->mask) 1313 ); 1314 1315 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1316 TP_PROTO( 1317 const struct nfsd_file *nf 1318 ), 1319 TP_ARGS(nf), 1320 TP_STRUCT__entry( 1321 __field(void *, nf_inode) 1322 __field(void *, nf_file) 1323 __field(int, nf_ref) 1324 __field(unsigned long, nf_flags) 1325 ), 1326 TP_fast_assign( 1327 __entry->nf_inode = nf->nf_inode; 1328 __entry->nf_file = nf->nf_file; 1329 __entry->nf_ref = refcount_read(&nf->nf_ref); 1330 __entry->nf_flags = nf->nf_flags; 1331 ), 1332 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1333 __entry->nf_inode, __entry->nf_ref, 1334 show_nf_flags(__entry->nf_flags), 1335 __entry->nf_file 1336 ) 1337 ); 1338 1339 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1340 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1341 TP_PROTO( \ 1342 const struct nfsd_file *nf \ 1343 ), \ 1344 TP_ARGS(nf)) 1345 1346 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1347 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1348 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1349 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1350 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1351 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1352 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1353 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_aged); 1354 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1355 1356 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1357 TP_PROTO( 1358 unsigned long removed, 1359 unsigned long remaining 1360 ), 1361 TP_ARGS(removed, remaining), 1362 TP_STRUCT__entry( 1363 __field(unsigned long, removed) 1364 __field(unsigned long, remaining) 1365 ), 1366 TP_fast_assign( 1367 __entry->removed = removed; 1368 __entry->remaining = remaining; 1369 ), 1370 TP_printk("%lu entries removed, %lu remaining", 1371 __entry->removed, __entry->remaining) 1372 ); 1373 1374 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1375 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1376 TP_PROTO( \ 1377 unsigned long removed, \ 1378 unsigned long remaining \ 1379 ), \ 1380 TP_ARGS(removed, remaining)) 1381 1382 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1383 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_recent); 1384 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1385 1386 TRACE_EVENT(nfsd_file_close, 1387 TP_PROTO( 1388 const struct inode *inode 1389 ), 1390 TP_ARGS(inode), 1391 TP_STRUCT__entry( 1392 __field(const void *, inode) 1393 ), 1394 TP_fast_assign( 1395 __entry->inode = inode; 1396 ), 1397 TP_printk("inode=%p", 1398 __entry->inode 1399 ) 1400 ); 1401 1402 #include "cache.h" 1403 1404 TRACE_DEFINE_ENUM(RC_DROPIT); 1405 TRACE_DEFINE_ENUM(RC_REPLY); 1406 TRACE_DEFINE_ENUM(RC_DOIT); 1407 1408 #define show_drc_retval(x) \ 1409 __print_symbolic(x, \ 1410 { RC_DROPIT, "DROPIT" }, \ 1411 { RC_REPLY, "REPLY" }, \ 1412 { RC_DOIT, "DOIT" }) 1413 1414 TRACE_EVENT(nfsd_drc_found, 1415 TP_PROTO( 1416 const struct nfsd_net *nn, 1417 const struct svc_rqst *rqstp, 1418 int result 1419 ), 1420 TP_ARGS(nn, rqstp, result), 1421 TP_STRUCT__entry( 1422 __field(unsigned long long, boot_time) 1423 __field(unsigned long, result) 1424 __field(u32, xid) 1425 ), 1426 TP_fast_assign( 1427 __entry->boot_time = nn->boot_time; 1428 __entry->result = result; 1429 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1430 ), 1431 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1432 __entry->boot_time, __entry->xid, 1433 show_drc_retval(__entry->result)) 1434 1435 ); 1436 1437 TRACE_EVENT(nfsd_drc_mismatch, 1438 TP_PROTO( 1439 const struct nfsd_net *nn, 1440 const struct nfsd_cacherep *key, 1441 const struct nfsd_cacherep *rp 1442 ), 1443 TP_ARGS(nn, key, rp), 1444 TP_STRUCT__entry( 1445 __field(unsigned long long, boot_time) 1446 __field(u32, xid) 1447 __field(u32, cached) 1448 __field(u32, ingress) 1449 ), 1450 TP_fast_assign( 1451 __entry->boot_time = nn->boot_time; 1452 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1453 __entry->cached = (__force u32)key->c_key.k_csum; 1454 __entry->ingress = (__force u32)rp->c_key.k_csum; 1455 ), 1456 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1457 __entry->boot_time, __entry->xid, __entry->cached, 1458 __entry->ingress) 1459 ); 1460 1461 TRACE_EVENT(nfsd_cb_args, 1462 TP_PROTO( 1463 const struct nfs4_client *clp, 1464 const struct nfs4_cb_conn *conn 1465 ), 1466 TP_ARGS(clp, conn), 1467 TP_STRUCT__entry( 1468 __field(u32, cl_boot) 1469 __field(u32, cl_id) 1470 __field(u32, prog) 1471 __field(u32, ident) 1472 __sockaddr(addr, conn->cb_addrlen) 1473 ), 1474 TP_fast_assign( 1475 __entry->cl_boot = clp->cl_clientid.cl_boot; 1476 __entry->cl_id = clp->cl_clientid.cl_id; 1477 __entry->prog = conn->cb_prog; 1478 __entry->ident = conn->cb_ident; 1479 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1480 ), 1481 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1482 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1483 __entry->prog, __entry->ident) 1484 ); 1485 1486 TRACE_EVENT(nfsd_cb_nodelegs, 1487 TP_PROTO(const struct nfs4_client *clp), 1488 TP_ARGS(clp), 1489 TP_STRUCT__entry( 1490 __field(u32, cl_boot) 1491 __field(u32, cl_id) 1492 ), 1493 TP_fast_assign( 1494 __entry->cl_boot = clp->cl_clientid.cl_boot; 1495 __entry->cl_id = clp->cl_clientid.cl_id; 1496 ), 1497 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1498 ) 1499 1500 #define show_cb_state(val) \ 1501 __print_symbolic(val, \ 1502 { NFSD4_CB_UP, "UP" }, \ 1503 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1504 { NFSD4_CB_DOWN, "DOWN" }, \ 1505 { NFSD4_CB_FAULT, "FAULT"}) 1506 1507 DECLARE_EVENT_CLASS(nfsd_cb_class, 1508 TP_PROTO(const struct nfs4_client *clp), 1509 TP_ARGS(clp), 1510 TP_STRUCT__entry( 1511 __field(unsigned long, state) 1512 __field(u32, cl_boot) 1513 __field(u32, cl_id) 1514 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1515 ), 1516 TP_fast_assign( 1517 __entry->state = clp->cl_cb_state; 1518 __entry->cl_boot = clp->cl_clientid.cl_boot; 1519 __entry->cl_id = clp->cl_clientid.cl_id; 1520 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1521 clp->cl_cb_conn.cb_addrlen) 1522 ), 1523 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1524 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1525 show_cb_state(__entry->state)) 1526 ); 1527 1528 #define DEFINE_NFSD_CB_EVENT(name) \ 1529 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1530 TP_PROTO(const struct nfs4_client *clp), \ 1531 TP_ARGS(clp)) 1532 1533 DEFINE_NFSD_CB_EVENT(start); 1534 DEFINE_NFSD_CB_EVENT(new_state); 1535 DEFINE_NFSD_CB_EVENT(probe); 1536 DEFINE_NFSD_CB_EVENT(lost); 1537 DEFINE_NFSD_CB_EVENT(shutdown); 1538 DEFINE_NFSD_CB_EVENT(rpc_prepare); 1539 DEFINE_NFSD_CB_EVENT(rpc_done); 1540 DEFINE_NFSD_CB_EVENT(rpc_release); 1541 1542 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1543 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1544 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1545 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1546 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1547 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1548 1549 #define show_nfsd_authflavor(val) \ 1550 __print_symbolic(val, \ 1551 { RPC_AUTH_NULL, "none" }, \ 1552 { RPC_AUTH_UNIX, "sys" }, \ 1553 { RPC_AUTH_GSS, "gss" }, \ 1554 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1555 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1556 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1557 1558 TRACE_EVENT(nfsd_cb_setup, 1559 TP_PROTO(const struct nfs4_client *clp, 1560 const char *netid, 1561 rpc_authflavor_t authflavor 1562 ), 1563 TP_ARGS(clp, netid, authflavor), 1564 TP_STRUCT__entry( 1565 __field(u32, cl_boot) 1566 __field(u32, cl_id) 1567 __field(unsigned long, authflavor) 1568 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1569 __string(netid, netid) 1570 ), 1571 TP_fast_assign( 1572 __entry->cl_boot = clp->cl_clientid.cl_boot; 1573 __entry->cl_id = clp->cl_clientid.cl_id; 1574 __assign_str(netid); 1575 __entry->authflavor = authflavor; 1576 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1577 clp->cl_cb_conn.cb_addrlen) 1578 ), 1579 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1580 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1581 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1582 ); 1583 1584 TRACE_EVENT(nfsd_cb_setup_err, 1585 TP_PROTO( 1586 const struct nfs4_client *clp, 1587 long error 1588 ), 1589 TP_ARGS(clp, error), 1590 TP_STRUCT__entry( 1591 __field(long, error) 1592 __field(u32, cl_boot) 1593 __field(u32, cl_id) 1594 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1595 ), 1596 TP_fast_assign( 1597 __entry->error = error; 1598 __entry->cl_boot = clp->cl_clientid.cl_boot; 1599 __entry->cl_id = clp->cl_clientid.cl_id; 1600 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1601 clp->cl_cb_conn.cb_addrlen) 1602 ), 1603 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1604 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1605 __entry->error) 1606 ); 1607 1608 /* Not a real opcode, but there is no 0 operation. */ 1609 #define _CB_NULL 0 1610 1611 #define show_nfsd_cb_opcode(val) \ 1612 __print_symbolic(val, \ 1613 { _CB_NULL, "CB_NULL" }, \ 1614 { OP_CB_GETATTR, "CB_GETATTR" }, \ 1615 { OP_CB_RECALL, "CB_RECALL" }, \ 1616 { OP_CB_LAYOUTRECALL, "CB_LAYOUTRECALL" }, \ 1617 { OP_CB_RECALL_ANY, "CB_RECALL_ANY" }, \ 1618 { OP_CB_NOTIFY_LOCK, "CB_NOTIFY_LOCK" }, \ 1619 { OP_CB_OFFLOAD, "CB_OFFLOAD" }) 1620 1621 DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class, 1622 TP_PROTO( 1623 const struct nfs4_client *clp, 1624 const struct nfsd4_callback *cb 1625 ), 1626 TP_ARGS(clp, cb), 1627 TP_STRUCT__entry( 1628 __field(u32, cl_boot) 1629 __field(u32, cl_id) 1630 __field(const void *, cb) 1631 __field(unsigned long, opcode) 1632 __field(bool, need_restart) 1633 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1634 ), 1635 TP_fast_assign( 1636 __entry->cl_boot = clp->cl_clientid.cl_boot; 1637 __entry->cl_id = clp->cl_clientid.cl_id; 1638 __entry->cb = cb; 1639 __entry->opcode = cb->cb_ops ? cb->cb_ops->opcode : _CB_NULL; 1640 __entry->need_restart = test_bit(NFSD4_CALLBACK_REQUEUE, &cb->cb_flags); 1641 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1642 clp->cl_cb_conn.cb_addrlen) 1643 ), 1644 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s opcode=%s", 1645 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, __entry->cb, 1646 __entry->need_restart ? " (need restart)" : " (first try)", 1647 show_nfsd_cb_opcode(__entry->opcode) 1648 ) 1649 ); 1650 1651 #define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \ 1652 DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \ 1653 TP_PROTO( \ 1654 const struct nfs4_client *clp, \ 1655 const struct nfsd4_callback *cb \ 1656 ), \ 1657 TP_ARGS(clp, cb)) 1658 1659 DEFINE_NFSD_CB_LIFETIME_EVENT(queue); 1660 DEFINE_NFSD_CB_LIFETIME_EVENT(destroy); 1661 DEFINE_NFSD_CB_LIFETIME_EVENT(restart); 1662 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update); 1663 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown); 1664 1665 TRACE_EVENT(nfsd_cb_seq_status, 1666 TP_PROTO( 1667 const struct rpc_task *task, 1668 const struct nfsd4_callback *cb 1669 ), 1670 TP_ARGS(task, cb), 1671 TP_STRUCT__entry( 1672 __field(unsigned int, task_id) 1673 __field(unsigned int, client_id) 1674 __field(u32, cl_boot) 1675 __field(u32, cl_id) 1676 __field(u32, seqno) 1677 __field(u32, reserved) 1678 __field(int, tk_status) 1679 __field(int, seq_status) 1680 ), 1681 TP_fast_assign( 1682 const struct nfs4_client *clp = cb->cb_clp; 1683 const struct nfsd4_session *session = clp->cl_cb_session; 1684 const struct nfsd4_sessionid *sid = 1685 (struct nfsd4_sessionid *)&session->se_sessionid; 1686 1687 __entry->task_id = task->tk_pid; 1688 __entry->client_id = task->tk_client ? 1689 task->tk_client->cl_clid : -1; 1690 __entry->cl_boot = sid->clientid.cl_boot; 1691 __entry->cl_id = sid->clientid.cl_id; 1692 __entry->seqno = sid->sequence; 1693 __entry->reserved = sid->reserved; 1694 __entry->tk_status = task->tk_status; 1695 __entry->seq_status = cb->cb_seq_status; 1696 ), 1697 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1698 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d", 1699 __entry->task_id, __entry->client_id, 1700 __entry->cl_boot, __entry->cl_id, 1701 __entry->seqno, __entry->reserved, 1702 __entry->tk_status, __entry->seq_status 1703 ) 1704 ); 1705 1706 TRACE_EVENT(nfsd_cb_free_slot, 1707 TP_PROTO( 1708 const struct rpc_task *task, 1709 const struct nfsd4_callback *cb 1710 ), 1711 TP_ARGS(task, cb), 1712 TP_STRUCT__entry( 1713 __field(unsigned int, task_id) 1714 __field(unsigned int, client_id) 1715 __field(u32, cl_boot) 1716 __field(u32, cl_id) 1717 __field(u32, seqno) 1718 __field(u32, reserved) 1719 __field(u32, slot_seqno) 1720 ), 1721 TP_fast_assign( 1722 const struct nfs4_client *clp = cb->cb_clp; 1723 const struct nfsd4_session *session = clp->cl_cb_session; 1724 const struct nfsd4_sessionid *sid = 1725 (struct nfsd4_sessionid *)&session->se_sessionid; 1726 1727 __entry->task_id = task->tk_pid; 1728 __entry->client_id = task->tk_client ? 1729 task->tk_client->cl_clid : -1; 1730 __entry->cl_boot = sid->clientid.cl_boot; 1731 __entry->cl_id = sid->clientid.cl_id; 1732 __entry->seqno = sid->sequence; 1733 __entry->reserved = sid->reserved; 1734 __entry->slot_seqno = session->se_cb_seq_nr[cb->cb_held_slot]; 1735 ), 1736 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1737 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u", 1738 __entry->task_id, __entry->client_id, 1739 __entry->cl_boot, __entry->cl_id, 1740 __entry->seqno, __entry->reserved, 1741 __entry->slot_seqno 1742 ) 1743 ); 1744 1745 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1746 TP_PROTO( 1747 const struct nfs4_stid *stid 1748 ), 1749 TP_ARGS(stid), 1750 TP_CONDITION(stid->sc_client), 1751 TP_STRUCT__entry( 1752 __field(u32, cl_boot) 1753 __field(u32, cl_id) 1754 __field(u32, si_id) 1755 __field(u32, si_generation) 1756 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1757 ), 1758 TP_fast_assign( 1759 const stateid_t *stp = &stid->sc_stateid; 1760 const struct nfs4_client *clp = stid->sc_client; 1761 1762 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1763 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1764 __entry->si_id = stp->si_opaque.so_id; 1765 __entry->si_generation = stp->si_generation; 1766 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1767 clp->cl_cb_conn.cb_addrlen) 1768 ), 1769 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1770 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1771 __entry->si_id, __entry->si_generation) 1772 ); 1773 1774 TRACE_EVENT(nfsd_cb_notify_lock, 1775 TP_PROTO( 1776 const struct nfs4_lockowner *lo, 1777 const struct nfsd4_blocked_lock *nbl 1778 ), 1779 TP_ARGS(lo, nbl), 1780 TP_STRUCT__entry( 1781 __field(u32, cl_boot) 1782 __field(u32, cl_id) 1783 __field(u32, fh_hash) 1784 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1785 ), 1786 TP_fast_assign( 1787 const struct nfs4_client *clp = lo->lo_owner.so_client; 1788 1789 __entry->cl_boot = clp->cl_clientid.cl_boot; 1790 __entry->cl_id = clp->cl_clientid.cl_id; 1791 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1792 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1793 clp->cl_cb_conn.cb_addrlen) 1794 ), 1795 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1796 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1797 __entry->fh_hash) 1798 ); 1799 1800 TRACE_EVENT(nfsd_cb_offload, 1801 TP_PROTO( 1802 const struct nfs4_client *clp, 1803 const stateid_t *stp, 1804 const struct knfsd_fh *fh, 1805 u64 count, 1806 __be32 status 1807 ), 1808 TP_ARGS(clp, stp, fh, count, status), 1809 TP_STRUCT__entry( 1810 __field(u32, cl_boot) 1811 __field(u32, cl_id) 1812 __field(u32, si_id) 1813 __field(u32, si_generation) 1814 __field(u32, fh_hash) 1815 __field(int, status) 1816 __field(u64, count) 1817 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1818 ), 1819 TP_fast_assign( 1820 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1821 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1822 __entry->si_id = stp->si_opaque.so_id; 1823 __entry->si_generation = stp->si_generation; 1824 __entry->fh_hash = knfsd_fh_hash(fh); 1825 __entry->status = be32_to_cpu(status); 1826 __entry->count = count; 1827 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1828 clp->cl_cb_conn.cb_addrlen) 1829 ), 1830 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1831 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1832 __entry->si_id, __entry->si_generation, 1833 __entry->fh_hash, __entry->count, __entry->status) 1834 ); 1835 1836 TRACE_EVENT(nfsd_cb_recall_any, 1837 TP_PROTO( 1838 const struct nfsd4_cb_recall_any *ra 1839 ), 1840 TP_ARGS(ra), 1841 TP_STRUCT__entry( 1842 __field(u32, cl_boot) 1843 __field(u32, cl_id) 1844 __field(u32, keep) 1845 __field(unsigned long, bmval0) 1846 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1847 ), 1848 TP_fast_assign( 1849 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1850 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1851 __entry->keep = ra->ra_keep; 1852 __entry->bmval0 = ra->ra_bmval[0]; 1853 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1854 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1855 ), 1856 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1857 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1858 __entry->keep, show_rca_mask(__entry->bmval0) 1859 ) 1860 ); 1861 1862 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1863 TP_PROTO( 1864 const stateid_t *stp, 1865 const struct rpc_task *task 1866 ), 1867 TP_ARGS(stp, task), 1868 TP_STRUCT__entry( 1869 __field(u32, cl_boot) 1870 __field(u32, cl_id) 1871 __field(u32, si_id) 1872 __field(u32, si_generation) 1873 __field(int, status) 1874 ), 1875 TP_fast_assign( 1876 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1877 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1878 __entry->si_id = stp->si_opaque.so_id; 1879 __entry->si_generation = stp->si_generation; 1880 __entry->status = task->tk_status; 1881 ), 1882 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1883 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1884 __entry->si_generation, __entry->status 1885 ) 1886 ); 1887 1888 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1889 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1890 TP_PROTO( \ 1891 const stateid_t *stp, \ 1892 const struct rpc_task *task \ 1893 ), \ 1894 TP_ARGS(stp, task)) 1895 1896 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1897 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1898 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1899 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1900 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_getattr_done); 1901 1902 TRACE_EVENT(nfsd_cb_recall_any_done, 1903 TP_PROTO( 1904 const struct nfsd4_callback *cb, 1905 const struct rpc_task *task 1906 ), 1907 TP_ARGS(cb, task), 1908 TP_STRUCT__entry( 1909 __field(u32, cl_boot) 1910 __field(u32, cl_id) 1911 __field(int, status) 1912 ), 1913 TP_fast_assign( 1914 __entry->status = task->tk_status; 1915 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1916 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1917 ), 1918 TP_printk("client %08x:%08x status=%d", 1919 __entry->cl_boot, __entry->cl_id, __entry->status 1920 ) 1921 ); 1922 1923 TRACE_EVENT(nfsd_ctl_unlock_ip, 1924 TP_PROTO( 1925 const struct net *net, 1926 const char *address 1927 ), 1928 TP_ARGS(net, address), 1929 TP_STRUCT__entry( 1930 __field(unsigned int, netns_ino) 1931 __string(address, address) 1932 ), 1933 TP_fast_assign( 1934 __entry->netns_ino = net->ns.inum; 1935 __assign_str(address); 1936 ), 1937 TP_printk("address=%s", 1938 __get_str(address) 1939 ) 1940 ); 1941 1942 TRACE_EVENT(nfsd_ctl_unlock_fs, 1943 TP_PROTO( 1944 const struct net *net, 1945 const char *path 1946 ), 1947 TP_ARGS(net, path), 1948 TP_STRUCT__entry( 1949 __field(unsigned int, netns_ino) 1950 __string(path, path) 1951 ), 1952 TP_fast_assign( 1953 __entry->netns_ino = net->ns.inum; 1954 __assign_str(path); 1955 ), 1956 TP_printk("path=%s", 1957 __get_str(path) 1958 ) 1959 ); 1960 1961 TRACE_EVENT(nfsd_ctl_filehandle, 1962 TP_PROTO( 1963 const struct net *net, 1964 const char *domain, 1965 const char *path, 1966 int maxsize 1967 ), 1968 TP_ARGS(net, domain, path, maxsize), 1969 TP_STRUCT__entry( 1970 __field(unsigned int, netns_ino) 1971 __field(int, maxsize) 1972 __string(domain, domain) 1973 __string(path, path) 1974 ), 1975 TP_fast_assign( 1976 __entry->netns_ino = net->ns.inum; 1977 __entry->maxsize = maxsize; 1978 __assign_str(domain); 1979 __assign_str(path); 1980 ), 1981 TP_printk("domain=%s path=%s maxsize=%d", 1982 __get_str(domain), __get_str(path), __entry->maxsize 1983 ) 1984 ); 1985 1986 TRACE_EVENT(nfsd_ctl_threads, 1987 TP_PROTO( 1988 const struct net *net, 1989 int newthreads 1990 ), 1991 TP_ARGS(net, newthreads), 1992 TP_STRUCT__entry( 1993 __field(unsigned int, netns_ino) 1994 __field(int, newthreads) 1995 ), 1996 TP_fast_assign( 1997 __entry->netns_ino = net->ns.inum; 1998 __entry->newthreads = newthreads; 1999 ), 2000 TP_printk("newthreads=%d", 2001 __entry->newthreads 2002 ) 2003 ); 2004 2005 TRACE_EVENT(nfsd_ctl_pool_threads, 2006 TP_PROTO( 2007 const struct net *net, 2008 int pool, 2009 int nrthreads 2010 ), 2011 TP_ARGS(net, pool, nrthreads), 2012 TP_STRUCT__entry( 2013 __field(unsigned int, netns_ino) 2014 __field(int, pool) 2015 __field(int, nrthreads) 2016 ), 2017 TP_fast_assign( 2018 __entry->netns_ino = net->ns.inum; 2019 __entry->pool = pool; 2020 __entry->nrthreads = nrthreads; 2021 ), 2022 TP_printk("pool=%d nrthreads=%d", 2023 __entry->pool, __entry->nrthreads 2024 ) 2025 ); 2026 2027 TRACE_EVENT(nfsd_ctl_version, 2028 TP_PROTO( 2029 const struct net *net, 2030 const char *mesg 2031 ), 2032 TP_ARGS(net, mesg), 2033 TP_STRUCT__entry( 2034 __field(unsigned int, netns_ino) 2035 __string(mesg, mesg) 2036 ), 2037 TP_fast_assign( 2038 __entry->netns_ino = net->ns.inum; 2039 __assign_str(mesg); 2040 ), 2041 TP_printk("%s", 2042 __get_str(mesg) 2043 ) 2044 ); 2045 2046 TRACE_EVENT(nfsd_ctl_ports_addfd, 2047 TP_PROTO( 2048 const struct net *net, 2049 int fd 2050 ), 2051 TP_ARGS(net, fd), 2052 TP_STRUCT__entry( 2053 __field(unsigned int, netns_ino) 2054 __field(int, fd) 2055 ), 2056 TP_fast_assign( 2057 __entry->netns_ino = net->ns.inum; 2058 __entry->fd = fd; 2059 ), 2060 TP_printk("fd=%d", 2061 __entry->fd 2062 ) 2063 ); 2064 2065 TRACE_EVENT(nfsd_ctl_ports_addxprt, 2066 TP_PROTO( 2067 const struct net *net, 2068 const char *transport, 2069 int port 2070 ), 2071 TP_ARGS(net, transport, port), 2072 TP_STRUCT__entry( 2073 __field(unsigned int, netns_ino) 2074 __field(int, port) 2075 __string(transport, transport) 2076 ), 2077 TP_fast_assign( 2078 __entry->netns_ino = net->ns.inum; 2079 __entry->port = port; 2080 __assign_str(transport); 2081 ), 2082 TP_printk("transport=%s port=%d", 2083 __get_str(transport), __entry->port 2084 ) 2085 ); 2086 2087 TRACE_EVENT(nfsd_ctl_maxblksize, 2088 TP_PROTO( 2089 const struct net *net, 2090 int bsize 2091 ), 2092 TP_ARGS(net, bsize), 2093 TP_STRUCT__entry( 2094 __field(unsigned int, netns_ino) 2095 __field(int, bsize) 2096 ), 2097 TP_fast_assign( 2098 __entry->netns_ino = net->ns.inum; 2099 __entry->bsize = bsize; 2100 ), 2101 TP_printk("bsize=%d", 2102 __entry->bsize 2103 ) 2104 ); 2105 2106 TRACE_EVENT(nfsd_ctl_maxconn, 2107 TP_PROTO( 2108 const struct net *net, 2109 int maxconn 2110 ), 2111 TP_ARGS(net, maxconn), 2112 TP_STRUCT__entry( 2113 __field(unsigned int, netns_ino) 2114 __field(int, maxconn) 2115 ), 2116 TP_fast_assign( 2117 __entry->netns_ino = net->ns.inum; 2118 __entry->maxconn = maxconn; 2119 ), 2120 TP_printk("maxconn=%d", 2121 __entry->maxconn 2122 ) 2123 ); 2124 2125 TRACE_EVENT(nfsd_ctl_time, 2126 TP_PROTO( 2127 const struct net *net, 2128 const char *name, 2129 size_t namelen, 2130 int time 2131 ), 2132 TP_ARGS(net, name, namelen, time), 2133 TP_STRUCT__entry( 2134 __field(unsigned int, netns_ino) 2135 __field(int, time) 2136 __string_len(name, name, namelen) 2137 ), 2138 TP_fast_assign( 2139 __entry->netns_ino = net->ns.inum; 2140 __entry->time = time; 2141 __assign_str(name); 2142 ), 2143 TP_printk("file=%s time=%d", 2144 __get_str(name), __entry->time 2145 ) 2146 ); 2147 2148 TRACE_EVENT(nfsd_ctl_recoverydir, 2149 TP_PROTO( 2150 const struct net *net, 2151 const char *recdir 2152 ), 2153 TP_ARGS(net, recdir), 2154 TP_STRUCT__entry( 2155 __field(unsigned int, netns_ino) 2156 __string(recdir, recdir) 2157 ), 2158 TP_fast_assign( 2159 __entry->netns_ino = net->ns.inum; 2160 __assign_str(recdir); 2161 ), 2162 TP_printk("recdir=%s", 2163 __get_str(recdir) 2164 ) 2165 ); 2166 2167 TRACE_EVENT(nfsd_end_grace, 2168 TP_PROTO( 2169 const struct net *net 2170 ), 2171 TP_ARGS(net), 2172 TP_STRUCT__entry( 2173 __field(unsigned int, netns_ino) 2174 ), 2175 TP_fast_assign( 2176 __entry->netns_ino = net->ns.inum; 2177 ), 2178 TP_printk("nn=%d", __entry->netns_ino 2179 ) 2180 ); 2181 2182 DECLARE_EVENT_CLASS(nfsd_copy_class, 2183 TP_PROTO( 2184 const struct nfsd4_copy *copy 2185 ), 2186 TP_ARGS(copy), 2187 TP_STRUCT__entry( 2188 __field(bool, intra) 2189 __field(bool, async) 2190 __field(u32, src_cl_boot) 2191 __field(u32, src_cl_id) 2192 __field(u32, src_so_id) 2193 __field(u32, src_si_generation) 2194 __field(u32, dst_cl_boot) 2195 __field(u32, dst_cl_id) 2196 __field(u32, dst_so_id) 2197 __field(u32, dst_si_generation) 2198 __field(u32, cb_cl_boot) 2199 __field(u32, cb_cl_id) 2200 __field(u32, cb_so_id) 2201 __field(u32, cb_si_generation) 2202 __field(u64, src_cp_pos) 2203 __field(u64, dst_cp_pos) 2204 __field(u64, cp_count) 2205 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2206 ), 2207 TP_fast_assign( 2208 const stateid_t *src_stp = ©->cp_src_stateid; 2209 const stateid_t *dst_stp = ©->cp_dst_stateid; 2210 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2211 2212 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2213 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2214 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2215 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2216 __entry->src_so_id = src_stp->si_opaque.so_id; 2217 __entry->src_si_generation = src_stp->si_generation; 2218 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2219 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2220 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2221 __entry->dst_si_generation = dst_stp->si_generation; 2222 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2223 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2224 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2225 __entry->cb_si_generation = cb_stp->si_generation; 2226 __entry->src_cp_pos = copy->cp_src_pos; 2227 __entry->dst_cp_pos = copy->cp_dst_pos; 2228 __entry->cp_count = copy->cp_count; 2229 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2230 sizeof(struct sockaddr_in6)); 2231 ), 2232 TP_printk("client=%pISpc intra=%d async=%d " 2233 "src_client %08x:%08x src_stateid %08x:%08x " 2234 "dst_client %08x:%08x dst_stateid %08x:%08x " 2235 "cb_client %08x:%08x cb_stateid %08x:%08x " 2236 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2237 __get_sockaddr(addr), __entry->intra, __entry->async, 2238 __entry->src_cl_boot, __entry->src_cl_id, 2239 __entry->src_so_id, __entry->src_si_generation, 2240 __entry->dst_cl_boot, __entry->dst_cl_id, 2241 __entry->dst_so_id, __entry->dst_si_generation, 2242 __entry->cb_cl_boot, __entry->cb_cl_id, 2243 __entry->cb_so_id, __entry->cb_si_generation, 2244 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2245 ) 2246 ); 2247 2248 #define DEFINE_COPY_EVENT(name) \ 2249 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \ 2250 TP_PROTO(const struct nfsd4_copy *copy), \ 2251 TP_ARGS(copy)) 2252 2253 DEFINE_COPY_EVENT(inter); 2254 DEFINE_COPY_EVENT(intra); 2255 DEFINE_COPY_EVENT(async); 2256 2257 TRACE_EVENT(nfsd_copy_done, 2258 TP_PROTO( 2259 const struct nfsd4_copy *copy, 2260 __be32 status 2261 ), 2262 TP_ARGS(copy, status), 2263 TP_STRUCT__entry( 2264 __field(int, status) 2265 __field(bool, intra) 2266 __field(bool, async) 2267 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2268 ), 2269 TP_fast_assign( 2270 __entry->status = be32_to_cpu(status); 2271 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2272 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2273 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2274 sizeof(struct sockaddr_in6)); 2275 ), 2276 TP_printk("addr=%pISpc status=%d intra=%d async=%d", 2277 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async 2278 ) 2279 ); 2280 2281 DECLARE_EVENT_CLASS(nfsd_copy_async_done_class, 2282 TP_PROTO( 2283 const struct nfsd4_copy *copy 2284 ), 2285 TP_ARGS(copy), 2286 TP_STRUCT__entry( 2287 __field(int, status) 2288 __field(bool, intra) 2289 __field(bool, async) 2290 __field(u32, src_cl_boot) 2291 __field(u32, src_cl_id) 2292 __field(u32, src_so_id) 2293 __field(u32, src_si_generation) 2294 __field(u32, dst_cl_boot) 2295 __field(u32, dst_cl_id) 2296 __field(u32, dst_so_id) 2297 __field(u32, dst_si_generation) 2298 __field(u32, cb_cl_boot) 2299 __field(u32, cb_cl_id) 2300 __field(u32, cb_so_id) 2301 __field(u32, cb_si_generation) 2302 __field(u64, src_cp_pos) 2303 __field(u64, dst_cp_pos) 2304 __field(u64, cp_count) 2305 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2306 ), 2307 TP_fast_assign( 2308 const stateid_t *src_stp = ©->cp_src_stateid; 2309 const stateid_t *dst_stp = ©->cp_dst_stateid; 2310 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2311 2312 __entry->status = be32_to_cpu(copy->nfserr); 2313 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2314 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2315 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2316 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2317 __entry->src_so_id = src_stp->si_opaque.so_id; 2318 __entry->src_si_generation = src_stp->si_generation; 2319 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2320 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2321 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2322 __entry->dst_si_generation = dst_stp->si_generation; 2323 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2324 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2325 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2326 __entry->cb_si_generation = cb_stp->si_generation; 2327 __entry->src_cp_pos = copy->cp_src_pos; 2328 __entry->dst_cp_pos = copy->cp_dst_pos; 2329 __entry->cp_count = copy->cp_count; 2330 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2331 sizeof(struct sockaddr_in6)); 2332 ), 2333 TP_printk("client=%pISpc status=%d intra=%d async=%d " 2334 "src_client %08x:%08x src_stateid %08x:%08x " 2335 "dst_client %08x:%08x dst_stateid %08x:%08x " 2336 "cb_client %08x:%08x cb_stateid %08x:%08x " 2337 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2338 __get_sockaddr(addr), 2339 __entry->status, __entry->intra, __entry->async, 2340 __entry->src_cl_boot, __entry->src_cl_id, 2341 __entry->src_so_id, __entry->src_si_generation, 2342 __entry->dst_cl_boot, __entry->dst_cl_id, 2343 __entry->dst_so_id, __entry->dst_si_generation, 2344 __entry->cb_cl_boot, __entry->cb_cl_id, 2345 __entry->cb_so_id, __entry->cb_si_generation, 2346 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2347 ) 2348 ); 2349 2350 #define DEFINE_COPY_ASYNC_DONE_EVENT(name) \ 2351 DEFINE_EVENT(nfsd_copy_async_done_class, \ 2352 nfsd_copy_async_##name, \ 2353 TP_PROTO(const struct nfsd4_copy *copy), \ 2354 TP_ARGS(copy)) 2355 2356 DEFINE_COPY_ASYNC_DONE_EVENT(done); 2357 DEFINE_COPY_ASYNC_DONE_EVENT(cancel); 2358 2359 TRACE_EVENT(nfsd_vfs_setattr, 2360 TP_PROTO( 2361 const struct svc_rqst *rqstp, 2362 const struct svc_fh *fhp, 2363 const struct iattr *iap, 2364 const struct timespec64 *guardtime 2365 ), 2366 TP_ARGS(rqstp, fhp, iap, guardtime), 2367 TP_STRUCT__entry( 2368 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2369 __field(u32, fh_hash) 2370 __field(s64, gtime_tv_sec) 2371 __field(u32, gtime_tv_nsec) 2372 __field(unsigned int, ia_valid) 2373 __field(loff_t, ia_size) 2374 __field(uid_t, ia_uid) 2375 __field(gid_t, ia_gid) 2376 __field(umode_t, ia_mode) 2377 ), 2378 TP_fast_assign( 2379 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2380 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2381 __entry->gtime_tv_sec = guardtime ? guardtime->tv_sec : 0; 2382 __entry->gtime_tv_nsec = guardtime ? guardtime->tv_nsec : 0; 2383 __entry->ia_valid = iap->ia_valid; 2384 __entry->ia_size = iap->ia_size; 2385 __entry->ia_uid = __kuid_val(iap->ia_uid); 2386 __entry->ia_gid = __kgid_val(iap->ia_gid); 2387 __entry->ia_mode = iap->ia_mode; 2388 ), 2389 TP_printk( 2390 "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", 2391 __entry->xid, __entry->fh_hash, show_ia_valid_flags(__entry->ia_valid), 2392 __entry->ia_size, __entry->ia_mode, __entry->ia_uid, __entry->ia_gid, 2393 __entry->gtime_tv_sec, __entry->gtime_tv_nsec 2394 ) 2395 ) 2396 2397 TRACE_EVENT(nfsd_vfs_lookup, 2398 TP_PROTO( 2399 const struct svc_rqst *rqstp, 2400 const struct svc_fh *fhp, 2401 const char *name, 2402 unsigned int len 2403 ), 2404 TP_ARGS(rqstp, fhp, name, len), 2405 TP_STRUCT__entry( 2406 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2407 __field(u32, fh_hash) 2408 __string_len(name, name, len) 2409 ), 2410 TP_fast_assign( 2411 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2412 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2413 __assign_str(name); 2414 ), 2415 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s", 2416 __entry->xid, __entry->fh_hash, __get_str(name) 2417 ) 2418 ); 2419 2420 TRACE_EVENT(nfsd_vfs_create, 2421 TP_PROTO( 2422 const struct svc_rqst *rqstp, 2423 const struct svc_fh *fhp, 2424 umode_t type, 2425 const char *name, 2426 unsigned int len 2427 ), 2428 TP_ARGS(rqstp, fhp, type, name, len), 2429 TP_STRUCT__entry( 2430 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2431 __field(u32, fh_hash) 2432 __field(umode_t, type) 2433 __string_len(name, name, len) 2434 ), 2435 TP_fast_assign( 2436 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2437 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2438 __entry->type = type; 2439 __assign_str(name); 2440 ), 2441 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s name=%s", 2442 __entry->xid, __entry->fh_hash, 2443 show_fs_file_type(__entry->type), __get_str(name) 2444 ) 2445 ); 2446 2447 TRACE_EVENT(nfsd_vfs_symlink, 2448 TP_PROTO( 2449 const struct svc_rqst *rqstp, 2450 const struct svc_fh *fhp, 2451 const char *name, 2452 unsigned int namelen, 2453 const char *target 2454 ), 2455 TP_ARGS(rqstp, fhp, name, namelen, target), 2456 TP_STRUCT__entry( 2457 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2458 __field(u32, fh_hash) 2459 __string_len(name, name, namelen) 2460 __string(target, target) 2461 ), 2462 TP_fast_assign( 2463 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2464 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2465 __assign_str(name); 2466 __assign_str(target); 2467 ), 2468 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s target=%s", 2469 __entry->xid, __entry->fh_hash, 2470 __get_str(name), __get_str(target) 2471 ) 2472 ); 2473 2474 TRACE_EVENT(nfsd_vfs_link, 2475 TP_PROTO( 2476 const struct svc_rqst *rqstp, 2477 const struct svc_fh *sfhp, 2478 const struct svc_fh *tfhp, 2479 const char *name, 2480 unsigned int namelen 2481 ), 2482 TP_ARGS(rqstp, sfhp, tfhp, name, namelen), 2483 TP_STRUCT__entry( 2484 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2485 __field(u32, sfh_hash) 2486 __field(u32, tfh_hash) 2487 __string_len(name, name, namelen) 2488 ), 2489 TP_fast_assign( 2490 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2491 __entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle); 2492 __entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle); 2493 __assign_str(name); 2494 ), 2495 TP_printk("xid=0x%08x src_fh=0x%08x tgt_fh=0x%08x name=%s", 2496 __entry->xid, __entry->sfh_hash, __entry->tfh_hash, 2497 __get_str(name) 2498 ) 2499 ); 2500 2501 TRACE_EVENT(nfsd_vfs_unlink, 2502 TP_PROTO( 2503 const struct svc_rqst *rqstp, 2504 const struct svc_fh *fhp, 2505 const char *name, 2506 unsigned int len 2507 ), 2508 TP_ARGS(rqstp, fhp, name, len), 2509 TP_STRUCT__entry( 2510 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2511 __field(u32, fh_hash) 2512 __string_len(name, name, len) 2513 ), 2514 TP_fast_assign( 2515 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2516 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2517 __assign_str(name); 2518 ), 2519 TP_printk("xid=0x%08x fh_hash=0x%08x name=%s", 2520 __entry->xid, __entry->fh_hash, 2521 __get_str(name) 2522 ) 2523 ); 2524 2525 TRACE_EVENT(nfsd_vfs_rename, 2526 TP_PROTO( 2527 const struct svc_rqst *rqstp, 2528 const struct svc_fh *sfhp, 2529 const struct svc_fh *tfhp, 2530 const char *source, 2531 unsigned int sourcelen, 2532 const char *target, 2533 unsigned int targetlen 2534 ), 2535 TP_ARGS(rqstp, sfhp, tfhp, source, sourcelen, target, targetlen), 2536 TP_STRUCT__entry( 2537 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2538 __field(u32, sfh_hash) 2539 __field(u32, tfh_hash) 2540 __string_len(source, source, sourcelen) 2541 __string_len(target, target, targetlen) 2542 ), 2543 TP_fast_assign( 2544 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2545 __entry->sfh_hash = knfsd_fh_hash(&sfhp->fh_handle); 2546 __entry->tfh_hash = knfsd_fh_hash(&tfhp->fh_handle); 2547 __assign_str(source); 2548 __assign_str(target); 2549 ), 2550 TP_printk("xid=0x%08x sfh_hash=0x%08x tfh_hash=0x%08x source=%s target=%s", 2551 __entry->xid, __entry->sfh_hash, __entry->tfh_hash, 2552 __get_str(source), __get_str(target) 2553 ) 2554 ); 2555 2556 TRACE_EVENT(nfsd_vfs_readdir, 2557 TP_PROTO( 2558 const struct svc_rqst *rqstp, 2559 const struct svc_fh *fhp, 2560 u32 count, 2561 u64 offset 2562 ), 2563 TP_ARGS(rqstp, fhp, count, offset), 2564 TP_STRUCT__entry( 2565 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2566 __field(u32, fh_hash) 2567 __field(u32, count) 2568 __field(u64, offset) 2569 ), 2570 TP_fast_assign( 2571 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2572 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2573 __entry->count = count; 2574 __entry->offset = offset; 2575 ), 2576 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu count=%u", 2577 __entry->xid, __entry->fh_hash, 2578 __entry->offset, __entry->count 2579 ) 2580 ); 2581 2582 DECLARE_EVENT_CLASS(nfsd_vfs_getattr_class, 2583 TP_PROTO( 2584 const struct svc_rqst *rqstp, 2585 const struct svc_fh *fhp 2586 ), 2587 TP_ARGS(rqstp, fhp), 2588 TP_STRUCT__entry( 2589 NFSD_TRACE_PROC_CALL_FIELDS(rqstp) 2590 __field(u32, fh_hash) 2591 ), 2592 TP_fast_assign( 2593 NFSD_TRACE_PROC_CALL_ASSIGNMENTS(rqstp); 2594 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 2595 ), 2596 TP_printk("xid=0x%08x fh_hash=0x%08x", 2597 __entry->xid, __entry->fh_hash 2598 ) 2599 ); 2600 2601 #define DEFINE_NFSD_VFS_GETATTR_EVENT(__name) \ 2602 DEFINE_EVENT(nfsd_vfs_getattr_class, __name, \ 2603 TP_PROTO( \ 2604 const struct svc_rqst *rqstp, \ 2605 const struct svc_fh *fhp \ 2606 ), \ 2607 TP_ARGS(rqstp, fhp)) 2608 2609 DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_getattr); 2610 DEFINE_NFSD_VFS_GETATTR_EVENT(nfsd_vfs_statfs); 2611 2612 #endif /* _NFSD_TRACE_H */ 2613 2614 #undef TRACE_INCLUDE_PATH 2615 #define TRACE_INCLUDE_PATH . 2616 #define TRACE_INCLUDE_FILE trace 2617 #include <trace/define_trace.h> 2618