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