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 13 #include "export.h" 14 #include "nfsfh.h" 15 16 #define NFSD_TRACE_PROC_ARG_FIELDS \ 17 __field(unsigned int, netns_ino) \ 18 __field(u32, xid) \ 19 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 20 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 21 22 #define NFSD_TRACE_PROC_ARG_ASSIGNMENTS \ 23 do { \ 24 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 25 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 26 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 27 rqstp->rq_xprt->xpt_locallen); \ 28 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 29 rqstp->rq_xprt->xpt_remotelen); \ 30 } while (0); 31 32 #define NFSD_TRACE_PROC_RES_FIELDS \ 33 __field(unsigned int, netns_ino) \ 34 __field(u32, xid) \ 35 __field(unsigned long, status) \ 36 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 37 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 38 39 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 40 do { \ 41 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 42 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 43 __entry->status = be32_to_cpu(error); \ 44 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 45 rqstp->rq_xprt->xpt_locallen); \ 46 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 47 rqstp->rq_xprt->xpt_remotelen); \ 48 } while (0); 49 50 DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 51 TP_PROTO( 52 const struct svc_rqst *rqstp 53 ), 54 TP_ARGS(rqstp), 55 TP_STRUCT__entry( 56 NFSD_TRACE_PROC_ARG_FIELDS 57 58 __field(u32, vers) 59 __field(u32, proc) 60 ), 61 TP_fast_assign( 62 NFSD_TRACE_PROC_ARG_ASSIGNMENTS 63 64 __entry->vers = rqstp->rq_vers; 65 __entry->proc = rqstp->rq_proc; 66 ), 67 TP_printk("xid=0x%08x vers=%u proc=%u", 68 __entry->xid, __entry->vers, __entry->proc 69 ) 70 ); 71 72 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 73 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 74 TP_PROTO(const struct svc_rqst *rqstp), \ 75 TP_ARGS(rqstp)) 76 77 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 78 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 79 80 #define show_nfsd_may_flags(x) \ 81 __print_flags(x, "|", \ 82 { NFSD_MAY_EXEC, "EXEC" }, \ 83 { NFSD_MAY_WRITE, "WRITE" }, \ 84 { NFSD_MAY_READ, "READ" }, \ 85 { NFSD_MAY_SATTR, "SATTR" }, \ 86 { NFSD_MAY_TRUNC, "TRUNC" }, \ 87 { NFSD_MAY_LOCK, "LOCK" }, \ 88 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 89 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 90 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 91 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 92 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 93 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 94 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 95 96 TRACE_EVENT(nfsd_compound, 97 TP_PROTO(const struct svc_rqst *rqst, 98 u32 args_opcnt), 99 TP_ARGS(rqst, args_opcnt), 100 TP_STRUCT__entry( 101 __field(u32, xid) 102 __field(u32, args_opcnt) 103 ), 104 TP_fast_assign( 105 __entry->xid = be32_to_cpu(rqst->rq_xid); 106 __entry->args_opcnt = args_opcnt; 107 ), 108 TP_printk("xid=0x%08x opcnt=%u", 109 __entry->xid, __entry->args_opcnt) 110 ) 111 112 TRACE_EVENT(nfsd_compound_status, 113 TP_PROTO(u32 args_opcnt, 114 u32 resp_opcnt, 115 __be32 status, 116 const char *name), 117 TP_ARGS(args_opcnt, resp_opcnt, status, name), 118 TP_STRUCT__entry( 119 __field(u32, args_opcnt) 120 __field(u32, resp_opcnt) 121 __field(int, status) 122 __string(name, name) 123 ), 124 TP_fast_assign( 125 __entry->args_opcnt = args_opcnt; 126 __entry->resp_opcnt = resp_opcnt; 127 __entry->status = be32_to_cpu(status); 128 __assign_str(name, name); 129 ), 130 TP_printk("op=%u/%u %s status=%d", 131 __entry->resp_opcnt, __entry->args_opcnt, 132 __get_str(name), __entry->status) 133 ) 134 135 TRACE_EVENT(nfsd_compound_decode_err, 136 TP_PROTO( 137 const struct svc_rqst *rqstp, 138 u32 args_opcnt, 139 u32 resp_opcnt, 140 u32 opnum, 141 __be32 status 142 ), 143 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 144 TP_STRUCT__entry( 145 NFSD_TRACE_PROC_RES_FIELDS 146 147 __field(u32, args_opcnt) 148 __field(u32, resp_opcnt) 149 __field(u32, opnum) 150 ), 151 TP_fast_assign( 152 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 153 154 __entry->args_opcnt = args_opcnt; 155 __entry->resp_opcnt = resp_opcnt; 156 __entry->opnum = opnum; 157 ), 158 TP_printk("op=%u/%u opnum=%u status=%lu", 159 __entry->resp_opcnt, __entry->args_opcnt, 160 __entry->opnum, __entry->status) 161 ); 162 163 TRACE_EVENT(nfsd_compound_encode_err, 164 TP_PROTO( 165 const struct svc_rqst *rqstp, 166 u32 opnum, 167 __be32 status 168 ), 169 TP_ARGS(rqstp, opnum, status), 170 TP_STRUCT__entry( 171 NFSD_TRACE_PROC_RES_FIELDS 172 173 __field(u32, opnum) 174 ), 175 TP_fast_assign( 176 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 177 178 __entry->opnum = opnum; 179 ), 180 TP_printk("opnum=%u status=%lu", 181 __entry->opnum, __entry->status) 182 ); 183 184 185 DECLARE_EVENT_CLASS(nfsd_fh_err_class, 186 TP_PROTO(struct svc_rqst *rqstp, 187 struct svc_fh *fhp, 188 int status), 189 TP_ARGS(rqstp, fhp, status), 190 TP_STRUCT__entry( 191 __field(u32, xid) 192 __field(u32, fh_hash) 193 __field(int, status) 194 ), 195 TP_fast_assign( 196 __entry->xid = be32_to_cpu(rqstp->rq_xid); 197 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 198 __entry->status = status; 199 ), 200 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 201 __entry->xid, __entry->fh_hash, 202 __entry->status) 203 ) 204 205 #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 206 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 207 TP_PROTO(struct svc_rqst *rqstp, \ 208 struct svc_fh *fhp, \ 209 int status), \ 210 TP_ARGS(rqstp, fhp, status)) 211 212 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 213 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 214 215 TRACE_EVENT(nfsd_exp_find_key, 216 TP_PROTO(const struct svc_expkey *key, 217 int status), 218 TP_ARGS(key, status), 219 TP_STRUCT__entry( 220 __field(int, fsidtype) 221 __array(u32, fsid, 6) 222 __string(auth_domain, key->ek_client->name) 223 __field(int, status) 224 ), 225 TP_fast_assign( 226 __entry->fsidtype = key->ek_fsidtype; 227 memcpy(__entry->fsid, key->ek_fsid, 4*6); 228 __assign_str(auth_domain, key->ek_client->name); 229 __entry->status = status; 230 ), 231 TP_printk("fsid=%x::%s domain=%s status=%d", 232 __entry->fsidtype, 233 __print_array(__entry->fsid, 6, 4), 234 __get_str(auth_domain), 235 __entry->status 236 ) 237 ); 238 239 TRACE_EVENT(nfsd_expkey_update, 240 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 241 TP_ARGS(key, exp_path), 242 TP_STRUCT__entry( 243 __field(int, fsidtype) 244 __array(u32, fsid, 6) 245 __string(auth_domain, key->ek_client->name) 246 __string(path, exp_path) 247 __field(bool, cache) 248 ), 249 TP_fast_assign( 250 __entry->fsidtype = key->ek_fsidtype; 251 memcpy(__entry->fsid, key->ek_fsid, 4*6); 252 __assign_str(auth_domain, key->ek_client->name); 253 __assign_str(path, exp_path); 254 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 255 ), 256 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 257 __entry->fsidtype, 258 __print_array(__entry->fsid, 6, 4), 259 __get_str(auth_domain), 260 __get_str(path), 261 __entry->cache ? "pos" : "neg" 262 ) 263 ); 264 265 TRACE_EVENT(nfsd_exp_get_by_name, 266 TP_PROTO(const struct svc_export *key, 267 int status), 268 TP_ARGS(key, status), 269 TP_STRUCT__entry( 270 __string(path, key->ex_path.dentry->d_name.name) 271 __string(auth_domain, key->ex_client->name) 272 __field(int, status) 273 ), 274 TP_fast_assign( 275 __assign_str(path, key->ex_path.dentry->d_name.name); 276 __assign_str(auth_domain, key->ex_client->name); 277 __entry->status = status; 278 ), 279 TP_printk("path=%s domain=%s status=%d", 280 __get_str(path), 281 __get_str(auth_domain), 282 __entry->status 283 ) 284 ); 285 286 TRACE_EVENT(nfsd_export_update, 287 TP_PROTO(const struct svc_export *key), 288 TP_ARGS(key), 289 TP_STRUCT__entry( 290 __string(path, key->ex_path.dentry->d_name.name) 291 __string(auth_domain, key->ex_client->name) 292 __field(bool, cache) 293 ), 294 TP_fast_assign( 295 __assign_str(path, key->ex_path.dentry->d_name.name); 296 __assign_str(auth_domain, key->ex_client->name); 297 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 298 ), 299 TP_printk("path=%s domain=%s cache=%s", 300 __get_str(path), 301 __get_str(auth_domain), 302 __entry->cache ? "pos" : "neg" 303 ) 304 ); 305 306 DECLARE_EVENT_CLASS(nfsd_io_class, 307 TP_PROTO(struct svc_rqst *rqstp, 308 struct svc_fh *fhp, 309 u64 offset, 310 u32 len), 311 TP_ARGS(rqstp, fhp, offset, len), 312 TP_STRUCT__entry( 313 __field(u32, xid) 314 __field(u32, fh_hash) 315 __field(u64, offset) 316 __field(u32, len) 317 ), 318 TP_fast_assign( 319 __entry->xid = be32_to_cpu(rqstp->rq_xid); 320 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 321 __entry->offset = offset; 322 __entry->len = len; 323 ), 324 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 325 __entry->xid, __entry->fh_hash, 326 __entry->offset, __entry->len) 327 ) 328 329 #define DEFINE_NFSD_IO_EVENT(name) \ 330 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 331 TP_PROTO(struct svc_rqst *rqstp, \ 332 struct svc_fh *fhp, \ 333 u64 offset, \ 334 u32 len), \ 335 TP_ARGS(rqstp, fhp, offset, len)) 336 337 DEFINE_NFSD_IO_EVENT(read_start); 338 DEFINE_NFSD_IO_EVENT(read_splice); 339 DEFINE_NFSD_IO_EVENT(read_vector); 340 DEFINE_NFSD_IO_EVENT(read_io_done); 341 DEFINE_NFSD_IO_EVENT(read_done); 342 DEFINE_NFSD_IO_EVENT(write_start); 343 DEFINE_NFSD_IO_EVENT(write_opened); 344 DEFINE_NFSD_IO_EVENT(write_io_done); 345 DEFINE_NFSD_IO_EVENT(write_done); 346 347 DECLARE_EVENT_CLASS(nfsd_err_class, 348 TP_PROTO(struct svc_rqst *rqstp, 349 struct svc_fh *fhp, 350 loff_t offset, 351 int status), 352 TP_ARGS(rqstp, fhp, offset, status), 353 TP_STRUCT__entry( 354 __field(u32, xid) 355 __field(u32, fh_hash) 356 __field(loff_t, offset) 357 __field(int, status) 358 ), 359 TP_fast_assign( 360 __entry->xid = be32_to_cpu(rqstp->rq_xid); 361 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 362 __entry->offset = offset; 363 __entry->status = status; 364 ), 365 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 366 __entry->xid, __entry->fh_hash, 367 __entry->offset, __entry->status) 368 ) 369 370 #define DEFINE_NFSD_ERR_EVENT(name) \ 371 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 372 TP_PROTO(struct svc_rqst *rqstp, \ 373 struct svc_fh *fhp, \ 374 loff_t offset, \ 375 int len), \ 376 TP_ARGS(rqstp, fhp, offset, len)) 377 378 DEFINE_NFSD_ERR_EVENT(read_err); 379 DEFINE_NFSD_ERR_EVENT(write_err); 380 381 TRACE_EVENT(nfsd_dirent, 382 TP_PROTO(struct svc_fh *fhp, 383 u64 ino, 384 const char *name, 385 int namlen), 386 TP_ARGS(fhp, ino, name, namlen), 387 TP_STRUCT__entry( 388 __field(u32, fh_hash) 389 __field(u64, ino) 390 __string_len(name, name, namlen) 391 ), 392 TP_fast_assign( 393 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 394 __entry->ino = ino; 395 __assign_str_len(name, name, namlen) 396 ), 397 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 398 __entry->fh_hash, __entry->ino, __get_str(name) 399 ) 400 ) 401 402 DECLARE_EVENT_CLASS(nfsd_copy_err_class, 403 TP_PROTO(struct svc_rqst *rqstp, 404 struct svc_fh *src_fhp, 405 loff_t src_offset, 406 struct svc_fh *dst_fhp, 407 loff_t dst_offset, 408 u64 count, 409 int status), 410 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 411 TP_STRUCT__entry( 412 __field(u32, xid) 413 __field(u32, src_fh_hash) 414 __field(loff_t, src_offset) 415 __field(u32, dst_fh_hash) 416 __field(loff_t, dst_offset) 417 __field(u64, count) 418 __field(int, status) 419 ), 420 TP_fast_assign( 421 __entry->xid = be32_to_cpu(rqstp->rq_xid); 422 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 423 __entry->src_offset = src_offset; 424 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 425 __entry->dst_offset = dst_offset; 426 __entry->count = count; 427 __entry->status = status; 428 ), 429 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 430 "dst_fh_hash=0x%08x dst_offset=%lld " 431 "count=%llu status=%d", 432 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 433 __entry->dst_fh_hash, __entry->dst_offset, 434 (unsigned long long)__entry->count, 435 __entry->status) 436 ) 437 438 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 439 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 440 TP_PROTO(struct svc_rqst *rqstp, \ 441 struct svc_fh *src_fhp, \ 442 loff_t src_offset, \ 443 struct svc_fh *dst_fhp, \ 444 loff_t dst_offset, \ 445 u64 count, \ 446 int status), \ 447 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 448 count, status)) 449 450 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 451 452 #include "state.h" 453 #include "filecache.h" 454 #include "vfs.h" 455 456 DECLARE_EVENT_CLASS(nfsd_stateid_class, 457 TP_PROTO(stateid_t *stp), 458 TP_ARGS(stp), 459 TP_STRUCT__entry( 460 __field(u32, cl_boot) 461 __field(u32, cl_id) 462 __field(u32, si_id) 463 __field(u32, si_generation) 464 ), 465 TP_fast_assign( 466 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 467 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 468 __entry->si_id = stp->si_opaque.so_id; 469 __entry->si_generation = stp->si_generation; 470 ), 471 TP_printk("client %08x:%08x stateid %08x:%08x", 472 __entry->cl_boot, 473 __entry->cl_id, 474 __entry->si_id, 475 __entry->si_generation) 476 ) 477 478 #define DEFINE_STATEID_EVENT(name) \ 479 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 480 TP_PROTO(stateid_t *stp), \ 481 TP_ARGS(stp)) 482 483 DEFINE_STATEID_EVENT(layoutstate_alloc); 484 DEFINE_STATEID_EVENT(layoutstate_unhash); 485 DEFINE_STATEID_EVENT(layoutstate_free); 486 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 487 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 488 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 489 DEFINE_STATEID_EVENT(layout_recall); 490 DEFINE_STATEID_EVENT(layout_recall_done); 491 DEFINE_STATEID_EVENT(layout_recall_fail); 492 DEFINE_STATEID_EVENT(layout_recall_release); 493 494 DEFINE_STATEID_EVENT(open); 495 DEFINE_STATEID_EVENT(deleg_read); 496 DEFINE_STATEID_EVENT(deleg_recall); 497 498 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 499 TP_PROTO(u32 seqid, const stateid_t *stp), 500 TP_ARGS(seqid, stp), 501 TP_STRUCT__entry( 502 __field(u32, seqid) 503 __field(u32, cl_boot) 504 __field(u32, cl_id) 505 __field(u32, si_id) 506 __field(u32, si_generation) 507 ), 508 TP_fast_assign( 509 __entry->seqid = seqid; 510 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 511 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 512 __entry->si_id = stp->si_opaque.so_id; 513 __entry->si_generation = stp->si_generation; 514 ), 515 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 516 __entry->seqid, __entry->cl_boot, __entry->cl_id, 517 __entry->si_id, __entry->si_generation) 518 ) 519 520 #define DEFINE_STATESEQID_EVENT(name) \ 521 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 522 TP_PROTO(u32 seqid, const stateid_t *stp), \ 523 TP_ARGS(seqid, stp)) 524 525 DEFINE_STATESEQID_EVENT(preprocess); 526 DEFINE_STATESEQID_EVENT(open_confirm); 527 528 DECLARE_EVENT_CLASS(nfsd_clientid_class, 529 TP_PROTO(const clientid_t *clid), 530 TP_ARGS(clid), 531 TP_STRUCT__entry( 532 __field(u32, cl_boot) 533 __field(u32, cl_id) 534 ), 535 TP_fast_assign( 536 __entry->cl_boot = clid->cl_boot; 537 __entry->cl_id = clid->cl_id; 538 ), 539 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 540 ) 541 542 #define DEFINE_CLIENTID_EVENT(name) \ 543 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 544 TP_PROTO(const clientid_t *clid), \ 545 TP_ARGS(clid)) 546 547 DEFINE_CLIENTID_EVENT(expire_unconf); 548 DEFINE_CLIENTID_EVENT(reclaim_complete); 549 DEFINE_CLIENTID_EVENT(confirmed); 550 DEFINE_CLIENTID_EVENT(destroyed); 551 DEFINE_CLIENTID_EVENT(admin_expired); 552 DEFINE_CLIENTID_EVENT(replaced); 553 DEFINE_CLIENTID_EVENT(purged); 554 DEFINE_CLIENTID_EVENT(renew); 555 DEFINE_CLIENTID_EVENT(stale); 556 557 DECLARE_EVENT_CLASS(nfsd_net_class, 558 TP_PROTO(const struct nfsd_net *nn), 559 TP_ARGS(nn), 560 TP_STRUCT__entry( 561 __field(unsigned long long, boot_time) 562 ), 563 TP_fast_assign( 564 __entry->boot_time = nn->boot_time; 565 ), 566 TP_printk("boot_time=%16llx", __entry->boot_time) 567 ) 568 569 #define DEFINE_NET_EVENT(name) \ 570 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 571 TP_PROTO(const struct nfsd_net *nn), \ 572 TP_ARGS(nn)) 573 574 DEFINE_NET_EVENT(grace_start); 575 DEFINE_NET_EVENT(grace_complete); 576 577 TRACE_EVENT(nfsd_writeverf_reset, 578 TP_PROTO( 579 const struct nfsd_net *nn, 580 const struct svc_rqst *rqstp, 581 int error 582 ), 583 TP_ARGS(nn, rqstp, error), 584 TP_STRUCT__entry( 585 __field(unsigned long long, boot_time) 586 __field(u32, xid) 587 __field(int, error) 588 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 589 ), 590 TP_fast_assign( 591 __entry->boot_time = nn->boot_time; 592 __entry->xid = be32_to_cpu(rqstp->rq_xid); 593 __entry->error = error; 594 595 /* avoid seqlock inside TP_fast_assign */ 596 memcpy(__entry->verifier, nn->writeverf, 597 NFS4_VERIFIER_SIZE); 598 ), 599 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 600 __entry->boot_time, __entry->xid, __entry->error, 601 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 602 ) 603 ); 604 605 TRACE_EVENT(nfsd_clid_cred_mismatch, 606 TP_PROTO( 607 const struct nfs4_client *clp, 608 const struct svc_rqst *rqstp 609 ), 610 TP_ARGS(clp, rqstp), 611 TP_STRUCT__entry( 612 __field(u32, cl_boot) 613 __field(u32, cl_id) 614 __field(unsigned long, cl_flavor) 615 __field(unsigned long, new_flavor) 616 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 617 ), 618 TP_fast_assign( 619 __entry->cl_boot = clp->cl_clientid.cl_boot; 620 __entry->cl_id = clp->cl_clientid.cl_id; 621 __entry->cl_flavor = clp->cl_cred.cr_flavor; 622 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 623 memcpy(__entry->addr, &rqstp->rq_xprt->xpt_remote, 624 sizeof(struct sockaddr_in6)); 625 ), 626 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 627 __entry->cl_boot, __entry->cl_id, 628 show_nfsd_authflavor(__entry->cl_flavor), 629 show_nfsd_authflavor(__entry->new_flavor), __entry->addr 630 ) 631 ) 632 633 TRACE_EVENT(nfsd_clid_verf_mismatch, 634 TP_PROTO( 635 const struct nfs4_client *clp, 636 const struct svc_rqst *rqstp, 637 const nfs4_verifier *verf 638 ), 639 TP_ARGS(clp, rqstp, verf), 640 TP_STRUCT__entry( 641 __field(u32, cl_boot) 642 __field(u32, cl_id) 643 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 644 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 645 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 646 ), 647 TP_fast_assign( 648 __entry->cl_boot = clp->cl_clientid.cl_boot; 649 __entry->cl_id = clp->cl_clientid.cl_id; 650 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 651 NFS4_VERIFIER_SIZE); 652 memcpy(__entry->new_verifier, (void *)verf, 653 NFS4_VERIFIER_SIZE); 654 memcpy(__entry->addr, &rqstp->rq_xprt->xpt_remote, 655 sizeof(struct sockaddr_in6)); 656 ), 657 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 658 __entry->cl_boot, __entry->cl_id, 659 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 660 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 661 __entry->addr 662 ) 663 ); 664 665 DECLARE_EVENT_CLASS(nfsd_clid_class, 666 TP_PROTO(const struct nfs4_client *clp), 667 TP_ARGS(clp), 668 TP_STRUCT__entry( 669 __field(u32, cl_boot) 670 __field(u32, cl_id) 671 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 672 __field(unsigned long, flavor) 673 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 674 __string_len(name, name, clp->cl_name.len) 675 ), 676 TP_fast_assign( 677 __entry->cl_boot = clp->cl_clientid.cl_boot; 678 __entry->cl_id = clp->cl_clientid.cl_id; 679 memcpy(__entry->addr, &clp->cl_addr, 680 sizeof(struct sockaddr_in6)); 681 __entry->flavor = clp->cl_cred.cr_flavor; 682 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 683 NFS4_VERIFIER_SIZE); 684 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 685 ), 686 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 687 __entry->addr, __get_str(name), 688 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 689 show_nfsd_authflavor(__entry->flavor), 690 __entry->cl_boot, __entry->cl_id) 691 ); 692 693 #define DEFINE_CLID_EVENT(name) \ 694 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 695 TP_PROTO(const struct nfs4_client *clp), \ 696 TP_ARGS(clp)) 697 698 DEFINE_CLID_EVENT(fresh); 699 DEFINE_CLID_EVENT(confirmed_r); 700 701 /* 702 * from fs/nfsd/filecache.h 703 */ 704 TRACE_DEFINE_ENUM(NFSD_FILE_HASHED); 705 TRACE_DEFINE_ENUM(NFSD_FILE_PENDING); 706 TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_READ); 707 TRACE_DEFINE_ENUM(NFSD_FILE_BREAK_WRITE); 708 TRACE_DEFINE_ENUM(NFSD_FILE_REFERENCED); 709 710 #define show_nf_flags(val) \ 711 __print_flags(val, "|", \ 712 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 713 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 714 { 1 << NFSD_FILE_BREAK_READ, "BREAK_READ" }, \ 715 { 1 << NFSD_FILE_BREAK_WRITE, "BREAK_WRITE" }, \ 716 { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}) 717 718 DECLARE_EVENT_CLASS(nfsd_file_class, 719 TP_PROTO(struct nfsd_file *nf), 720 TP_ARGS(nf), 721 TP_STRUCT__entry( 722 __field(unsigned int, nf_hashval) 723 __field(void *, nf_inode) 724 __field(int, nf_ref) 725 __field(unsigned long, nf_flags) 726 __field(unsigned char, nf_may) 727 __field(struct file *, nf_file) 728 ), 729 TP_fast_assign( 730 __entry->nf_hashval = nf->nf_hashval; 731 __entry->nf_inode = nf->nf_inode; 732 __entry->nf_ref = refcount_read(&nf->nf_ref); 733 __entry->nf_flags = nf->nf_flags; 734 __entry->nf_may = nf->nf_may; 735 __entry->nf_file = nf->nf_file; 736 ), 737 TP_printk("hash=0x%x inode=%p ref=%d flags=%s may=%s file=%p", 738 __entry->nf_hashval, 739 __entry->nf_inode, 740 __entry->nf_ref, 741 show_nf_flags(__entry->nf_flags), 742 show_nfsd_may_flags(__entry->nf_may), 743 __entry->nf_file) 744 ) 745 746 #define DEFINE_NFSD_FILE_EVENT(name) \ 747 DEFINE_EVENT(nfsd_file_class, name, \ 748 TP_PROTO(struct nfsd_file *nf), \ 749 TP_ARGS(nf)) 750 751 DEFINE_NFSD_FILE_EVENT(nfsd_file_alloc); 752 DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 753 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 754 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 755 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_release_locked); 756 757 TRACE_EVENT(nfsd_file_acquire, 758 TP_PROTO(struct svc_rqst *rqstp, unsigned int hash, 759 struct inode *inode, unsigned int may_flags, 760 struct nfsd_file *nf, __be32 status), 761 762 TP_ARGS(rqstp, hash, inode, may_flags, nf, status), 763 764 TP_STRUCT__entry( 765 __field(u32, xid) 766 __field(unsigned int, hash) 767 __field(void *, inode) 768 __field(unsigned long, may_flags) 769 __field(int, nf_ref) 770 __field(unsigned long, nf_flags) 771 __field(unsigned long, nf_may) 772 __field(struct file *, nf_file) 773 __field(u32, status) 774 ), 775 776 TP_fast_assign( 777 __entry->xid = be32_to_cpu(rqstp->rq_xid); 778 __entry->hash = hash; 779 __entry->inode = inode; 780 __entry->may_flags = may_flags; 781 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 782 __entry->nf_flags = nf ? nf->nf_flags : 0; 783 __entry->nf_may = nf ? nf->nf_may : 0; 784 __entry->nf_file = nf ? nf->nf_file : NULL; 785 __entry->status = be32_to_cpu(status); 786 ), 787 788 TP_printk("xid=0x%x hash=0x%x inode=%p may_flags=%s ref=%d nf_flags=%s nf_may=%s nf_file=%p status=%u", 789 __entry->xid, __entry->hash, __entry->inode, 790 show_nfsd_may_flags(__entry->may_flags), 791 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 792 show_nfsd_may_flags(__entry->nf_may), 793 __entry->nf_file, __entry->status) 794 ); 795 796 DECLARE_EVENT_CLASS(nfsd_file_search_class, 797 TP_PROTO(struct inode *inode, unsigned int hash, int found), 798 TP_ARGS(inode, hash, found), 799 TP_STRUCT__entry( 800 __field(struct inode *, inode) 801 __field(unsigned int, hash) 802 __field(int, found) 803 ), 804 TP_fast_assign( 805 __entry->inode = inode; 806 __entry->hash = hash; 807 __entry->found = found; 808 ), 809 TP_printk("hash=0x%x inode=%p found=%d", __entry->hash, 810 __entry->inode, __entry->found) 811 ); 812 813 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 814 DEFINE_EVENT(nfsd_file_search_class, name, \ 815 TP_PROTO(struct inode *inode, unsigned int hash, int found), \ 816 TP_ARGS(inode, hash, found)) 817 818 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 819 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 820 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_is_cached); 821 822 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 823 TP_PROTO(struct inode *inode, u32 mask), 824 TP_ARGS(inode, mask), 825 TP_STRUCT__entry( 826 __field(struct inode *, inode) 827 __field(unsigned int, nlink) 828 __field(umode_t, mode) 829 __field(u32, mask) 830 ), 831 TP_fast_assign( 832 __entry->inode = inode; 833 __entry->nlink = inode->i_nlink; 834 __entry->mode = inode->i_mode; 835 __entry->mask = mask; 836 ), 837 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 838 __entry->nlink, __entry->mode, __entry->mask) 839 ); 840 841 #include "cache.h" 842 843 TRACE_DEFINE_ENUM(RC_DROPIT); 844 TRACE_DEFINE_ENUM(RC_REPLY); 845 TRACE_DEFINE_ENUM(RC_DOIT); 846 847 #define show_drc_retval(x) \ 848 __print_symbolic(x, \ 849 { RC_DROPIT, "DROPIT" }, \ 850 { RC_REPLY, "REPLY" }, \ 851 { RC_DOIT, "DOIT" }) 852 853 TRACE_EVENT(nfsd_drc_found, 854 TP_PROTO( 855 const struct nfsd_net *nn, 856 const struct svc_rqst *rqstp, 857 int result 858 ), 859 TP_ARGS(nn, rqstp, result), 860 TP_STRUCT__entry( 861 __field(unsigned long long, boot_time) 862 __field(unsigned long, result) 863 __field(u32, xid) 864 ), 865 TP_fast_assign( 866 __entry->boot_time = nn->boot_time; 867 __entry->result = result; 868 __entry->xid = be32_to_cpu(rqstp->rq_xid); 869 ), 870 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 871 __entry->boot_time, __entry->xid, 872 show_drc_retval(__entry->result)) 873 874 ); 875 876 TRACE_EVENT(nfsd_drc_mismatch, 877 TP_PROTO( 878 const struct nfsd_net *nn, 879 const struct svc_cacherep *key, 880 const struct svc_cacherep *rp 881 ), 882 TP_ARGS(nn, key, rp), 883 TP_STRUCT__entry( 884 __field(unsigned long long, boot_time) 885 __field(u32, xid) 886 __field(u32, cached) 887 __field(u32, ingress) 888 ), 889 TP_fast_assign( 890 __entry->boot_time = nn->boot_time; 891 __entry->xid = be32_to_cpu(key->c_key.k_xid); 892 __entry->cached = (__force u32)key->c_key.k_csum; 893 __entry->ingress = (__force u32)rp->c_key.k_csum; 894 ), 895 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 896 __entry->boot_time, __entry->xid, __entry->cached, 897 __entry->ingress) 898 ); 899 900 TRACE_EVENT(nfsd_cb_args, 901 TP_PROTO( 902 const struct nfs4_client *clp, 903 const struct nfs4_cb_conn *conn 904 ), 905 TP_ARGS(clp, conn), 906 TP_STRUCT__entry( 907 __field(u32, cl_boot) 908 __field(u32, cl_id) 909 __field(u32, prog) 910 __field(u32, ident) 911 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 912 ), 913 TP_fast_assign( 914 __entry->cl_boot = clp->cl_clientid.cl_boot; 915 __entry->cl_id = clp->cl_clientid.cl_id; 916 __entry->prog = conn->cb_prog; 917 __entry->ident = conn->cb_ident; 918 memcpy(__entry->addr, &conn->cb_addr, 919 sizeof(struct sockaddr_in6)); 920 ), 921 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 922 __entry->addr, __entry->cl_boot, __entry->cl_id, 923 __entry->prog, __entry->ident) 924 ); 925 926 TRACE_EVENT(nfsd_cb_nodelegs, 927 TP_PROTO(const struct nfs4_client *clp), 928 TP_ARGS(clp), 929 TP_STRUCT__entry( 930 __field(u32, cl_boot) 931 __field(u32, cl_id) 932 ), 933 TP_fast_assign( 934 __entry->cl_boot = clp->cl_clientid.cl_boot; 935 __entry->cl_id = clp->cl_clientid.cl_id; 936 ), 937 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 938 ) 939 940 #define show_cb_state(val) \ 941 __print_symbolic(val, \ 942 { NFSD4_CB_UP, "UP" }, \ 943 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 944 { NFSD4_CB_DOWN, "DOWN" }, \ 945 { NFSD4_CB_FAULT, "FAULT"}) 946 947 DECLARE_EVENT_CLASS(nfsd_cb_class, 948 TP_PROTO(const struct nfs4_client *clp), 949 TP_ARGS(clp), 950 TP_STRUCT__entry( 951 __field(unsigned long, state) 952 __field(u32, cl_boot) 953 __field(u32, cl_id) 954 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 955 ), 956 TP_fast_assign( 957 __entry->state = clp->cl_cb_state; 958 __entry->cl_boot = clp->cl_clientid.cl_boot; 959 __entry->cl_id = clp->cl_clientid.cl_id; 960 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 961 sizeof(struct sockaddr_in6)); 962 ), 963 TP_printk("addr=%pISpc client %08x:%08x state=%s", 964 __entry->addr, __entry->cl_boot, __entry->cl_id, 965 show_cb_state(__entry->state)) 966 ); 967 968 #define DEFINE_NFSD_CB_EVENT(name) \ 969 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 970 TP_PROTO(const struct nfs4_client *clp), \ 971 TP_ARGS(clp)) 972 973 DEFINE_NFSD_CB_EVENT(state); 974 DEFINE_NFSD_CB_EVENT(probe); 975 DEFINE_NFSD_CB_EVENT(lost); 976 DEFINE_NFSD_CB_EVENT(shutdown); 977 978 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 979 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 980 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 981 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 982 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 983 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 984 985 #define show_nfsd_authflavor(val) \ 986 __print_symbolic(val, \ 987 { RPC_AUTH_NULL, "none" }, \ 988 { RPC_AUTH_UNIX, "sys" }, \ 989 { RPC_AUTH_GSS, "gss" }, \ 990 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 991 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 992 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 993 994 TRACE_EVENT(nfsd_cb_setup, 995 TP_PROTO(const struct nfs4_client *clp, 996 const char *netid, 997 rpc_authflavor_t authflavor 998 ), 999 TP_ARGS(clp, netid, authflavor), 1000 TP_STRUCT__entry( 1001 __field(u32, cl_boot) 1002 __field(u32, cl_id) 1003 __field(unsigned long, authflavor) 1004 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1005 __array(unsigned char, netid, 8) 1006 ), 1007 TP_fast_assign( 1008 __entry->cl_boot = clp->cl_clientid.cl_boot; 1009 __entry->cl_id = clp->cl_clientid.cl_id; 1010 strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 1011 __entry->authflavor = authflavor; 1012 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 1013 sizeof(struct sockaddr_in6)); 1014 ), 1015 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1016 __entry->addr, __entry->cl_boot, __entry->cl_id, 1017 __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 1018 ); 1019 1020 TRACE_EVENT(nfsd_cb_setup_err, 1021 TP_PROTO( 1022 const struct nfs4_client *clp, 1023 long error 1024 ), 1025 TP_ARGS(clp, error), 1026 TP_STRUCT__entry( 1027 __field(long, error) 1028 __field(u32, cl_boot) 1029 __field(u32, cl_id) 1030 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1031 ), 1032 TP_fast_assign( 1033 __entry->error = error; 1034 __entry->cl_boot = clp->cl_clientid.cl_boot; 1035 __entry->cl_id = clp->cl_clientid.cl_id; 1036 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 1037 sizeof(struct sockaddr_in6)); 1038 ), 1039 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1040 __entry->addr, __entry->cl_boot, __entry->cl_id, __entry->error) 1041 ); 1042 1043 TRACE_EVENT(nfsd_cb_recall, 1044 TP_PROTO( 1045 const struct nfs4_stid *stid 1046 ), 1047 TP_ARGS(stid), 1048 TP_STRUCT__entry( 1049 __field(u32, cl_boot) 1050 __field(u32, cl_id) 1051 __field(u32, si_id) 1052 __field(u32, si_generation) 1053 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1054 ), 1055 TP_fast_assign( 1056 const stateid_t *stp = &stid->sc_stateid; 1057 const struct nfs4_client *clp = stid->sc_client; 1058 1059 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1060 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1061 __entry->si_id = stp->si_opaque.so_id; 1062 __entry->si_generation = stp->si_generation; 1063 if (clp) 1064 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 1065 sizeof(struct sockaddr_in6)); 1066 else 1067 memset(__entry->addr, 0, sizeof(struct sockaddr_in6)); 1068 ), 1069 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1070 __entry->addr, __entry->cl_boot, __entry->cl_id, 1071 __entry->si_id, __entry->si_generation) 1072 ); 1073 1074 TRACE_EVENT(nfsd_cb_notify_lock, 1075 TP_PROTO( 1076 const struct nfs4_lockowner *lo, 1077 const struct nfsd4_blocked_lock *nbl 1078 ), 1079 TP_ARGS(lo, nbl), 1080 TP_STRUCT__entry( 1081 __field(u32, cl_boot) 1082 __field(u32, cl_id) 1083 __field(u32, fh_hash) 1084 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1085 ), 1086 TP_fast_assign( 1087 const struct nfs4_client *clp = lo->lo_owner.so_client; 1088 1089 __entry->cl_boot = clp->cl_clientid.cl_boot; 1090 __entry->cl_id = clp->cl_clientid.cl_id; 1091 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1092 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 1093 sizeof(struct sockaddr_in6)); 1094 ), 1095 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1096 __entry->addr, __entry->cl_boot, __entry->cl_id, 1097 __entry->fh_hash) 1098 ); 1099 1100 TRACE_EVENT(nfsd_cb_offload, 1101 TP_PROTO( 1102 const struct nfs4_client *clp, 1103 const stateid_t *stp, 1104 const struct knfsd_fh *fh, 1105 u64 count, 1106 __be32 status 1107 ), 1108 TP_ARGS(clp, stp, fh, count, status), 1109 TP_STRUCT__entry( 1110 __field(u32, cl_boot) 1111 __field(u32, cl_id) 1112 __field(u32, si_id) 1113 __field(u32, si_generation) 1114 __field(u32, fh_hash) 1115 __field(int, status) 1116 __field(u64, count) 1117 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 1118 ), 1119 TP_fast_assign( 1120 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1121 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1122 __entry->si_id = stp->si_opaque.so_id; 1123 __entry->si_generation = stp->si_generation; 1124 __entry->fh_hash = knfsd_fh_hash(fh); 1125 __entry->status = be32_to_cpu(status); 1126 __entry->count = count; 1127 memcpy(__entry->addr, &clp->cl_cb_conn.cb_addr, 1128 sizeof(struct sockaddr_in6)); 1129 ), 1130 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1131 __entry->addr, __entry->cl_boot, __entry->cl_id, 1132 __entry->si_id, __entry->si_generation, 1133 __entry->fh_hash, __entry->count, __entry->status) 1134 ); 1135 1136 #endif /* _NFSD_TRACE_H */ 1137 1138 #undef TRACE_INCLUDE_PATH 1139 #define TRACE_INCLUDE_PATH . 1140 #define TRACE_INCLUDE_FILE trace 1141 #include <trace/define_trace.h> 1142