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