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/xprt.h> 13#include <trace/misc/nfs.h> 14 15#include "export.h" 16#include "nfsfh.h" 17#include "xdr4.h" 18 19#define NFSD_TRACE_PROC_RES_FIELDS \ 20 __field(unsigned int, netns_ino) \ 21 __field(u32, xid) \ 22 __field(unsigned long, status) \ 23 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 24 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 25 26#define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 27 do { \ 28 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 29 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 30 __entry->status = be32_to_cpu(error); \ 31 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 32 rqstp->rq_xprt->xpt_locallen); \ 33 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 34 rqstp->rq_xprt->xpt_remotelen); \ 35 } while (0); 36 37DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 38 TP_PROTO( 39 const struct svc_rqst *rqstp 40 ), 41 TP_ARGS(rqstp), 42 TP_STRUCT__entry( 43 __field(unsigned int, netns_ino) 44 __field(u32, xid) 45 __field(u32, vers) 46 __field(u32, proc) 47 __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 48 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 49 ), 50 TP_fast_assign( 51 const struct svc_xprt *xprt = rqstp->rq_xprt; 52 53 __entry->netns_ino = xprt->xpt_net->ns.inum; 54 __entry->xid = be32_to_cpu(rqstp->rq_xid); 55 __entry->vers = rqstp->rq_vers; 56 __entry->proc = rqstp->rq_proc; 57 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 58 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 59 ), 60 TP_printk("xid=0x%08x vers=%u proc=%u", 61 __entry->xid, __entry->vers, __entry->proc 62 ) 63); 64 65#define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 66DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 67 TP_PROTO(const struct svc_rqst *rqstp), \ 68 TP_ARGS(rqstp)) 69 70DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 71DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 72 73#define show_nfsd_may_flags(x) \ 74 __print_flags(x, "|", \ 75 { NFSD_MAY_EXEC, "EXEC" }, \ 76 { NFSD_MAY_WRITE, "WRITE" }, \ 77 { NFSD_MAY_READ, "READ" }, \ 78 { NFSD_MAY_SATTR, "SATTR" }, \ 79 { NFSD_MAY_TRUNC, "TRUNC" }, \ 80 { NFSD_MAY_LOCK, "LOCK" }, \ 81 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 82 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 83 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 84 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 85 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 86 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 87 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 88 89TRACE_EVENT(nfsd_compound, 90 TP_PROTO( 91 const struct svc_rqst *rqst, 92 const char *tag, 93 u32 taglen, 94 u32 opcnt 95 ), 96 TP_ARGS(rqst, tag, taglen, opcnt), 97 TP_STRUCT__entry( 98 __field(u32, xid) 99 __field(u32, opcnt) 100 __string_len(tag, tag, taglen) 101 ), 102 TP_fast_assign( 103 __entry->xid = be32_to_cpu(rqst->rq_xid); 104 __entry->opcnt = opcnt; 105 __assign_str_len(tag, tag, taglen); 106 ), 107 TP_printk("xid=0x%08x opcnt=%u tag=%s", 108 __entry->xid, __entry->opcnt, __get_str(tag) 109 ) 110) 111 112TRACE_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 135TRACE_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 163TRACE_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#define show_fs_file_type(x) \ 185 __print_symbolic(x, \ 186 { S_IFLNK, "LNK" }, \ 187 { S_IFREG, "REG" }, \ 188 { S_IFDIR, "DIR" }, \ 189 { S_IFCHR, "CHR" }, \ 190 { S_IFBLK, "BLK" }, \ 191 { S_IFIFO, "FIFO" }, \ 192 { S_IFSOCK, "SOCK" }) 193 194TRACE_EVENT(nfsd_fh_verify, 195 TP_PROTO( 196 const struct svc_rqst *rqstp, 197 const struct svc_fh *fhp, 198 umode_t type, 199 int access 200 ), 201 TP_ARGS(rqstp, fhp, type, access), 202 TP_STRUCT__entry( 203 __field(unsigned int, netns_ino) 204 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 205 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 206 __field(u32, xid) 207 __field(u32, fh_hash) 208 __field(const void *, inode) 209 __field(unsigned long, type) 210 __field(unsigned long, access) 211 ), 212 TP_fast_assign( 213 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 214 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 215 rqstp->rq_xprt->xpt_locallen); 216 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 217 rqstp->rq_xprt->xpt_remotelen); 218 __entry->xid = be32_to_cpu(rqstp->rq_xid); 219 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 220 __entry->inode = d_inode(fhp->fh_dentry); 221 __entry->type = type; 222 __entry->access = access; 223 ), 224 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 225 __entry->xid, __entry->fh_hash, 226 show_fs_file_type(__entry->type), 227 show_nfsd_may_flags(__entry->access) 228 ) 229); 230 231TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 232 TP_PROTO( 233 const struct svc_rqst *rqstp, 234 const struct svc_fh *fhp, 235 umode_t type, 236 int access, 237 __be32 error 238 ), 239 TP_ARGS(rqstp, fhp, type, access, error), 240 TP_CONDITION(error), 241 TP_STRUCT__entry( 242 __field(unsigned int, netns_ino) 243 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 244 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 245 __field(u32, xid) 246 __field(u32, fh_hash) 247 __field(const void *, inode) 248 __field(unsigned long, type) 249 __field(unsigned long, access) 250 __field(int, error) 251 ), 252 TP_fast_assign( 253 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 254 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 255 rqstp->rq_xprt->xpt_locallen); 256 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 257 rqstp->rq_xprt->xpt_remotelen); 258 __entry->xid = be32_to_cpu(rqstp->rq_xid); 259 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 260 if (fhp->fh_dentry) 261 __entry->inode = d_inode(fhp->fh_dentry); 262 else 263 __entry->inode = NULL; 264 __entry->type = type; 265 __entry->access = access; 266 __entry->error = be32_to_cpu(error); 267 ), 268 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 269 __entry->xid, __entry->fh_hash, 270 show_fs_file_type(__entry->type), 271 show_nfsd_may_flags(__entry->access), 272 __entry->error 273 ) 274); 275 276DECLARE_EVENT_CLASS(nfsd_fh_err_class, 277 TP_PROTO(struct svc_rqst *rqstp, 278 struct svc_fh *fhp, 279 int status), 280 TP_ARGS(rqstp, fhp, status), 281 TP_STRUCT__entry( 282 __field(u32, xid) 283 __field(u32, fh_hash) 284 __field(int, status) 285 ), 286 TP_fast_assign( 287 __entry->xid = be32_to_cpu(rqstp->rq_xid); 288 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 289 __entry->status = status; 290 ), 291 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 292 __entry->xid, __entry->fh_hash, 293 __entry->status) 294) 295 296#define DEFINE_NFSD_FH_ERR_EVENT(name) \ 297DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 298 TP_PROTO(struct svc_rqst *rqstp, \ 299 struct svc_fh *fhp, \ 300 int status), \ 301 TP_ARGS(rqstp, fhp, status)) 302 303DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 304DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 305 306TRACE_EVENT(nfsd_exp_find_key, 307 TP_PROTO(const struct svc_expkey *key, 308 int status), 309 TP_ARGS(key, status), 310 TP_STRUCT__entry( 311 __field(int, fsidtype) 312 __array(u32, fsid, 6) 313 __string(auth_domain, key->ek_client->name) 314 __field(int, status) 315 ), 316 TP_fast_assign( 317 __entry->fsidtype = key->ek_fsidtype; 318 memcpy(__entry->fsid, key->ek_fsid, 4*6); 319 __assign_str(auth_domain, key->ek_client->name); 320 __entry->status = status; 321 ), 322 TP_printk("fsid=%x::%s domain=%s status=%d", 323 __entry->fsidtype, 324 __print_array(__entry->fsid, 6, 4), 325 __get_str(auth_domain), 326 __entry->status 327 ) 328); 329 330TRACE_EVENT(nfsd_expkey_update, 331 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 332 TP_ARGS(key, exp_path), 333 TP_STRUCT__entry( 334 __field(int, fsidtype) 335 __array(u32, fsid, 6) 336 __string(auth_domain, key->ek_client->name) 337 __string(path, exp_path) 338 __field(bool, cache) 339 ), 340 TP_fast_assign( 341 __entry->fsidtype = key->ek_fsidtype; 342 memcpy(__entry->fsid, key->ek_fsid, 4*6); 343 __assign_str(auth_domain, key->ek_client->name); 344 __assign_str(path, exp_path); 345 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 346 ), 347 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 348 __entry->fsidtype, 349 __print_array(__entry->fsid, 6, 4), 350 __get_str(auth_domain), 351 __get_str(path), 352 __entry->cache ? "pos" : "neg" 353 ) 354); 355 356TRACE_EVENT(nfsd_exp_get_by_name, 357 TP_PROTO(const struct svc_export *key, 358 int status), 359 TP_ARGS(key, status), 360 TP_STRUCT__entry( 361 __string(path, key->ex_path.dentry->d_name.name) 362 __string(auth_domain, key->ex_client->name) 363 __field(int, status) 364 ), 365 TP_fast_assign( 366 __assign_str(path, key->ex_path.dentry->d_name.name); 367 __assign_str(auth_domain, key->ex_client->name); 368 __entry->status = status; 369 ), 370 TP_printk("path=%s domain=%s status=%d", 371 __get_str(path), 372 __get_str(auth_domain), 373 __entry->status 374 ) 375); 376 377TRACE_EVENT(nfsd_export_update, 378 TP_PROTO(const struct svc_export *key), 379 TP_ARGS(key), 380 TP_STRUCT__entry( 381 __string(path, key->ex_path.dentry->d_name.name) 382 __string(auth_domain, key->ex_client->name) 383 __field(bool, cache) 384 ), 385 TP_fast_assign( 386 __assign_str(path, key->ex_path.dentry->d_name.name); 387 __assign_str(auth_domain, key->ex_client->name); 388 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 389 ), 390 TP_printk("path=%s domain=%s cache=%s", 391 __get_str(path), 392 __get_str(auth_domain), 393 __entry->cache ? "pos" : "neg" 394 ) 395); 396 397DECLARE_EVENT_CLASS(nfsd_io_class, 398 TP_PROTO(struct svc_rqst *rqstp, 399 struct svc_fh *fhp, 400 u64 offset, 401 u32 len), 402 TP_ARGS(rqstp, fhp, offset, len), 403 TP_STRUCT__entry( 404 __field(u32, xid) 405 __field(u32, fh_hash) 406 __field(u64, offset) 407 __field(u32, len) 408 ), 409 TP_fast_assign( 410 __entry->xid = be32_to_cpu(rqstp->rq_xid); 411 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 412 __entry->offset = offset; 413 __entry->len = len; 414 ), 415 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 416 __entry->xid, __entry->fh_hash, 417 __entry->offset, __entry->len) 418) 419 420#define DEFINE_NFSD_IO_EVENT(name) \ 421DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 422 TP_PROTO(struct svc_rqst *rqstp, \ 423 struct svc_fh *fhp, \ 424 u64 offset, \ 425 u32 len), \ 426 TP_ARGS(rqstp, fhp, offset, len)) 427 428DEFINE_NFSD_IO_EVENT(read_start); 429DEFINE_NFSD_IO_EVENT(read_splice); 430DEFINE_NFSD_IO_EVENT(read_vector); 431DEFINE_NFSD_IO_EVENT(read_io_done); 432DEFINE_NFSD_IO_EVENT(read_done); 433DEFINE_NFSD_IO_EVENT(write_start); 434DEFINE_NFSD_IO_EVENT(write_opened); 435DEFINE_NFSD_IO_EVENT(write_io_done); 436DEFINE_NFSD_IO_EVENT(write_done); 437 438DECLARE_EVENT_CLASS(nfsd_err_class, 439 TP_PROTO(struct svc_rqst *rqstp, 440 struct svc_fh *fhp, 441 loff_t offset, 442 int status), 443 TP_ARGS(rqstp, fhp, offset, status), 444 TP_STRUCT__entry( 445 __field(u32, xid) 446 __field(u32, fh_hash) 447 __field(loff_t, offset) 448 __field(int, status) 449 ), 450 TP_fast_assign( 451 __entry->xid = be32_to_cpu(rqstp->rq_xid); 452 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 453 __entry->offset = offset; 454 __entry->status = status; 455 ), 456 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 457 __entry->xid, __entry->fh_hash, 458 __entry->offset, __entry->status) 459) 460 461#define DEFINE_NFSD_ERR_EVENT(name) \ 462DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 463 TP_PROTO(struct svc_rqst *rqstp, \ 464 struct svc_fh *fhp, \ 465 loff_t offset, \ 466 int len), \ 467 TP_ARGS(rqstp, fhp, offset, len)) 468 469DEFINE_NFSD_ERR_EVENT(read_err); 470DEFINE_NFSD_ERR_EVENT(write_err); 471 472TRACE_EVENT(nfsd_dirent, 473 TP_PROTO(struct svc_fh *fhp, 474 u64 ino, 475 const char *name, 476 int namlen), 477 TP_ARGS(fhp, ino, name, namlen), 478 TP_STRUCT__entry( 479 __field(u32, fh_hash) 480 __field(u64, ino) 481 __string_len(name, name, namlen) 482 ), 483 TP_fast_assign( 484 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 485 __entry->ino = ino; 486 __assign_str_len(name, name, namlen) 487 ), 488 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 489 __entry->fh_hash, __entry->ino, __get_str(name) 490 ) 491) 492 493DECLARE_EVENT_CLASS(nfsd_copy_err_class, 494 TP_PROTO(struct svc_rqst *rqstp, 495 struct svc_fh *src_fhp, 496 loff_t src_offset, 497 struct svc_fh *dst_fhp, 498 loff_t dst_offset, 499 u64 count, 500 int status), 501 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 502 TP_STRUCT__entry( 503 __field(u32, xid) 504 __field(u32, src_fh_hash) 505 __field(loff_t, src_offset) 506 __field(u32, dst_fh_hash) 507 __field(loff_t, dst_offset) 508 __field(u64, count) 509 __field(int, status) 510 ), 511 TP_fast_assign( 512 __entry->xid = be32_to_cpu(rqstp->rq_xid); 513 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 514 __entry->src_offset = src_offset; 515 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 516 __entry->dst_offset = dst_offset; 517 __entry->count = count; 518 __entry->status = status; 519 ), 520 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 521 "dst_fh_hash=0x%08x dst_offset=%lld " 522 "count=%llu status=%d", 523 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 524 __entry->dst_fh_hash, __entry->dst_offset, 525 (unsigned long long)__entry->count, 526 __entry->status) 527) 528 529#define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 530DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 531 TP_PROTO(struct svc_rqst *rqstp, \ 532 struct svc_fh *src_fhp, \ 533 loff_t src_offset, \ 534 struct svc_fh *dst_fhp, \ 535 loff_t dst_offset, \ 536 u64 count, \ 537 int status), \ 538 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 539 count, status)) 540 541DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 542 543#include "state.h" 544#include "filecache.h" 545#include "vfs.h" 546 547TRACE_EVENT(nfsd_delegret_wakeup, 548 TP_PROTO( 549 const struct svc_rqst *rqstp, 550 const struct inode *inode, 551 long timeo 552 ), 553 TP_ARGS(rqstp, inode, timeo), 554 TP_STRUCT__entry( 555 __field(u32, xid) 556 __field(const void *, inode) 557 __field(long, timeo) 558 ), 559 TP_fast_assign( 560 __entry->xid = be32_to_cpu(rqstp->rq_xid); 561 __entry->inode = inode; 562 __entry->timeo = timeo; 563 ), 564 TP_printk("xid=0x%08x inode=%p%s", 565 __entry->xid, __entry->inode, 566 __entry->timeo == 0 ? " (timed out)" : "" 567 ) 568); 569 570DECLARE_EVENT_CLASS(nfsd_stateid_class, 571 TP_PROTO(stateid_t *stp), 572 TP_ARGS(stp), 573 TP_STRUCT__entry( 574 __field(u32, cl_boot) 575 __field(u32, cl_id) 576 __field(u32, si_id) 577 __field(u32, si_generation) 578 ), 579 TP_fast_assign( 580 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 581 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 582 __entry->si_id = stp->si_opaque.so_id; 583 __entry->si_generation = stp->si_generation; 584 ), 585 TP_printk("client %08x:%08x stateid %08x:%08x", 586 __entry->cl_boot, 587 __entry->cl_id, 588 __entry->si_id, 589 __entry->si_generation) 590) 591 592#define DEFINE_STATEID_EVENT(name) \ 593DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 594 TP_PROTO(stateid_t *stp), \ 595 TP_ARGS(stp)) 596 597DEFINE_STATEID_EVENT(layoutstate_alloc); 598DEFINE_STATEID_EVENT(layoutstate_unhash); 599DEFINE_STATEID_EVENT(layoutstate_free); 600DEFINE_STATEID_EVENT(layout_get_lookup_fail); 601DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 602DEFINE_STATEID_EVENT(layout_return_lookup_fail); 603DEFINE_STATEID_EVENT(layout_recall); 604DEFINE_STATEID_EVENT(layout_recall_done); 605DEFINE_STATEID_EVENT(layout_recall_fail); 606DEFINE_STATEID_EVENT(layout_recall_release); 607 608DEFINE_STATEID_EVENT(open); 609DEFINE_STATEID_EVENT(deleg_read); 610DEFINE_STATEID_EVENT(deleg_write); 611DEFINE_STATEID_EVENT(deleg_return); 612DEFINE_STATEID_EVENT(deleg_recall); 613 614DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 615 TP_PROTO(u32 seqid, const stateid_t *stp), 616 TP_ARGS(seqid, stp), 617 TP_STRUCT__entry( 618 __field(u32, seqid) 619 __field(u32, cl_boot) 620 __field(u32, cl_id) 621 __field(u32, si_id) 622 __field(u32, si_generation) 623 ), 624 TP_fast_assign( 625 __entry->seqid = seqid; 626 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 627 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 628 __entry->si_id = stp->si_opaque.so_id; 629 __entry->si_generation = stp->si_generation; 630 ), 631 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 632 __entry->seqid, __entry->cl_boot, __entry->cl_id, 633 __entry->si_id, __entry->si_generation) 634) 635 636#define DEFINE_STATESEQID_EVENT(name) \ 637DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 638 TP_PROTO(u32 seqid, const stateid_t *stp), \ 639 TP_ARGS(seqid, stp)) 640 641DEFINE_STATESEQID_EVENT(preprocess); 642DEFINE_STATESEQID_EVENT(open_confirm); 643 644TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 645TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 646TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 647TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 648TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 649TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 650TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 651 652#define show_stid_type(x) \ 653 __print_flags(x, "|", \ 654 { NFS4_OPEN_STID, "OPEN" }, \ 655 { NFS4_LOCK_STID, "LOCK" }, \ 656 { NFS4_DELEG_STID, "DELEG" }, \ 657 { NFS4_CLOSED_STID, "CLOSED" }, \ 658 { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 659 { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 660 { NFS4_LAYOUT_STID, "LAYOUT" }) 661 662DECLARE_EVENT_CLASS(nfsd_stid_class, 663 TP_PROTO( 664 const struct nfs4_stid *stid 665 ), 666 TP_ARGS(stid), 667 TP_STRUCT__entry( 668 __field(unsigned long, sc_type) 669 __field(int, sc_count) 670 __field(u32, cl_boot) 671 __field(u32, cl_id) 672 __field(u32, si_id) 673 __field(u32, si_generation) 674 ), 675 TP_fast_assign( 676 const stateid_t *stp = &stid->sc_stateid; 677 678 __entry->sc_type = stid->sc_type; 679 __entry->sc_count = refcount_read(&stid->sc_count); 680 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 681 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 682 __entry->si_id = stp->si_opaque.so_id; 683 __entry->si_generation = stp->si_generation; 684 ), 685 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 686 __entry->cl_boot, __entry->cl_id, 687 __entry->si_id, __entry->si_generation, 688 __entry->sc_count, show_stid_type(__entry->sc_type) 689 ) 690); 691 692#define DEFINE_STID_EVENT(name) \ 693DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 694 TP_PROTO(const struct nfs4_stid *stid), \ 695 TP_ARGS(stid)) 696 697DEFINE_STID_EVENT(revoke); 698 699DECLARE_EVENT_CLASS(nfsd_clientid_class, 700 TP_PROTO(const clientid_t *clid), 701 TP_ARGS(clid), 702 TP_STRUCT__entry( 703 __field(u32, cl_boot) 704 __field(u32, cl_id) 705 ), 706 TP_fast_assign( 707 __entry->cl_boot = clid->cl_boot; 708 __entry->cl_id = clid->cl_id; 709 ), 710 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 711) 712 713#define DEFINE_CLIENTID_EVENT(name) \ 714DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 715 TP_PROTO(const clientid_t *clid), \ 716 TP_ARGS(clid)) 717 718DEFINE_CLIENTID_EVENT(expire_unconf); 719DEFINE_CLIENTID_EVENT(reclaim_complete); 720DEFINE_CLIENTID_EVENT(confirmed); 721DEFINE_CLIENTID_EVENT(destroyed); 722DEFINE_CLIENTID_EVENT(admin_expired); 723DEFINE_CLIENTID_EVENT(replaced); 724DEFINE_CLIENTID_EVENT(purged); 725DEFINE_CLIENTID_EVENT(renew); 726DEFINE_CLIENTID_EVENT(stale); 727 728DECLARE_EVENT_CLASS(nfsd_net_class, 729 TP_PROTO(const struct nfsd_net *nn), 730 TP_ARGS(nn), 731 TP_STRUCT__entry( 732 __field(unsigned long long, boot_time) 733 ), 734 TP_fast_assign( 735 __entry->boot_time = nn->boot_time; 736 ), 737 TP_printk("boot_time=%16llx", __entry->boot_time) 738) 739 740#define DEFINE_NET_EVENT(name) \ 741DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 742 TP_PROTO(const struct nfsd_net *nn), \ 743 TP_ARGS(nn)) 744 745DEFINE_NET_EVENT(grace_start); 746DEFINE_NET_EVENT(grace_complete); 747 748TRACE_EVENT(nfsd_writeverf_reset, 749 TP_PROTO( 750 const struct nfsd_net *nn, 751 const struct svc_rqst *rqstp, 752 int error 753 ), 754 TP_ARGS(nn, rqstp, error), 755 TP_STRUCT__entry( 756 __field(unsigned long long, boot_time) 757 __field(u32, xid) 758 __field(int, error) 759 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 760 ), 761 TP_fast_assign( 762 __entry->boot_time = nn->boot_time; 763 __entry->xid = be32_to_cpu(rqstp->rq_xid); 764 __entry->error = error; 765 766 /* avoid seqlock inside TP_fast_assign */ 767 memcpy(__entry->verifier, nn->writeverf, 768 NFS4_VERIFIER_SIZE); 769 ), 770 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 771 __entry->boot_time, __entry->xid, __entry->error, 772 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 773 ) 774); 775 776TRACE_EVENT(nfsd_clid_cred_mismatch, 777 TP_PROTO( 778 const struct nfs4_client *clp, 779 const struct svc_rqst *rqstp 780 ), 781 TP_ARGS(clp, rqstp), 782 TP_STRUCT__entry( 783 __field(u32, cl_boot) 784 __field(u32, cl_id) 785 __field(unsigned long, cl_flavor) 786 __field(unsigned long, new_flavor) 787 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 788 ), 789 TP_fast_assign( 790 __entry->cl_boot = clp->cl_clientid.cl_boot; 791 __entry->cl_id = clp->cl_clientid.cl_id; 792 __entry->cl_flavor = clp->cl_cred.cr_flavor; 793 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 794 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 795 rqstp->rq_xprt->xpt_remotelen); 796 ), 797 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 798 __entry->cl_boot, __entry->cl_id, 799 show_nfsd_authflavor(__entry->cl_flavor), 800 show_nfsd_authflavor(__entry->new_flavor), 801 __get_sockaddr(addr) 802 ) 803) 804 805TRACE_EVENT(nfsd_clid_verf_mismatch, 806 TP_PROTO( 807 const struct nfs4_client *clp, 808 const struct svc_rqst *rqstp, 809 const nfs4_verifier *verf 810 ), 811 TP_ARGS(clp, rqstp, verf), 812 TP_STRUCT__entry( 813 __field(u32, cl_boot) 814 __field(u32, cl_id) 815 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 816 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 817 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 818 ), 819 TP_fast_assign( 820 __entry->cl_boot = clp->cl_clientid.cl_boot; 821 __entry->cl_id = clp->cl_clientid.cl_id; 822 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 823 NFS4_VERIFIER_SIZE); 824 memcpy(__entry->new_verifier, (void *)verf, 825 NFS4_VERIFIER_SIZE); 826 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 827 rqstp->rq_xprt->xpt_remotelen); 828 ), 829 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 830 __entry->cl_boot, __entry->cl_id, 831 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 832 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 833 __get_sockaddr(addr) 834 ) 835); 836 837DECLARE_EVENT_CLASS(nfsd_clid_class, 838 TP_PROTO(const struct nfs4_client *clp), 839 TP_ARGS(clp), 840 TP_STRUCT__entry( 841 __field(u32, cl_boot) 842 __field(u32, cl_id) 843 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 844 __field(unsigned long, flavor) 845 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 846 __string_len(name, name, clp->cl_name.len) 847 ), 848 TP_fast_assign( 849 __entry->cl_boot = clp->cl_clientid.cl_boot; 850 __entry->cl_id = clp->cl_clientid.cl_id; 851 memcpy(__entry->addr, &clp->cl_addr, 852 sizeof(struct sockaddr_in6)); 853 __entry->flavor = clp->cl_cred.cr_flavor; 854 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 855 NFS4_VERIFIER_SIZE); 856 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 857 ), 858 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 859 __entry->addr, __get_str(name), 860 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 861 show_nfsd_authflavor(__entry->flavor), 862 __entry->cl_boot, __entry->cl_id) 863); 864 865#define DEFINE_CLID_EVENT(name) \ 866DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 867 TP_PROTO(const struct nfs4_client *clp), \ 868 TP_ARGS(clp)) 869 870DEFINE_CLID_EVENT(fresh); 871DEFINE_CLID_EVENT(confirmed_r); 872 873/* 874 * from fs/nfsd/filecache.h 875 */ 876#define show_nf_flags(val) \ 877 __print_flags(val, "|", \ 878 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 879 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 880 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 881 { 1 << NFSD_FILE_GC, "GC" }) 882 883DECLARE_EVENT_CLASS(nfsd_file_class, 884 TP_PROTO(struct nfsd_file *nf), 885 TP_ARGS(nf), 886 TP_STRUCT__entry( 887 __field(void *, nf_inode) 888 __field(int, nf_ref) 889 __field(unsigned long, nf_flags) 890 __field(unsigned char, nf_may) 891 __field(struct file *, nf_file) 892 ), 893 TP_fast_assign( 894 __entry->nf_inode = nf->nf_inode; 895 __entry->nf_ref = refcount_read(&nf->nf_ref); 896 __entry->nf_flags = nf->nf_flags; 897 __entry->nf_may = nf->nf_may; 898 __entry->nf_file = nf->nf_file; 899 ), 900 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 901 __entry->nf_inode, 902 __entry->nf_ref, 903 show_nf_flags(__entry->nf_flags), 904 show_nfsd_may_flags(__entry->nf_may), 905 __entry->nf_file) 906) 907 908#define DEFINE_NFSD_FILE_EVENT(name) \ 909DEFINE_EVENT(nfsd_file_class, name, \ 910 TP_PROTO(struct nfsd_file *nf), \ 911 TP_ARGS(nf)) 912 913DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 914DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 915DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 916DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 917DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 918 919TRACE_EVENT(nfsd_file_alloc, 920 TP_PROTO( 921 const struct nfsd_file *nf 922 ), 923 TP_ARGS(nf), 924 TP_STRUCT__entry( 925 __field(const void *, nf_inode) 926 __field(unsigned long, nf_flags) 927 __field(unsigned long, nf_may) 928 __field(unsigned int, nf_ref) 929 ), 930 TP_fast_assign( 931 __entry->nf_inode = nf->nf_inode; 932 __entry->nf_flags = nf->nf_flags; 933 __entry->nf_ref = refcount_read(&nf->nf_ref); 934 __entry->nf_may = nf->nf_may; 935 ), 936 TP_printk("inode=%p ref=%u flags=%s may=%s", 937 __entry->nf_inode, __entry->nf_ref, 938 show_nf_flags(__entry->nf_flags), 939 show_nfsd_may_flags(__entry->nf_may) 940 ) 941); 942 943TRACE_EVENT(nfsd_file_acquire, 944 TP_PROTO( 945 const struct svc_rqst *rqstp, 946 const struct inode *inode, 947 unsigned int may_flags, 948 const struct nfsd_file *nf, 949 __be32 status 950 ), 951 952 TP_ARGS(rqstp, inode, may_flags, nf, status), 953 954 TP_STRUCT__entry( 955 __field(u32, xid) 956 __field(const void *, inode) 957 __field(unsigned long, may_flags) 958 __field(unsigned int, nf_ref) 959 __field(unsigned long, nf_flags) 960 __field(unsigned long, nf_may) 961 __field(const void *, nf_file) 962 __field(u32, status) 963 ), 964 965 TP_fast_assign( 966 __entry->xid = be32_to_cpu(rqstp->rq_xid); 967 __entry->inode = inode; 968 __entry->may_flags = may_flags; 969 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 970 __entry->nf_flags = nf ? nf->nf_flags : 0; 971 __entry->nf_may = nf ? nf->nf_may : 0; 972 __entry->nf_file = nf ? nf->nf_file : NULL; 973 __entry->status = be32_to_cpu(status); 974 ), 975 976 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 977 __entry->xid, __entry->inode, 978 show_nfsd_may_flags(__entry->may_flags), 979 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 980 show_nfsd_may_flags(__entry->nf_may), 981 __entry->nf_file, __entry->status 982 ) 983); 984 985TRACE_EVENT(nfsd_file_insert_err, 986 TP_PROTO( 987 const struct svc_rqst *rqstp, 988 const struct inode *inode, 989 unsigned int may_flags, 990 long error 991 ), 992 TP_ARGS(rqstp, inode, may_flags, error), 993 TP_STRUCT__entry( 994 __field(u32, xid) 995 __field(const void *, inode) 996 __field(unsigned long, may_flags) 997 __field(long, error) 998 ), 999 TP_fast_assign( 1000 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1001 __entry->inode = inode; 1002 __entry->may_flags = may_flags; 1003 __entry->error = error; 1004 ), 1005 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1006 __entry->xid, __entry->inode, 1007 show_nfsd_may_flags(__entry->may_flags), 1008 __entry->error 1009 ) 1010); 1011 1012TRACE_EVENT(nfsd_file_cons_err, 1013 TP_PROTO( 1014 const struct svc_rqst *rqstp, 1015 const struct inode *inode, 1016 unsigned int may_flags, 1017 const struct nfsd_file *nf 1018 ), 1019 TP_ARGS(rqstp, inode, may_flags, nf), 1020 TP_STRUCT__entry( 1021 __field(u32, xid) 1022 __field(const void *, inode) 1023 __field(unsigned long, may_flags) 1024 __field(unsigned int, nf_ref) 1025 __field(unsigned long, nf_flags) 1026 __field(unsigned long, nf_may) 1027 __field(const void *, nf_file) 1028 ), 1029 TP_fast_assign( 1030 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1031 __entry->inode = inode; 1032 __entry->may_flags = may_flags; 1033 __entry->nf_ref = refcount_read(&nf->nf_ref); 1034 __entry->nf_flags = nf->nf_flags; 1035 __entry->nf_may = nf->nf_may; 1036 __entry->nf_file = nf->nf_file; 1037 ), 1038 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1039 __entry->xid, __entry->inode, 1040 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1041 show_nf_flags(__entry->nf_flags), 1042 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1043 ) 1044); 1045 1046DECLARE_EVENT_CLASS(nfsd_file_open_class, 1047 TP_PROTO(const struct nfsd_file *nf, __be32 status), 1048 TP_ARGS(nf, status), 1049 TP_STRUCT__entry( 1050 __field(void *, nf_inode) /* cannot be dereferenced */ 1051 __field(int, nf_ref) 1052 __field(unsigned long, nf_flags) 1053 __field(unsigned long, nf_may) 1054 __field(void *, nf_file) /* cannot be dereferenced */ 1055 ), 1056 TP_fast_assign( 1057 __entry->nf_inode = nf->nf_inode; 1058 __entry->nf_ref = refcount_read(&nf->nf_ref); 1059 __entry->nf_flags = nf->nf_flags; 1060 __entry->nf_may = nf->nf_may; 1061 __entry->nf_file = nf->nf_file; 1062 ), 1063 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1064 __entry->nf_inode, 1065 __entry->nf_ref, 1066 show_nf_flags(__entry->nf_flags), 1067 show_nfsd_may_flags(__entry->nf_may), 1068 __entry->nf_file) 1069) 1070 1071#define DEFINE_NFSD_FILE_OPEN_EVENT(name) \ 1072DEFINE_EVENT(nfsd_file_open_class, name, \ 1073 TP_PROTO( \ 1074 const struct nfsd_file *nf, \ 1075 __be32 status \ 1076 ), \ 1077 TP_ARGS(nf, status)) 1078 1079DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1080DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1081 1082TRACE_EVENT(nfsd_file_is_cached, 1083 TP_PROTO( 1084 const struct inode *inode, 1085 int found 1086 ), 1087 TP_ARGS(inode, found), 1088 TP_STRUCT__entry( 1089 __field(const struct inode *, inode) 1090 __field(int, found) 1091 ), 1092 TP_fast_assign( 1093 __entry->inode = inode; 1094 __entry->found = found; 1095 ), 1096 TP_printk("inode=%p is %scached", 1097 __entry->inode, 1098 __entry->found ? "" : "not " 1099 ) 1100); 1101 1102TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1103 TP_PROTO(struct inode *inode, u32 mask), 1104 TP_ARGS(inode, mask), 1105 TP_STRUCT__entry( 1106 __field(struct inode *, inode) 1107 __field(unsigned int, nlink) 1108 __field(umode_t, mode) 1109 __field(u32, mask) 1110 ), 1111 TP_fast_assign( 1112 __entry->inode = inode; 1113 __entry->nlink = inode->i_nlink; 1114 __entry->mode = inode->i_mode; 1115 __entry->mask = mask; 1116 ), 1117 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1118 __entry->nlink, __entry->mode, __entry->mask) 1119); 1120 1121DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1122 TP_PROTO( 1123 const struct nfsd_file *nf 1124 ), 1125 TP_ARGS(nf), 1126 TP_STRUCT__entry( 1127 __field(void *, nf_inode) 1128 __field(void *, nf_file) 1129 __field(int, nf_ref) 1130 __field(unsigned long, nf_flags) 1131 ), 1132 TP_fast_assign( 1133 __entry->nf_inode = nf->nf_inode; 1134 __entry->nf_file = nf->nf_file; 1135 __entry->nf_ref = refcount_read(&nf->nf_ref); 1136 __entry->nf_flags = nf->nf_flags; 1137 ), 1138 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1139 __entry->nf_inode, __entry->nf_ref, 1140 show_nf_flags(__entry->nf_flags), 1141 __entry->nf_file 1142 ) 1143); 1144 1145#define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1146DEFINE_EVENT(nfsd_file_gc_class, name, \ 1147 TP_PROTO( \ 1148 const struct nfsd_file *nf \ 1149 ), \ 1150 TP_ARGS(nf)) 1151 1152DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1153DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1154DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1155DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1156DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1157DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1158DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1159DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1160 1161DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1162 TP_PROTO( 1163 unsigned long removed, 1164 unsigned long remaining 1165 ), 1166 TP_ARGS(removed, remaining), 1167 TP_STRUCT__entry( 1168 __field(unsigned long, removed) 1169 __field(unsigned long, remaining) 1170 ), 1171 TP_fast_assign( 1172 __entry->removed = removed; 1173 __entry->remaining = remaining; 1174 ), 1175 TP_printk("%lu entries removed, %lu remaining", 1176 __entry->removed, __entry->remaining) 1177); 1178 1179#define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1180DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1181 TP_PROTO( \ 1182 unsigned long removed, \ 1183 unsigned long remaining \ 1184 ), \ 1185 TP_ARGS(removed, remaining)) 1186 1187DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1188DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1189 1190TRACE_EVENT(nfsd_file_close, 1191 TP_PROTO( 1192 const struct inode *inode 1193 ), 1194 TP_ARGS(inode), 1195 TP_STRUCT__entry( 1196 __field(const void *, inode) 1197 ), 1198 TP_fast_assign( 1199 __entry->inode = inode; 1200 ), 1201 TP_printk("inode=%p", 1202 __entry->inode 1203 ) 1204); 1205 1206#include "cache.h" 1207 1208TRACE_DEFINE_ENUM(RC_DROPIT); 1209TRACE_DEFINE_ENUM(RC_REPLY); 1210TRACE_DEFINE_ENUM(RC_DOIT); 1211 1212#define show_drc_retval(x) \ 1213 __print_symbolic(x, \ 1214 { RC_DROPIT, "DROPIT" }, \ 1215 { RC_REPLY, "REPLY" }, \ 1216 { RC_DOIT, "DOIT" }) 1217 1218TRACE_EVENT(nfsd_drc_found, 1219 TP_PROTO( 1220 const struct nfsd_net *nn, 1221 const struct svc_rqst *rqstp, 1222 int result 1223 ), 1224 TP_ARGS(nn, rqstp, result), 1225 TP_STRUCT__entry( 1226 __field(unsigned long long, boot_time) 1227 __field(unsigned long, result) 1228 __field(u32, xid) 1229 ), 1230 TP_fast_assign( 1231 __entry->boot_time = nn->boot_time; 1232 __entry->result = result; 1233 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1234 ), 1235 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1236 __entry->boot_time, __entry->xid, 1237 show_drc_retval(__entry->result)) 1238 1239); 1240 1241TRACE_EVENT(nfsd_drc_mismatch, 1242 TP_PROTO( 1243 const struct nfsd_net *nn, 1244 const struct nfsd_cacherep *key, 1245 const struct nfsd_cacherep *rp 1246 ), 1247 TP_ARGS(nn, key, rp), 1248 TP_STRUCT__entry( 1249 __field(unsigned long long, boot_time) 1250 __field(u32, xid) 1251 __field(u32, cached) 1252 __field(u32, ingress) 1253 ), 1254 TP_fast_assign( 1255 __entry->boot_time = nn->boot_time; 1256 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1257 __entry->cached = (__force u32)key->c_key.k_csum; 1258 __entry->ingress = (__force u32)rp->c_key.k_csum; 1259 ), 1260 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1261 __entry->boot_time, __entry->xid, __entry->cached, 1262 __entry->ingress) 1263); 1264 1265TRACE_EVENT_CONDITION(nfsd_drc_gc, 1266 TP_PROTO( 1267 const struct nfsd_net *nn, 1268 unsigned long freed 1269 ), 1270 TP_ARGS(nn, freed), 1271 TP_CONDITION(freed > 0), 1272 TP_STRUCT__entry( 1273 __field(unsigned long long, boot_time) 1274 __field(unsigned long, freed) 1275 __field(int, total) 1276 ), 1277 TP_fast_assign( 1278 __entry->boot_time = nn->boot_time; 1279 __entry->freed = freed; 1280 __entry->total = atomic_read(&nn->num_drc_entries); 1281 ), 1282 TP_printk("boot_time=%16llx total=%d freed=%lu", 1283 __entry->boot_time, __entry->total, __entry->freed 1284 ) 1285); 1286 1287TRACE_EVENT(nfsd_cb_args, 1288 TP_PROTO( 1289 const struct nfs4_client *clp, 1290 const struct nfs4_cb_conn *conn 1291 ), 1292 TP_ARGS(clp, conn), 1293 TP_STRUCT__entry( 1294 __field(u32, cl_boot) 1295 __field(u32, cl_id) 1296 __field(u32, prog) 1297 __field(u32, ident) 1298 __sockaddr(addr, conn->cb_addrlen) 1299 ), 1300 TP_fast_assign( 1301 __entry->cl_boot = clp->cl_clientid.cl_boot; 1302 __entry->cl_id = clp->cl_clientid.cl_id; 1303 __entry->prog = conn->cb_prog; 1304 __entry->ident = conn->cb_ident; 1305 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1306 ), 1307 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1308 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1309 __entry->prog, __entry->ident) 1310); 1311 1312TRACE_EVENT(nfsd_cb_nodelegs, 1313 TP_PROTO(const struct nfs4_client *clp), 1314 TP_ARGS(clp), 1315 TP_STRUCT__entry( 1316 __field(u32, cl_boot) 1317 __field(u32, cl_id) 1318 ), 1319 TP_fast_assign( 1320 __entry->cl_boot = clp->cl_clientid.cl_boot; 1321 __entry->cl_id = clp->cl_clientid.cl_id; 1322 ), 1323 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1324) 1325 1326#define show_cb_state(val) \ 1327 __print_symbolic(val, \ 1328 { NFSD4_CB_UP, "UP" }, \ 1329 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1330 { NFSD4_CB_DOWN, "DOWN" }, \ 1331 { NFSD4_CB_FAULT, "FAULT"}) 1332 1333DECLARE_EVENT_CLASS(nfsd_cb_class, 1334 TP_PROTO(const struct nfs4_client *clp), 1335 TP_ARGS(clp), 1336 TP_STRUCT__entry( 1337 __field(unsigned long, state) 1338 __field(u32, cl_boot) 1339 __field(u32, cl_id) 1340 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1341 ), 1342 TP_fast_assign( 1343 __entry->state = clp->cl_cb_state; 1344 __entry->cl_boot = clp->cl_clientid.cl_boot; 1345 __entry->cl_id = clp->cl_clientid.cl_id; 1346 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1347 clp->cl_cb_conn.cb_addrlen) 1348 ), 1349 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1350 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1351 show_cb_state(__entry->state)) 1352); 1353 1354#define DEFINE_NFSD_CB_EVENT(name) \ 1355DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1356 TP_PROTO(const struct nfs4_client *clp), \ 1357 TP_ARGS(clp)) 1358 1359DEFINE_NFSD_CB_EVENT(state); 1360DEFINE_NFSD_CB_EVENT(probe); 1361DEFINE_NFSD_CB_EVENT(lost); 1362DEFINE_NFSD_CB_EVENT(shutdown); 1363 1364TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1365TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1366TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1367TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1368TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1369TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1370 1371#define show_nfsd_authflavor(val) \ 1372 __print_symbolic(val, \ 1373 { RPC_AUTH_NULL, "none" }, \ 1374 { RPC_AUTH_UNIX, "sys" }, \ 1375 { RPC_AUTH_GSS, "gss" }, \ 1376 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1377 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1378 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1379 1380TRACE_EVENT(nfsd_cb_setup, 1381 TP_PROTO(const struct nfs4_client *clp, 1382 const char *netid, 1383 rpc_authflavor_t authflavor 1384 ), 1385 TP_ARGS(clp, netid, authflavor), 1386 TP_STRUCT__entry( 1387 __field(u32, cl_boot) 1388 __field(u32, cl_id) 1389 __field(unsigned long, authflavor) 1390 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1391 __string(netid, netid) 1392 ), 1393 TP_fast_assign( 1394 __entry->cl_boot = clp->cl_clientid.cl_boot; 1395 __entry->cl_id = clp->cl_clientid.cl_id; 1396 __assign_str(netid, netid); 1397 __entry->authflavor = authflavor; 1398 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1399 clp->cl_cb_conn.cb_addrlen) 1400 ), 1401 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1402 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1403 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1404); 1405 1406TRACE_EVENT(nfsd_cb_setup_err, 1407 TP_PROTO( 1408 const struct nfs4_client *clp, 1409 long error 1410 ), 1411 TP_ARGS(clp, error), 1412 TP_STRUCT__entry( 1413 __field(long, error) 1414 __field(u32, cl_boot) 1415 __field(u32, cl_id) 1416 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1417 ), 1418 TP_fast_assign( 1419 __entry->error = error; 1420 __entry->cl_boot = clp->cl_clientid.cl_boot; 1421 __entry->cl_id = clp->cl_clientid.cl_id; 1422 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1423 clp->cl_cb_conn.cb_addrlen) 1424 ), 1425 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1426 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1427 __entry->error) 1428); 1429 1430TRACE_EVENT_CONDITION(nfsd_cb_recall, 1431 TP_PROTO( 1432 const struct nfs4_stid *stid 1433 ), 1434 TP_ARGS(stid), 1435 TP_CONDITION(stid->sc_client), 1436 TP_STRUCT__entry( 1437 __field(u32, cl_boot) 1438 __field(u32, cl_id) 1439 __field(u32, si_id) 1440 __field(u32, si_generation) 1441 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1442 ), 1443 TP_fast_assign( 1444 const stateid_t *stp = &stid->sc_stateid; 1445 const struct nfs4_client *clp = stid->sc_client; 1446 1447 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1448 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1449 __entry->si_id = stp->si_opaque.so_id; 1450 __entry->si_generation = stp->si_generation; 1451 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1452 clp->cl_cb_conn.cb_addrlen) 1453 ), 1454 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1455 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1456 __entry->si_id, __entry->si_generation) 1457); 1458 1459TRACE_EVENT(nfsd_cb_notify_lock, 1460 TP_PROTO( 1461 const struct nfs4_lockowner *lo, 1462 const struct nfsd4_blocked_lock *nbl 1463 ), 1464 TP_ARGS(lo, nbl), 1465 TP_STRUCT__entry( 1466 __field(u32, cl_boot) 1467 __field(u32, cl_id) 1468 __field(u32, fh_hash) 1469 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1470 ), 1471 TP_fast_assign( 1472 const struct nfs4_client *clp = lo->lo_owner.so_client; 1473 1474 __entry->cl_boot = clp->cl_clientid.cl_boot; 1475 __entry->cl_id = clp->cl_clientid.cl_id; 1476 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1477 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1478 clp->cl_cb_conn.cb_addrlen) 1479 ), 1480 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1481 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1482 __entry->fh_hash) 1483); 1484 1485TRACE_EVENT(nfsd_cb_offload, 1486 TP_PROTO( 1487 const struct nfs4_client *clp, 1488 const stateid_t *stp, 1489 const struct knfsd_fh *fh, 1490 u64 count, 1491 __be32 status 1492 ), 1493 TP_ARGS(clp, stp, fh, count, status), 1494 TP_STRUCT__entry( 1495 __field(u32, cl_boot) 1496 __field(u32, cl_id) 1497 __field(u32, si_id) 1498 __field(u32, si_generation) 1499 __field(u32, fh_hash) 1500 __field(int, status) 1501 __field(u64, count) 1502 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1503 ), 1504 TP_fast_assign( 1505 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1506 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1507 __entry->si_id = stp->si_opaque.so_id; 1508 __entry->si_generation = stp->si_generation; 1509 __entry->fh_hash = knfsd_fh_hash(fh); 1510 __entry->status = be32_to_cpu(status); 1511 __entry->count = count; 1512 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1513 clp->cl_cb_conn.cb_addrlen) 1514 ), 1515 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1516 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1517 __entry->si_id, __entry->si_generation, 1518 __entry->fh_hash, __entry->count, __entry->status) 1519); 1520 1521TRACE_EVENT(nfsd_cb_recall_any, 1522 TP_PROTO( 1523 const struct nfsd4_cb_recall_any *ra 1524 ), 1525 TP_ARGS(ra), 1526 TP_STRUCT__entry( 1527 __field(u32, cl_boot) 1528 __field(u32, cl_id) 1529 __field(u32, keep) 1530 __field(unsigned long, bmval0) 1531 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1532 ), 1533 TP_fast_assign( 1534 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1535 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1536 __entry->keep = ra->ra_keep; 1537 __entry->bmval0 = ra->ra_bmval[0]; 1538 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1539 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1540 ), 1541 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1542 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1543 __entry->keep, show_rca_mask(__entry->bmval0) 1544 ) 1545); 1546 1547DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1548 TP_PROTO( 1549 const stateid_t *stp, 1550 const struct rpc_task *task 1551 ), 1552 TP_ARGS(stp, task), 1553 TP_STRUCT__entry( 1554 __field(u32, cl_boot) 1555 __field(u32, cl_id) 1556 __field(u32, si_id) 1557 __field(u32, si_generation) 1558 __field(int, status) 1559 ), 1560 TP_fast_assign( 1561 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1562 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1563 __entry->si_id = stp->si_opaque.so_id; 1564 __entry->si_generation = stp->si_generation; 1565 __entry->status = task->tk_status; 1566 ), 1567 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1568 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1569 __entry->si_generation, __entry->status 1570 ) 1571); 1572 1573#define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1574DEFINE_EVENT(nfsd_cb_done_class, name, \ 1575 TP_PROTO( \ 1576 const stateid_t *stp, \ 1577 const struct rpc_task *task \ 1578 ), \ 1579 TP_ARGS(stp, task)) 1580 1581DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1582DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1583DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1584DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1585 1586TRACE_EVENT(nfsd_cb_recall_any_done, 1587 TP_PROTO( 1588 const struct nfsd4_callback *cb, 1589 const struct rpc_task *task 1590 ), 1591 TP_ARGS(cb, task), 1592 TP_STRUCT__entry( 1593 __field(u32, cl_boot) 1594 __field(u32, cl_id) 1595 __field(int, status) 1596 ), 1597 TP_fast_assign( 1598 __entry->status = task->tk_status; 1599 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1600 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1601 ), 1602 TP_printk("client %08x:%08x status=%d", 1603 __entry->cl_boot, __entry->cl_id, __entry->status 1604 ) 1605); 1606 1607TRACE_EVENT(nfsd_ctl_unlock_ip, 1608 TP_PROTO( 1609 const struct net *net, 1610 const char *address 1611 ), 1612 TP_ARGS(net, address), 1613 TP_STRUCT__entry( 1614 __field(unsigned int, netns_ino) 1615 __string(address, address) 1616 ), 1617 TP_fast_assign( 1618 __entry->netns_ino = net->ns.inum; 1619 __assign_str(address, address); 1620 ), 1621 TP_printk("address=%s", 1622 __get_str(address) 1623 ) 1624); 1625 1626TRACE_EVENT(nfsd_ctl_unlock_fs, 1627 TP_PROTO( 1628 const struct net *net, 1629 const char *path 1630 ), 1631 TP_ARGS(net, path), 1632 TP_STRUCT__entry( 1633 __field(unsigned int, netns_ino) 1634 __string(path, path) 1635 ), 1636 TP_fast_assign( 1637 __entry->netns_ino = net->ns.inum; 1638 __assign_str(path, path); 1639 ), 1640 TP_printk("path=%s", 1641 __get_str(path) 1642 ) 1643); 1644 1645TRACE_EVENT(nfsd_ctl_filehandle, 1646 TP_PROTO( 1647 const struct net *net, 1648 const char *domain, 1649 const char *path, 1650 int maxsize 1651 ), 1652 TP_ARGS(net, domain, path, maxsize), 1653 TP_STRUCT__entry( 1654 __field(unsigned int, netns_ino) 1655 __field(int, maxsize) 1656 __string(domain, domain) 1657 __string(path, path) 1658 ), 1659 TP_fast_assign( 1660 __entry->netns_ino = net->ns.inum; 1661 __entry->maxsize = maxsize; 1662 __assign_str(domain, domain); 1663 __assign_str(path, path); 1664 ), 1665 TP_printk("domain=%s path=%s maxsize=%d", 1666 __get_str(domain), __get_str(path), __entry->maxsize 1667 ) 1668); 1669 1670TRACE_EVENT(nfsd_ctl_threads, 1671 TP_PROTO( 1672 const struct net *net, 1673 int newthreads 1674 ), 1675 TP_ARGS(net, newthreads), 1676 TP_STRUCT__entry( 1677 __field(unsigned int, netns_ino) 1678 __field(int, newthreads) 1679 ), 1680 TP_fast_assign( 1681 __entry->netns_ino = net->ns.inum; 1682 __entry->newthreads = newthreads; 1683 ), 1684 TP_printk("newthreads=%d", 1685 __entry->newthreads 1686 ) 1687); 1688 1689TRACE_EVENT(nfsd_ctl_pool_threads, 1690 TP_PROTO( 1691 const struct net *net, 1692 int pool, 1693 int nrthreads 1694 ), 1695 TP_ARGS(net, pool, nrthreads), 1696 TP_STRUCT__entry( 1697 __field(unsigned int, netns_ino) 1698 __field(int, pool) 1699 __field(int, nrthreads) 1700 ), 1701 TP_fast_assign( 1702 __entry->netns_ino = net->ns.inum; 1703 __entry->pool = pool; 1704 __entry->nrthreads = nrthreads; 1705 ), 1706 TP_printk("pool=%d nrthreads=%d", 1707 __entry->pool, __entry->nrthreads 1708 ) 1709); 1710 1711TRACE_EVENT(nfsd_ctl_version, 1712 TP_PROTO( 1713 const struct net *net, 1714 const char *mesg 1715 ), 1716 TP_ARGS(net, mesg), 1717 TP_STRUCT__entry( 1718 __field(unsigned int, netns_ino) 1719 __string(mesg, mesg) 1720 ), 1721 TP_fast_assign( 1722 __entry->netns_ino = net->ns.inum; 1723 __assign_str(mesg, mesg); 1724 ), 1725 TP_printk("%s", 1726 __get_str(mesg) 1727 ) 1728); 1729 1730TRACE_EVENT(nfsd_ctl_ports_addfd, 1731 TP_PROTO( 1732 const struct net *net, 1733 int fd 1734 ), 1735 TP_ARGS(net, fd), 1736 TP_STRUCT__entry( 1737 __field(unsigned int, netns_ino) 1738 __field(int, fd) 1739 ), 1740 TP_fast_assign( 1741 __entry->netns_ino = net->ns.inum; 1742 __entry->fd = fd; 1743 ), 1744 TP_printk("fd=%d", 1745 __entry->fd 1746 ) 1747); 1748 1749TRACE_EVENT(nfsd_ctl_ports_addxprt, 1750 TP_PROTO( 1751 const struct net *net, 1752 const char *transport, 1753 int port 1754 ), 1755 TP_ARGS(net, transport, port), 1756 TP_STRUCT__entry( 1757 __field(unsigned int, netns_ino) 1758 __field(int, port) 1759 __string(transport, transport) 1760 ), 1761 TP_fast_assign( 1762 __entry->netns_ino = net->ns.inum; 1763 __entry->port = port; 1764 __assign_str(transport, transport); 1765 ), 1766 TP_printk("transport=%s port=%d", 1767 __get_str(transport), __entry->port 1768 ) 1769); 1770 1771TRACE_EVENT(nfsd_ctl_maxblksize, 1772 TP_PROTO( 1773 const struct net *net, 1774 int bsize 1775 ), 1776 TP_ARGS(net, bsize), 1777 TP_STRUCT__entry( 1778 __field(unsigned int, netns_ino) 1779 __field(int, bsize) 1780 ), 1781 TP_fast_assign( 1782 __entry->netns_ino = net->ns.inum; 1783 __entry->bsize = bsize; 1784 ), 1785 TP_printk("bsize=%d", 1786 __entry->bsize 1787 ) 1788); 1789 1790TRACE_EVENT(nfsd_ctl_maxconn, 1791 TP_PROTO( 1792 const struct net *net, 1793 int maxconn 1794 ), 1795 TP_ARGS(net, maxconn), 1796 TP_STRUCT__entry( 1797 __field(unsigned int, netns_ino) 1798 __field(int, maxconn) 1799 ), 1800 TP_fast_assign( 1801 __entry->netns_ino = net->ns.inum; 1802 __entry->maxconn = maxconn; 1803 ), 1804 TP_printk("maxconn=%d", 1805 __entry->maxconn 1806 ) 1807); 1808 1809TRACE_EVENT(nfsd_ctl_time, 1810 TP_PROTO( 1811 const struct net *net, 1812 const char *name, 1813 size_t namelen, 1814 int time 1815 ), 1816 TP_ARGS(net, name, namelen, time), 1817 TP_STRUCT__entry( 1818 __field(unsigned int, netns_ino) 1819 __field(int, time) 1820 __string_len(name, name, namelen) 1821 ), 1822 TP_fast_assign( 1823 __entry->netns_ino = net->ns.inum; 1824 __entry->time = time; 1825 __assign_str_len(name, name, namelen); 1826 ), 1827 TP_printk("file=%s time=%d\n", 1828 __get_str(name), __entry->time 1829 ) 1830); 1831 1832TRACE_EVENT(nfsd_ctl_recoverydir, 1833 TP_PROTO( 1834 const struct net *net, 1835 const char *recdir 1836 ), 1837 TP_ARGS(net, recdir), 1838 TP_STRUCT__entry( 1839 __field(unsigned int, netns_ino) 1840 __string(recdir, recdir) 1841 ), 1842 TP_fast_assign( 1843 __entry->netns_ino = net->ns.inum; 1844 __assign_str(recdir, recdir); 1845 ), 1846 TP_printk("recdir=%s", 1847 __get_str(recdir) 1848 ) 1849); 1850 1851TRACE_EVENT(nfsd_end_grace, 1852 TP_PROTO( 1853 const struct net *net 1854 ), 1855 TP_ARGS(net), 1856 TP_STRUCT__entry( 1857 __field(unsigned int, netns_ino) 1858 ), 1859 TP_fast_assign( 1860 __entry->netns_ino = net->ns.inum; 1861 ), 1862 TP_printk("nn=%d", __entry->netns_ino 1863 ) 1864); 1865 1866#endif /* _NFSD_TRACE_H */ 1867 1868#undef TRACE_INCLUDE_PATH 1869#define TRACE_INCLUDE_PATH . 1870#define TRACE_INCLUDE_FILE trace 1871#include <trace/define_trace.h> 1872