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