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