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