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