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_closing); 916 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 917 918 TRACE_EVENT(nfsd_file_alloc, 919 TP_PROTO( 920 const struct nfsd_file *nf 921 ), 922 TP_ARGS(nf), 923 TP_STRUCT__entry( 924 __field(const void *, nf_inode) 925 __field(unsigned long, nf_flags) 926 __field(unsigned long, nf_may) 927 __field(unsigned int, nf_ref) 928 ), 929 TP_fast_assign( 930 __entry->nf_inode = nf->nf_inode; 931 __entry->nf_flags = nf->nf_flags; 932 __entry->nf_ref = refcount_read(&nf->nf_ref); 933 __entry->nf_may = nf->nf_may; 934 ), 935 TP_printk("inode=%p ref=%u flags=%s may=%s", 936 __entry->nf_inode, __entry->nf_ref, 937 show_nf_flags(__entry->nf_flags), 938 show_nfsd_may_flags(__entry->nf_may) 939 ) 940 ); 941 942 TRACE_EVENT(nfsd_file_acquire, 943 TP_PROTO( 944 const struct svc_rqst *rqstp, 945 const struct inode *inode, 946 unsigned int may_flags, 947 const struct nfsd_file *nf, 948 __be32 status 949 ), 950 951 TP_ARGS(rqstp, inode, may_flags, nf, status), 952 953 TP_STRUCT__entry( 954 __field(u32, xid) 955 __field(const void *, inode) 956 __field(unsigned long, may_flags) 957 __field(unsigned int, nf_ref) 958 __field(unsigned long, nf_flags) 959 __field(unsigned long, nf_may) 960 __field(const void *, nf_file) 961 __field(u32, status) 962 ), 963 964 TP_fast_assign( 965 __entry->xid = be32_to_cpu(rqstp->rq_xid); 966 __entry->inode = inode; 967 __entry->may_flags = may_flags; 968 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 969 __entry->nf_flags = nf ? nf->nf_flags : 0; 970 __entry->nf_may = nf ? nf->nf_may : 0; 971 __entry->nf_file = nf ? nf->nf_file : NULL; 972 __entry->status = be32_to_cpu(status); 973 ), 974 975 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 976 __entry->xid, __entry->inode, 977 show_nfsd_may_flags(__entry->may_flags), 978 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 979 show_nfsd_may_flags(__entry->nf_may), 980 __entry->nf_file, __entry->status 981 ) 982 ); 983 984 TRACE_EVENT(nfsd_file_insert_err, 985 TP_PROTO( 986 const struct svc_rqst *rqstp, 987 const struct inode *inode, 988 unsigned int may_flags, 989 long error 990 ), 991 TP_ARGS(rqstp, inode, may_flags, error), 992 TP_STRUCT__entry( 993 __field(u32, xid) 994 __field(const void *, inode) 995 __field(unsigned long, may_flags) 996 __field(long, error) 997 ), 998 TP_fast_assign( 999 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1000 __entry->inode = inode; 1001 __entry->may_flags = may_flags; 1002 __entry->error = error; 1003 ), 1004 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1005 __entry->xid, __entry->inode, 1006 show_nfsd_may_flags(__entry->may_flags), 1007 __entry->error 1008 ) 1009 ); 1010 1011 TRACE_EVENT(nfsd_file_cons_err, 1012 TP_PROTO( 1013 const struct svc_rqst *rqstp, 1014 const struct inode *inode, 1015 unsigned int may_flags, 1016 const struct nfsd_file *nf 1017 ), 1018 TP_ARGS(rqstp, inode, may_flags, nf), 1019 TP_STRUCT__entry( 1020 __field(u32, xid) 1021 __field(const void *, inode) 1022 __field(unsigned long, may_flags) 1023 __field(unsigned int, nf_ref) 1024 __field(unsigned long, nf_flags) 1025 __field(unsigned long, nf_may) 1026 __field(const void *, nf_file) 1027 ), 1028 TP_fast_assign( 1029 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1030 __entry->inode = inode; 1031 __entry->may_flags = may_flags; 1032 __entry->nf_ref = refcount_read(&nf->nf_ref); 1033 __entry->nf_flags = nf->nf_flags; 1034 __entry->nf_may = nf->nf_may; 1035 __entry->nf_file = nf->nf_file; 1036 ), 1037 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1038 __entry->xid, __entry->inode, 1039 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1040 show_nf_flags(__entry->nf_flags), 1041 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1042 ) 1043 ); 1044 1045 DECLARE_EVENT_CLASS(nfsd_file_open_class, 1046 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1047 TP_ARGS(nf, status), 1048 TP_STRUCT__entry( 1049 __field(void *, nf_inode) /* cannot be dereferenced */ 1050 __field(int, nf_ref) 1051 __field(unsigned long, nf_flags) 1052 __field(unsigned long, nf_may) 1053 __field(void *, nf_file) /* cannot be dereferenced */ 1054 ), 1055 TP_fast_assign( 1056 __entry->nf_inode = nf->nf_inode; 1057 __entry->nf_ref = refcount_read(&nf->nf_ref); 1058 __entry->nf_flags = nf->nf_flags; 1059 __entry->nf_may = nf->nf_may; 1060 __entry->nf_file = nf->nf_file; 1061 ), 1062 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1063 __entry->nf_inode, 1064 __entry->nf_ref, 1065 show_nf_flags(__entry->nf_flags), 1066 show_nfsd_may_flags(__entry->nf_may), 1067 __entry->nf_file) 1068 ) 1069 1070 #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1071 DEFINE_EVENT(nfsd_file_open_class, name, \ 1072 TP_PROTO( \ 1073 const struct nfsd_file *nf, \ 1074 __be32 status \ 1075 ), \ 1076 TP_ARGS(nf, status)) 1077 1078 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1079 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1080 1081 TRACE_EVENT(nfsd_file_is_cached, 1082 TP_PROTO( 1083 const struct inode *inode, 1084 int found 1085 ), 1086 TP_ARGS(inode, found), 1087 TP_STRUCT__entry( 1088 __field(const struct inode *, inode) 1089 __field(int, found) 1090 ), 1091 TP_fast_assign( 1092 __entry->inode = inode; 1093 __entry->found = found; 1094 ), 1095 TP_printk("inode=%p is %scached", 1096 __entry->inode, 1097 __entry->found ? "" : "not " 1098 ) 1099 ); 1100 1101 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1102 TP_PROTO(struct inode *inode, u32 mask), 1103 TP_ARGS(inode, mask), 1104 TP_STRUCT__entry( 1105 __field(struct inode *, inode) 1106 __field(unsigned int, nlink) 1107 __field(umode_t, mode) 1108 __field(u32, mask) 1109 ), 1110 TP_fast_assign( 1111 __entry->inode = inode; 1112 __entry->nlink = inode->i_nlink; 1113 __entry->mode = inode->i_mode; 1114 __entry->mask = mask; 1115 ), 1116 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1117 __entry->nlink, __entry->mode, __entry->mask) 1118 ); 1119 1120 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1121 TP_PROTO( 1122 const struct nfsd_file *nf 1123 ), 1124 TP_ARGS(nf), 1125 TP_STRUCT__entry( 1126 __field(void *, nf_inode) 1127 __field(void *, nf_file) 1128 __field(int, nf_ref) 1129 __field(unsigned long, nf_flags) 1130 ), 1131 TP_fast_assign( 1132 __entry->nf_inode = nf->nf_inode; 1133 __entry->nf_file = nf->nf_file; 1134 __entry->nf_ref = refcount_read(&nf->nf_ref); 1135 __entry->nf_flags = nf->nf_flags; 1136 ), 1137 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1138 __entry->nf_inode, __entry->nf_ref, 1139 show_nf_flags(__entry->nf_flags), 1140 __entry->nf_file 1141 ) 1142 ); 1143 1144 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1145 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1146 TP_PROTO( \ 1147 const struct nfsd_file *nf \ 1148 ), \ 1149 TP_ARGS(nf)) 1150 1151 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1152 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1153 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1154 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1155 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1156 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1157 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1158 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1159 1160 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1161 TP_PROTO( 1162 unsigned long removed, 1163 unsigned long remaining 1164 ), 1165 TP_ARGS(removed, remaining), 1166 TP_STRUCT__entry( 1167 __field(unsigned long, removed) 1168 __field(unsigned long, remaining) 1169 ), 1170 TP_fast_assign( 1171 __entry->removed = removed; 1172 __entry->remaining = remaining; 1173 ), 1174 TP_printk("%lu entries removed, %lu remaining", 1175 __entry->removed, __entry->remaining) 1176 ); 1177 1178 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1179 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1180 TP_PROTO( \ 1181 unsigned long removed, \ 1182 unsigned long remaining \ 1183 ), \ 1184 TP_ARGS(removed, remaining)) 1185 1186 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1187 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1188 1189 TRACE_EVENT(nfsd_file_close, 1190 TP_PROTO( 1191 const struct inode *inode 1192 ), 1193 TP_ARGS(inode), 1194 TP_STRUCT__entry( 1195 __field(const void *, inode) 1196 ), 1197 TP_fast_assign( 1198 __entry->inode = inode; 1199 ), 1200 TP_printk("inode=%p", 1201 __entry->inode 1202 ) 1203 ); 1204 1205 #include "cache.h" 1206 1207 TRACE_DEFINE_ENUM(RC_DROPIT); 1208 TRACE_DEFINE_ENUM(RC_REPLY); 1209 TRACE_DEFINE_ENUM(RC_DOIT); 1210 1211 #define show_drc_retval(x) \ 1212 __print_symbolic(x, \ 1213 { RC_DROPIT, "DROPIT" }, \ 1214 { RC_REPLY, "REPLY" }, \ 1215 { RC_DOIT, "DOIT" }) 1216 1217 TRACE_EVENT(nfsd_drc_found, 1218 TP_PROTO( 1219 const struct nfsd_net *nn, 1220 const struct svc_rqst *rqstp, 1221 int result 1222 ), 1223 TP_ARGS(nn, rqstp, result), 1224 TP_STRUCT__entry( 1225 __field(unsigned long long, boot_time) 1226 __field(unsigned long, result) 1227 __field(u32, xid) 1228 ), 1229 TP_fast_assign( 1230 __entry->boot_time = nn->boot_time; 1231 __entry->result = result; 1232 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1233 ), 1234 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1235 __entry->boot_time, __entry->xid, 1236 show_drc_retval(__entry->result)) 1237 1238 ); 1239 1240 TRACE_EVENT(nfsd_drc_mismatch, 1241 TP_PROTO( 1242 const struct nfsd_net *nn, 1243 const struct svc_cacherep *key, 1244 const struct svc_cacherep *rp 1245 ), 1246 TP_ARGS(nn, key, rp), 1247 TP_STRUCT__entry( 1248 __field(unsigned long long, boot_time) 1249 __field(u32, xid) 1250 __field(u32, cached) 1251 __field(u32, ingress) 1252 ), 1253 TP_fast_assign( 1254 __entry->boot_time = nn->boot_time; 1255 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1256 __entry->cached = (__force u32)key->c_key.k_csum; 1257 __entry->ingress = (__force u32)rp->c_key.k_csum; 1258 ), 1259 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1260 __entry->boot_time, __entry->xid, __entry->cached, 1261 __entry->ingress) 1262 ); 1263 1264 TRACE_EVENT(nfsd_cb_args, 1265 TP_PROTO( 1266 const struct nfs4_client *clp, 1267 const struct nfs4_cb_conn *conn 1268 ), 1269 TP_ARGS(clp, conn), 1270 TP_STRUCT__entry( 1271 __field(u32, cl_boot) 1272 __field(u32, cl_id) 1273 __field(u32, prog) 1274 __field(u32, ident) 1275 __sockaddr(addr, conn->cb_addrlen) 1276 ), 1277 TP_fast_assign( 1278 __entry->cl_boot = clp->cl_clientid.cl_boot; 1279 __entry->cl_id = clp->cl_clientid.cl_id; 1280 __entry->prog = conn->cb_prog; 1281 __entry->ident = conn->cb_ident; 1282 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1283 ), 1284 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1285 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1286 __entry->prog, __entry->ident) 1287 ); 1288 1289 TRACE_EVENT(nfsd_cb_nodelegs, 1290 TP_PROTO(const struct nfs4_client *clp), 1291 TP_ARGS(clp), 1292 TP_STRUCT__entry( 1293 __field(u32, cl_boot) 1294 __field(u32, cl_id) 1295 ), 1296 TP_fast_assign( 1297 __entry->cl_boot = clp->cl_clientid.cl_boot; 1298 __entry->cl_id = clp->cl_clientid.cl_id; 1299 ), 1300 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1301 ) 1302 1303 #define show_cb_state(val) \ 1304 __print_symbolic(val, \ 1305 { NFSD4_CB_UP, "UP" }, \ 1306 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1307 { NFSD4_CB_DOWN, "DOWN" }, \ 1308 { NFSD4_CB_FAULT, "FAULT"}) 1309 1310 DECLARE_EVENT_CLASS(nfsd_cb_class, 1311 TP_PROTO(const struct nfs4_client *clp), 1312 TP_ARGS(clp), 1313 TP_STRUCT__entry( 1314 __field(unsigned long, state) 1315 __field(u32, cl_boot) 1316 __field(u32, cl_id) 1317 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1318 ), 1319 TP_fast_assign( 1320 __entry->state = clp->cl_cb_state; 1321 __entry->cl_boot = clp->cl_clientid.cl_boot; 1322 __entry->cl_id = clp->cl_clientid.cl_id; 1323 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1324 clp->cl_cb_conn.cb_addrlen) 1325 ), 1326 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1327 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1328 show_cb_state(__entry->state)) 1329 ); 1330 1331 #define DEFINE_NFSD_CB_EVENT(name) \ 1332 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1333 TP_PROTO(const struct nfs4_client *clp), \ 1334 TP_ARGS(clp)) 1335 1336 DEFINE_NFSD_CB_EVENT(state); 1337 DEFINE_NFSD_CB_EVENT(probe); 1338 DEFINE_NFSD_CB_EVENT(lost); 1339 DEFINE_NFSD_CB_EVENT(shutdown); 1340 1341 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1342 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1343 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1344 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1345 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1346 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1347 1348 #define show_nfsd_authflavor(val) \ 1349 __print_symbolic(val, \ 1350 { RPC_AUTH_NULL, "none" }, \ 1351 { RPC_AUTH_UNIX, "sys" }, \ 1352 { RPC_AUTH_GSS, "gss" }, \ 1353 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1354 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1355 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1356 1357 TRACE_EVENT(nfsd_cb_setup, 1358 TP_PROTO(const struct nfs4_client *clp, 1359 const char *netid, 1360 rpc_authflavor_t authflavor 1361 ), 1362 TP_ARGS(clp, netid, authflavor), 1363 TP_STRUCT__entry( 1364 __field(u32, cl_boot) 1365 __field(u32, cl_id) 1366 __field(unsigned long, authflavor) 1367 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1368 __string(netid, netid) 1369 ), 1370 TP_fast_assign( 1371 __entry->cl_boot = clp->cl_clientid.cl_boot; 1372 __entry->cl_id = clp->cl_clientid.cl_id; 1373 __assign_str(netid, netid); 1374 __entry->authflavor = authflavor; 1375 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1376 clp->cl_cb_conn.cb_addrlen) 1377 ), 1378 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1379 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1380 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1381 ); 1382 1383 TRACE_EVENT(nfsd_cb_setup_err, 1384 TP_PROTO( 1385 const struct nfs4_client *clp, 1386 long error 1387 ), 1388 TP_ARGS(clp, error), 1389 TP_STRUCT__entry( 1390 __field(long, error) 1391 __field(u32, cl_boot) 1392 __field(u32, cl_id) 1393 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1394 ), 1395 TP_fast_assign( 1396 __entry->error = error; 1397 __entry->cl_boot = clp->cl_clientid.cl_boot; 1398 __entry->cl_id = clp->cl_clientid.cl_id; 1399 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1400 clp->cl_cb_conn.cb_addrlen) 1401 ), 1402 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1403 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1404 __entry->error) 1405 ); 1406 1407 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1408 TP_PROTO( 1409 const struct nfs4_stid *stid 1410 ), 1411 TP_ARGS(stid), 1412 TP_CONDITION(stid->sc_client), 1413 TP_STRUCT__entry( 1414 __field(u32, cl_boot) 1415 __field(u32, cl_id) 1416 __field(u32, si_id) 1417 __field(u32, si_generation) 1418 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1419 ), 1420 TP_fast_assign( 1421 const stateid_t *stp = &stid->sc_stateid; 1422 const struct nfs4_client *clp = stid->sc_client; 1423 1424 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1425 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1426 __entry->si_id = stp->si_opaque.so_id; 1427 __entry->si_generation = stp->si_generation; 1428 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1429 clp->cl_cb_conn.cb_addrlen) 1430 ), 1431 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1432 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1433 __entry->si_id, __entry->si_generation) 1434 ); 1435 1436 TRACE_EVENT(nfsd_cb_notify_lock, 1437 TP_PROTO( 1438 const struct nfs4_lockowner *lo, 1439 const struct nfsd4_blocked_lock *nbl 1440 ), 1441 TP_ARGS(lo, nbl), 1442 TP_STRUCT__entry( 1443 __field(u32, cl_boot) 1444 __field(u32, cl_id) 1445 __field(u32, fh_hash) 1446 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1447 ), 1448 TP_fast_assign( 1449 const struct nfs4_client *clp = lo->lo_owner.so_client; 1450 1451 __entry->cl_boot = clp->cl_clientid.cl_boot; 1452 __entry->cl_id = clp->cl_clientid.cl_id; 1453 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1454 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1455 clp->cl_cb_conn.cb_addrlen) 1456 ), 1457 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1458 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1459 __entry->fh_hash) 1460 ); 1461 1462 TRACE_EVENT(nfsd_cb_offload, 1463 TP_PROTO( 1464 const struct nfs4_client *clp, 1465 const stateid_t *stp, 1466 const struct knfsd_fh *fh, 1467 u64 count, 1468 __be32 status 1469 ), 1470 TP_ARGS(clp, stp, fh, count, status), 1471 TP_STRUCT__entry( 1472 __field(u32, cl_boot) 1473 __field(u32, cl_id) 1474 __field(u32, si_id) 1475 __field(u32, si_generation) 1476 __field(u32, fh_hash) 1477 __field(int, status) 1478 __field(u64, count) 1479 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1480 ), 1481 TP_fast_assign( 1482 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1483 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1484 __entry->si_id = stp->si_opaque.so_id; 1485 __entry->si_generation = stp->si_generation; 1486 __entry->fh_hash = knfsd_fh_hash(fh); 1487 __entry->status = be32_to_cpu(status); 1488 __entry->count = count; 1489 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1490 clp->cl_cb_conn.cb_addrlen) 1491 ), 1492 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1493 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1494 __entry->si_id, __entry->si_generation, 1495 __entry->fh_hash, __entry->count, __entry->status) 1496 ); 1497 1498 TRACE_EVENT(nfsd_cb_recall_any, 1499 TP_PROTO( 1500 const struct nfsd4_cb_recall_any *ra 1501 ), 1502 TP_ARGS(ra), 1503 TP_STRUCT__entry( 1504 __field(u32, cl_boot) 1505 __field(u32, cl_id) 1506 __field(u32, keep) 1507 __field(unsigned long, bmval0) 1508 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1509 ), 1510 TP_fast_assign( 1511 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1512 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1513 __entry->keep = ra->ra_keep; 1514 __entry->bmval0 = ra->ra_bmval[0]; 1515 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1516 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1517 ), 1518 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1519 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1520 __entry->keep, show_rca_mask(__entry->bmval0) 1521 ) 1522 ); 1523 1524 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1525 TP_PROTO( 1526 const stateid_t *stp, 1527 const struct rpc_task *task 1528 ), 1529 TP_ARGS(stp, task), 1530 TP_STRUCT__entry( 1531 __field(u32, cl_boot) 1532 __field(u32, cl_id) 1533 __field(u32, si_id) 1534 __field(u32, si_generation) 1535 __field(int, status) 1536 ), 1537 TP_fast_assign( 1538 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1539 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1540 __entry->si_id = stp->si_opaque.so_id; 1541 __entry->si_generation = stp->si_generation; 1542 __entry->status = task->tk_status; 1543 ), 1544 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1545 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1546 __entry->si_generation, __entry->status 1547 ) 1548 ); 1549 1550 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1551 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1552 TP_PROTO( \ 1553 const stateid_t *stp, \ 1554 const struct rpc_task *task \ 1555 ), \ 1556 TP_ARGS(stp, task)) 1557 1558 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1559 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1560 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1561 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1562 1563 TRACE_EVENT(nfsd_cb_recall_any_done, 1564 TP_PROTO( 1565 const struct nfsd4_callback *cb, 1566 const struct rpc_task *task 1567 ), 1568 TP_ARGS(cb, task), 1569 TP_STRUCT__entry( 1570 __field(u32, cl_boot) 1571 __field(u32, cl_id) 1572 __field(int, status) 1573 ), 1574 TP_fast_assign( 1575 __entry->status = task->tk_status; 1576 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1577 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1578 ), 1579 TP_printk("client %08x:%08x status=%d", 1580 __entry->cl_boot, __entry->cl_id, __entry->status 1581 ) 1582 ); 1583 1584 #endif /* _NFSD_TRACE_H */ 1585 1586 #undef TRACE_INCLUDE_PATH 1587 #define TRACE_INCLUDE_PATH . 1588 #define TRACE_INCLUDE_FILE trace 1589 #include <trace/define_trace.h> 1590