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 TRACE_EVENT(nfsd_slot_seqid_sequence, 807 TP_PROTO( 808 const struct nfs4_client *clp, 809 const struct nfsd4_sequence *seq, 810 const struct nfsd4_slot *slot 811 ), 812 TP_ARGS(clp, seq, slot), 813 TP_STRUCT__entry( 814 __field(u32, seqid) 815 __field(u32, slot_seqid) 816 __field(u32, cl_boot) 817 __field(u32, cl_id) 818 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 819 __field(bool, in_use) 820 ), 821 TP_fast_assign( 822 __entry->cl_boot = clp->cl_clientid.cl_boot; 823 __entry->cl_id = clp->cl_clientid.cl_id; 824 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 825 clp->cl_cb_conn.cb_addrlen); 826 __entry->seqid = seq->seqid; 827 __entry->slot_seqid = slot->sl_seqid; 828 ), 829 TP_printk("addr=%pISpc client %08x:%08x seqid=%u slot_seqid=%u (%sin use)", 830 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 831 __entry->seqid, __entry->slot_seqid, 832 __entry->in_use ? "" : "not " 833 ) 834 ); 835 836 DECLARE_EVENT_CLASS(nfsd_clientid_class, 837 TP_PROTO(const clientid_t *clid), 838 TP_ARGS(clid), 839 TP_STRUCT__entry( 840 __field(u32, cl_boot) 841 __field(u32, cl_id) 842 ), 843 TP_fast_assign( 844 __entry->cl_boot = clid->cl_boot; 845 __entry->cl_id = clid->cl_id; 846 ), 847 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 848 ) 849 850 #define DEFINE_CLIENTID_EVENT(name) \ 851 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 852 TP_PROTO(const clientid_t *clid), \ 853 TP_ARGS(clid)) 854 855 DEFINE_CLIENTID_EVENT(expire_unconf); 856 DEFINE_CLIENTID_EVENT(reclaim_complete); 857 DEFINE_CLIENTID_EVENT(confirmed); 858 DEFINE_CLIENTID_EVENT(destroyed); 859 DEFINE_CLIENTID_EVENT(admin_expired); 860 DEFINE_CLIENTID_EVENT(replaced); 861 DEFINE_CLIENTID_EVENT(purged); 862 DEFINE_CLIENTID_EVENT(renew); 863 DEFINE_CLIENTID_EVENT(stale); 864 865 TRACE_EVENT(nfsd_mark_client_expired, 866 TP_PROTO( 867 const struct nfs4_client *clp, 868 int cl_rpc_users 869 ), 870 TP_ARGS(clp, cl_rpc_users), 871 TP_STRUCT__entry( 872 __field(int, cl_rpc_users) 873 __field(u32, cl_boot) 874 __field(u32, cl_id) 875 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 876 ), 877 TP_fast_assign( 878 __entry->cl_rpc_users = cl_rpc_users; 879 __entry->cl_boot = clp->cl_clientid.cl_boot; 880 __entry->cl_id = clp->cl_clientid.cl_id; 881 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 882 clp->cl_cb_conn.cb_addrlen) 883 ), 884 TP_printk("addr=%pISpc client %08x:%08x cl_rpc_users=%d", 885 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 886 __entry->cl_rpc_users) 887 ); 888 889 DECLARE_EVENT_CLASS(nfsd_net_class, 890 TP_PROTO(const struct nfsd_net *nn), 891 TP_ARGS(nn), 892 TP_STRUCT__entry( 893 __field(unsigned long long, boot_time) 894 ), 895 TP_fast_assign( 896 __entry->boot_time = nn->boot_time; 897 ), 898 TP_printk("boot_time=%16llx", __entry->boot_time) 899 ) 900 901 #define DEFINE_NET_EVENT(name) \ 902 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 903 TP_PROTO(const struct nfsd_net *nn), \ 904 TP_ARGS(nn)) 905 906 DEFINE_NET_EVENT(grace_start); 907 DEFINE_NET_EVENT(grace_complete); 908 909 TRACE_EVENT(nfsd_writeverf_reset, 910 TP_PROTO( 911 const struct nfsd_net *nn, 912 const struct svc_rqst *rqstp, 913 int error 914 ), 915 TP_ARGS(nn, rqstp, error), 916 TP_STRUCT__entry( 917 __field(unsigned long long, boot_time) 918 __field(u32, xid) 919 __field(int, error) 920 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 921 ), 922 TP_fast_assign( 923 __entry->boot_time = nn->boot_time; 924 __entry->xid = be32_to_cpu(rqstp->rq_xid); 925 __entry->error = error; 926 927 /* avoid seqlock inside TP_fast_assign */ 928 memcpy(__entry->verifier, nn->writeverf, 929 NFS4_VERIFIER_SIZE); 930 ), 931 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 932 __entry->boot_time, __entry->xid, __entry->error, 933 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 934 ) 935 ); 936 937 TRACE_EVENT(nfsd_clid_cred_mismatch, 938 TP_PROTO( 939 const struct nfs4_client *clp, 940 const struct svc_rqst *rqstp 941 ), 942 TP_ARGS(clp, rqstp), 943 TP_STRUCT__entry( 944 __field(u32, cl_boot) 945 __field(u32, cl_id) 946 __field(unsigned long, cl_flavor) 947 __field(unsigned long, new_flavor) 948 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 949 ), 950 TP_fast_assign( 951 __entry->cl_boot = clp->cl_clientid.cl_boot; 952 __entry->cl_id = clp->cl_clientid.cl_id; 953 __entry->cl_flavor = clp->cl_cred.cr_flavor; 954 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 955 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 956 rqstp->rq_xprt->xpt_remotelen); 957 ), 958 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 959 __entry->cl_boot, __entry->cl_id, 960 show_nfsd_authflavor(__entry->cl_flavor), 961 show_nfsd_authflavor(__entry->new_flavor), 962 __get_sockaddr(addr) 963 ) 964 ) 965 966 TRACE_EVENT(nfsd_clid_verf_mismatch, 967 TP_PROTO( 968 const struct nfs4_client *clp, 969 const struct svc_rqst *rqstp, 970 const nfs4_verifier *verf 971 ), 972 TP_ARGS(clp, rqstp, verf), 973 TP_STRUCT__entry( 974 __field(u32, cl_boot) 975 __field(u32, cl_id) 976 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 977 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 978 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 979 ), 980 TP_fast_assign( 981 __entry->cl_boot = clp->cl_clientid.cl_boot; 982 __entry->cl_id = clp->cl_clientid.cl_id; 983 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 984 NFS4_VERIFIER_SIZE); 985 memcpy(__entry->new_verifier, (void *)verf, 986 NFS4_VERIFIER_SIZE); 987 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 988 rqstp->rq_xprt->xpt_remotelen); 989 ), 990 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 991 __entry->cl_boot, __entry->cl_id, 992 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 993 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 994 __get_sockaddr(addr) 995 ) 996 ); 997 998 DECLARE_EVENT_CLASS(nfsd_clid_class, 999 TP_PROTO(const struct nfs4_client *clp), 1000 TP_ARGS(clp), 1001 TP_STRUCT__entry( 1002 __field(u32, cl_boot) 1003 __field(u32, cl_id) 1004 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1005 __field(unsigned long, flavor) 1006 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 1007 __string_len(name, clp->cl_name.data, clp->cl_name.len) 1008 ), 1009 TP_fast_assign( 1010 __entry->cl_boot = clp->cl_clientid.cl_boot; 1011 __entry->cl_id = clp->cl_clientid.cl_id; 1012 memcpy(__entry->addr, &clp->cl_addr, 1013 sizeof(struct sockaddr_in6)); 1014 __entry->flavor = clp->cl_cred.cr_flavor; 1015 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 1016 NFS4_VERIFIER_SIZE); 1017 __assign_str(name); 1018 ), 1019 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 1020 __entry->addr, __get_str(name), 1021 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 1022 show_nfsd_authflavor(__entry->flavor), 1023 __entry->cl_boot, __entry->cl_id) 1024 ); 1025 1026 #define DEFINE_CLID_EVENT(name) \ 1027 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 1028 TP_PROTO(const struct nfs4_client *clp), \ 1029 TP_ARGS(clp)) 1030 1031 DEFINE_CLID_EVENT(fresh); 1032 DEFINE_CLID_EVENT(confirmed_r); 1033 1034 /* 1035 * from fs/nfsd/filecache.h 1036 */ 1037 #define show_nf_flags(val) \ 1038 __print_flags(val, "|", \ 1039 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 1040 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 1041 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 1042 { 1 << NFSD_FILE_GC, "GC" }) 1043 1044 DECLARE_EVENT_CLASS(nfsd_file_class, 1045 TP_PROTO(struct nfsd_file *nf), 1046 TP_ARGS(nf), 1047 TP_STRUCT__entry( 1048 __field(void *, nf_inode) 1049 __field(int, nf_ref) 1050 __field(unsigned long, nf_flags) 1051 __field(unsigned char, nf_may) 1052 __field(struct file *, nf_file) 1053 ), 1054 TP_fast_assign( 1055 __entry->nf_inode = nf->nf_inode; 1056 __entry->nf_ref = refcount_read(&nf->nf_ref); 1057 __entry->nf_flags = nf->nf_flags; 1058 __entry->nf_may = nf->nf_may; 1059 __entry->nf_file = nf->nf_file; 1060 ), 1061 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 1062 __entry->nf_inode, 1063 __entry->nf_ref, 1064 show_nf_flags(__entry->nf_flags), 1065 show_nfsd_may_flags(__entry->nf_may), 1066 __entry->nf_file) 1067 ) 1068 1069 #define DEFINE_NFSD_FILE_EVENT(name) \ 1070 DEFINE_EVENT(nfsd_file_class, name, \ 1071 TP_PROTO(struct nfsd_file *nf), \ 1072 TP_ARGS(nf)) 1073 1074 DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 1075 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 1076 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 1077 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 1078 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 1079 1080 TRACE_EVENT(nfsd_file_alloc, 1081 TP_PROTO( 1082 const struct nfsd_file *nf 1083 ), 1084 TP_ARGS(nf), 1085 TP_STRUCT__entry( 1086 __field(const void *, nf_inode) 1087 __field(unsigned long, nf_flags) 1088 __field(unsigned long, nf_may) 1089 __field(unsigned int, nf_ref) 1090 ), 1091 TP_fast_assign( 1092 __entry->nf_inode = nf->nf_inode; 1093 __entry->nf_flags = nf->nf_flags; 1094 __entry->nf_ref = refcount_read(&nf->nf_ref); 1095 __entry->nf_may = nf->nf_may; 1096 ), 1097 TP_printk("inode=%p ref=%u flags=%s may=%s", 1098 __entry->nf_inode, __entry->nf_ref, 1099 show_nf_flags(__entry->nf_flags), 1100 show_nfsd_may_flags(__entry->nf_may) 1101 ) 1102 ); 1103 1104 TRACE_EVENT(nfsd_file_acquire, 1105 TP_PROTO( 1106 const struct svc_rqst *rqstp, 1107 const struct inode *inode, 1108 unsigned int may_flags, 1109 const struct nfsd_file *nf, 1110 __be32 status 1111 ), 1112 1113 TP_ARGS(rqstp, inode, may_flags, nf, status), 1114 1115 TP_STRUCT__entry( 1116 __field(u32, xid) 1117 __field(const void *, inode) 1118 __field(unsigned long, may_flags) 1119 __field(unsigned int, nf_ref) 1120 __field(unsigned long, nf_flags) 1121 __field(unsigned long, nf_may) 1122 __field(const void *, nf_file) 1123 __field(u32, status) 1124 ), 1125 1126 TP_fast_assign( 1127 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1128 __entry->inode = inode; 1129 __entry->may_flags = may_flags; 1130 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 1131 __entry->nf_flags = nf ? nf->nf_flags : 0; 1132 __entry->nf_may = nf ? nf->nf_may : 0; 1133 __entry->nf_file = nf ? nf->nf_file : NULL; 1134 __entry->status = be32_to_cpu(status); 1135 ), 1136 1137 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 1138 __entry->xid, __entry->inode, 1139 show_nfsd_may_flags(__entry->may_flags), 1140 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1141 show_nfsd_may_flags(__entry->nf_may), 1142 __entry->nf_file, __entry->status 1143 ) 1144 ); 1145 1146 TRACE_EVENT(nfsd_file_insert_err, 1147 TP_PROTO( 1148 const struct svc_rqst *rqstp, 1149 const struct inode *inode, 1150 unsigned int may_flags, 1151 long error 1152 ), 1153 TP_ARGS(rqstp, inode, may_flags, error), 1154 TP_STRUCT__entry( 1155 __field(u32, xid) 1156 __field(const void *, inode) 1157 __field(unsigned long, may_flags) 1158 __field(long, error) 1159 ), 1160 TP_fast_assign( 1161 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1162 __entry->inode = inode; 1163 __entry->may_flags = may_flags; 1164 __entry->error = error; 1165 ), 1166 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1167 __entry->xid, __entry->inode, 1168 show_nfsd_may_flags(__entry->may_flags), 1169 __entry->error 1170 ) 1171 ); 1172 1173 TRACE_EVENT(nfsd_file_cons_err, 1174 TP_PROTO( 1175 const struct svc_rqst *rqstp, 1176 const struct inode *inode, 1177 unsigned int may_flags, 1178 const struct nfsd_file *nf 1179 ), 1180 TP_ARGS(rqstp, inode, may_flags, nf), 1181 TP_STRUCT__entry( 1182 __field(u32, xid) 1183 __field(const void *, inode) 1184 __field(unsigned long, may_flags) 1185 __field(unsigned int, nf_ref) 1186 __field(unsigned long, nf_flags) 1187 __field(unsigned long, nf_may) 1188 __field(const void *, nf_file) 1189 ), 1190 TP_fast_assign( 1191 __entry->xid = rqstp ? be32_to_cpu(rqstp->rq_xid) : 0; 1192 __entry->inode = inode; 1193 __entry->may_flags = may_flags; 1194 __entry->nf_ref = refcount_read(&nf->nf_ref); 1195 __entry->nf_flags = nf->nf_flags; 1196 __entry->nf_may = nf->nf_may; 1197 __entry->nf_file = nf->nf_file; 1198 ), 1199 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1200 __entry->xid, __entry->inode, 1201 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1202 show_nf_flags(__entry->nf_flags), 1203 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1204 ) 1205 ); 1206 1207 DECLARE_EVENT_CLASS(nfsd_file_open_class, 1208 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1209 TP_ARGS(nf, status), 1210 TP_STRUCT__entry( 1211 __field(void *, nf_inode) /* cannot be dereferenced */ 1212 __field(int, nf_ref) 1213 __field(unsigned long, nf_flags) 1214 __field(unsigned long, nf_may) 1215 __field(void *, nf_file) /* cannot be dereferenced */ 1216 ), 1217 TP_fast_assign( 1218 __entry->nf_inode = nf->nf_inode; 1219 __entry->nf_ref = refcount_read(&nf->nf_ref); 1220 __entry->nf_flags = nf->nf_flags; 1221 __entry->nf_may = nf->nf_may; 1222 __entry->nf_file = nf->nf_file; 1223 ), 1224 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1225 __entry->nf_inode, 1226 __entry->nf_ref, 1227 show_nf_flags(__entry->nf_flags), 1228 show_nfsd_may_flags(__entry->nf_may), 1229 __entry->nf_file) 1230 ) 1231 1232 #define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1233 DEFINE_EVENT(nfsd_file_open_class, name, \ 1234 TP_PROTO( \ 1235 const struct nfsd_file *nf, \ 1236 __be32 status \ 1237 ), \ 1238 TP_ARGS(nf, status)) 1239 1240 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1241 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1242 1243 TRACE_EVENT(nfsd_file_is_cached, 1244 TP_PROTO( 1245 const struct inode *inode, 1246 int found 1247 ), 1248 TP_ARGS(inode, found), 1249 TP_STRUCT__entry( 1250 __field(const struct inode *, inode) 1251 __field(int, found) 1252 ), 1253 TP_fast_assign( 1254 __entry->inode = inode; 1255 __entry->found = found; 1256 ), 1257 TP_printk("inode=%p is %scached", 1258 __entry->inode, 1259 __entry->found ? "" : "not " 1260 ) 1261 ); 1262 1263 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1264 TP_PROTO(struct inode *inode, u32 mask), 1265 TP_ARGS(inode, mask), 1266 TP_STRUCT__entry( 1267 __field(struct inode *, inode) 1268 __field(unsigned int, nlink) 1269 __field(umode_t, mode) 1270 __field(u32, mask) 1271 ), 1272 TP_fast_assign( 1273 __entry->inode = inode; 1274 __entry->nlink = inode->i_nlink; 1275 __entry->mode = inode->i_mode; 1276 __entry->mask = mask; 1277 ), 1278 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1279 __entry->nlink, __entry->mode, __entry->mask) 1280 ); 1281 1282 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1283 TP_PROTO( 1284 const struct nfsd_file *nf 1285 ), 1286 TP_ARGS(nf), 1287 TP_STRUCT__entry( 1288 __field(void *, nf_inode) 1289 __field(void *, nf_file) 1290 __field(int, nf_ref) 1291 __field(unsigned long, nf_flags) 1292 ), 1293 TP_fast_assign( 1294 __entry->nf_inode = nf->nf_inode; 1295 __entry->nf_file = nf->nf_file; 1296 __entry->nf_ref = refcount_read(&nf->nf_ref); 1297 __entry->nf_flags = nf->nf_flags; 1298 ), 1299 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1300 __entry->nf_inode, __entry->nf_ref, 1301 show_nf_flags(__entry->nf_flags), 1302 __entry->nf_file 1303 ) 1304 ); 1305 1306 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1307 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1308 TP_PROTO( \ 1309 const struct nfsd_file *nf \ 1310 ), \ 1311 TP_ARGS(nf)) 1312 1313 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1314 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1315 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1316 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1317 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1318 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1319 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1320 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1321 1322 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1323 TP_PROTO( 1324 unsigned long removed, 1325 unsigned long remaining 1326 ), 1327 TP_ARGS(removed, remaining), 1328 TP_STRUCT__entry( 1329 __field(unsigned long, removed) 1330 __field(unsigned long, remaining) 1331 ), 1332 TP_fast_assign( 1333 __entry->removed = removed; 1334 __entry->remaining = remaining; 1335 ), 1336 TP_printk("%lu entries removed, %lu remaining", 1337 __entry->removed, __entry->remaining) 1338 ); 1339 1340 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1341 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1342 TP_PROTO( \ 1343 unsigned long removed, \ 1344 unsigned long remaining \ 1345 ), \ 1346 TP_ARGS(removed, remaining)) 1347 1348 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1349 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1350 1351 TRACE_EVENT(nfsd_file_close, 1352 TP_PROTO( 1353 const struct inode *inode 1354 ), 1355 TP_ARGS(inode), 1356 TP_STRUCT__entry( 1357 __field(const void *, inode) 1358 ), 1359 TP_fast_assign( 1360 __entry->inode = inode; 1361 ), 1362 TP_printk("inode=%p", 1363 __entry->inode 1364 ) 1365 ); 1366 1367 #include "cache.h" 1368 1369 TRACE_DEFINE_ENUM(RC_DROPIT); 1370 TRACE_DEFINE_ENUM(RC_REPLY); 1371 TRACE_DEFINE_ENUM(RC_DOIT); 1372 1373 #define show_drc_retval(x) \ 1374 __print_symbolic(x, \ 1375 { RC_DROPIT, "DROPIT" }, \ 1376 { RC_REPLY, "REPLY" }, \ 1377 { RC_DOIT, "DOIT" }) 1378 1379 TRACE_EVENT(nfsd_drc_found, 1380 TP_PROTO( 1381 const struct nfsd_net *nn, 1382 const struct svc_rqst *rqstp, 1383 int result 1384 ), 1385 TP_ARGS(nn, rqstp, result), 1386 TP_STRUCT__entry( 1387 __field(unsigned long long, boot_time) 1388 __field(unsigned long, result) 1389 __field(u32, xid) 1390 ), 1391 TP_fast_assign( 1392 __entry->boot_time = nn->boot_time; 1393 __entry->result = result; 1394 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1395 ), 1396 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1397 __entry->boot_time, __entry->xid, 1398 show_drc_retval(__entry->result)) 1399 1400 ); 1401 1402 TRACE_EVENT(nfsd_drc_mismatch, 1403 TP_PROTO( 1404 const struct nfsd_net *nn, 1405 const struct nfsd_cacherep *key, 1406 const struct nfsd_cacherep *rp 1407 ), 1408 TP_ARGS(nn, key, rp), 1409 TP_STRUCT__entry( 1410 __field(unsigned long long, boot_time) 1411 __field(u32, xid) 1412 __field(u32, cached) 1413 __field(u32, ingress) 1414 ), 1415 TP_fast_assign( 1416 __entry->boot_time = nn->boot_time; 1417 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1418 __entry->cached = (__force u32)key->c_key.k_csum; 1419 __entry->ingress = (__force u32)rp->c_key.k_csum; 1420 ), 1421 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1422 __entry->boot_time, __entry->xid, __entry->cached, 1423 __entry->ingress) 1424 ); 1425 1426 TRACE_EVENT(nfsd_cb_args, 1427 TP_PROTO( 1428 const struct nfs4_client *clp, 1429 const struct nfs4_cb_conn *conn 1430 ), 1431 TP_ARGS(clp, conn), 1432 TP_STRUCT__entry( 1433 __field(u32, cl_boot) 1434 __field(u32, cl_id) 1435 __field(u32, prog) 1436 __field(u32, ident) 1437 __sockaddr(addr, conn->cb_addrlen) 1438 ), 1439 TP_fast_assign( 1440 __entry->cl_boot = clp->cl_clientid.cl_boot; 1441 __entry->cl_id = clp->cl_clientid.cl_id; 1442 __entry->prog = conn->cb_prog; 1443 __entry->ident = conn->cb_ident; 1444 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1445 ), 1446 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1447 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1448 __entry->prog, __entry->ident) 1449 ); 1450 1451 TRACE_EVENT(nfsd_cb_nodelegs, 1452 TP_PROTO(const struct nfs4_client *clp), 1453 TP_ARGS(clp), 1454 TP_STRUCT__entry( 1455 __field(u32, cl_boot) 1456 __field(u32, cl_id) 1457 ), 1458 TP_fast_assign( 1459 __entry->cl_boot = clp->cl_clientid.cl_boot; 1460 __entry->cl_id = clp->cl_clientid.cl_id; 1461 ), 1462 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1463 ) 1464 1465 #define show_cb_state(val) \ 1466 __print_symbolic(val, \ 1467 { NFSD4_CB_UP, "UP" }, \ 1468 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1469 { NFSD4_CB_DOWN, "DOWN" }, \ 1470 { NFSD4_CB_FAULT, "FAULT"}) 1471 1472 DECLARE_EVENT_CLASS(nfsd_cb_class, 1473 TP_PROTO(const struct nfs4_client *clp), 1474 TP_ARGS(clp), 1475 TP_STRUCT__entry( 1476 __field(unsigned long, state) 1477 __field(u32, cl_boot) 1478 __field(u32, cl_id) 1479 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1480 ), 1481 TP_fast_assign( 1482 __entry->state = clp->cl_cb_state; 1483 __entry->cl_boot = clp->cl_clientid.cl_boot; 1484 __entry->cl_id = clp->cl_clientid.cl_id; 1485 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1486 clp->cl_cb_conn.cb_addrlen) 1487 ), 1488 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1489 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1490 show_cb_state(__entry->state)) 1491 ); 1492 1493 #define DEFINE_NFSD_CB_EVENT(name) \ 1494 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1495 TP_PROTO(const struct nfs4_client *clp), \ 1496 TP_ARGS(clp)) 1497 1498 DEFINE_NFSD_CB_EVENT(start); 1499 DEFINE_NFSD_CB_EVENT(new_state); 1500 DEFINE_NFSD_CB_EVENT(probe); 1501 DEFINE_NFSD_CB_EVENT(lost); 1502 DEFINE_NFSD_CB_EVENT(shutdown); 1503 DEFINE_NFSD_CB_EVENT(rpc_prepare); 1504 DEFINE_NFSD_CB_EVENT(rpc_done); 1505 DEFINE_NFSD_CB_EVENT(rpc_release); 1506 1507 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1508 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1509 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1510 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1511 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1512 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1513 1514 #define show_nfsd_authflavor(val) \ 1515 __print_symbolic(val, \ 1516 { RPC_AUTH_NULL, "none" }, \ 1517 { RPC_AUTH_UNIX, "sys" }, \ 1518 { RPC_AUTH_GSS, "gss" }, \ 1519 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1520 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1521 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1522 1523 TRACE_EVENT(nfsd_cb_setup, 1524 TP_PROTO(const struct nfs4_client *clp, 1525 const char *netid, 1526 rpc_authflavor_t authflavor 1527 ), 1528 TP_ARGS(clp, netid, authflavor), 1529 TP_STRUCT__entry( 1530 __field(u32, cl_boot) 1531 __field(u32, cl_id) 1532 __field(unsigned long, authflavor) 1533 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1534 __string(netid, netid) 1535 ), 1536 TP_fast_assign( 1537 __entry->cl_boot = clp->cl_clientid.cl_boot; 1538 __entry->cl_id = clp->cl_clientid.cl_id; 1539 __assign_str(netid); 1540 __entry->authflavor = authflavor; 1541 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1542 clp->cl_cb_conn.cb_addrlen) 1543 ), 1544 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1545 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1546 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1547 ); 1548 1549 TRACE_EVENT(nfsd_cb_setup_err, 1550 TP_PROTO( 1551 const struct nfs4_client *clp, 1552 long error 1553 ), 1554 TP_ARGS(clp, error), 1555 TP_STRUCT__entry( 1556 __field(long, error) 1557 __field(u32, cl_boot) 1558 __field(u32, cl_id) 1559 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1560 ), 1561 TP_fast_assign( 1562 __entry->error = error; 1563 __entry->cl_boot = clp->cl_clientid.cl_boot; 1564 __entry->cl_id = clp->cl_clientid.cl_id; 1565 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1566 clp->cl_cb_conn.cb_addrlen) 1567 ), 1568 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1569 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1570 __entry->error) 1571 ); 1572 1573 /* Not a real opcode, but there is no 0 operation. */ 1574 #define _CB_NULL 0 1575 1576 #define show_nfsd_cb_opcode(val) \ 1577 __print_symbolic(val, \ 1578 { _CB_NULL, "CB_NULL" }, \ 1579 { OP_CB_GETATTR, "CB_GETATTR" }, \ 1580 { OP_CB_RECALL, "CB_RECALL" }, \ 1581 { OP_CB_LAYOUTRECALL, "CB_LAYOUTRECALL" }, \ 1582 { OP_CB_RECALL_ANY, "CB_RECALL_ANY" }, \ 1583 { OP_CB_NOTIFY_LOCK, "CB_NOTIFY_LOCK" }, \ 1584 { OP_CB_OFFLOAD, "CB_OFFLOAD" }) 1585 1586 DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class, 1587 TP_PROTO( 1588 const struct nfs4_client *clp, 1589 const struct nfsd4_callback *cb 1590 ), 1591 TP_ARGS(clp, cb), 1592 TP_STRUCT__entry( 1593 __field(u32, cl_boot) 1594 __field(u32, cl_id) 1595 __field(const void *, cb) 1596 __field(unsigned long, opcode) 1597 __field(bool, need_restart) 1598 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1599 ), 1600 TP_fast_assign( 1601 __entry->cl_boot = clp->cl_clientid.cl_boot; 1602 __entry->cl_id = clp->cl_clientid.cl_id; 1603 __entry->cb = cb; 1604 __entry->opcode = cb->cb_ops ? cb->cb_ops->opcode : _CB_NULL; 1605 __entry->need_restart = cb->cb_need_restart; 1606 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1607 clp->cl_cb_conn.cb_addrlen) 1608 ), 1609 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s opcode=%s", 1610 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, __entry->cb, 1611 __entry->need_restart ? " (need restart)" : " (first try)", 1612 show_nfsd_cb_opcode(__entry->opcode) 1613 ) 1614 ); 1615 1616 #define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \ 1617 DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \ 1618 TP_PROTO( \ 1619 const struct nfs4_client *clp, \ 1620 const struct nfsd4_callback *cb \ 1621 ), \ 1622 TP_ARGS(clp, cb)) 1623 1624 DEFINE_NFSD_CB_LIFETIME_EVENT(queue); 1625 DEFINE_NFSD_CB_LIFETIME_EVENT(destroy); 1626 DEFINE_NFSD_CB_LIFETIME_EVENT(restart); 1627 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update); 1628 DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown); 1629 1630 TRACE_EVENT(nfsd_cb_seq_status, 1631 TP_PROTO( 1632 const struct rpc_task *task, 1633 const struct nfsd4_callback *cb 1634 ), 1635 TP_ARGS(task, cb), 1636 TP_STRUCT__entry( 1637 __field(unsigned int, task_id) 1638 __field(unsigned int, client_id) 1639 __field(u32, cl_boot) 1640 __field(u32, cl_id) 1641 __field(u32, seqno) 1642 __field(u32, reserved) 1643 __field(int, tk_status) 1644 __field(int, seq_status) 1645 ), 1646 TP_fast_assign( 1647 const struct nfs4_client *clp = cb->cb_clp; 1648 const struct nfsd4_session *session = clp->cl_cb_session; 1649 const struct nfsd4_sessionid *sid = 1650 (struct nfsd4_sessionid *)&session->se_sessionid; 1651 1652 __entry->task_id = task->tk_pid; 1653 __entry->client_id = task->tk_client ? 1654 task->tk_client->cl_clid : -1; 1655 __entry->cl_boot = sid->clientid.cl_boot; 1656 __entry->cl_id = sid->clientid.cl_id; 1657 __entry->seqno = sid->sequence; 1658 __entry->reserved = sid->reserved; 1659 __entry->tk_status = task->tk_status; 1660 __entry->seq_status = cb->cb_seq_status; 1661 ), 1662 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1663 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d", 1664 __entry->task_id, __entry->client_id, 1665 __entry->cl_boot, __entry->cl_id, 1666 __entry->seqno, __entry->reserved, 1667 __entry->tk_status, __entry->seq_status 1668 ) 1669 ); 1670 1671 TRACE_EVENT(nfsd_cb_free_slot, 1672 TP_PROTO( 1673 const struct rpc_task *task, 1674 const struct nfsd4_callback *cb 1675 ), 1676 TP_ARGS(task, cb), 1677 TP_STRUCT__entry( 1678 __field(unsigned int, task_id) 1679 __field(unsigned int, client_id) 1680 __field(u32, cl_boot) 1681 __field(u32, cl_id) 1682 __field(u32, seqno) 1683 __field(u32, reserved) 1684 __field(u32, slot_seqno) 1685 ), 1686 TP_fast_assign( 1687 const struct nfs4_client *clp = cb->cb_clp; 1688 const struct nfsd4_session *session = clp->cl_cb_session; 1689 const struct nfsd4_sessionid *sid = 1690 (struct nfsd4_sessionid *)&session->se_sessionid; 1691 1692 __entry->task_id = task->tk_pid; 1693 __entry->client_id = task->tk_client ? 1694 task->tk_client->cl_clid : -1; 1695 __entry->cl_boot = sid->clientid.cl_boot; 1696 __entry->cl_id = sid->clientid.cl_id; 1697 __entry->seqno = sid->sequence; 1698 __entry->reserved = sid->reserved; 1699 __entry->slot_seqno = session->se_cb_seq_nr[cb->cb_held_slot]; 1700 ), 1701 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1702 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u", 1703 __entry->task_id, __entry->client_id, 1704 __entry->cl_boot, __entry->cl_id, 1705 __entry->seqno, __entry->reserved, 1706 __entry->slot_seqno 1707 ) 1708 ); 1709 1710 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1711 TP_PROTO( 1712 const struct nfs4_stid *stid 1713 ), 1714 TP_ARGS(stid), 1715 TP_CONDITION(stid->sc_client), 1716 TP_STRUCT__entry( 1717 __field(u32, cl_boot) 1718 __field(u32, cl_id) 1719 __field(u32, si_id) 1720 __field(u32, si_generation) 1721 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1722 ), 1723 TP_fast_assign( 1724 const stateid_t *stp = &stid->sc_stateid; 1725 const struct nfs4_client *clp = stid->sc_client; 1726 1727 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1728 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1729 __entry->si_id = stp->si_opaque.so_id; 1730 __entry->si_generation = stp->si_generation; 1731 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1732 clp->cl_cb_conn.cb_addrlen) 1733 ), 1734 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1735 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1736 __entry->si_id, __entry->si_generation) 1737 ); 1738 1739 TRACE_EVENT(nfsd_cb_notify_lock, 1740 TP_PROTO( 1741 const struct nfs4_lockowner *lo, 1742 const struct nfsd4_blocked_lock *nbl 1743 ), 1744 TP_ARGS(lo, nbl), 1745 TP_STRUCT__entry( 1746 __field(u32, cl_boot) 1747 __field(u32, cl_id) 1748 __field(u32, fh_hash) 1749 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1750 ), 1751 TP_fast_assign( 1752 const struct nfs4_client *clp = lo->lo_owner.so_client; 1753 1754 __entry->cl_boot = clp->cl_clientid.cl_boot; 1755 __entry->cl_id = clp->cl_clientid.cl_id; 1756 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1757 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1758 clp->cl_cb_conn.cb_addrlen) 1759 ), 1760 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1761 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1762 __entry->fh_hash) 1763 ); 1764 1765 TRACE_EVENT(nfsd_cb_offload, 1766 TP_PROTO( 1767 const struct nfs4_client *clp, 1768 const stateid_t *stp, 1769 const struct knfsd_fh *fh, 1770 u64 count, 1771 __be32 status 1772 ), 1773 TP_ARGS(clp, stp, fh, count, status), 1774 TP_STRUCT__entry( 1775 __field(u32, cl_boot) 1776 __field(u32, cl_id) 1777 __field(u32, si_id) 1778 __field(u32, si_generation) 1779 __field(u32, fh_hash) 1780 __field(int, status) 1781 __field(u64, count) 1782 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1783 ), 1784 TP_fast_assign( 1785 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1786 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1787 __entry->si_id = stp->si_opaque.so_id; 1788 __entry->si_generation = stp->si_generation; 1789 __entry->fh_hash = knfsd_fh_hash(fh); 1790 __entry->status = be32_to_cpu(status); 1791 __entry->count = count; 1792 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1793 clp->cl_cb_conn.cb_addrlen) 1794 ), 1795 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1796 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1797 __entry->si_id, __entry->si_generation, 1798 __entry->fh_hash, __entry->count, __entry->status) 1799 ); 1800 1801 TRACE_EVENT(nfsd_cb_recall_any, 1802 TP_PROTO( 1803 const struct nfsd4_cb_recall_any *ra 1804 ), 1805 TP_ARGS(ra), 1806 TP_STRUCT__entry( 1807 __field(u32, cl_boot) 1808 __field(u32, cl_id) 1809 __field(u32, keep) 1810 __field(unsigned long, bmval0) 1811 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1812 ), 1813 TP_fast_assign( 1814 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1815 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1816 __entry->keep = ra->ra_keep; 1817 __entry->bmval0 = ra->ra_bmval[0]; 1818 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1819 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1820 ), 1821 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1822 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1823 __entry->keep, show_rca_mask(__entry->bmval0) 1824 ) 1825 ); 1826 1827 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1828 TP_PROTO( 1829 const stateid_t *stp, 1830 const struct rpc_task *task 1831 ), 1832 TP_ARGS(stp, task), 1833 TP_STRUCT__entry( 1834 __field(u32, cl_boot) 1835 __field(u32, cl_id) 1836 __field(u32, si_id) 1837 __field(u32, si_generation) 1838 __field(int, status) 1839 ), 1840 TP_fast_assign( 1841 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1842 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1843 __entry->si_id = stp->si_opaque.so_id; 1844 __entry->si_generation = stp->si_generation; 1845 __entry->status = task->tk_status; 1846 ), 1847 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1848 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1849 __entry->si_generation, __entry->status 1850 ) 1851 ); 1852 1853 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1854 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1855 TP_PROTO( \ 1856 const stateid_t *stp, \ 1857 const struct rpc_task *task \ 1858 ), \ 1859 TP_ARGS(stp, task)) 1860 1861 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1862 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1863 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1864 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1865 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_getattr_done); 1866 1867 TRACE_EVENT(nfsd_cb_recall_any_done, 1868 TP_PROTO( 1869 const struct nfsd4_callback *cb, 1870 const struct rpc_task *task 1871 ), 1872 TP_ARGS(cb, task), 1873 TP_STRUCT__entry( 1874 __field(u32, cl_boot) 1875 __field(u32, cl_id) 1876 __field(int, status) 1877 ), 1878 TP_fast_assign( 1879 __entry->status = task->tk_status; 1880 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1881 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1882 ), 1883 TP_printk("client %08x:%08x status=%d", 1884 __entry->cl_boot, __entry->cl_id, __entry->status 1885 ) 1886 ); 1887 1888 TRACE_EVENT(nfsd_ctl_unlock_ip, 1889 TP_PROTO( 1890 const struct net *net, 1891 const char *address 1892 ), 1893 TP_ARGS(net, address), 1894 TP_STRUCT__entry( 1895 __field(unsigned int, netns_ino) 1896 __string(address, address) 1897 ), 1898 TP_fast_assign( 1899 __entry->netns_ino = net->ns.inum; 1900 __assign_str(address); 1901 ), 1902 TP_printk("address=%s", 1903 __get_str(address) 1904 ) 1905 ); 1906 1907 TRACE_EVENT(nfsd_ctl_unlock_fs, 1908 TP_PROTO( 1909 const struct net *net, 1910 const char *path 1911 ), 1912 TP_ARGS(net, path), 1913 TP_STRUCT__entry( 1914 __field(unsigned int, netns_ino) 1915 __string(path, path) 1916 ), 1917 TP_fast_assign( 1918 __entry->netns_ino = net->ns.inum; 1919 __assign_str(path); 1920 ), 1921 TP_printk("path=%s", 1922 __get_str(path) 1923 ) 1924 ); 1925 1926 TRACE_EVENT(nfsd_ctl_filehandle, 1927 TP_PROTO( 1928 const struct net *net, 1929 const char *domain, 1930 const char *path, 1931 int maxsize 1932 ), 1933 TP_ARGS(net, domain, path, maxsize), 1934 TP_STRUCT__entry( 1935 __field(unsigned int, netns_ino) 1936 __field(int, maxsize) 1937 __string(domain, domain) 1938 __string(path, path) 1939 ), 1940 TP_fast_assign( 1941 __entry->netns_ino = net->ns.inum; 1942 __entry->maxsize = maxsize; 1943 __assign_str(domain); 1944 __assign_str(path); 1945 ), 1946 TP_printk("domain=%s path=%s maxsize=%d", 1947 __get_str(domain), __get_str(path), __entry->maxsize 1948 ) 1949 ); 1950 1951 TRACE_EVENT(nfsd_ctl_threads, 1952 TP_PROTO( 1953 const struct net *net, 1954 int newthreads 1955 ), 1956 TP_ARGS(net, newthreads), 1957 TP_STRUCT__entry( 1958 __field(unsigned int, netns_ino) 1959 __field(int, newthreads) 1960 ), 1961 TP_fast_assign( 1962 __entry->netns_ino = net->ns.inum; 1963 __entry->newthreads = newthreads; 1964 ), 1965 TP_printk("newthreads=%d", 1966 __entry->newthreads 1967 ) 1968 ); 1969 1970 TRACE_EVENT(nfsd_ctl_pool_threads, 1971 TP_PROTO( 1972 const struct net *net, 1973 int pool, 1974 int nrthreads 1975 ), 1976 TP_ARGS(net, pool, nrthreads), 1977 TP_STRUCT__entry( 1978 __field(unsigned int, netns_ino) 1979 __field(int, pool) 1980 __field(int, nrthreads) 1981 ), 1982 TP_fast_assign( 1983 __entry->netns_ino = net->ns.inum; 1984 __entry->pool = pool; 1985 __entry->nrthreads = nrthreads; 1986 ), 1987 TP_printk("pool=%d nrthreads=%d", 1988 __entry->pool, __entry->nrthreads 1989 ) 1990 ); 1991 1992 TRACE_EVENT(nfsd_ctl_version, 1993 TP_PROTO( 1994 const struct net *net, 1995 const char *mesg 1996 ), 1997 TP_ARGS(net, mesg), 1998 TP_STRUCT__entry( 1999 __field(unsigned int, netns_ino) 2000 __string(mesg, mesg) 2001 ), 2002 TP_fast_assign( 2003 __entry->netns_ino = net->ns.inum; 2004 __assign_str(mesg); 2005 ), 2006 TP_printk("%s", 2007 __get_str(mesg) 2008 ) 2009 ); 2010 2011 TRACE_EVENT(nfsd_ctl_ports_addfd, 2012 TP_PROTO( 2013 const struct net *net, 2014 int fd 2015 ), 2016 TP_ARGS(net, fd), 2017 TP_STRUCT__entry( 2018 __field(unsigned int, netns_ino) 2019 __field(int, fd) 2020 ), 2021 TP_fast_assign( 2022 __entry->netns_ino = net->ns.inum; 2023 __entry->fd = fd; 2024 ), 2025 TP_printk("fd=%d", 2026 __entry->fd 2027 ) 2028 ); 2029 2030 TRACE_EVENT(nfsd_ctl_ports_addxprt, 2031 TP_PROTO( 2032 const struct net *net, 2033 const char *transport, 2034 int port 2035 ), 2036 TP_ARGS(net, transport, port), 2037 TP_STRUCT__entry( 2038 __field(unsigned int, netns_ino) 2039 __field(int, port) 2040 __string(transport, transport) 2041 ), 2042 TP_fast_assign( 2043 __entry->netns_ino = net->ns.inum; 2044 __entry->port = port; 2045 __assign_str(transport); 2046 ), 2047 TP_printk("transport=%s port=%d", 2048 __get_str(transport), __entry->port 2049 ) 2050 ); 2051 2052 TRACE_EVENT(nfsd_ctl_maxblksize, 2053 TP_PROTO( 2054 const struct net *net, 2055 int bsize 2056 ), 2057 TP_ARGS(net, bsize), 2058 TP_STRUCT__entry( 2059 __field(unsigned int, netns_ino) 2060 __field(int, bsize) 2061 ), 2062 TP_fast_assign( 2063 __entry->netns_ino = net->ns.inum; 2064 __entry->bsize = bsize; 2065 ), 2066 TP_printk("bsize=%d", 2067 __entry->bsize 2068 ) 2069 ); 2070 2071 TRACE_EVENT(nfsd_ctl_maxconn, 2072 TP_PROTO( 2073 const struct net *net, 2074 int maxconn 2075 ), 2076 TP_ARGS(net, maxconn), 2077 TP_STRUCT__entry( 2078 __field(unsigned int, netns_ino) 2079 __field(int, maxconn) 2080 ), 2081 TP_fast_assign( 2082 __entry->netns_ino = net->ns.inum; 2083 __entry->maxconn = maxconn; 2084 ), 2085 TP_printk("maxconn=%d", 2086 __entry->maxconn 2087 ) 2088 ); 2089 2090 TRACE_EVENT(nfsd_ctl_time, 2091 TP_PROTO( 2092 const struct net *net, 2093 const char *name, 2094 size_t namelen, 2095 int time 2096 ), 2097 TP_ARGS(net, name, namelen, time), 2098 TP_STRUCT__entry( 2099 __field(unsigned int, netns_ino) 2100 __field(int, time) 2101 __string_len(name, name, namelen) 2102 ), 2103 TP_fast_assign( 2104 __entry->netns_ino = net->ns.inum; 2105 __entry->time = time; 2106 __assign_str(name); 2107 ), 2108 TP_printk("file=%s time=%d", 2109 __get_str(name), __entry->time 2110 ) 2111 ); 2112 2113 TRACE_EVENT(nfsd_ctl_recoverydir, 2114 TP_PROTO( 2115 const struct net *net, 2116 const char *recdir 2117 ), 2118 TP_ARGS(net, recdir), 2119 TP_STRUCT__entry( 2120 __field(unsigned int, netns_ino) 2121 __string(recdir, recdir) 2122 ), 2123 TP_fast_assign( 2124 __entry->netns_ino = net->ns.inum; 2125 __assign_str(recdir); 2126 ), 2127 TP_printk("recdir=%s", 2128 __get_str(recdir) 2129 ) 2130 ); 2131 2132 TRACE_EVENT(nfsd_end_grace, 2133 TP_PROTO( 2134 const struct net *net 2135 ), 2136 TP_ARGS(net), 2137 TP_STRUCT__entry( 2138 __field(unsigned int, netns_ino) 2139 ), 2140 TP_fast_assign( 2141 __entry->netns_ino = net->ns.inum; 2142 ), 2143 TP_printk("nn=%d", __entry->netns_ino 2144 ) 2145 ); 2146 2147 DECLARE_EVENT_CLASS(nfsd_copy_class, 2148 TP_PROTO( 2149 const struct nfsd4_copy *copy 2150 ), 2151 TP_ARGS(copy), 2152 TP_STRUCT__entry( 2153 __field(bool, intra) 2154 __field(bool, async) 2155 __field(u32, src_cl_boot) 2156 __field(u32, src_cl_id) 2157 __field(u32, src_so_id) 2158 __field(u32, src_si_generation) 2159 __field(u32, dst_cl_boot) 2160 __field(u32, dst_cl_id) 2161 __field(u32, dst_so_id) 2162 __field(u32, dst_si_generation) 2163 __field(u32, cb_cl_boot) 2164 __field(u32, cb_cl_id) 2165 __field(u32, cb_so_id) 2166 __field(u32, cb_si_generation) 2167 __field(u64, src_cp_pos) 2168 __field(u64, dst_cp_pos) 2169 __field(u64, cp_count) 2170 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2171 ), 2172 TP_fast_assign( 2173 const stateid_t *src_stp = ©->cp_src_stateid; 2174 const stateid_t *dst_stp = ©->cp_dst_stateid; 2175 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2176 2177 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2178 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2179 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2180 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2181 __entry->src_so_id = src_stp->si_opaque.so_id; 2182 __entry->src_si_generation = src_stp->si_generation; 2183 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2184 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2185 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2186 __entry->dst_si_generation = dst_stp->si_generation; 2187 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2188 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2189 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2190 __entry->cb_si_generation = cb_stp->si_generation; 2191 __entry->src_cp_pos = copy->cp_src_pos; 2192 __entry->dst_cp_pos = copy->cp_dst_pos; 2193 __entry->cp_count = copy->cp_count; 2194 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2195 sizeof(struct sockaddr_in6)); 2196 ), 2197 TP_printk("client=%pISpc intra=%d async=%d " 2198 "src_client %08x:%08x src_stateid %08x:%08x " 2199 "dst_client %08x:%08x dst_stateid %08x:%08x " 2200 "cb_client %08x:%08x cb_stateid %08x:%08x " 2201 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2202 __get_sockaddr(addr), __entry->intra, __entry->async, 2203 __entry->src_cl_boot, __entry->src_cl_id, 2204 __entry->src_so_id, __entry->src_si_generation, 2205 __entry->dst_cl_boot, __entry->dst_cl_id, 2206 __entry->dst_so_id, __entry->dst_si_generation, 2207 __entry->cb_cl_boot, __entry->cb_cl_id, 2208 __entry->cb_so_id, __entry->cb_si_generation, 2209 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2210 ) 2211 ); 2212 2213 #define DEFINE_COPY_EVENT(name) \ 2214 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \ 2215 TP_PROTO(const struct nfsd4_copy *copy), \ 2216 TP_ARGS(copy)) 2217 2218 DEFINE_COPY_EVENT(inter); 2219 DEFINE_COPY_EVENT(intra); 2220 DEFINE_COPY_EVENT(async); 2221 2222 TRACE_EVENT(nfsd_copy_done, 2223 TP_PROTO( 2224 const struct nfsd4_copy *copy, 2225 __be32 status 2226 ), 2227 TP_ARGS(copy, status), 2228 TP_STRUCT__entry( 2229 __field(int, status) 2230 __field(bool, intra) 2231 __field(bool, async) 2232 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2233 ), 2234 TP_fast_assign( 2235 __entry->status = be32_to_cpu(status); 2236 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2237 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2238 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2239 sizeof(struct sockaddr_in6)); 2240 ), 2241 TP_printk("addr=%pISpc status=%d intra=%d async=%d", 2242 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async 2243 ) 2244 ); 2245 2246 DECLARE_EVENT_CLASS(nfsd_copy_async_done_class, 2247 TP_PROTO( 2248 const struct nfsd4_copy *copy 2249 ), 2250 TP_ARGS(copy), 2251 TP_STRUCT__entry( 2252 __field(int, status) 2253 __field(bool, intra) 2254 __field(bool, async) 2255 __field(u32, src_cl_boot) 2256 __field(u32, src_cl_id) 2257 __field(u32, src_so_id) 2258 __field(u32, src_si_generation) 2259 __field(u32, dst_cl_boot) 2260 __field(u32, dst_cl_id) 2261 __field(u32, dst_so_id) 2262 __field(u32, dst_si_generation) 2263 __field(u32, cb_cl_boot) 2264 __field(u32, cb_cl_id) 2265 __field(u32, cb_so_id) 2266 __field(u32, cb_si_generation) 2267 __field(u64, src_cp_pos) 2268 __field(u64, dst_cp_pos) 2269 __field(u64, cp_count) 2270 __sockaddr(addr, sizeof(struct sockaddr_in6)) 2271 ), 2272 TP_fast_assign( 2273 const stateid_t *src_stp = ©->cp_src_stateid; 2274 const stateid_t *dst_stp = ©->cp_dst_stateid; 2275 const stateid_t *cb_stp = ©->cp_res.cb_stateid; 2276 2277 __entry->status = be32_to_cpu(copy->nfserr); 2278 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 2279 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 2280 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 2281 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 2282 __entry->src_so_id = src_stp->si_opaque.so_id; 2283 __entry->src_si_generation = src_stp->si_generation; 2284 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 2285 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 2286 __entry->dst_so_id = dst_stp->si_opaque.so_id; 2287 __entry->dst_si_generation = dst_stp->si_generation; 2288 __entry->cb_cl_boot = cb_stp->si_opaque.so_clid.cl_boot; 2289 __entry->cb_cl_id = cb_stp->si_opaque.so_clid.cl_id; 2290 __entry->cb_so_id = cb_stp->si_opaque.so_id; 2291 __entry->cb_si_generation = cb_stp->si_generation; 2292 __entry->src_cp_pos = copy->cp_src_pos; 2293 __entry->dst_cp_pos = copy->cp_dst_pos; 2294 __entry->cp_count = copy->cp_count; 2295 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 2296 sizeof(struct sockaddr_in6)); 2297 ), 2298 TP_printk("client=%pISpc status=%d intra=%d async=%d " 2299 "src_client %08x:%08x src_stateid %08x:%08x " 2300 "dst_client %08x:%08x dst_stateid %08x:%08x " 2301 "cb_client %08x:%08x cb_stateid %08x:%08x " 2302 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 2303 __get_sockaddr(addr), 2304 __entry->status, __entry->intra, __entry->async, 2305 __entry->src_cl_boot, __entry->src_cl_id, 2306 __entry->src_so_id, __entry->src_si_generation, 2307 __entry->dst_cl_boot, __entry->dst_cl_id, 2308 __entry->dst_so_id, __entry->dst_si_generation, 2309 __entry->cb_cl_boot, __entry->cb_cl_id, 2310 __entry->cb_so_id, __entry->cb_si_generation, 2311 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 2312 ) 2313 ); 2314 2315 #define DEFINE_COPY_ASYNC_DONE_EVENT(name) \ 2316 DEFINE_EVENT(nfsd_copy_async_done_class, \ 2317 nfsd_copy_async_##name, \ 2318 TP_PROTO(const struct nfsd4_copy *copy), \ 2319 TP_ARGS(copy)) 2320 2321 DEFINE_COPY_ASYNC_DONE_EVENT(done); 2322 DEFINE_COPY_ASYNC_DONE_EVENT(cancel); 2323 2324 #endif /* _NFSD_TRACE_H */ 2325 2326 #undef TRACE_INCLUDE_PATH 2327 #define TRACE_INCLUDE_PATH . 2328 #define TRACE_INCLUDE_FILE trace 2329 #include <trace/define_trace.h> 2330