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/xprt.h> 13 #include <trace/misc/nfs.h> 14 15 #include "export.h" 16 #include "nfsfh.h" 17 #include "xdr4.h" 18 19 #define NFSD_TRACE_PROC_RES_FIELDS \ 20 __field(unsigned int, netns_ino) \ 21 __field(u32, xid) \ 22 __field(unsigned long, status) \ 23 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 24 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 25 26 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 27 do { \ 28 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 29 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 30 __entry->status = be32_to_cpu(error); \ 31 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 32 rqstp->rq_xprt->xpt_locallen); \ 33 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 34 rqstp->rq_xprt->xpt_remotelen); \ 35 } while (0); 36 37 DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 38 TP_PROTO( 39 const struct svc_rqst *rqstp 40 ), 41 TP_ARGS(rqstp), 42 TP_STRUCT__entry( 43 __field(unsigned int, netns_ino) 44 __field(u32, xid) 45 __field(u32, vers) 46 __field(u32, proc) 47 __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 48 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 49 ), 50 TP_fast_assign( 51 const struct svc_xprt *xprt = rqstp->rq_xprt; 52 53 __entry->netns_ino = xprt->xpt_net->ns.inum; 54 __entry->xid = be32_to_cpu(rqstp->rq_xid); 55 __entry->vers = rqstp->rq_vers; 56 __entry->proc = rqstp->rq_proc; 57 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 58 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 59 ), 60 TP_printk("xid=0x%08x vers=%u proc=%u", 61 __entry->xid, __entry->vers, __entry->proc 62 ) 63 ); 64 65 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 66 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 67 TP_PROTO(const struct svc_rqst *rqstp), \ 68 TP_ARGS(rqstp)) 69 70 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 71 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 72 73 #define show_nfsd_may_flags(x) \ 74 __print_flags(x, "|", \ 75 { NFSD_MAY_EXEC, "EXEC" }, \ 76 { NFSD_MAY_WRITE, "WRITE" }, \ 77 { NFSD_MAY_READ, "READ" }, \ 78 { NFSD_MAY_SATTR, "SATTR" }, \ 79 { NFSD_MAY_TRUNC, "TRUNC" }, \ 80 { NFSD_MAY_LOCK, "LOCK" }, \ 81 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 82 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 83 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 84 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 85 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 86 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 87 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 88 89 TRACE_EVENT(nfsd_compound, 90 TP_PROTO( 91 const struct svc_rqst *rqst, 92 const char *tag, 93 u32 taglen, 94 u32 opcnt 95 ), 96 TP_ARGS(rqst, tag, taglen, opcnt), 97 TP_STRUCT__entry( 98 __field(u32, xid) 99 __field(u32, opcnt) 100 __string_len(tag, tag, taglen) 101 ), 102 TP_fast_assign( 103 __entry->xid = be32_to_cpu(rqst->rq_xid); 104 __entry->opcnt = opcnt; 105 __assign_str_len(tag, tag, taglen); 106 ), 107 TP_printk("xid=0x%08x opcnt=%u tag=%s", 108 __entry->xid, __entry->opcnt, __get_str(tag) 109 ) 110 ) 111 112 TRACE_EVENT(nfsd_compound_status, 113 TP_PROTO(u32 args_opcnt, 114 u32 resp_opcnt, 115 __be32 status, 116 const char *name), 117 TP_ARGS(args_opcnt, resp_opcnt, status, name), 118 TP_STRUCT__entry( 119 __field(u32, args_opcnt) 120 __field(u32, resp_opcnt) 121 __field(int, status) 122 __string(name, name) 123 ), 124 TP_fast_assign( 125 __entry->args_opcnt = args_opcnt; 126 __entry->resp_opcnt = resp_opcnt; 127 __entry->status = be32_to_cpu(status); 128 __assign_str(name, name); 129 ), 130 TP_printk("op=%u/%u %s status=%d", 131 __entry->resp_opcnt, __entry->args_opcnt, 132 __get_str(name), __entry->status) 133 ) 134 135 TRACE_EVENT(nfsd_compound_decode_err, 136 TP_PROTO( 137 const struct svc_rqst *rqstp, 138 u32 args_opcnt, 139 u32 resp_opcnt, 140 u32 opnum, 141 __be32 status 142 ), 143 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 144 TP_STRUCT__entry( 145 NFSD_TRACE_PROC_RES_FIELDS 146 147 __field(u32, args_opcnt) 148 __field(u32, resp_opcnt) 149 __field(u32, opnum) 150 ), 151 TP_fast_assign( 152 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 153 154 __entry->args_opcnt = args_opcnt; 155 __entry->resp_opcnt = resp_opcnt; 156 __entry->opnum = opnum; 157 ), 158 TP_printk("op=%u/%u opnum=%u status=%lu", 159 __entry->resp_opcnt, __entry->args_opcnt, 160 __entry->opnum, __entry->status) 161 ); 162 163 TRACE_EVENT(nfsd_compound_encode_err, 164 TP_PROTO( 165 const struct svc_rqst *rqstp, 166 u32 opnum, 167 __be32 status 168 ), 169 TP_ARGS(rqstp, opnum, status), 170 TP_STRUCT__entry( 171 NFSD_TRACE_PROC_RES_FIELDS 172 173 __field(u32, opnum) 174 ), 175 TP_fast_assign( 176 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 177 178 __entry->opnum = opnum; 179 ), 180 TP_printk("opnum=%u status=%lu", 181 __entry->opnum, __entry->status) 182 ); 183 184 #define show_fs_file_type(x) \ 185 __print_symbolic(x, \ 186 { S_IFLNK, "LNK" }, \ 187 { S_IFREG, "REG" }, \ 188 { S_IFDIR, "DIR" }, \ 189 { S_IFCHR, "CHR" }, \ 190 { S_IFBLK, "BLK" }, \ 191 { S_IFIFO, "FIFO" }, \ 192 { S_IFSOCK, "SOCK" }) 193 194 TRACE_EVENT(nfsd_fh_verify, 195 TP_PROTO( 196 const struct svc_rqst *rqstp, 197 const struct svc_fh *fhp, 198 umode_t type, 199 int access 200 ), 201 TP_ARGS(rqstp, fhp, type, access), 202 TP_STRUCT__entry( 203 __field(unsigned int, netns_ino) 204 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 205 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 206 __field(u32, xid) 207 __field(u32, fh_hash) 208 __field(const void *, inode) 209 __field(unsigned long, type) 210 __field(unsigned long, access) 211 ), 212 TP_fast_assign( 213 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 214 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 215 rqstp->rq_xprt->xpt_locallen); 216 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 217 rqstp->rq_xprt->xpt_remotelen); 218 __entry->xid = be32_to_cpu(rqstp->rq_xid); 219 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 220 __entry->inode = d_inode(fhp->fh_dentry); 221 __entry->type = type; 222 __entry->access = access; 223 ), 224 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 225 __entry->xid, __entry->fh_hash, 226 show_fs_file_type(__entry->type), 227 show_nfsd_may_flags(__entry->access) 228 ) 229 ); 230 231 TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 232 TP_PROTO( 233 const struct svc_rqst *rqstp, 234 const struct svc_fh *fhp, 235 umode_t type, 236 int access, 237 __be32 error 238 ), 239 TP_ARGS(rqstp, fhp, type, access, error), 240 TP_CONDITION(error), 241 TP_STRUCT__entry( 242 __field(unsigned int, netns_ino) 243 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 244 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 245 __field(u32, xid) 246 __field(u32, fh_hash) 247 __field(const void *, inode) 248 __field(unsigned long, type) 249 __field(unsigned long, access) 250 __field(int, error) 251 ), 252 TP_fast_assign( 253 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 254 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 255 rqstp->rq_xprt->xpt_locallen); 256 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 257 rqstp->rq_xprt->xpt_remotelen); 258 __entry->xid = be32_to_cpu(rqstp->rq_xid); 259 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 260 if (fhp->fh_dentry) 261 __entry->inode = d_inode(fhp->fh_dentry); 262 else 263 __entry->inode = NULL; 264 __entry->type = type; 265 __entry->access = access; 266 __entry->error = be32_to_cpu(error); 267 ), 268 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 269 __entry->xid, __entry->fh_hash, 270 show_fs_file_type(__entry->type), 271 show_nfsd_may_flags(__entry->access), 272 __entry->error 273 ) 274 ); 275 276 DECLARE_EVENT_CLASS(nfsd_fh_err_class, 277 TP_PROTO(struct svc_rqst *rqstp, 278 struct svc_fh *fhp, 279 int status), 280 TP_ARGS(rqstp, fhp, status), 281 TP_STRUCT__entry( 282 __field(u32, xid) 283 __field(u32, fh_hash) 284 __field(int, status) 285 ), 286 TP_fast_assign( 287 __entry->xid = be32_to_cpu(rqstp->rq_xid); 288 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 289 __entry->status = status; 290 ), 291 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 292 __entry->xid, __entry->fh_hash, 293 __entry->status) 294 ) 295 296 #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 297 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 298 TP_PROTO(struct svc_rqst *rqstp, \ 299 struct svc_fh *fhp, \ 300 int status), \ 301 TP_ARGS(rqstp, fhp, status)) 302 303 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 304 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 305 306 TRACE_EVENT(nfsd_exp_find_key, 307 TP_PROTO(const struct svc_expkey *key, 308 int status), 309 TP_ARGS(key, status), 310 TP_STRUCT__entry( 311 __field(int, fsidtype) 312 __array(u32, fsid, 6) 313 __string(auth_domain, key->ek_client->name) 314 __field(int, status) 315 ), 316 TP_fast_assign( 317 __entry->fsidtype = key->ek_fsidtype; 318 memcpy(__entry->fsid, key->ek_fsid, 4*6); 319 __assign_str(auth_domain, key->ek_client->name); 320 __entry->status = status; 321 ), 322 TP_printk("fsid=%x::%s domain=%s status=%d", 323 __entry->fsidtype, 324 __print_array(__entry->fsid, 6, 4), 325 __get_str(auth_domain), 326 __entry->status 327 ) 328 ); 329 330 TRACE_EVENT(nfsd_expkey_update, 331 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 332 TP_ARGS(key, exp_path), 333 TP_STRUCT__entry( 334 __field(int, fsidtype) 335 __array(u32, fsid, 6) 336 __string(auth_domain, key->ek_client->name) 337 __string(path, exp_path) 338 __field(bool, cache) 339 ), 340 TP_fast_assign( 341 __entry->fsidtype = key->ek_fsidtype; 342 memcpy(__entry->fsid, key->ek_fsid, 4*6); 343 __assign_str(auth_domain, key->ek_client->name); 344 __assign_str(path, exp_path); 345 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 346 ), 347 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 348 __entry->fsidtype, 349 __print_array(__entry->fsid, 6, 4), 350 __get_str(auth_domain), 351 __get_str(path), 352 __entry->cache ? "pos" : "neg" 353 ) 354 ); 355 356 TRACE_EVENT(nfsd_exp_get_by_name, 357 TP_PROTO(const struct svc_export *key, 358 int status), 359 TP_ARGS(key, status), 360 TP_STRUCT__entry( 361 __string(path, key->ex_path.dentry->d_name.name) 362 __string(auth_domain, key->ex_client->name) 363 __field(int, status) 364 ), 365 TP_fast_assign( 366 __assign_str(path, key->ex_path.dentry->d_name.name); 367 __assign_str(auth_domain, key->ex_client->name); 368 __entry->status = status; 369 ), 370 TP_printk("path=%s domain=%s status=%d", 371 __get_str(path), 372 __get_str(auth_domain), 373 __entry->status 374 ) 375 ); 376 377 TRACE_EVENT(nfsd_export_update, 378 TP_PROTO(const struct svc_export *key), 379 TP_ARGS(key), 380 TP_STRUCT__entry( 381 __string(path, key->ex_path.dentry->d_name.name) 382 __string(auth_domain, key->ex_client->name) 383 __field(bool, cache) 384 ), 385 TP_fast_assign( 386 __assign_str(path, key->ex_path.dentry->d_name.name); 387 __assign_str(auth_domain, key->ex_client->name); 388 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 389 ), 390 TP_printk("path=%s domain=%s cache=%s", 391 __get_str(path), 392 __get_str(auth_domain), 393 __entry->cache ? "pos" : "neg" 394 ) 395 ); 396 397 DECLARE_EVENT_CLASS(nfsd_io_class, 398 TP_PROTO(struct svc_rqst *rqstp, 399 struct svc_fh *fhp, 400 u64 offset, 401 u32 len), 402 TP_ARGS(rqstp, fhp, offset, len), 403 TP_STRUCT__entry( 404 __field(u32, xid) 405 __field(u32, fh_hash) 406 __field(u64, offset) 407 __field(u32, len) 408 ), 409 TP_fast_assign( 410 __entry->xid = be32_to_cpu(rqstp->rq_xid); 411 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 412 __entry->offset = offset; 413 __entry->len = len; 414 ), 415 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 416 __entry->xid, __entry->fh_hash, 417 __entry->offset, __entry->len) 418 ) 419 420 #define DEFINE_NFSD_IO_EVENT(name) \ 421 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 422 TP_PROTO(struct svc_rqst *rqstp, \ 423 struct svc_fh *fhp, \ 424 u64 offset, \ 425 u32 len), \ 426 TP_ARGS(rqstp, fhp, offset, len)) 427 428 DEFINE_NFSD_IO_EVENT(read_start); 429 DEFINE_NFSD_IO_EVENT(read_splice); 430 DEFINE_NFSD_IO_EVENT(read_vector); 431 DEFINE_NFSD_IO_EVENT(read_io_done); 432 DEFINE_NFSD_IO_EVENT(read_done); 433 DEFINE_NFSD_IO_EVENT(write_start); 434 DEFINE_NFSD_IO_EVENT(write_opened); 435 DEFINE_NFSD_IO_EVENT(write_io_done); 436 DEFINE_NFSD_IO_EVENT(write_done); 437 438 DECLARE_EVENT_CLASS(nfsd_err_class, 439 TP_PROTO(struct svc_rqst *rqstp, 440 struct svc_fh *fhp, 441 loff_t offset, 442 int status), 443 TP_ARGS(rqstp, fhp, offset, status), 444 TP_STRUCT__entry( 445 __field(u32, xid) 446 __field(u32, fh_hash) 447 __field(loff_t, offset) 448 __field(int, status) 449 ), 450 TP_fast_assign( 451 __entry->xid = be32_to_cpu(rqstp->rq_xid); 452 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 453 __entry->offset = offset; 454 __entry->status = status; 455 ), 456 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 457 __entry->xid, __entry->fh_hash, 458 __entry->offset, __entry->status) 459 ) 460 461 #define DEFINE_NFSD_ERR_EVENT(name) \ 462 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 463 TP_PROTO(struct svc_rqst *rqstp, \ 464 struct svc_fh *fhp, \ 465 loff_t offset, \ 466 int len), \ 467 TP_ARGS(rqstp, fhp, offset, len)) 468 469 DEFINE_NFSD_ERR_EVENT(read_err); 470 DEFINE_NFSD_ERR_EVENT(write_err); 471 472 TRACE_EVENT(nfsd_dirent, 473 TP_PROTO(struct svc_fh *fhp, 474 u64 ino, 475 const char *name, 476 int namlen), 477 TP_ARGS(fhp, ino, name, namlen), 478 TP_STRUCT__entry( 479 __field(u32, fh_hash) 480 __field(u64, ino) 481 __string_len(name, name, namlen) 482 ), 483 TP_fast_assign( 484 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 485 __entry->ino = ino; 486 __assign_str_len(name, name, namlen) 487 ), 488 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 489 __entry->fh_hash, __entry->ino, __get_str(name) 490 ) 491 ) 492 493 DECLARE_EVENT_CLASS(nfsd_copy_err_class, 494 TP_PROTO(struct svc_rqst *rqstp, 495 struct svc_fh *src_fhp, 496 loff_t src_offset, 497 struct svc_fh *dst_fhp, 498 loff_t dst_offset, 499 u64 count, 500 int status), 501 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 502 TP_STRUCT__entry( 503 __field(u32, xid) 504 __field(u32, src_fh_hash) 505 __field(loff_t, src_offset) 506 __field(u32, dst_fh_hash) 507 __field(loff_t, dst_offset) 508 __field(u64, count) 509 __field(int, status) 510 ), 511 TP_fast_assign( 512 __entry->xid = be32_to_cpu(rqstp->rq_xid); 513 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 514 __entry->src_offset = src_offset; 515 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 516 __entry->dst_offset = dst_offset; 517 __entry->count = count; 518 __entry->status = status; 519 ), 520 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 521 "dst_fh_hash=0x%08x dst_offset=%lld " 522 "count=%llu status=%d", 523 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 524 __entry->dst_fh_hash, __entry->dst_offset, 525 (unsigned long long)__entry->count, 526 __entry->status) 527 ) 528 529 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 530 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 531 TP_PROTO(struct svc_rqst *rqstp, \ 532 struct svc_fh *src_fhp, \ 533 loff_t src_offset, \ 534 struct svc_fh *dst_fhp, \ 535 loff_t dst_offset, \ 536 u64 count, \ 537 int status), \ 538 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 539 count, status)) 540 541 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 542 543 #include "state.h" 544 #include "filecache.h" 545 #include "vfs.h" 546 547 TRACE_EVENT(nfsd_delegret_wakeup, 548 TP_PROTO( 549 const struct svc_rqst *rqstp, 550 const struct inode *inode, 551 long timeo 552 ), 553 TP_ARGS(rqstp, inode, timeo), 554 TP_STRUCT__entry( 555 __field(u32, xid) 556 __field(const void *, inode) 557 __field(long, timeo) 558 ), 559 TP_fast_assign( 560 __entry->xid = be32_to_cpu(rqstp->rq_xid); 561 __entry->inode = inode; 562 __entry->timeo = timeo; 563 ), 564 TP_printk("xid=0x%08x inode=%p%s", 565 __entry->xid, __entry->inode, 566 __entry->timeo == 0 ? " (timed out)" : "" 567 ) 568 ); 569 570 DECLARE_EVENT_CLASS(nfsd_stateid_class, 571 TP_PROTO(stateid_t *stp), 572 TP_ARGS(stp), 573 TP_STRUCT__entry( 574 __field(u32, cl_boot) 575 __field(u32, cl_id) 576 __field(u32, si_id) 577 __field(u32, si_generation) 578 ), 579 TP_fast_assign( 580 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 581 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 582 __entry->si_id = stp->si_opaque.so_id; 583 __entry->si_generation = stp->si_generation; 584 ), 585 TP_printk("client %08x:%08x stateid %08x:%08x", 586 __entry->cl_boot, 587 __entry->cl_id, 588 __entry->si_id, 589 __entry->si_generation) 590 ) 591 592 #define DEFINE_STATEID_EVENT(name) \ 593 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 594 TP_PROTO(stateid_t *stp), \ 595 TP_ARGS(stp)) 596 597 DEFINE_STATEID_EVENT(layoutstate_alloc); 598 DEFINE_STATEID_EVENT(layoutstate_unhash); 599 DEFINE_STATEID_EVENT(layoutstate_free); 600 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 601 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 602 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 603 DEFINE_STATEID_EVENT(layout_recall); 604 DEFINE_STATEID_EVENT(layout_recall_done); 605 DEFINE_STATEID_EVENT(layout_recall_fail); 606 DEFINE_STATEID_EVENT(layout_recall_release); 607 608 DEFINE_STATEID_EVENT(open); 609 DEFINE_STATEID_EVENT(deleg_read); 610 DEFINE_STATEID_EVENT(deleg_return); 611 DEFINE_STATEID_EVENT(deleg_recall); 612 613 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 614 TP_PROTO(u32 seqid, const stateid_t *stp), 615 TP_ARGS(seqid, stp), 616 TP_STRUCT__entry( 617 __field(u32, seqid) 618 __field(u32, cl_boot) 619 __field(u32, cl_id) 620 __field(u32, si_id) 621 __field(u32, si_generation) 622 ), 623 TP_fast_assign( 624 __entry->seqid = seqid; 625 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 626 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 627 __entry->si_id = stp->si_opaque.so_id; 628 __entry->si_generation = stp->si_generation; 629 ), 630 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 631 __entry->seqid, __entry->cl_boot, __entry->cl_id, 632 __entry->si_id, __entry->si_generation) 633 ) 634 635 #define DEFINE_STATESEQID_EVENT(name) \ 636 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 637 TP_PROTO(u32 seqid, const stateid_t *stp), \ 638 TP_ARGS(seqid, stp)) 639 640 DEFINE_STATESEQID_EVENT(preprocess); 641 DEFINE_STATESEQID_EVENT(open_confirm); 642 643 TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 644 TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 645 TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 646 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 647 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 648 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 649 TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 650 651 #define show_stid_type(x) \ 652 __print_flags(x, "|", \ 653 { NFS4_OPEN_STID, "OPEN" }, \ 654 { NFS4_LOCK_STID, "LOCK" }, \ 655 { NFS4_DELEG_STID, "DELEG" }, \ 656 { NFS4_CLOSED_STID, "CLOSED" }, \ 657 { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 658 { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 659 { NFS4_LAYOUT_STID, "LAYOUT" }) 660 661 DECLARE_EVENT_CLASS(nfsd_stid_class, 662 TP_PROTO( 663 const struct nfs4_stid *stid 664 ), 665 TP_ARGS(stid), 666 TP_STRUCT__entry( 667 __field(unsigned long, sc_type) 668 __field(int, sc_count) 669 __field(u32, cl_boot) 670 __field(u32, cl_id) 671 __field(u32, si_id) 672 __field(u32, si_generation) 673 ), 674 TP_fast_assign( 675 const stateid_t *stp = &stid->sc_stateid; 676 677 __entry->sc_type = stid->sc_type; 678 __entry->sc_count = refcount_read(&stid->sc_count); 679 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 680 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 681 __entry->si_id = stp->si_opaque.so_id; 682 __entry->si_generation = stp->si_generation; 683 ), 684 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 685 __entry->cl_boot, __entry->cl_id, 686 __entry->si_id, __entry->si_generation, 687 __entry->sc_count, show_stid_type(__entry->sc_type) 688 ) 689 ); 690 691 #define DEFINE_STID_EVENT(name) \ 692 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 693 TP_PROTO(const struct nfs4_stid *stid), \ 694 TP_ARGS(stid)) 695 696 DEFINE_STID_EVENT(revoke); 697 698 DECLARE_EVENT_CLASS(nfsd_clientid_class, 699 TP_PROTO(const clientid_t *clid), 700 TP_ARGS(clid), 701 TP_STRUCT__entry( 702 __field(u32, cl_boot) 703 __field(u32, cl_id) 704 ), 705 TP_fast_assign( 706 __entry->cl_boot = clid->cl_boot; 707 __entry->cl_id = clid->cl_id; 708 ), 709 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 710 ) 711 712 #define DEFINE_CLIENTID_EVENT(name) \ 713 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 714 TP_PROTO(const clientid_t *clid), \ 715 TP_ARGS(clid)) 716 717 DEFINE_CLIENTID_EVENT(expire_unconf); 718 DEFINE_CLIENTID_EVENT(reclaim_complete); 719 DEFINE_CLIENTID_EVENT(confirmed); 720 DEFINE_CLIENTID_EVENT(destroyed); 721 DEFINE_CLIENTID_EVENT(admin_expired); 722 DEFINE_CLIENTID_EVENT(replaced); 723 DEFINE_CLIENTID_EVENT(purged); 724 DEFINE_CLIENTID_EVENT(renew); 725 DEFINE_CLIENTID_EVENT(stale); 726 727 DECLARE_EVENT_CLASS(nfsd_net_class, 728 TP_PROTO(const struct nfsd_net *nn), 729 TP_ARGS(nn), 730 TP_STRUCT__entry( 731 __field(unsigned long long, boot_time) 732 ), 733 TP_fast_assign( 734 __entry->boot_time = nn->boot_time; 735 ), 736 TP_printk("boot_time=%16llx", __entry->boot_time) 737 ) 738 739 #define DEFINE_NET_EVENT(name) \ 740 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 741 TP_PROTO(const struct nfsd_net *nn), \ 742 TP_ARGS(nn)) 743 744 DEFINE_NET_EVENT(grace_start); 745 DEFINE_NET_EVENT(grace_complete); 746 747 TRACE_EVENT(nfsd_writeverf_reset, 748 TP_PROTO( 749 const struct nfsd_net *nn, 750 const struct svc_rqst *rqstp, 751 int error 752 ), 753 TP_ARGS(nn, rqstp, error), 754 TP_STRUCT__entry( 755 __field(unsigned long long, boot_time) 756 __field(u32, xid) 757 __field(int, error) 758 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 759 ), 760 TP_fast_assign( 761 __entry->boot_time = nn->boot_time; 762 __entry->xid = be32_to_cpu(rqstp->rq_xid); 763 __entry->error = error; 764 765 /* avoid seqlock inside TP_fast_assign */ 766 memcpy(__entry->verifier, nn->writeverf, 767 NFS4_VERIFIER_SIZE); 768 ), 769 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 770 __entry->boot_time, __entry->xid, __entry->error, 771 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 772 ) 773 ); 774 775 TRACE_EVENT(nfsd_clid_cred_mismatch, 776 TP_PROTO( 777 const struct nfs4_client *clp, 778 const struct svc_rqst *rqstp 779 ), 780 TP_ARGS(clp, rqstp), 781 TP_STRUCT__entry( 782 __field(u32, cl_boot) 783 __field(u32, cl_id) 784 __field(unsigned long, cl_flavor) 785 __field(unsigned long, new_flavor) 786 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 787 ), 788 TP_fast_assign( 789 __entry->cl_boot = clp->cl_clientid.cl_boot; 790 __entry->cl_id = clp->cl_clientid.cl_id; 791 __entry->cl_flavor = clp->cl_cred.cr_flavor; 792 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 793 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 794 rqstp->rq_xprt->xpt_remotelen); 795 ), 796 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 797 __entry->cl_boot, __entry->cl_id, 798 show_nfsd_authflavor(__entry->cl_flavor), 799 show_nfsd_authflavor(__entry->new_flavor), 800 __get_sockaddr(addr) 801 ) 802 ) 803 804 TRACE_EVENT(nfsd_clid_verf_mismatch, 805 TP_PROTO( 806 const struct nfs4_client *clp, 807 const struct svc_rqst *rqstp, 808 const nfs4_verifier *verf 809 ), 810 TP_ARGS(clp, rqstp, verf), 811 TP_STRUCT__entry( 812 __field(u32, cl_boot) 813 __field(u32, cl_id) 814 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 815 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 816 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 817 ), 818 TP_fast_assign( 819 __entry->cl_boot = clp->cl_clientid.cl_boot; 820 __entry->cl_id = clp->cl_clientid.cl_id; 821 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 822 NFS4_VERIFIER_SIZE); 823 memcpy(__entry->new_verifier, (void *)verf, 824 NFS4_VERIFIER_SIZE); 825 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 826 rqstp->rq_xprt->xpt_remotelen); 827 ), 828 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 829 __entry->cl_boot, __entry->cl_id, 830 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 831 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 832 __get_sockaddr(addr) 833 ) 834 ); 835 836 DECLARE_EVENT_CLASS(nfsd_clid_class, 837 TP_PROTO(const struct nfs4_client *clp), 838 TP_ARGS(clp), 839 TP_STRUCT__entry( 840 __field(u32, cl_boot) 841 __field(u32, cl_id) 842 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 843 __field(unsigned long, flavor) 844 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 845 __string_len(name, name, clp->cl_name.len) 846 ), 847 TP_fast_assign( 848 __entry->cl_boot = clp->cl_clientid.cl_boot; 849 __entry->cl_id = clp->cl_clientid.cl_id; 850 memcpy(__entry->addr, &clp->cl_addr, 851 sizeof(struct sockaddr_in6)); 852 __entry->flavor = clp->cl_cred.cr_flavor; 853 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 854 NFS4_VERIFIER_SIZE); 855 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 856 ), 857 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 858 __entry->addr, __get_str(name), 859 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 860 show_nfsd_authflavor(__entry->flavor), 861 __entry->cl_boot, __entry->cl_id) 862 ); 863 864 #define DEFINE_CLID_EVENT(name) \ 865 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 866 TP_PROTO(const struct nfs4_client *clp), \ 867 TP_ARGS(clp)) 868 869 DEFINE_CLID_EVENT(fresh); 870 DEFINE_CLID_EVENT(confirmed_r); 871 872 /* 873 * from fs/nfsd/filecache.h 874 */ 875 #define show_nf_flags(val) \ 876 __print_flags(val, "|", \ 877 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 878 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 879 { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}, \ 880 { 1 << NFSD_FILE_GC, "GC"}) 881 882 DECLARE_EVENT_CLASS(nfsd_file_class, 883 TP_PROTO(struct nfsd_file *nf), 884 TP_ARGS(nf), 885 TP_STRUCT__entry( 886 __field(void *, nf_inode) 887 __field(int, nf_ref) 888 __field(unsigned long, nf_flags) 889 __field(unsigned char, nf_may) 890 __field(struct file *, nf_file) 891 ), 892 TP_fast_assign( 893 __entry->nf_inode = nf->nf_inode; 894 __entry->nf_ref = refcount_read(&nf->nf_ref); 895 __entry->nf_flags = nf->nf_flags; 896 __entry->nf_may = nf->nf_may; 897 __entry->nf_file = nf->nf_file; 898 ), 899 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 900 __entry->nf_inode, 901 __entry->nf_ref, 902 show_nf_flags(__entry->nf_flags), 903 show_nfsd_may_flags(__entry->nf_may), 904 __entry->nf_file) 905 ) 906 907 #define DEFINE_NFSD_FILE_EVENT(name) \ 908 DEFINE_EVENT(nfsd_file_class, name, \ 909 TP_PROTO(struct nfsd_file *nf), \ 910 TP_ARGS(nf)) 911 912 DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 913 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 914 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 915 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 916 917 TRACE_EVENT(nfsd_file_alloc, 918 TP_PROTO( 919 const struct nfsd_file *nf 920 ), 921 TP_ARGS(nf), 922 TP_STRUCT__entry( 923 __field(const void *, nf_inode) 924 __field(unsigned long, nf_flags) 925 __field(unsigned long, nf_may) 926 __field(unsigned int, nf_ref) 927 ), 928 TP_fast_assign( 929 __entry->nf_inode = nf->nf_inode; 930 __entry->nf_flags = nf->nf_flags; 931 __entry->nf_ref = refcount_read(&nf->nf_ref); 932 __entry->nf_may = nf->nf_may; 933 ), 934 TP_printk("inode=%p ref=%u flags=%s may=%s", 935 __entry->nf_inode, __entry->nf_ref, 936 show_nf_flags(__entry->nf_flags), 937 show_nfsd_may_flags(__entry->nf_may) 938 ) 939 ); 940 941 TRACE_EVENT(nfsd_file_acquire, 942 TP_PROTO( 943 const struct svc_rqst *rqstp, 944 const struct inode *inode, 945 unsigned int may_flags, 946 const struct nfsd_file *nf, 947 __be32 status 948 ), 949 950 TP_ARGS(rqstp, inode, may_flags, nf, status), 951 952 TP_STRUCT__entry( 953 __field(u32, xid) 954 __field(const void *, inode) 955 __field(unsigned long, may_flags) 956 __field(unsigned int, nf_ref) 957 __field(unsigned long, nf_flags) 958 __field(unsigned long, nf_may) 959 __field(const void *, nf_file) 960 __field(u32, status) 961 ), 962 963 TP_fast_assign( 964 __entry->xid = be32_to_cpu(rqstp->rq_xid); 965 __entry->inode = inode; 966 __entry->may_flags = may_flags; 967 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 968 __entry->nf_flags = nf ? nf->nf_flags : 0; 969 __entry->nf_may = nf ? nf->nf_may : 0; 970 __entry->nf_file = nf ? nf->nf_file : NULL; 971 __entry->status = be32_to_cpu(status); 972 ), 973 974 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 975 __entry->xid, __entry->inode, 976 show_nfsd_may_flags(__entry->may_flags), 977 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 978 show_nfsd_may_flags(__entry->nf_may), 979 __entry->nf_file, __entry->status 980 ) 981 ); 982 983 TRACE_EVENT(nfsd_file_create, 984 TP_PROTO( 985 const struct svc_rqst *rqstp, 986 unsigned int may_flags, 987 const struct nfsd_file *nf 988 ), 989 990 TP_ARGS(rqstp, may_flags, nf), 991 992 TP_STRUCT__entry( 993 __field(const void *, nf_inode) 994 __field(const void *, nf_file) 995 __field(unsigned long, may_flags) 996 __field(unsigned long, nf_flags) 997 __field(unsigned long, nf_may) 998 __field(unsigned int, nf_ref) 999 __field(u32, xid) 1000 ), 1001 1002 TP_fast_assign( 1003 __entry->nf_inode = nf->nf_inode; 1004 __entry->nf_file = nf->nf_file; 1005 __entry->may_flags = may_flags; 1006 __entry->nf_flags = nf->nf_flags; 1007 __entry->nf_may = nf->nf_may; 1008 __entry->nf_ref = refcount_read(&nf->nf_ref); 1009 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1010 ), 1011 1012 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1013 __entry->xid, __entry->nf_inode, 1014 show_nfsd_may_flags(__entry->may_flags), 1015 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1016 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1017 ) 1018 ); 1019 1020 TRACE_EVENT(nfsd_file_insert_err, 1021 TP_PROTO( 1022 const struct svc_rqst *rqstp, 1023 const struct inode *inode, 1024 unsigned int may_flags, 1025 long error 1026 ), 1027 TP_ARGS(rqstp, inode, may_flags, error), 1028 TP_STRUCT__entry( 1029 __field(u32, xid) 1030 __field(const void *, inode) 1031 __field(unsigned long, may_flags) 1032 __field(long, error) 1033 ), 1034 TP_fast_assign( 1035 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1036 __entry->inode = inode; 1037 __entry->may_flags = may_flags; 1038 __entry->error = error; 1039 ), 1040 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1041 __entry->xid, __entry->inode, 1042 show_nfsd_may_flags(__entry->may_flags), 1043 __entry->error 1044 ) 1045 ); 1046 1047 TRACE_EVENT(nfsd_file_cons_err, 1048 TP_PROTO( 1049 const struct svc_rqst *rqstp, 1050 const struct inode *inode, 1051 unsigned int may_flags, 1052 const struct nfsd_file *nf 1053 ), 1054 TP_ARGS(rqstp, inode, may_flags, nf), 1055 TP_STRUCT__entry( 1056 __field(u32, xid) 1057 __field(const void *, inode) 1058 __field(unsigned long, may_flags) 1059 __field(unsigned int, nf_ref) 1060 __field(unsigned long, nf_flags) 1061 __field(unsigned long, nf_may) 1062 __field(const void *, nf_file) 1063 ), 1064 TP_fast_assign( 1065 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1066 __entry->inode = inode; 1067 __entry->may_flags = may_flags; 1068 __entry->nf_ref = refcount_read(&nf->nf_ref); 1069 __entry->nf_flags = nf->nf_flags; 1070 __entry->nf_may = nf->nf_may; 1071 __entry->nf_file = nf->nf_file; 1072 ), 1073 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1074 __entry->xid, __entry->inode, 1075 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1076 show_nf_flags(__entry->nf_flags), 1077 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1078 ) 1079 ); 1080 1081 TRACE_EVENT(nfsd_file_open, 1082 TP_PROTO(struct nfsd_file *nf, __be32 status), 1083 TP_ARGS(nf, status), 1084 TP_STRUCT__entry( 1085 __field(void *, nf_inode) /* cannot be dereferenced */ 1086 __field(int, nf_ref) 1087 __field(unsigned long, nf_flags) 1088 __field(unsigned long, nf_may) 1089 __field(void *, nf_file) /* cannot be dereferenced */ 1090 ), 1091 TP_fast_assign( 1092 __entry->nf_inode = nf->nf_inode; 1093 __entry->nf_ref = refcount_read(&nf->nf_ref); 1094 __entry->nf_flags = nf->nf_flags; 1095 __entry->nf_may = nf->nf_may; 1096 __entry->nf_file = nf->nf_file; 1097 ), 1098 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1099 __entry->nf_inode, 1100 __entry->nf_ref, 1101 show_nf_flags(__entry->nf_flags), 1102 show_nfsd_may_flags(__entry->nf_may), 1103 __entry->nf_file) 1104 ) 1105 1106 DECLARE_EVENT_CLASS(nfsd_file_search_class, 1107 TP_PROTO( 1108 const struct inode *inode, 1109 unsigned int count 1110 ), 1111 TP_ARGS(inode, count), 1112 TP_STRUCT__entry( 1113 __field(const struct inode *, inode) 1114 __field(unsigned int, count) 1115 ), 1116 TP_fast_assign( 1117 __entry->inode = inode; 1118 __entry->count = count; 1119 ), 1120 TP_printk("inode=%p count=%u", 1121 __entry->inode, __entry->count) 1122 ); 1123 1124 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 1125 DEFINE_EVENT(nfsd_file_search_class, name, \ 1126 TP_PROTO( \ 1127 const struct inode *inode, \ 1128 unsigned int count \ 1129 ), \ 1130 TP_ARGS(inode, count)) 1131 1132 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 1133 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 1134 1135 TRACE_EVENT(nfsd_file_is_cached, 1136 TP_PROTO( 1137 const struct inode *inode, 1138 int found 1139 ), 1140 TP_ARGS(inode, found), 1141 TP_STRUCT__entry( 1142 __field(const struct inode *, inode) 1143 __field(int, found) 1144 ), 1145 TP_fast_assign( 1146 __entry->inode = inode; 1147 __entry->found = found; 1148 ), 1149 TP_printk("inode=%p is %scached", 1150 __entry->inode, 1151 __entry->found ? "" : "not " 1152 ) 1153 ); 1154 1155 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1156 TP_PROTO(struct inode *inode, u32 mask), 1157 TP_ARGS(inode, mask), 1158 TP_STRUCT__entry( 1159 __field(struct inode *, inode) 1160 __field(unsigned int, nlink) 1161 __field(umode_t, mode) 1162 __field(u32, mask) 1163 ), 1164 TP_fast_assign( 1165 __entry->inode = inode; 1166 __entry->nlink = inode->i_nlink; 1167 __entry->mode = inode->i_mode; 1168 __entry->mask = mask; 1169 ), 1170 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1171 __entry->nlink, __entry->mode, __entry->mask) 1172 ); 1173 1174 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1175 TP_PROTO( 1176 const struct nfsd_file *nf 1177 ), 1178 TP_ARGS(nf), 1179 TP_STRUCT__entry( 1180 __field(void *, nf_inode) 1181 __field(void *, nf_file) 1182 __field(int, nf_ref) 1183 __field(unsigned long, nf_flags) 1184 ), 1185 TP_fast_assign( 1186 __entry->nf_inode = nf->nf_inode; 1187 __entry->nf_file = nf->nf_file; 1188 __entry->nf_ref = refcount_read(&nf->nf_ref); 1189 __entry->nf_flags = nf->nf_flags; 1190 ), 1191 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1192 __entry->nf_inode, __entry->nf_ref, 1193 show_nf_flags(__entry->nf_flags), 1194 __entry->nf_file 1195 ) 1196 ); 1197 1198 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1199 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1200 TP_PROTO( \ 1201 const struct nfsd_file *nf \ 1202 ), \ 1203 TP_ARGS(nf)) 1204 1205 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1206 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1207 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1208 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1209 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1210 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1211 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1212 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed); 1213 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1214 1215 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1216 TP_PROTO( 1217 unsigned long removed, 1218 unsigned long remaining 1219 ), 1220 TP_ARGS(removed, remaining), 1221 TP_STRUCT__entry( 1222 __field(unsigned long, removed) 1223 __field(unsigned long, remaining) 1224 ), 1225 TP_fast_assign( 1226 __entry->removed = removed; 1227 __entry->remaining = remaining; 1228 ), 1229 TP_printk("%lu entries removed, %lu remaining", 1230 __entry->removed, __entry->remaining) 1231 ); 1232 1233 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1234 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1235 TP_PROTO( \ 1236 unsigned long removed, \ 1237 unsigned long remaining \ 1238 ), \ 1239 TP_ARGS(removed, remaining)) 1240 1241 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1242 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1243 1244 TRACE_EVENT(nfsd_file_fsync, 1245 TP_PROTO( 1246 const struct nfsd_file *nf, 1247 int ret 1248 ), 1249 TP_ARGS(nf, ret), 1250 TP_STRUCT__entry( 1251 __field(void *, nf_inode) 1252 __field(int, nf_ref) 1253 __field(int, ret) 1254 __field(unsigned long, nf_flags) 1255 __field(unsigned char, nf_may) 1256 __field(struct file *, nf_file) 1257 ), 1258 TP_fast_assign( 1259 __entry->nf_inode = nf->nf_inode; 1260 __entry->nf_ref = refcount_read(&nf->nf_ref); 1261 __entry->ret = ret; 1262 __entry->nf_flags = nf->nf_flags; 1263 __entry->nf_may = nf->nf_may; 1264 __entry->nf_file = nf->nf_file; 1265 ), 1266 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p ret=%d", 1267 __entry->nf_inode, 1268 __entry->nf_ref, 1269 show_nf_flags(__entry->nf_flags), 1270 show_nfsd_may_flags(__entry->nf_may), 1271 __entry->nf_file, __entry->ret 1272 ) 1273 ); 1274 1275 #include "cache.h" 1276 1277 TRACE_DEFINE_ENUM(RC_DROPIT); 1278 TRACE_DEFINE_ENUM(RC_REPLY); 1279 TRACE_DEFINE_ENUM(RC_DOIT); 1280 1281 #define show_drc_retval(x) \ 1282 __print_symbolic(x, \ 1283 { RC_DROPIT, "DROPIT" }, \ 1284 { RC_REPLY, "REPLY" }, \ 1285 { RC_DOIT, "DOIT" }) 1286 1287 TRACE_EVENT(nfsd_drc_found, 1288 TP_PROTO( 1289 const struct nfsd_net *nn, 1290 const struct svc_rqst *rqstp, 1291 int result 1292 ), 1293 TP_ARGS(nn, rqstp, result), 1294 TP_STRUCT__entry( 1295 __field(unsigned long long, boot_time) 1296 __field(unsigned long, result) 1297 __field(u32, xid) 1298 ), 1299 TP_fast_assign( 1300 __entry->boot_time = nn->boot_time; 1301 __entry->result = result; 1302 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1303 ), 1304 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1305 __entry->boot_time, __entry->xid, 1306 show_drc_retval(__entry->result)) 1307 1308 ); 1309 1310 TRACE_EVENT(nfsd_drc_mismatch, 1311 TP_PROTO( 1312 const struct nfsd_net *nn, 1313 const struct svc_cacherep *key, 1314 const struct svc_cacherep *rp 1315 ), 1316 TP_ARGS(nn, key, rp), 1317 TP_STRUCT__entry( 1318 __field(unsigned long long, boot_time) 1319 __field(u32, xid) 1320 __field(u32, cached) 1321 __field(u32, ingress) 1322 ), 1323 TP_fast_assign( 1324 __entry->boot_time = nn->boot_time; 1325 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1326 __entry->cached = (__force u32)key->c_key.k_csum; 1327 __entry->ingress = (__force u32)rp->c_key.k_csum; 1328 ), 1329 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1330 __entry->boot_time, __entry->xid, __entry->cached, 1331 __entry->ingress) 1332 ); 1333 1334 TRACE_EVENT(nfsd_cb_args, 1335 TP_PROTO( 1336 const struct nfs4_client *clp, 1337 const struct nfs4_cb_conn *conn 1338 ), 1339 TP_ARGS(clp, conn), 1340 TP_STRUCT__entry( 1341 __field(u32, cl_boot) 1342 __field(u32, cl_id) 1343 __field(u32, prog) 1344 __field(u32, ident) 1345 __sockaddr(addr, conn->cb_addrlen) 1346 ), 1347 TP_fast_assign( 1348 __entry->cl_boot = clp->cl_clientid.cl_boot; 1349 __entry->cl_id = clp->cl_clientid.cl_id; 1350 __entry->prog = conn->cb_prog; 1351 __entry->ident = conn->cb_ident; 1352 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1353 ), 1354 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1355 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1356 __entry->prog, __entry->ident) 1357 ); 1358 1359 TRACE_EVENT(nfsd_cb_nodelegs, 1360 TP_PROTO(const struct nfs4_client *clp), 1361 TP_ARGS(clp), 1362 TP_STRUCT__entry( 1363 __field(u32, cl_boot) 1364 __field(u32, cl_id) 1365 ), 1366 TP_fast_assign( 1367 __entry->cl_boot = clp->cl_clientid.cl_boot; 1368 __entry->cl_id = clp->cl_clientid.cl_id; 1369 ), 1370 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1371 ) 1372 1373 #define show_cb_state(val) \ 1374 __print_symbolic(val, \ 1375 { NFSD4_CB_UP, "UP" }, \ 1376 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1377 { NFSD4_CB_DOWN, "DOWN" }, \ 1378 { NFSD4_CB_FAULT, "FAULT"}) 1379 1380 DECLARE_EVENT_CLASS(nfsd_cb_class, 1381 TP_PROTO(const struct nfs4_client *clp), 1382 TP_ARGS(clp), 1383 TP_STRUCT__entry( 1384 __field(unsigned long, state) 1385 __field(u32, cl_boot) 1386 __field(u32, cl_id) 1387 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1388 ), 1389 TP_fast_assign( 1390 __entry->state = clp->cl_cb_state; 1391 __entry->cl_boot = clp->cl_clientid.cl_boot; 1392 __entry->cl_id = clp->cl_clientid.cl_id; 1393 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1394 clp->cl_cb_conn.cb_addrlen) 1395 ), 1396 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1397 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1398 show_cb_state(__entry->state)) 1399 ); 1400 1401 #define DEFINE_NFSD_CB_EVENT(name) \ 1402 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1403 TP_PROTO(const struct nfs4_client *clp), \ 1404 TP_ARGS(clp)) 1405 1406 DEFINE_NFSD_CB_EVENT(state); 1407 DEFINE_NFSD_CB_EVENT(probe); 1408 DEFINE_NFSD_CB_EVENT(lost); 1409 DEFINE_NFSD_CB_EVENT(shutdown); 1410 1411 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1412 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1413 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1414 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1415 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1416 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1417 1418 #define show_nfsd_authflavor(val) \ 1419 __print_symbolic(val, \ 1420 { RPC_AUTH_NULL, "none" }, \ 1421 { RPC_AUTH_UNIX, "sys" }, \ 1422 { RPC_AUTH_GSS, "gss" }, \ 1423 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1424 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1425 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1426 1427 TRACE_EVENT(nfsd_cb_setup, 1428 TP_PROTO(const struct nfs4_client *clp, 1429 const char *netid, 1430 rpc_authflavor_t authflavor 1431 ), 1432 TP_ARGS(clp, netid, authflavor), 1433 TP_STRUCT__entry( 1434 __field(u32, cl_boot) 1435 __field(u32, cl_id) 1436 __field(unsigned long, authflavor) 1437 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1438 __array(unsigned char, netid, 8) 1439 ), 1440 TP_fast_assign( 1441 __entry->cl_boot = clp->cl_clientid.cl_boot; 1442 __entry->cl_id = clp->cl_clientid.cl_id; 1443 strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 1444 __entry->authflavor = authflavor; 1445 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1446 clp->cl_cb_conn.cb_addrlen) 1447 ), 1448 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1449 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1450 __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 1451 ); 1452 1453 TRACE_EVENT(nfsd_cb_setup_err, 1454 TP_PROTO( 1455 const struct nfs4_client *clp, 1456 long error 1457 ), 1458 TP_ARGS(clp, error), 1459 TP_STRUCT__entry( 1460 __field(long, error) 1461 __field(u32, cl_boot) 1462 __field(u32, cl_id) 1463 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1464 ), 1465 TP_fast_assign( 1466 __entry->error = error; 1467 __entry->cl_boot = clp->cl_clientid.cl_boot; 1468 __entry->cl_id = clp->cl_clientid.cl_id; 1469 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1470 clp->cl_cb_conn.cb_addrlen) 1471 ), 1472 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1473 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1474 __entry->error) 1475 ); 1476 1477 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1478 TP_PROTO( 1479 const struct nfs4_stid *stid 1480 ), 1481 TP_ARGS(stid), 1482 TP_CONDITION(stid->sc_client), 1483 TP_STRUCT__entry( 1484 __field(u32, cl_boot) 1485 __field(u32, cl_id) 1486 __field(u32, si_id) 1487 __field(u32, si_generation) 1488 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1489 ), 1490 TP_fast_assign( 1491 const stateid_t *stp = &stid->sc_stateid; 1492 const struct nfs4_client *clp = stid->sc_client; 1493 1494 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1495 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1496 __entry->si_id = stp->si_opaque.so_id; 1497 __entry->si_generation = stp->si_generation; 1498 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1499 clp->cl_cb_conn.cb_addrlen) 1500 ), 1501 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1502 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1503 __entry->si_id, __entry->si_generation) 1504 ); 1505 1506 TRACE_EVENT(nfsd_cb_notify_lock, 1507 TP_PROTO( 1508 const struct nfs4_lockowner *lo, 1509 const struct nfsd4_blocked_lock *nbl 1510 ), 1511 TP_ARGS(lo, nbl), 1512 TP_STRUCT__entry( 1513 __field(u32, cl_boot) 1514 __field(u32, cl_id) 1515 __field(u32, fh_hash) 1516 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1517 ), 1518 TP_fast_assign( 1519 const struct nfs4_client *clp = lo->lo_owner.so_client; 1520 1521 __entry->cl_boot = clp->cl_clientid.cl_boot; 1522 __entry->cl_id = clp->cl_clientid.cl_id; 1523 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1524 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1525 clp->cl_cb_conn.cb_addrlen) 1526 ), 1527 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1528 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1529 __entry->fh_hash) 1530 ); 1531 1532 TRACE_EVENT(nfsd_cb_offload, 1533 TP_PROTO( 1534 const struct nfs4_client *clp, 1535 const stateid_t *stp, 1536 const struct knfsd_fh *fh, 1537 u64 count, 1538 __be32 status 1539 ), 1540 TP_ARGS(clp, stp, fh, count, status), 1541 TP_STRUCT__entry( 1542 __field(u32, cl_boot) 1543 __field(u32, cl_id) 1544 __field(u32, si_id) 1545 __field(u32, si_generation) 1546 __field(u32, fh_hash) 1547 __field(int, status) 1548 __field(u64, count) 1549 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1550 ), 1551 TP_fast_assign( 1552 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1553 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1554 __entry->si_id = stp->si_opaque.so_id; 1555 __entry->si_generation = stp->si_generation; 1556 __entry->fh_hash = knfsd_fh_hash(fh); 1557 __entry->status = be32_to_cpu(status); 1558 __entry->count = count; 1559 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1560 clp->cl_cb_conn.cb_addrlen) 1561 ), 1562 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1563 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1564 __entry->si_id, __entry->si_generation, 1565 __entry->fh_hash, __entry->count, __entry->status) 1566 ); 1567 1568 TRACE_EVENT(nfsd_cb_recall_any, 1569 TP_PROTO( 1570 const struct nfsd4_cb_recall_any *ra 1571 ), 1572 TP_ARGS(ra), 1573 TP_STRUCT__entry( 1574 __field(u32, cl_boot) 1575 __field(u32, cl_id) 1576 __field(u32, keep) 1577 __field(unsigned long, bmval0) 1578 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1579 ), 1580 TP_fast_assign( 1581 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1582 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1583 __entry->keep = ra->ra_keep; 1584 __entry->bmval0 = ra->ra_bmval[0]; 1585 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1586 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1587 ), 1588 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1589 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1590 __entry->keep, show_rca_mask(__entry->bmval0) 1591 ) 1592 ); 1593 1594 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1595 TP_PROTO( 1596 const stateid_t *stp, 1597 const struct rpc_task *task 1598 ), 1599 TP_ARGS(stp, task), 1600 TP_STRUCT__entry( 1601 __field(u32, cl_boot) 1602 __field(u32, cl_id) 1603 __field(u32, si_id) 1604 __field(u32, si_generation) 1605 __field(int, status) 1606 ), 1607 TP_fast_assign( 1608 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1609 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1610 __entry->si_id = stp->si_opaque.so_id; 1611 __entry->si_generation = stp->si_generation; 1612 __entry->status = task->tk_status; 1613 ), 1614 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1615 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1616 __entry->si_generation, __entry->status 1617 ) 1618 ); 1619 1620 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1621 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1622 TP_PROTO( \ 1623 const stateid_t *stp, \ 1624 const struct rpc_task *task \ 1625 ), \ 1626 TP_ARGS(stp, task)) 1627 1628 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1629 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1630 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1631 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1632 1633 TRACE_EVENT(nfsd_cb_recall_any_done, 1634 TP_PROTO( 1635 const struct nfsd4_callback *cb, 1636 const struct rpc_task *task 1637 ), 1638 TP_ARGS(cb, task), 1639 TP_STRUCT__entry( 1640 __field(u32, cl_boot) 1641 __field(u32, cl_id) 1642 __field(int, status) 1643 ), 1644 TP_fast_assign( 1645 __entry->status = task->tk_status; 1646 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1647 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1648 ), 1649 TP_printk("client %08x:%08x status=%d", 1650 __entry->cl_boot, __entry->cl_id, __entry->status 1651 ) 1652 ); 1653 1654 #endif /* _NFSD_TRACE_H */ 1655 1656 #undef TRACE_INCLUDE_PATH 1657 #define TRACE_INCLUDE_PATH . 1658 #define TRACE_INCLUDE_FILE trace 1659 #include <trace/define_trace.h> 1660