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