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