1/* SPDX-License-Identifier: GPL-2.0 */ 2/* 3 * Copyright (c) 2014 Christoph Hellwig. 4 */ 5#undef TRACE_SYSTEM 6#define TRACE_SYSTEM nfsd 7 8#if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 9#define _NFSD_TRACE_H 10 11#include <linux/tracepoint.h> 12#include <linux/sunrpc/clnt.h> 13#include <linux/sunrpc/xprt.h> 14#include <trace/misc/nfs.h> 15#include <trace/misc/sunrpc.h> 16 17#include "export.h" 18#include "nfsfh.h" 19#include "xdr4.h" 20 21#define NFSD_TRACE_PROC_RES_FIELDS \ 22 __field(unsigned int, netns_ino) \ 23 __field(u32, xid) \ 24 __field(unsigned long, status) \ 25 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 26 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 27 28#define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 29 do { \ 30 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 31 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 32 __entry->status = be32_to_cpu(error); \ 33 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 34 rqstp->rq_xprt->xpt_locallen); \ 35 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 36 rqstp->rq_xprt->xpt_remotelen); \ 37 } while (0); 38 39DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 40 TP_PROTO( 41 const struct svc_rqst *rqstp 42 ), 43 TP_ARGS(rqstp), 44 TP_STRUCT__entry( 45 __field(unsigned int, netns_ino) 46 __field(u32, xid) 47 __field(u32, vers) 48 __field(u32, proc) 49 __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 50 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 51 ), 52 TP_fast_assign( 53 const struct svc_xprt *xprt = rqstp->rq_xprt; 54 55 __entry->netns_ino = xprt->xpt_net->ns.inum; 56 __entry->xid = be32_to_cpu(rqstp->rq_xid); 57 __entry->vers = rqstp->rq_vers; 58 __entry->proc = rqstp->rq_proc; 59 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 60 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 61 ), 62 TP_printk("xid=0x%08x vers=%u proc=%u", 63 __entry->xid, __entry->vers, __entry->proc 64 ) 65); 66 67#define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 68DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 69 TP_PROTO(const struct svc_rqst *rqstp), \ 70 TP_ARGS(rqstp)) 71 72DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 73DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 74 75#define show_nfsd_may_flags(x) \ 76 __print_flags(x, "|", \ 77 { NFSD_MAY_EXEC, "EXEC" }, \ 78 { NFSD_MAY_WRITE, "WRITE" }, \ 79 { NFSD_MAY_READ, "READ" }, \ 80 { NFSD_MAY_SATTR, "SATTR" }, \ 81 { NFSD_MAY_TRUNC, "TRUNC" }, \ 82 { NFSD_MAY_LOCK, "LOCK" }, \ 83 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 84 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 85 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 86 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 87 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 88 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 89 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 90 91TRACE_EVENT(nfsd_compound, 92 TP_PROTO( 93 const struct svc_rqst *rqst, 94 const char *tag, 95 u32 taglen, 96 u32 opcnt 97 ), 98 TP_ARGS(rqst, tag, taglen, opcnt), 99 TP_STRUCT__entry( 100 __field(u32, xid) 101 __field(u32, opcnt) 102 __string_len(tag, tag, taglen) 103 ), 104 TP_fast_assign( 105 __entry->xid = be32_to_cpu(rqst->rq_xid); 106 __entry->opcnt = opcnt; 107 __assign_str(tag, tag); 108 ), 109 TP_printk("xid=0x%08x opcnt=%u tag=%s", 110 __entry->xid, __entry->opcnt, __get_str(tag) 111 ) 112) 113 114TRACE_EVENT(nfsd_compound_status, 115 TP_PROTO(u32 args_opcnt, 116 u32 resp_opcnt, 117 __be32 status, 118 const char *name), 119 TP_ARGS(args_opcnt, resp_opcnt, status, name), 120 TP_STRUCT__entry( 121 __field(u32, args_opcnt) 122 __field(u32, resp_opcnt) 123 __field(int, status) 124 __string(name, name) 125 ), 126 TP_fast_assign( 127 __entry->args_opcnt = args_opcnt; 128 __entry->resp_opcnt = resp_opcnt; 129 __entry->status = be32_to_cpu(status); 130 __assign_str(name, name); 131 ), 132 TP_printk("op=%u/%u %s status=%d", 133 __entry->resp_opcnt, __entry->args_opcnt, 134 __get_str(name), __entry->status) 135) 136 137TRACE_EVENT(nfsd_compound_decode_err, 138 TP_PROTO( 139 const struct svc_rqst *rqstp, 140 u32 args_opcnt, 141 u32 resp_opcnt, 142 u32 opnum, 143 __be32 status 144 ), 145 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 146 TP_STRUCT__entry( 147 NFSD_TRACE_PROC_RES_FIELDS 148 149 __field(u32, args_opcnt) 150 __field(u32, resp_opcnt) 151 __field(u32, opnum) 152 ), 153 TP_fast_assign( 154 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 155 156 __entry->args_opcnt = args_opcnt; 157 __entry->resp_opcnt = resp_opcnt; 158 __entry->opnum = opnum; 159 ), 160 TP_printk("op=%u/%u opnum=%u status=%lu", 161 __entry->resp_opcnt, __entry->args_opcnt, 162 __entry->opnum, __entry->status) 163); 164 165TRACE_EVENT(nfsd_compound_encode_err, 166 TP_PROTO( 167 const struct svc_rqst *rqstp, 168 u32 opnum, 169 __be32 status 170 ), 171 TP_ARGS(rqstp, opnum, status), 172 TP_STRUCT__entry( 173 NFSD_TRACE_PROC_RES_FIELDS 174 175 __field(u32, opnum) 176 ), 177 TP_fast_assign( 178 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 179 180 __entry->opnum = opnum; 181 ), 182 TP_printk("opnum=%u status=%lu", 183 __entry->opnum, __entry->status) 184); 185 186#define show_fs_file_type(x) \ 187 __print_symbolic(x, \ 188 { S_IFLNK, "LNK" }, \ 189 { S_IFREG, "REG" }, \ 190 { S_IFDIR, "DIR" }, \ 191 { S_IFCHR, "CHR" }, \ 192 { S_IFBLK, "BLK" }, \ 193 { S_IFIFO, "FIFO" }, \ 194 { S_IFSOCK, "SOCK" }) 195 196TRACE_EVENT(nfsd_fh_verify, 197 TP_PROTO( 198 const struct svc_rqst *rqstp, 199 const struct svc_fh *fhp, 200 umode_t type, 201 int access 202 ), 203 TP_ARGS(rqstp, fhp, type, access), 204 TP_STRUCT__entry( 205 __field(unsigned int, netns_ino) 206 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 207 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 208 __field(u32, xid) 209 __field(u32, fh_hash) 210 __field(const void *, inode) 211 __field(unsigned long, type) 212 __field(unsigned long, access) 213 ), 214 TP_fast_assign( 215 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 216 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 217 rqstp->rq_xprt->xpt_locallen); 218 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 219 rqstp->rq_xprt->xpt_remotelen); 220 __entry->xid = be32_to_cpu(rqstp->rq_xid); 221 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 222 __entry->inode = d_inode(fhp->fh_dentry); 223 __entry->type = type; 224 __entry->access = access; 225 ), 226 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 227 __entry->xid, __entry->fh_hash, 228 show_fs_file_type(__entry->type), 229 show_nfsd_may_flags(__entry->access) 230 ) 231); 232 233TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 234 TP_PROTO( 235 const struct svc_rqst *rqstp, 236 const struct svc_fh *fhp, 237 umode_t type, 238 int access, 239 __be32 error 240 ), 241 TP_ARGS(rqstp, fhp, type, access, error), 242 TP_CONDITION(error), 243 TP_STRUCT__entry( 244 __field(unsigned int, netns_ino) 245 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 246 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 247 __field(u32, xid) 248 __field(u32, fh_hash) 249 __field(const void *, inode) 250 __field(unsigned long, type) 251 __field(unsigned long, access) 252 __field(int, error) 253 ), 254 TP_fast_assign( 255 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 256 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 257 rqstp->rq_xprt->xpt_locallen); 258 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 259 rqstp->rq_xprt->xpt_remotelen); 260 __entry->xid = be32_to_cpu(rqstp->rq_xid); 261 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 262 if (fhp->fh_dentry) 263 __entry->inode = d_inode(fhp->fh_dentry); 264 else 265 __entry->inode = NULL; 266 __entry->type = type; 267 __entry->access = access; 268 __entry->error = be32_to_cpu(error); 269 ), 270 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 271 __entry->xid, __entry->fh_hash, 272 show_fs_file_type(__entry->type), 273 show_nfsd_may_flags(__entry->access), 274 __entry->error 275 ) 276); 277 278DECLARE_EVENT_CLASS(nfsd_fh_err_class, 279 TP_PROTO(struct svc_rqst *rqstp, 280 struct svc_fh *fhp, 281 int status), 282 TP_ARGS(rqstp, fhp, status), 283 TP_STRUCT__entry( 284 __field(u32, xid) 285 __field(u32, fh_hash) 286 __field(int, status) 287 ), 288 TP_fast_assign( 289 __entry->xid = be32_to_cpu(rqstp->rq_xid); 290 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 291 __entry->status = status; 292 ), 293 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 294 __entry->xid, __entry->fh_hash, 295 __entry->status) 296) 297 298#define DEFINE_NFSD_FH_ERR_EVENT(name) \ 299DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 300 TP_PROTO(struct svc_rqst *rqstp, \ 301 struct svc_fh *fhp, \ 302 int status), \ 303 TP_ARGS(rqstp, fhp, status)) 304 305DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 306DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 307 308TRACE_EVENT(nfsd_exp_find_key, 309 TP_PROTO(const struct svc_expkey *key, 310 int status), 311 TP_ARGS(key, status), 312 TP_STRUCT__entry( 313 __field(int, fsidtype) 314 __array(u32, fsid, 6) 315 __string(auth_domain, key->ek_client->name) 316 __field(int, status) 317 ), 318 TP_fast_assign( 319 __entry->fsidtype = key->ek_fsidtype; 320 memcpy(__entry->fsid, key->ek_fsid, 4*6); 321 __assign_str(auth_domain, key->ek_client->name); 322 __entry->status = status; 323 ), 324 TP_printk("fsid=%x::%s domain=%s status=%d", 325 __entry->fsidtype, 326 __print_array(__entry->fsid, 6, 4), 327 __get_str(auth_domain), 328 __entry->status 329 ) 330); 331 332TRACE_EVENT(nfsd_expkey_update, 333 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 334 TP_ARGS(key, exp_path), 335 TP_STRUCT__entry( 336 __field(int, fsidtype) 337 __array(u32, fsid, 6) 338 __string(auth_domain, key->ek_client->name) 339 __string(path, exp_path) 340 __field(bool, cache) 341 ), 342 TP_fast_assign( 343 __entry->fsidtype = key->ek_fsidtype; 344 memcpy(__entry->fsid, key->ek_fsid, 4*6); 345 __assign_str(auth_domain, key->ek_client->name); 346 __assign_str(path, exp_path); 347 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 348 ), 349 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 350 __entry->fsidtype, 351 __print_array(__entry->fsid, 6, 4), 352 __get_str(auth_domain), 353 __get_str(path), 354 __entry->cache ? "pos" : "neg" 355 ) 356); 357 358TRACE_EVENT(nfsd_exp_get_by_name, 359 TP_PROTO(const struct svc_export *key, 360 int status), 361 TP_ARGS(key, status), 362 TP_STRUCT__entry( 363 __string(path, key->ex_path.dentry->d_name.name) 364 __string(auth_domain, key->ex_client->name) 365 __field(int, status) 366 ), 367 TP_fast_assign( 368 __assign_str(path, key->ex_path.dentry->d_name.name); 369 __assign_str(auth_domain, key->ex_client->name); 370 __entry->status = status; 371 ), 372 TP_printk("path=%s domain=%s status=%d", 373 __get_str(path), 374 __get_str(auth_domain), 375 __entry->status 376 ) 377); 378 379TRACE_EVENT(nfsd_export_update, 380 TP_PROTO(const struct svc_export *key), 381 TP_ARGS(key), 382 TP_STRUCT__entry( 383 __string(path, key->ex_path.dentry->d_name.name) 384 __string(auth_domain, key->ex_client->name) 385 __field(bool, cache) 386 ), 387 TP_fast_assign( 388 __assign_str(path, key->ex_path.dentry->d_name.name); 389 __assign_str(auth_domain, key->ex_client->name); 390 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 391 ), 392 TP_printk("path=%s domain=%s cache=%s", 393 __get_str(path), 394 __get_str(auth_domain), 395 __entry->cache ? "pos" : "neg" 396 ) 397); 398 399DECLARE_EVENT_CLASS(nfsd_io_class, 400 TP_PROTO(struct svc_rqst *rqstp, 401 struct svc_fh *fhp, 402 u64 offset, 403 u32 len), 404 TP_ARGS(rqstp, fhp, offset, len), 405 TP_STRUCT__entry( 406 __field(u32, xid) 407 __field(u32, fh_hash) 408 __field(u64, offset) 409 __field(u32, len) 410 ), 411 TP_fast_assign( 412 __entry->xid = be32_to_cpu(rqstp->rq_xid); 413 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 414 __entry->offset = offset; 415 __entry->len = len; 416 ), 417 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 418 __entry->xid, __entry->fh_hash, 419 __entry->offset, __entry->len) 420) 421 422#define DEFINE_NFSD_IO_EVENT(name) \ 423DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 424 TP_PROTO(struct svc_rqst *rqstp, \ 425 struct svc_fh *fhp, \ 426 u64 offset, \ 427 u32 len), \ 428 TP_ARGS(rqstp, fhp, offset, len)) 429 430DEFINE_NFSD_IO_EVENT(read_start); 431DEFINE_NFSD_IO_EVENT(read_splice); 432DEFINE_NFSD_IO_EVENT(read_vector); 433DEFINE_NFSD_IO_EVENT(read_io_done); 434DEFINE_NFSD_IO_EVENT(read_done); 435DEFINE_NFSD_IO_EVENT(write_start); 436DEFINE_NFSD_IO_EVENT(write_opened); 437DEFINE_NFSD_IO_EVENT(write_io_done); 438DEFINE_NFSD_IO_EVENT(write_done); 439 440DECLARE_EVENT_CLASS(nfsd_err_class, 441 TP_PROTO(struct svc_rqst *rqstp, 442 struct svc_fh *fhp, 443 loff_t offset, 444 int status), 445 TP_ARGS(rqstp, fhp, offset, status), 446 TP_STRUCT__entry( 447 __field(u32, xid) 448 __field(u32, fh_hash) 449 __field(loff_t, offset) 450 __field(int, status) 451 ), 452 TP_fast_assign( 453 __entry->xid = be32_to_cpu(rqstp->rq_xid); 454 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 455 __entry->offset = offset; 456 __entry->status = status; 457 ), 458 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 459 __entry->xid, __entry->fh_hash, 460 __entry->offset, __entry->status) 461) 462 463#define DEFINE_NFSD_ERR_EVENT(name) \ 464DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 465 TP_PROTO(struct svc_rqst *rqstp, \ 466 struct svc_fh *fhp, \ 467 loff_t offset, \ 468 int len), \ 469 TP_ARGS(rqstp, fhp, offset, len)) 470 471DEFINE_NFSD_ERR_EVENT(read_err); 472DEFINE_NFSD_ERR_EVENT(write_err); 473 474TRACE_EVENT(nfsd_dirent, 475 TP_PROTO(struct svc_fh *fhp, 476 u64 ino, 477 const char *name, 478 int namlen), 479 TP_ARGS(fhp, ino, name, namlen), 480 TP_STRUCT__entry( 481 __field(u32, fh_hash) 482 __field(u64, ino) 483 __string_len(name, name, namlen) 484 ), 485 TP_fast_assign( 486 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 487 __entry->ino = ino; 488 __assign_str(name, name); 489 ), 490 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 491 __entry->fh_hash, __entry->ino, __get_str(name) 492 ) 493) 494 495DECLARE_EVENT_CLASS(nfsd_copy_err_class, 496 TP_PROTO(struct svc_rqst *rqstp, 497 struct svc_fh *src_fhp, 498 loff_t src_offset, 499 struct svc_fh *dst_fhp, 500 loff_t dst_offset, 501 u64 count, 502 int status), 503 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 504 TP_STRUCT__entry( 505 __field(u32, xid) 506 __field(u32, src_fh_hash) 507 __field(loff_t, src_offset) 508 __field(u32, dst_fh_hash) 509 __field(loff_t, dst_offset) 510 __field(u64, count) 511 __field(int, status) 512 ), 513 TP_fast_assign( 514 __entry->xid = be32_to_cpu(rqstp->rq_xid); 515 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 516 __entry->src_offset = src_offset; 517 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 518 __entry->dst_offset = dst_offset; 519 __entry->count = count; 520 __entry->status = status; 521 ), 522 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 523 "dst_fh_hash=0x%08x dst_offset=%lld " 524 "count=%llu status=%d", 525 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 526 __entry->dst_fh_hash, __entry->dst_offset, 527 (unsigned long long)__entry->count, 528 __entry->status) 529) 530 531#define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 532DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 533 TP_PROTO(struct svc_rqst *rqstp, \ 534 struct svc_fh *src_fhp, \ 535 loff_t src_offset, \ 536 struct svc_fh *dst_fhp, \ 537 loff_t dst_offset, \ 538 u64 count, \ 539 int status), \ 540 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 541 count, status)) 542 543DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 544 545#include "state.h" 546#include "filecache.h" 547#include "vfs.h" 548 549TRACE_EVENT(nfsd_delegret_wakeup, 550 TP_PROTO( 551 const struct svc_rqst *rqstp, 552 const struct inode *inode, 553 long timeo 554 ), 555 TP_ARGS(rqstp, inode, timeo), 556 TP_STRUCT__entry( 557 __field(u32, xid) 558 __field(const void *, inode) 559 __field(long, timeo) 560 ), 561 TP_fast_assign( 562 __entry->xid = be32_to_cpu(rqstp->rq_xid); 563 __entry->inode = inode; 564 __entry->timeo = timeo; 565 ), 566 TP_printk("xid=0x%08x inode=%p%s", 567 __entry->xid, __entry->inode, 568 __entry->timeo == 0 ? " (timed out)" : "" 569 ) 570); 571 572DECLARE_EVENT_CLASS(nfsd_stateid_class, 573 TP_PROTO(stateid_t *stp), 574 TP_ARGS(stp), 575 TP_STRUCT__entry( 576 __field(u32, cl_boot) 577 __field(u32, cl_id) 578 __field(u32, si_id) 579 __field(u32, si_generation) 580 ), 581 TP_fast_assign( 582 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 583 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 584 __entry->si_id = stp->si_opaque.so_id; 585 __entry->si_generation = stp->si_generation; 586 ), 587 TP_printk("client %08x:%08x stateid %08x:%08x", 588 __entry->cl_boot, 589 __entry->cl_id, 590 __entry->si_id, 591 __entry->si_generation) 592) 593 594#define DEFINE_STATEID_EVENT(name) \ 595DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 596 TP_PROTO(stateid_t *stp), \ 597 TP_ARGS(stp)) 598 599DEFINE_STATEID_EVENT(layoutstate_alloc); 600DEFINE_STATEID_EVENT(layoutstate_unhash); 601DEFINE_STATEID_EVENT(layoutstate_free); 602DEFINE_STATEID_EVENT(layout_get_lookup_fail); 603DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 604DEFINE_STATEID_EVENT(layout_return_lookup_fail); 605DEFINE_STATEID_EVENT(layout_recall); 606DEFINE_STATEID_EVENT(layout_recall_done); 607DEFINE_STATEID_EVENT(layout_recall_fail); 608DEFINE_STATEID_EVENT(layout_recall_release); 609 610DEFINE_STATEID_EVENT(open); 611DEFINE_STATEID_EVENT(deleg_read); 612DEFINE_STATEID_EVENT(deleg_write); 613DEFINE_STATEID_EVENT(deleg_return); 614DEFINE_STATEID_EVENT(deleg_recall); 615 616DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 617 TP_PROTO(u32 seqid, const stateid_t *stp), 618 TP_ARGS(seqid, stp), 619 TP_STRUCT__entry( 620 __field(u32, seqid) 621 __field(u32, cl_boot) 622 __field(u32, cl_id) 623 __field(u32, si_id) 624 __field(u32, si_generation) 625 ), 626 TP_fast_assign( 627 __entry->seqid = seqid; 628 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 629 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 630 __entry->si_id = stp->si_opaque.so_id; 631 __entry->si_generation = stp->si_generation; 632 ), 633 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 634 __entry->seqid, __entry->cl_boot, __entry->cl_id, 635 __entry->si_id, __entry->si_generation) 636) 637 638#define DEFINE_STATESEQID_EVENT(name) \ 639DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 640 TP_PROTO(u32 seqid, const stateid_t *stp), \ 641 TP_ARGS(seqid, stp)) 642 643DEFINE_STATESEQID_EVENT(preprocess); 644DEFINE_STATESEQID_EVENT(open_confirm); 645 646#define show_stid_type(x) \ 647 __print_flags(x, "|", \ 648 { SC_TYPE_OPEN, "OPEN" }, \ 649 { SC_TYPE_LOCK, "LOCK" }, \ 650 { SC_TYPE_DELEG, "DELEG" }, \ 651 { SC_TYPE_LAYOUT, "LAYOUT" }) 652 653#define show_stid_status(x) \ 654 __print_flags(x, "|", \ 655 { SC_STATUS_CLOSED, "CLOSED" }, \ 656 { SC_STATUS_REVOKED, "REVOKED" }, \ 657 { SC_STATUS_ADMIN_REVOKED, "ADMIN_REVOKED" }) 658 659DECLARE_EVENT_CLASS(nfsd_stid_class, 660 TP_PROTO( 661 const struct nfs4_stid *stid 662 ), 663 TP_ARGS(stid), 664 TP_STRUCT__entry( 665 __field(unsigned long, sc_type) 666 __field(unsigned long, sc_status) 667 __field(int, sc_count) 668 __field(u32, cl_boot) 669 __field(u32, cl_id) 670 __field(u32, si_id) 671 __field(u32, si_generation) 672 ), 673 TP_fast_assign( 674 const stateid_t *stp = &stid->sc_stateid; 675 676 __entry->sc_type = stid->sc_type; 677 __entry->sc_status = stid->sc_status; 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 state=%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 show_stid_status(__entry->sc_status) 689 ) 690); 691 692#define DEFINE_STID_EVENT(name) \ 693DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 694 TP_PROTO(const struct nfs4_stid *stid), \ 695 TP_ARGS(stid)) 696 697DEFINE_STID_EVENT(revoke); 698 699TRACE_EVENT(nfsd_stateowner_replay, 700 TP_PROTO( 701 u32 opnum, 702 const struct nfs4_replay *rp 703 ), 704 TP_ARGS(opnum, rp), 705 TP_STRUCT__entry( 706 __field(unsigned long, status) 707 __field(u32, opnum) 708 ), 709 TP_fast_assign( 710 __entry->status = be32_to_cpu(rp->rp_status); 711 __entry->opnum = opnum; 712 ), 713 TP_printk("opnum=%u status=%lu", 714 __entry->opnum, __entry->status) 715); 716 717TRACE_EVENT_CONDITION(nfsd_seq4_status, 718 TP_PROTO( 719 const struct svc_rqst *rqstp, 720 const struct nfsd4_sequence *sequence 721 ), 722 TP_ARGS(rqstp, sequence), 723 TP_CONDITION(sequence->status_flags), 724 TP_STRUCT__entry( 725 __field(unsigned int, netns_ino) 726 __field(u32, xid) 727 __field(u32, cl_boot) 728 __field(u32, cl_id) 729 __field(u32, seqno) 730 __field(u32, reserved) 731 __field(unsigned long, status_flags) 732 ), 733 TP_fast_assign( 734 const struct nfsd4_sessionid *sid = 735 (struct nfsd4_sessionid *)&sequence->sessionid; 736 737 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 738 __entry->xid = be32_to_cpu(rqstp->rq_xid); 739 __entry->cl_boot = sid->clientid.cl_boot; 740 __entry->cl_id = sid->clientid.cl_id; 741 __entry->seqno = sid->sequence; 742 __entry->reserved = sid->reserved; 743 __entry->status_flags = sequence->status_flags; 744 ), 745 TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s", 746 __entry->xid, __entry->cl_boot, __entry->cl_id, 747 __entry->seqno, __entry->reserved, 748 show_nfs4_seq4_status(__entry->status_flags) 749 ) 750); 751 752DECLARE_EVENT_CLASS(nfsd_clientid_class, 753 TP_PROTO(const clientid_t *clid), 754 TP_ARGS(clid), 755 TP_STRUCT__entry( 756 __field(u32, cl_boot) 757 __field(u32, cl_id) 758 ), 759 TP_fast_assign( 760 __entry->cl_boot = clid->cl_boot; 761 __entry->cl_id = clid->cl_id; 762 ), 763 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 764) 765 766#define DEFINE_CLIENTID_EVENT(name) \ 767DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 768 TP_PROTO(const clientid_t *clid), \ 769 TP_ARGS(clid)) 770 771DEFINE_CLIENTID_EVENT(expire_unconf); 772DEFINE_CLIENTID_EVENT(reclaim_complete); 773DEFINE_CLIENTID_EVENT(confirmed); 774DEFINE_CLIENTID_EVENT(destroyed); 775DEFINE_CLIENTID_EVENT(admin_expired); 776DEFINE_CLIENTID_EVENT(replaced); 777DEFINE_CLIENTID_EVENT(purged); 778DEFINE_CLIENTID_EVENT(renew); 779DEFINE_CLIENTID_EVENT(stale); 780 781DECLARE_EVENT_CLASS(nfsd_net_class, 782 TP_PROTO(const struct nfsd_net *nn), 783 TP_ARGS(nn), 784 TP_STRUCT__entry( 785 __field(unsigned long long, boot_time) 786 ), 787 TP_fast_assign( 788 __entry->boot_time = nn->boot_time; 789 ), 790 TP_printk("boot_time=%16llx", __entry->boot_time) 791) 792 793#define DEFINE_NET_EVENT(name) \ 794DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 795 TP_PROTO(const struct nfsd_net *nn), \ 796 TP_ARGS(nn)) 797 798DEFINE_NET_EVENT(grace_start); 799DEFINE_NET_EVENT(grace_complete); 800 801TRACE_EVENT(nfsd_writeverf_reset, 802 TP_PROTO( 803 const struct nfsd_net *nn, 804 const struct svc_rqst *rqstp, 805 int error 806 ), 807 TP_ARGS(nn, rqstp, error), 808 TP_STRUCT__entry( 809 __field(unsigned long long, boot_time) 810 __field(u32, xid) 811 __field(int, error) 812 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 813 ), 814 TP_fast_assign( 815 __entry->boot_time = nn->boot_time; 816 __entry->xid = be32_to_cpu(rqstp->rq_xid); 817 __entry->error = error; 818 819 /* avoid seqlock inside TP_fast_assign */ 820 memcpy(__entry->verifier, nn->writeverf, 821 NFS4_VERIFIER_SIZE); 822 ), 823 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 824 __entry->boot_time, __entry->xid, __entry->error, 825 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 826 ) 827); 828 829TRACE_EVENT(nfsd_clid_cred_mismatch, 830 TP_PROTO( 831 const struct nfs4_client *clp, 832 const struct svc_rqst *rqstp 833 ), 834 TP_ARGS(clp, rqstp), 835 TP_STRUCT__entry( 836 __field(u32, cl_boot) 837 __field(u32, cl_id) 838 __field(unsigned long, cl_flavor) 839 __field(unsigned long, new_flavor) 840 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 841 ), 842 TP_fast_assign( 843 __entry->cl_boot = clp->cl_clientid.cl_boot; 844 __entry->cl_id = clp->cl_clientid.cl_id; 845 __entry->cl_flavor = clp->cl_cred.cr_flavor; 846 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 847 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 848 rqstp->rq_xprt->xpt_remotelen); 849 ), 850 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 851 __entry->cl_boot, __entry->cl_id, 852 show_nfsd_authflavor(__entry->cl_flavor), 853 show_nfsd_authflavor(__entry->new_flavor), 854 __get_sockaddr(addr) 855 ) 856) 857 858TRACE_EVENT(nfsd_clid_verf_mismatch, 859 TP_PROTO( 860 const struct nfs4_client *clp, 861 const struct svc_rqst *rqstp, 862 const nfs4_verifier *verf 863 ), 864 TP_ARGS(clp, rqstp, verf), 865 TP_STRUCT__entry( 866 __field(u32, cl_boot) 867 __field(u32, cl_id) 868 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 869 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 870 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 871 ), 872 TP_fast_assign( 873 __entry->cl_boot = clp->cl_clientid.cl_boot; 874 __entry->cl_id = clp->cl_clientid.cl_id; 875 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 876 NFS4_VERIFIER_SIZE); 877 memcpy(__entry->new_verifier, (void *)verf, 878 NFS4_VERIFIER_SIZE); 879 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 880 rqstp->rq_xprt->xpt_remotelen); 881 ), 882 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 883 __entry->cl_boot, __entry->cl_id, 884 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 885 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 886 __get_sockaddr(addr) 887 ) 888); 889 890DECLARE_EVENT_CLASS(nfsd_clid_class, 891 TP_PROTO(const struct nfs4_client *clp), 892 TP_ARGS(clp), 893 TP_STRUCT__entry( 894 __field(u32, cl_boot) 895 __field(u32, cl_id) 896 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 897 __field(unsigned long, flavor) 898 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 899 __string_len(name, clp->cl_name.data, clp->cl_name.len) 900 ), 901 TP_fast_assign( 902 __entry->cl_boot = clp->cl_clientid.cl_boot; 903 __entry->cl_id = clp->cl_clientid.cl_id; 904 memcpy(__entry->addr, &clp->cl_addr, 905 sizeof(struct sockaddr_in6)); 906 __entry->flavor = clp->cl_cred.cr_flavor; 907 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 908 NFS4_VERIFIER_SIZE); 909 __assign_str(name, clp->cl_name.data); 910 ), 911 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 912 __entry->addr, __get_str(name), 913 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 914 show_nfsd_authflavor(__entry->flavor), 915 __entry->cl_boot, __entry->cl_id) 916); 917 918#define DEFINE_CLID_EVENT(name) \ 919DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 920 TP_PROTO(const struct nfs4_client *clp), \ 921 TP_ARGS(clp)) 922 923DEFINE_CLID_EVENT(fresh); 924DEFINE_CLID_EVENT(confirmed_r); 925 926/* 927 * from fs/nfsd/filecache.h 928 */ 929#define show_nf_flags(val) \ 930 __print_flags(val, "|", \ 931 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 932 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 933 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 934 { 1 << NFSD_FILE_GC, "GC" }) 935 936DECLARE_EVENT_CLASS(nfsd_file_class, 937 TP_PROTO(struct nfsd_file *nf), 938 TP_ARGS(nf), 939 TP_STRUCT__entry( 940 __field(void *, nf_inode) 941 __field(int, nf_ref) 942 __field(unsigned long, nf_flags) 943 __field(unsigned char, nf_may) 944 __field(struct file *, nf_file) 945 ), 946 TP_fast_assign( 947 __entry->nf_inode = nf->nf_inode; 948 __entry->nf_ref = refcount_read(&nf->nf_ref); 949 __entry->nf_flags = nf->nf_flags; 950 __entry->nf_may = nf->nf_may; 951 __entry->nf_file = nf->nf_file; 952 ), 953 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 954 __entry->nf_inode, 955 __entry->nf_ref, 956 show_nf_flags(__entry->nf_flags), 957 show_nfsd_may_flags(__entry->nf_may), 958 __entry->nf_file) 959) 960 961#define DEFINE_NFSD_FILE_EVENT(name) \ 962DEFINE_EVENT(nfsd_file_class, name, \ 963 TP_PROTO(struct nfsd_file *nf), \ 964 TP_ARGS(nf)) 965 966DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 967DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 968DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 969DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 970DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 971 972TRACE_EVENT(nfsd_file_alloc, 973 TP_PROTO( 974 const struct nfsd_file *nf 975 ), 976 TP_ARGS(nf), 977 TP_STRUCT__entry( 978 __field(const void *, nf_inode) 979 __field(unsigned long, nf_flags) 980 __field(unsigned long, nf_may) 981 __field(unsigned int, nf_ref) 982 ), 983 TP_fast_assign( 984 __entry->nf_inode = nf->nf_inode; 985 __entry->nf_flags = nf->nf_flags; 986 __entry->nf_ref = refcount_read(&nf->nf_ref); 987 __entry->nf_may = nf->nf_may; 988 ), 989 TP_printk("inode=%p ref=%u flags=%s may=%s", 990 __entry->nf_inode, __entry->nf_ref, 991 show_nf_flags(__entry->nf_flags), 992 show_nfsd_may_flags(__entry->nf_may) 993 ) 994); 995 996TRACE_EVENT(nfsd_file_acquire, 997 TP_PROTO( 998 const struct svc_rqst *rqstp, 999 const struct inode *inode, 1000 unsigned int may_flags, 1001 const struct nfsd_file *nf, 1002 __be32 status 1003 ), 1004 1005 TP_ARGS(rqstp, inode, may_flags, nf, status), 1006 1007 TP_STRUCT__entry( 1008 __field(u32, xid) 1009 __field(const void *, inode) 1010 __field(unsigned long, may_flags) 1011 __field(unsigned int, nf_ref) 1012 __field(unsigned long, nf_flags) 1013 __field(unsigned long, nf_may) 1014 __field(const void *, nf_file) 1015 __field(u32, status) 1016 ), 1017 1018 TP_fast_assign( 1019 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1020 __entry->inode = inode; 1021 __entry->may_flags = may_flags; 1022 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 1023 __entry->nf_flags = nf ? nf->nf_flags : 0; 1024 __entry->nf_may = nf ? nf->nf_may : 0; 1025 __entry->nf_file = nf ? nf->nf_file : NULL; 1026 __entry->status = be32_to_cpu(status); 1027 ), 1028 1029 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 1030 __entry->xid, __entry->inode, 1031 show_nfsd_may_flags(__entry->may_flags), 1032 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1033 show_nfsd_may_flags(__entry->nf_may), 1034 __entry->nf_file, __entry->status 1035 ) 1036); 1037 1038TRACE_EVENT(nfsd_file_insert_err, 1039 TP_PROTO( 1040 const struct svc_rqst *rqstp, 1041 const struct inode *inode, 1042 unsigned int may_flags, 1043 long error 1044 ), 1045 TP_ARGS(rqstp, inode, may_flags, error), 1046 TP_STRUCT__entry( 1047 __field(u32, xid) 1048 __field(const void *, inode) 1049 __field(unsigned long, may_flags) 1050 __field(long, error) 1051 ), 1052 TP_fast_assign( 1053 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1054 __entry->inode = inode; 1055 __entry->may_flags = may_flags; 1056 __entry->error = error; 1057 ), 1058 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1059 __entry->xid, __entry->inode, 1060 show_nfsd_may_flags(__entry->may_flags), 1061 __entry->error 1062 ) 1063); 1064 1065TRACE_EVENT(nfsd_file_cons_err, 1066 TP_PROTO( 1067 const struct svc_rqst *rqstp, 1068 const struct inode *inode, 1069 unsigned int may_flags, 1070 const struct nfsd_file *nf 1071 ), 1072 TP_ARGS(rqstp, inode, may_flags, nf), 1073 TP_STRUCT__entry( 1074 __field(u32, xid) 1075 __field(const void *, inode) 1076 __field(unsigned long, may_flags) 1077 __field(unsigned int, nf_ref) 1078 __field(unsigned long, nf_flags) 1079 __field(unsigned long, nf_may) 1080 __field(const void *, nf_file) 1081 ), 1082 TP_fast_assign( 1083 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1084 __entry->inode = inode; 1085 __entry->may_flags = may_flags; 1086 __entry->nf_ref = refcount_read(&nf->nf_ref); 1087 __entry->nf_flags = nf->nf_flags; 1088 __entry->nf_may = nf->nf_may; 1089 __entry->nf_file = nf->nf_file; 1090 ), 1091 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1092 __entry->xid, __entry->inode, 1093 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1094 show_nf_flags(__entry->nf_flags), 1095 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1096 ) 1097); 1098 1099DECLARE_EVENT_CLASS(nfsd_file_open_class, 1100 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1101 TP_ARGS(nf, status), 1102 TP_STRUCT__entry( 1103 __field(void *, nf_inode) /* cannot be dereferenced */ 1104 __field(int, nf_ref) 1105 __field(unsigned long, nf_flags) 1106 __field(unsigned long, nf_may) 1107 __field(void *, nf_file) /* cannot be dereferenced */ 1108 ), 1109 TP_fast_assign( 1110 __entry->nf_inode = nf->nf_inode; 1111 __entry->nf_ref = refcount_read(&nf->nf_ref); 1112 __entry->nf_flags = nf->nf_flags; 1113 __entry->nf_may = nf->nf_may; 1114 __entry->nf_file = nf->nf_file; 1115 ), 1116 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1117 __entry->nf_inode, 1118 __entry->nf_ref, 1119 show_nf_flags(__entry->nf_flags), 1120 show_nfsd_may_flags(__entry->nf_may), 1121 __entry->nf_file) 1122) 1123 1124#define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1125DEFINE_EVENT(nfsd_file_open_class, name, \ 1126 TP_PROTO( \ 1127 const struct nfsd_file *nf, \ 1128 __be32 status \ 1129 ), \ 1130 TP_ARGS(nf, status)) 1131 1132DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1133DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1134 1135TRACE_EVENT(nfsd_file_is_cached, 1136 TP_PROTO( 1137 const struct inode *inode, 1138 int found 1139 ), 1140 TP_ARGS(inode, found), 1141 TP_STRUCT__entry( 1142 __field(const struct inode *, inode) 1143 __field(int, found) 1144 ), 1145 TP_fast_assign( 1146 __entry->inode = inode; 1147 __entry->found = found; 1148 ), 1149 TP_printk("inode=%p is %scached", 1150 __entry->inode, 1151 __entry->found ? "" : "not " 1152 ) 1153); 1154 1155TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1156 TP_PROTO(struct inode *inode, u32 mask), 1157 TP_ARGS(inode, mask), 1158 TP_STRUCT__entry( 1159 __field(struct inode *, inode) 1160 __field(unsigned int, nlink) 1161 __field(umode_t, mode) 1162 __field(u32, mask) 1163 ), 1164 TP_fast_assign( 1165 __entry->inode = inode; 1166 __entry->nlink = inode->i_nlink; 1167 __entry->mode = inode->i_mode; 1168 __entry->mask = mask; 1169 ), 1170 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1171 __entry->nlink, __entry->mode, __entry->mask) 1172); 1173 1174DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1175 TP_PROTO( 1176 const struct nfsd_file *nf 1177 ), 1178 TP_ARGS(nf), 1179 TP_STRUCT__entry( 1180 __field(void *, nf_inode) 1181 __field(void *, nf_file) 1182 __field(int, nf_ref) 1183 __field(unsigned long, nf_flags) 1184 ), 1185 TP_fast_assign( 1186 __entry->nf_inode = nf->nf_inode; 1187 __entry->nf_file = nf->nf_file; 1188 __entry->nf_ref = refcount_read(&nf->nf_ref); 1189 __entry->nf_flags = nf->nf_flags; 1190 ), 1191 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1192 __entry->nf_inode, __entry->nf_ref, 1193 show_nf_flags(__entry->nf_flags), 1194 __entry->nf_file 1195 ) 1196); 1197 1198#define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1199DEFINE_EVENT(nfsd_file_gc_class, name, \ 1200 TP_PROTO( \ 1201 const struct nfsd_file *nf \ 1202 ), \ 1203 TP_ARGS(nf)) 1204 1205DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1206DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1207DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1208DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1209DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1210DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1211DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1212DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1213 1214DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1215 TP_PROTO( 1216 unsigned long removed, 1217 unsigned long remaining 1218 ), 1219 TP_ARGS(removed, remaining), 1220 TP_STRUCT__entry( 1221 __field(unsigned long, removed) 1222 __field(unsigned long, remaining) 1223 ), 1224 TP_fast_assign( 1225 __entry->removed = removed; 1226 __entry->remaining = remaining; 1227 ), 1228 TP_printk("%lu entries removed, %lu remaining", 1229 __entry->removed, __entry->remaining) 1230); 1231 1232#define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1233DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1234 TP_PROTO( \ 1235 unsigned long removed, \ 1236 unsigned long remaining \ 1237 ), \ 1238 TP_ARGS(removed, remaining)) 1239 1240DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1241DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1242 1243TRACE_EVENT(nfsd_file_close, 1244 TP_PROTO( 1245 const struct inode *inode 1246 ), 1247 TP_ARGS(inode), 1248 TP_STRUCT__entry( 1249 __field(const void *, inode) 1250 ), 1251 TP_fast_assign( 1252 __entry->inode = inode; 1253 ), 1254 TP_printk("inode=%p", 1255 __entry->inode 1256 ) 1257); 1258 1259#include "cache.h" 1260 1261TRACE_DEFINE_ENUM(RC_DROPIT); 1262TRACE_DEFINE_ENUM(RC_REPLY); 1263TRACE_DEFINE_ENUM(RC_DOIT); 1264 1265#define show_drc_retval(x) \ 1266 __print_symbolic(x, \ 1267 { RC_DROPIT, "DROPIT" }, \ 1268 { RC_REPLY, "REPLY" }, \ 1269 { RC_DOIT, "DOIT" }) 1270 1271TRACE_EVENT(nfsd_drc_found, 1272 TP_PROTO( 1273 const struct nfsd_net *nn, 1274 const struct svc_rqst *rqstp, 1275 int result 1276 ), 1277 TP_ARGS(nn, rqstp, result), 1278 TP_STRUCT__entry( 1279 __field(unsigned long long, boot_time) 1280 __field(unsigned long, result) 1281 __field(u32, xid) 1282 ), 1283 TP_fast_assign( 1284 __entry->boot_time = nn->boot_time; 1285 __entry->result = result; 1286 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1287 ), 1288 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1289 __entry->boot_time, __entry->xid, 1290 show_drc_retval(__entry->result)) 1291 1292); 1293 1294TRACE_EVENT(nfsd_drc_mismatch, 1295 TP_PROTO( 1296 const struct nfsd_net *nn, 1297 const struct nfsd_cacherep *key, 1298 const struct nfsd_cacherep *rp 1299 ), 1300 TP_ARGS(nn, key, rp), 1301 TP_STRUCT__entry( 1302 __field(unsigned long long, boot_time) 1303 __field(u32, xid) 1304 __field(u32, cached) 1305 __field(u32, ingress) 1306 ), 1307 TP_fast_assign( 1308 __entry->boot_time = nn->boot_time; 1309 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1310 __entry->cached = (__force u32)key->c_key.k_csum; 1311 __entry->ingress = (__force u32)rp->c_key.k_csum; 1312 ), 1313 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1314 __entry->boot_time, __entry->xid, __entry->cached, 1315 __entry->ingress) 1316); 1317 1318TRACE_EVENT(nfsd_cb_args, 1319 TP_PROTO( 1320 const struct nfs4_client *clp, 1321 const struct nfs4_cb_conn *conn 1322 ), 1323 TP_ARGS(clp, conn), 1324 TP_STRUCT__entry( 1325 __field(u32, cl_boot) 1326 __field(u32, cl_id) 1327 __field(u32, prog) 1328 __field(u32, ident) 1329 __sockaddr(addr, conn->cb_addrlen) 1330 ), 1331 TP_fast_assign( 1332 __entry->cl_boot = clp->cl_clientid.cl_boot; 1333 __entry->cl_id = clp->cl_clientid.cl_id; 1334 __entry->prog = conn->cb_prog; 1335 __entry->ident = conn->cb_ident; 1336 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1337 ), 1338 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1339 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1340 __entry->prog, __entry->ident) 1341); 1342 1343TRACE_EVENT(nfsd_cb_nodelegs, 1344 TP_PROTO(const struct nfs4_client *clp), 1345 TP_ARGS(clp), 1346 TP_STRUCT__entry( 1347 __field(u32, cl_boot) 1348 __field(u32, cl_id) 1349 ), 1350 TP_fast_assign( 1351 __entry->cl_boot = clp->cl_clientid.cl_boot; 1352 __entry->cl_id = clp->cl_clientid.cl_id; 1353 ), 1354 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1355) 1356 1357#define show_cb_state(val) \ 1358 __print_symbolic(val, \ 1359 { NFSD4_CB_UP, "UP" }, \ 1360 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1361 { NFSD4_CB_DOWN, "DOWN" }, \ 1362 { NFSD4_CB_FAULT, "FAULT"}) 1363 1364DECLARE_EVENT_CLASS(nfsd_cb_class, 1365 TP_PROTO(const struct nfs4_client *clp), 1366 TP_ARGS(clp), 1367 TP_STRUCT__entry( 1368 __field(unsigned long, state) 1369 __field(u32, cl_boot) 1370 __field(u32, cl_id) 1371 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1372 ), 1373 TP_fast_assign( 1374 __entry->state = clp->cl_cb_state; 1375 __entry->cl_boot = clp->cl_clientid.cl_boot; 1376 __entry->cl_id = clp->cl_clientid.cl_id; 1377 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1378 clp->cl_cb_conn.cb_addrlen) 1379 ), 1380 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1381 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1382 show_cb_state(__entry->state)) 1383); 1384 1385#define DEFINE_NFSD_CB_EVENT(name) \ 1386DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1387 TP_PROTO(const struct nfs4_client *clp), \ 1388 TP_ARGS(clp)) 1389 1390DEFINE_NFSD_CB_EVENT(start); 1391DEFINE_NFSD_CB_EVENT(new_state); 1392DEFINE_NFSD_CB_EVENT(probe); 1393DEFINE_NFSD_CB_EVENT(lost); 1394DEFINE_NFSD_CB_EVENT(shutdown); 1395 1396TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1397TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1398TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1399TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1400TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1401TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1402 1403#define show_nfsd_authflavor(val) \ 1404 __print_symbolic(val, \ 1405 { RPC_AUTH_NULL, "none" }, \ 1406 { RPC_AUTH_UNIX, "sys" }, \ 1407 { RPC_AUTH_GSS, "gss" }, \ 1408 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1409 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1410 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1411 1412TRACE_EVENT(nfsd_cb_setup, 1413 TP_PROTO(const struct nfs4_client *clp, 1414 const char *netid, 1415 rpc_authflavor_t authflavor 1416 ), 1417 TP_ARGS(clp, netid, authflavor), 1418 TP_STRUCT__entry( 1419 __field(u32, cl_boot) 1420 __field(u32, cl_id) 1421 __field(unsigned long, authflavor) 1422 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1423 __string(netid, netid) 1424 ), 1425 TP_fast_assign( 1426 __entry->cl_boot = clp->cl_clientid.cl_boot; 1427 __entry->cl_id = clp->cl_clientid.cl_id; 1428 __assign_str(netid, netid); 1429 __entry->authflavor = authflavor; 1430 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1431 clp->cl_cb_conn.cb_addrlen) 1432 ), 1433 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1434 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1435 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1436); 1437 1438TRACE_EVENT(nfsd_cb_setup_err, 1439 TP_PROTO( 1440 const struct nfs4_client *clp, 1441 long error 1442 ), 1443 TP_ARGS(clp, error), 1444 TP_STRUCT__entry( 1445 __field(long, error) 1446 __field(u32, cl_boot) 1447 __field(u32, cl_id) 1448 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1449 ), 1450 TP_fast_assign( 1451 __entry->error = error; 1452 __entry->cl_boot = clp->cl_clientid.cl_boot; 1453 __entry->cl_id = clp->cl_clientid.cl_id; 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 error=%ld", 1458 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1459 __entry->error) 1460); 1461 1462DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class, 1463 TP_PROTO( 1464 const struct nfs4_client *clp, 1465 const struct nfsd4_callback *cb 1466 ), 1467 TP_ARGS(clp, cb), 1468 TP_STRUCT__entry( 1469 __field(u32, cl_boot) 1470 __field(u32, cl_id) 1471 __field(const void *, cb) 1472 __field(bool, need_restart) 1473 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1474 ), 1475 TP_fast_assign( 1476 __entry->cl_boot = clp->cl_clientid.cl_boot; 1477 __entry->cl_id = clp->cl_clientid.cl_id; 1478 __entry->cb = cb; 1479 __entry->need_restart = cb->cb_need_restart; 1480 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1481 clp->cl_cb_conn.cb_addrlen) 1482 ), 1483 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s", 1484 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1485 __entry->cb, __entry->need_restart ? 1486 " (need restart)" : " (first try)" 1487 ) 1488); 1489 1490#define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \ 1491DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \ 1492 TP_PROTO( \ 1493 const struct nfs4_client *clp, \ 1494 const struct nfsd4_callback *cb \ 1495 ), \ 1496 TP_ARGS(clp, cb)) 1497 1498DEFINE_NFSD_CB_LIFETIME_EVENT(queue); 1499DEFINE_NFSD_CB_LIFETIME_EVENT(destroy); 1500DEFINE_NFSD_CB_LIFETIME_EVENT(restart); 1501DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update); 1502DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown); 1503 1504TRACE_EVENT(nfsd_cb_seq_status, 1505 TP_PROTO( 1506 const struct rpc_task *task, 1507 const struct nfsd4_callback *cb 1508 ), 1509 TP_ARGS(task, cb), 1510 TP_STRUCT__entry( 1511 __field(unsigned int, task_id) 1512 __field(unsigned int, client_id) 1513 __field(u32, cl_boot) 1514 __field(u32, cl_id) 1515 __field(u32, seqno) 1516 __field(u32, reserved) 1517 __field(int, tk_status) 1518 __field(int, seq_status) 1519 ), 1520 TP_fast_assign( 1521 const struct nfs4_client *clp = cb->cb_clp; 1522 const struct nfsd4_session *session = clp->cl_cb_session; 1523 const struct nfsd4_sessionid *sid = 1524 (struct nfsd4_sessionid *)&session->se_sessionid; 1525 1526 __entry->task_id = task->tk_pid; 1527 __entry->client_id = task->tk_client ? 1528 task->tk_client->cl_clid : -1; 1529 __entry->cl_boot = sid->clientid.cl_boot; 1530 __entry->cl_id = sid->clientid.cl_id; 1531 __entry->seqno = sid->sequence; 1532 __entry->reserved = sid->reserved; 1533 __entry->tk_status = task->tk_status; 1534 __entry->seq_status = cb->cb_seq_status; 1535 ), 1536 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1537 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d\n", 1538 __entry->task_id, __entry->client_id, 1539 __entry->cl_boot, __entry->cl_id, 1540 __entry->seqno, __entry->reserved, 1541 __entry->tk_status, __entry->seq_status 1542 ) 1543); 1544 1545TRACE_EVENT(nfsd_cb_free_slot, 1546 TP_PROTO( 1547 const struct rpc_task *task, 1548 const struct nfsd4_callback *cb 1549 ), 1550 TP_ARGS(task, cb), 1551 TP_STRUCT__entry( 1552 __field(unsigned int, task_id) 1553 __field(unsigned int, client_id) 1554 __field(u32, cl_boot) 1555 __field(u32, cl_id) 1556 __field(u32, seqno) 1557 __field(u32, reserved) 1558 __field(u32, slot_seqno) 1559 ), 1560 TP_fast_assign( 1561 const struct nfs4_client *clp = cb->cb_clp; 1562 const struct nfsd4_session *session = clp->cl_cb_session; 1563 const struct nfsd4_sessionid *sid = 1564 (struct nfsd4_sessionid *)&session->se_sessionid; 1565 1566 __entry->task_id = task->tk_pid; 1567 __entry->client_id = task->tk_client ? 1568 task->tk_client->cl_clid : -1; 1569 __entry->cl_boot = sid->clientid.cl_boot; 1570 __entry->cl_id = sid->clientid.cl_id; 1571 __entry->seqno = sid->sequence; 1572 __entry->reserved = sid->reserved; 1573 __entry->slot_seqno = session->se_cb_seq_nr; 1574 ), 1575 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1576 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u\n", 1577 __entry->task_id, __entry->client_id, 1578 __entry->cl_boot, __entry->cl_id, 1579 __entry->seqno, __entry->reserved, 1580 __entry->slot_seqno 1581 ) 1582); 1583 1584TRACE_EVENT_CONDITION(nfsd_cb_recall, 1585 TP_PROTO( 1586 const struct nfs4_stid *stid 1587 ), 1588 TP_ARGS(stid), 1589 TP_CONDITION(stid->sc_client), 1590 TP_STRUCT__entry( 1591 __field(u32, cl_boot) 1592 __field(u32, cl_id) 1593 __field(u32, si_id) 1594 __field(u32, si_generation) 1595 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1596 ), 1597 TP_fast_assign( 1598 const stateid_t *stp = &stid->sc_stateid; 1599 const struct nfs4_client *clp = stid->sc_client; 1600 1601 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1602 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1603 __entry->si_id = stp->si_opaque.so_id; 1604 __entry->si_generation = stp->si_generation; 1605 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1606 clp->cl_cb_conn.cb_addrlen) 1607 ), 1608 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1609 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1610 __entry->si_id, __entry->si_generation) 1611); 1612 1613TRACE_EVENT(nfsd_cb_notify_lock, 1614 TP_PROTO( 1615 const struct nfs4_lockowner *lo, 1616 const struct nfsd4_blocked_lock *nbl 1617 ), 1618 TP_ARGS(lo, nbl), 1619 TP_STRUCT__entry( 1620 __field(u32, cl_boot) 1621 __field(u32, cl_id) 1622 __field(u32, fh_hash) 1623 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1624 ), 1625 TP_fast_assign( 1626 const struct nfs4_client *clp = lo->lo_owner.so_client; 1627 1628 __entry->cl_boot = clp->cl_clientid.cl_boot; 1629 __entry->cl_id = clp->cl_clientid.cl_id; 1630 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1631 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1632 clp->cl_cb_conn.cb_addrlen) 1633 ), 1634 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1635 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1636 __entry->fh_hash) 1637); 1638 1639TRACE_EVENT(nfsd_cb_offload, 1640 TP_PROTO( 1641 const struct nfs4_client *clp, 1642 const stateid_t *stp, 1643 const struct knfsd_fh *fh, 1644 u64 count, 1645 __be32 status 1646 ), 1647 TP_ARGS(clp, stp, fh, count, status), 1648 TP_STRUCT__entry( 1649 __field(u32, cl_boot) 1650 __field(u32, cl_id) 1651 __field(u32, si_id) 1652 __field(u32, si_generation) 1653 __field(u32, fh_hash) 1654 __field(int, status) 1655 __field(u64, count) 1656 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1657 ), 1658 TP_fast_assign( 1659 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1660 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1661 __entry->si_id = stp->si_opaque.so_id; 1662 __entry->si_generation = stp->si_generation; 1663 __entry->fh_hash = knfsd_fh_hash(fh); 1664 __entry->status = be32_to_cpu(status); 1665 __entry->count = count; 1666 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1667 clp->cl_cb_conn.cb_addrlen) 1668 ), 1669 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1670 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1671 __entry->si_id, __entry->si_generation, 1672 __entry->fh_hash, __entry->count, __entry->status) 1673); 1674 1675TRACE_EVENT(nfsd_cb_recall_any, 1676 TP_PROTO( 1677 const struct nfsd4_cb_recall_any *ra 1678 ), 1679 TP_ARGS(ra), 1680 TP_STRUCT__entry( 1681 __field(u32, cl_boot) 1682 __field(u32, cl_id) 1683 __field(u32, keep) 1684 __field(unsigned long, bmval0) 1685 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1686 ), 1687 TP_fast_assign( 1688 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1689 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1690 __entry->keep = ra->ra_keep; 1691 __entry->bmval0 = ra->ra_bmval[0]; 1692 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1693 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1694 ), 1695 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1696 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1697 __entry->keep, show_rca_mask(__entry->bmval0) 1698 ) 1699); 1700 1701DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1702 TP_PROTO( 1703 const stateid_t *stp, 1704 const struct rpc_task *task 1705 ), 1706 TP_ARGS(stp, task), 1707 TP_STRUCT__entry( 1708 __field(u32, cl_boot) 1709 __field(u32, cl_id) 1710 __field(u32, si_id) 1711 __field(u32, si_generation) 1712 __field(int, status) 1713 ), 1714 TP_fast_assign( 1715 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1716 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1717 __entry->si_id = stp->si_opaque.so_id; 1718 __entry->si_generation = stp->si_generation; 1719 __entry->status = task->tk_status; 1720 ), 1721 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1722 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1723 __entry->si_generation, __entry->status 1724 ) 1725); 1726 1727#define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1728DEFINE_EVENT(nfsd_cb_done_class, name, \ 1729 TP_PROTO( \ 1730 const stateid_t *stp, \ 1731 const struct rpc_task *task \ 1732 ), \ 1733 TP_ARGS(stp, task)) 1734 1735DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1736DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1737DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1738DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1739 1740TRACE_EVENT(nfsd_cb_recall_any_done, 1741 TP_PROTO( 1742 const struct nfsd4_callback *cb, 1743 const struct rpc_task *task 1744 ), 1745 TP_ARGS(cb, task), 1746 TP_STRUCT__entry( 1747 __field(u32, cl_boot) 1748 __field(u32, cl_id) 1749 __field(int, status) 1750 ), 1751 TP_fast_assign( 1752 __entry->status = task->tk_status; 1753 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1754 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1755 ), 1756 TP_printk("client %08x:%08x status=%d", 1757 __entry->cl_boot, __entry->cl_id, __entry->status 1758 ) 1759); 1760 1761TRACE_EVENT(nfsd_ctl_unlock_ip, 1762 TP_PROTO( 1763 const struct net *net, 1764 const char *address 1765 ), 1766 TP_ARGS(net, address), 1767 TP_STRUCT__entry( 1768 __field(unsigned int, netns_ino) 1769 __string(address, address) 1770 ), 1771 TP_fast_assign( 1772 __entry->netns_ino = net->ns.inum; 1773 __assign_str(address, address); 1774 ), 1775 TP_printk("address=%s", 1776 __get_str(address) 1777 ) 1778); 1779 1780TRACE_EVENT(nfsd_ctl_unlock_fs, 1781 TP_PROTO( 1782 const struct net *net, 1783 const char *path 1784 ), 1785 TP_ARGS(net, path), 1786 TP_STRUCT__entry( 1787 __field(unsigned int, netns_ino) 1788 __string(path, path) 1789 ), 1790 TP_fast_assign( 1791 __entry->netns_ino = net->ns.inum; 1792 __assign_str(path, path); 1793 ), 1794 TP_printk("path=%s", 1795 __get_str(path) 1796 ) 1797); 1798 1799TRACE_EVENT(nfsd_ctl_filehandle, 1800 TP_PROTO( 1801 const struct net *net, 1802 const char *domain, 1803 const char *path, 1804 int maxsize 1805 ), 1806 TP_ARGS(net, domain, path, maxsize), 1807 TP_STRUCT__entry( 1808 __field(unsigned int, netns_ino) 1809 __field(int, maxsize) 1810 __string(domain, domain) 1811 __string(path, path) 1812 ), 1813 TP_fast_assign( 1814 __entry->netns_ino = net->ns.inum; 1815 __entry->maxsize = maxsize; 1816 __assign_str(domain, domain); 1817 __assign_str(path, path); 1818 ), 1819 TP_printk("domain=%s path=%s maxsize=%d", 1820 __get_str(domain), __get_str(path), __entry->maxsize 1821 ) 1822); 1823 1824TRACE_EVENT(nfsd_ctl_threads, 1825 TP_PROTO( 1826 const struct net *net, 1827 int newthreads 1828 ), 1829 TP_ARGS(net, newthreads), 1830 TP_STRUCT__entry( 1831 __field(unsigned int, netns_ino) 1832 __field(int, newthreads) 1833 ), 1834 TP_fast_assign( 1835 __entry->netns_ino = net->ns.inum; 1836 __entry->newthreads = newthreads; 1837 ), 1838 TP_printk("newthreads=%d", 1839 __entry->newthreads 1840 ) 1841); 1842 1843TRACE_EVENT(nfsd_ctl_pool_threads, 1844 TP_PROTO( 1845 const struct net *net, 1846 int pool, 1847 int nrthreads 1848 ), 1849 TP_ARGS(net, pool, nrthreads), 1850 TP_STRUCT__entry( 1851 __field(unsigned int, netns_ino) 1852 __field(int, pool) 1853 __field(int, nrthreads) 1854 ), 1855 TP_fast_assign( 1856 __entry->netns_ino = net->ns.inum; 1857 __entry->pool = pool; 1858 __entry->nrthreads = nrthreads; 1859 ), 1860 TP_printk("pool=%d nrthreads=%d", 1861 __entry->pool, __entry->nrthreads 1862 ) 1863); 1864 1865TRACE_EVENT(nfsd_ctl_version, 1866 TP_PROTO( 1867 const struct net *net, 1868 const char *mesg 1869 ), 1870 TP_ARGS(net, mesg), 1871 TP_STRUCT__entry( 1872 __field(unsigned int, netns_ino) 1873 __string(mesg, mesg) 1874 ), 1875 TP_fast_assign( 1876 __entry->netns_ino = net->ns.inum; 1877 __assign_str(mesg, mesg); 1878 ), 1879 TP_printk("%s", 1880 __get_str(mesg) 1881 ) 1882); 1883 1884TRACE_EVENT(nfsd_ctl_ports_addfd, 1885 TP_PROTO( 1886 const struct net *net, 1887 int fd 1888 ), 1889 TP_ARGS(net, fd), 1890 TP_STRUCT__entry( 1891 __field(unsigned int, netns_ino) 1892 __field(int, fd) 1893 ), 1894 TP_fast_assign( 1895 __entry->netns_ino = net->ns.inum; 1896 __entry->fd = fd; 1897 ), 1898 TP_printk("fd=%d", 1899 __entry->fd 1900 ) 1901); 1902 1903TRACE_EVENT(nfsd_ctl_ports_addxprt, 1904 TP_PROTO( 1905 const struct net *net, 1906 const char *transport, 1907 int port 1908 ), 1909 TP_ARGS(net, transport, port), 1910 TP_STRUCT__entry( 1911 __field(unsigned int, netns_ino) 1912 __field(int, port) 1913 __string(transport, transport) 1914 ), 1915 TP_fast_assign( 1916 __entry->netns_ino = net->ns.inum; 1917 __entry->port = port; 1918 __assign_str(transport, transport); 1919 ), 1920 TP_printk("transport=%s port=%d", 1921 __get_str(transport), __entry->port 1922 ) 1923); 1924 1925TRACE_EVENT(nfsd_ctl_maxblksize, 1926 TP_PROTO( 1927 const struct net *net, 1928 int bsize 1929 ), 1930 TP_ARGS(net, bsize), 1931 TP_STRUCT__entry( 1932 __field(unsigned int, netns_ino) 1933 __field(int, bsize) 1934 ), 1935 TP_fast_assign( 1936 __entry->netns_ino = net->ns.inum; 1937 __entry->bsize = bsize; 1938 ), 1939 TP_printk("bsize=%d", 1940 __entry->bsize 1941 ) 1942); 1943 1944TRACE_EVENT(nfsd_ctl_maxconn, 1945 TP_PROTO( 1946 const struct net *net, 1947 int maxconn 1948 ), 1949 TP_ARGS(net, maxconn), 1950 TP_STRUCT__entry( 1951 __field(unsigned int, netns_ino) 1952 __field(int, maxconn) 1953 ), 1954 TP_fast_assign( 1955 __entry->netns_ino = net->ns.inum; 1956 __entry->maxconn = maxconn; 1957 ), 1958 TP_printk("maxconn=%d", 1959 __entry->maxconn 1960 ) 1961); 1962 1963TRACE_EVENT(nfsd_ctl_time, 1964 TP_PROTO( 1965 const struct net *net, 1966 const char *name, 1967 size_t namelen, 1968 int time 1969 ), 1970 TP_ARGS(net, name, namelen, time), 1971 TP_STRUCT__entry( 1972 __field(unsigned int, netns_ino) 1973 __field(int, time) 1974 __string_len(name, name, namelen) 1975 ), 1976 TP_fast_assign( 1977 __entry->netns_ino = net->ns.inum; 1978 __entry->time = time; 1979 __assign_str(name, name); 1980 ), 1981 TP_printk("file=%s time=%d\n", 1982 __get_str(name), __entry->time 1983 ) 1984); 1985 1986TRACE_EVENT(nfsd_ctl_recoverydir, 1987 TP_PROTO( 1988 const struct net *net, 1989 const char *recdir 1990 ), 1991 TP_ARGS(net, recdir), 1992 TP_STRUCT__entry( 1993 __field(unsigned int, netns_ino) 1994 __string(recdir, recdir) 1995 ), 1996 TP_fast_assign( 1997 __entry->netns_ino = net->ns.inum; 1998 __assign_str(recdir, recdir); 1999 ), 2000 TP_printk("recdir=%s", 2001 __get_str(recdir) 2002 ) 2003); 2004 2005TRACE_EVENT(nfsd_end_grace, 2006 TP_PROTO( 2007 const struct net *net 2008 ), 2009 TP_ARGS(net), 2010 TP_STRUCT__entry( 2011 __field(unsigned int, netns_ino) 2012 ), 2013 TP_fast_assign( 2014 __entry->netns_ino = net->ns.inum; 2015 ), 2016 TP_printk("nn=%d", __entry->netns_ino 2017 ) 2018); 2019 2020DECLARE_EVENT_CLASS(nfsd_copy_class, 2021 TP_PROTO( 2022 const struct nfsd4_copy *copy 2023 ), 2024 TP_ARGS(copy), 2025 TP_STRUCT__entry( 2026 __field(bool, intra) 2027 __field(bool, async) 2028 __field(u32, src_cl_boot) 2029 __field(u32, src_cl_id) 2030 __field(u32, src_so_id) 2031 __field(u32, src_si_generation) 2032 __field(u32, dst_cl_boot) 2033 __field(u32, dst_cl_id) 2034 __field(u32, dst_so_id) 2035 __field(u32, dst_si_generation) 2036 __field(u64, src_cp_pos) 2037 __field(u64, dst_cp_pos) 2038 __field(u64, cp_count) 2039 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2040 ), 2041 TP_fast_assign( 2042 const stateid_t *src_stp = ©->cp_src_stateid; 2043 const stateid_t *dst_stp = ©->cp_dst_stateid; 2044 2045 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2046 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2047 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2048 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2049 __entry->src_so_id = src_stp->si_opaque.so_id; 2050 __entry->src_si_generation = src_stp->si_generation; 2051 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2052 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2053 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2054 __entry->dst_si_generation = dst_stp->si_generation; 2055 __entry->src_cp_pos = copy->cp_src_pos; 2056 __entry->dst_cp_pos = copy->cp_dst_pos; 2057 __entry->cp_count = copy->cp_count; 2058 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2059 sizeof(struct sockaddr_in6)); 2060 ), 2061 TP_printk("client=%pISpc intra=%d async=%d " 2062 "src_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] " 2063 "dst_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] " 2064 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2065 __get_sockaddr(addr), __entry->intra, __entry->async, 2066 __entry->src_si_generation, __entry->src_cl_boot, 2067 __entry->src_cl_id, __entry->src_so_id, 2068 __entry->dst_si_generation, __entry->dst_cl_boot, 2069 __entry->dst_cl_id, __entry->dst_so_id, 2070 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2071 ) 2072); 2073 2074#define DEFINE_COPY_EVENT(name) \ 2075DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \ 2076 TP_PROTO(const struct nfsd4_copy *copy), \ 2077 TP_ARGS(copy)) 2078 2079DEFINE_COPY_EVENT(inter); 2080DEFINE_COPY_EVENT(intra); 2081DEFINE_COPY_EVENT(do_async); 2082 2083TRACE_EVENT(nfsd_copy_done, 2084 TP_PROTO( 2085 const struct nfsd4_copy *copy, 2086 __be32 status 2087 ), 2088 TP_ARGS(copy, status), 2089 TP_STRUCT__entry( 2090 __field(int, status) 2091 __field(bool, intra) 2092 __field(bool, async) 2093 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2094 ), 2095 TP_fast_assign( 2096 __entry->status = be32_to_cpu(status); 2097 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2098 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2099 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2100 sizeof(struct sockaddr_in6)); 2101 ), 2102 TP_printk("addr=%pISpc status=%d intra=%d async=%d ", 2103 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async 2104 ) 2105); 2106 2107#endif /* _NFSD_TRACE_H */ 2108 2109#undef TRACE_INCLUDE_PATH 2110#define TRACE_INCLUDE_PATH . 2111#define TRACE_INCLUDE_FILE trace 2112#include <trace/define_trace.h> 2113