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