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 37 DECLARE_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) \ 66 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 67 TP_PROTO(const struct svc_rqst *rqstp), \ 68 TP_ARGS(rqstp)) 69 70 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 71 DEFINE_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 89 TRACE_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 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 #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 194 TRACE_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 231 TRACE_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 276 DECLARE_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) \ 297 DEFINE_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 303 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 304 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 305 306 TRACE_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 330 TRACE_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 356 TRACE_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 377 TRACE_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 397 DECLARE_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) \ 421 DEFINE_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 428 DEFINE_NFSD_IO_EVENT(read_start); 429 DEFINE_NFSD_IO_EVENT(read_splice); 430 DEFINE_NFSD_IO_EVENT(read_vector); 431 DEFINE_NFSD_IO_EVENT(read_io_done); 432 DEFINE_NFSD_IO_EVENT(read_done); 433 DEFINE_NFSD_IO_EVENT(write_start); 434 DEFINE_NFSD_IO_EVENT(write_opened); 435 DEFINE_NFSD_IO_EVENT(write_io_done); 436 DEFINE_NFSD_IO_EVENT(write_done); 437 438 DECLARE_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) \ 462 DEFINE_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 469 DEFINE_NFSD_ERR_EVENT(read_err); 470 DEFINE_NFSD_ERR_EVENT(write_err); 471 472 TRACE_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 493 DECLARE_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) \ 530 DEFINE_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 541 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 542 543 #include "state.h" 544 #include "filecache.h" 545 #include "vfs.h" 546 547 TRACE_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 570 DECLARE_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) \ 593 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 594 TP_PROTO(stateid_t *stp), \ 595 TP_ARGS(stp)) 596 597 DEFINE_STATEID_EVENT(layoutstate_alloc); 598 DEFINE_STATEID_EVENT(layoutstate_unhash); 599 DEFINE_STATEID_EVENT(layoutstate_free); 600 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 601 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 602 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 603 DEFINE_STATEID_EVENT(layout_recall); 604 DEFINE_STATEID_EVENT(layout_recall_done); 605 DEFINE_STATEID_EVENT(layout_recall_fail); 606 DEFINE_STATEID_EVENT(layout_recall_release); 607 608 DEFINE_STATEID_EVENT(open); 609 DEFINE_STATEID_EVENT(deleg_read); 610 DEFINE_STATEID_EVENT(deleg_write); 611 DEFINE_STATEID_EVENT(deleg_return); 612 DEFINE_STATEID_EVENT(deleg_recall); 613 614 DECLARE_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) \ 637 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 638 TP_PROTO(u32 seqid, const stateid_t *stp), \ 639 TP_ARGS(seqid, stp)) 640 641 DEFINE_STATESEQID_EVENT(preprocess); 642 DEFINE_STATESEQID_EVENT(open_confirm); 643 644 TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 645 TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 646 TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 647 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 648 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 649 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 650 TRACE_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 662 DECLARE_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) \ 693 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 694 TP_PROTO(const struct nfs4_stid *stid), \ 695 TP_ARGS(stid)) 696 697 DEFINE_STID_EVENT(revoke); 698 699 DECLARE_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) \ 714 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 715 TP_PROTO(const clientid_t *clid), \ 716 TP_ARGS(clid)) 717 718 DEFINE_CLIENTID_EVENT(expire_unconf); 719 DEFINE_CLIENTID_EVENT(reclaim_complete); 720 DEFINE_CLIENTID_EVENT(confirmed); 721 DEFINE_CLIENTID_EVENT(destroyed); 722 DEFINE_CLIENTID_EVENT(admin_expired); 723 DEFINE_CLIENTID_EVENT(replaced); 724 DEFINE_CLIENTID_EVENT(purged); 725 DEFINE_CLIENTID_EVENT(renew); 726 DEFINE_CLIENTID_EVENT(stale); 727 728 DECLARE_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) \ 741 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 742 TP_PROTO(const struct nfsd_net *nn), \ 743 TP_ARGS(nn)) 744 745 DEFINE_NET_EVENT(grace_start); 746 DEFINE_NET_EVENT(grace_complete); 747 748 TRACE_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 776 TRACE_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 805 TRACE_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 837 DECLARE_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) \ 866 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 867 TP_PROTO(const struct nfs4_client *clp), \ 868 TP_ARGS(clp)) 869 870 DEFINE_CLID_EVENT(fresh); 871 DEFINE_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 883 DECLARE_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) \ 909 DEFINE_EVENT(nfsd_file_class, name, \ 910 TP_PROTO(struct nfsd_file *nf), \ 911 TP_ARGS(nf)) 912 913 DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 914 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 915 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 916 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 917 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 918 919 TRACE_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 943 TRACE_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 985 TRACE_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 1012 TRACE_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 1046 DECLARE_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) \ 1072 DEFINE_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 1079 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open); 1080 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened); 1081 1082 TRACE_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 1102 TRACE_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 1121 DECLARE_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) \ 1146 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1147 TP_PROTO( \ 1148 const struct nfsd_file *nf \ 1149 ), \ 1150 TP_ARGS(nf)) 1151 1152 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1153 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1154 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1155 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1156 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1157 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1158 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1159 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1160 1161 DECLARE_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) \ 1180 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1181 TP_PROTO( \ 1182 unsigned long removed, \ 1183 unsigned long remaining \ 1184 ), \ 1185 TP_ARGS(removed, remaining)) 1186 1187 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1188 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1189 1190 TRACE_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 1208 TRACE_DEFINE_ENUM(RC_DROPIT); 1209 TRACE_DEFINE_ENUM(RC_REPLY); 1210 TRACE_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 1218 TRACE_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 1241 TRACE_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 1265 TRACE_EVENT(nfsd_cb_args, 1266 TP_PROTO( 1267 const struct nfs4_client *clp, 1268 const struct nfs4_cb_conn *conn 1269 ), 1270 TP_ARGS(clp, conn), 1271 TP_STRUCT__entry( 1272 __field(u32, cl_boot) 1273 __field(u32, cl_id) 1274 __field(u32, prog) 1275 __field(u32, ident) 1276 __sockaddr(addr, conn->cb_addrlen) 1277 ), 1278 TP_fast_assign( 1279 __entry->cl_boot = clp->cl_clientid.cl_boot; 1280 __entry->cl_id = clp->cl_clientid.cl_id; 1281 __entry->prog = conn->cb_prog; 1282 __entry->ident = conn->cb_ident; 1283 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1284 ), 1285 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1286 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1287 __entry->prog, __entry->ident) 1288 ); 1289 1290 TRACE_EVENT(nfsd_cb_nodelegs, 1291 TP_PROTO(const struct nfs4_client *clp), 1292 TP_ARGS(clp), 1293 TP_STRUCT__entry( 1294 __field(u32, cl_boot) 1295 __field(u32, cl_id) 1296 ), 1297 TP_fast_assign( 1298 __entry->cl_boot = clp->cl_clientid.cl_boot; 1299 __entry->cl_id = clp->cl_clientid.cl_id; 1300 ), 1301 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1302 ) 1303 1304 #define show_cb_state(val) \ 1305 __print_symbolic(val, \ 1306 { NFSD4_CB_UP, "UP" }, \ 1307 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1308 { NFSD4_CB_DOWN, "DOWN" }, \ 1309 { NFSD4_CB_FAULT, "FAULT"}) 1310 1311 DECLARE_EVENT_CLASS(nfsd_cb_class, 1312 TP_PROTO(const struct nfs4_client *clp), 1313 TP_ARGS(clp), 1314 TP_STRUCT__entry( 1315 __field(unsigned long, state) 1316 __field(u32, cl_boot) 1317 __field(u32, cl_id) 1318 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1319 ), 1320 TP_fast_assign( 1321 __entry->state = clp->cl_cb_state; 1322 __entry->cl_boot = clp->cl_clientid.cl_boot; 1323 __entry->cl_id = clp->cl_clientid.cl_id; 1324 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1325 clp->cl_cb_conn.cb_addrlen) 1326 ), 1327 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1328 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1329 show_cb_state(__entry->state)) 1330 ); 1331 1332 #define DEFINE_NFSD_CB_EVENT(name) \ 1333 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1334 TP_PROTO(const struct nfs4_client *clp), \ 1335 TP_ARGS(clp)) 1336 1337 DEFINE_NFSD_CB_EVENT(state); 1338 DEFINE_NFSD_CB_EVENT(probe); 1339 DEFINE_NFSD_CB_EVENT(lost); 1340 DEFINE_NFSD_CB_EVENT(shutdown); 1341 1342 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1343 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1344 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1345 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1346 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1347 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1348 1349 #define show_nfsd_authflavor(val) \ 1350 __print_symbolic(val, \ 1351 { RPC_AUTH_NULL, "none" }, \ 1352 { RPC_AUTH_UNIX, "sys" }, \ 1353 { RPC_AUTH_GSS, "gss" }, \ 1354 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1355 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1356 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1357 1358 TRACE_EVENT(nfsd_cb_setup, 1359 TP_PROTO(const struct nfs4_client *clp, 1360 const char *netid, 1361 rpc_authflavor_t authflavor 1362 ), 1363 TP_ARGS(clp, netid, authflavor), 1364 TP_STRUCT__entry( 1365 __field(u32, cl_boot) 1366 __field(u32, cl_id) 1367 __field(unsigned long, authflavor) 1368 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1369 __string(netid, netid) 1370 ), 1371 TP_fast_assign( 1372 __entry->cl_boot = clp->cl_clientid.cl_boot; 1373 __entry->cl_id = clp->cl_clientid.cl_id; 1374 __assign_str(netid, netid); 1375 __entry->authflavor = authflavor; 1376 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1377 clp->cl_cb_conn.cb_addrlen) 1378 ), 1379 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1380 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1381 __get_str(netid), show_nfsd_authflavor(__entry->authflavor)) 1382 ); 1383 1384 TRACE_EVENT(nfsd_cb_setup_err, 1385 TP_PROTO( 1386 const struct nfs4_client *clp, 1387 long error 1388 ), 1389 TP_ARGS(clp, error), 1390 TP_STRUCT__entry( 1391 __field(long, error) 1392 __field(u32, cl_boot) 1393 __field(u32, cl_id) 1394 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1395 ), 1396 TP_fast_assign( 1397 __entry->error = error; 1398 __entry->cl_boot = clp->cl_clientid.cl_boot; 1399 __entry->cl_id = clp->cl_clientid.cl_id; 1400 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1401 clp->cl_cb_conn.cb_addrlen) 1402 ), 1403 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1404 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1405 __entry->error) 1406 ); 1407 1408 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1409 TP_PROTO( 1410 const struct nfs4_stid *stid 1411 ), 1412 TP_ARGS(stid), 1413 TP_CONDITION(stid->sc_client), 1414 TP_STRUCT__entry( 1415 __field(u32, cl_boot) 1416 __field(u32, cl_id) 1417 __field(u32, si_id) 1418 __field(u32, si_generation) 1419 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1420 ), 1421 TP_fast_assign( 1422 const stateid_t *stp = &stid->sc_stateid; 1423 const struct nfs4_client *clp = stid->sc_client; 1424 1425 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1426 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1427 __entry->si_id = stp->si_opaque.so_id; 1428 __entry->si_generation = stp->si_generation; 1429 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1430 clp->cl_cb_conn.cb_addrlen) 1431 ), 1432 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1433 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1434 __entry->si_id, __entry->si_generation) 1435 ); 1436 1437 TRACE_EVENT(nfsd_cb_notify_lock, 1438 TP_PROTO( 1439 const struct nfs4_lockowner *lo, 1440 const struct nfsd4_blocked_lock *nbl 1441 ), 1442 TP_ARGS(lo, nbl), 1443 TP_STRUCT__entry( 1444 __field(u32, cl_boot) 1445 __field(u32, cl_id) 1446 __field(u32, fh_hash) 1447 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1448 ), 1449 TP_fast_assign( 1450 const struct nfs4_client *clp = lo->lo_owner.so_client; 1451 1452 __entry->cl_boot = clp->cl_clientid.cl_boot; 1453 __entry->cl_id = clp->cl_clientid.cl_id; 1454 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1455 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1456 clp->cl_cb_conn.cb_addrlen) 1457 ), 1458 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1459 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1460 __entry->fh_hash) 1461 ); 1462 1463 TRACE_EVENT(nfsd_cb_offload, 1464 TP_PROTO( 1465 const struct nfs4_client *clp, 1466 const stateid_t *stp, 1467 const struct knfsd_fh *fh, 1468 u64 count, 1469 __be32 status 1470 ), 1471 TP_ARGS(clp, stp, fh, count, status), 1472 TP_STRUCT__entry( 1473 __field(u32, cl_boot) 1474 __field(u32, cl_id) 1475 __field(u32, si_id) 1476 __field(u32, si_generation) 1477 __field(u32, fh_hash) 1478 __field(int, status) 1479 __field(u64, count) 1480 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1481 ), 1482 TP_fast_assign( 1483 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1484 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1485 __entry->si_id = stp->si_opaque.so_id; 1486 __entry->si_generation = stp->si_generation; 1487 __entry->fh_hash = knfsd_fh_hash(fh); 1488 __entry->status = be32_to_cpu(status); 1489 __entry->count = count; 1490 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1491 clp->cl_cb_conn.cb_addrlen) 1492 ), 1493 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1494 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1495 __entry->si_id, __entry->si_generation, 1496 __entry->fh_hash, __entry->count, __entry->status) 1497 ); 1498 1499 TRACE_EVENT(nfsd_cb_recall_any, 1500 TP_PROTO( 1501 const struct nfsd4_cb_recall_any *ra 1502 ), 1503 TP_ARGS(ra), 1504 TP_STRUCT__entry( 1505 __field(u32, cl_boot) 1506 __field(u32, cl_id) 1507 __field(u32, keep) 1508 __field(unsigned long, bmval0) 1509 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1510 ), 1511 TP_fast_assign( 1512 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1513 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1514 __entry->keep = ra->ra_keep; 1515 __entry->bmval0 = ra->ra_bmval[0]; 1516 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1517 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1518 ), 1519 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1520 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1521 __entry->keep, show_rca_mask(__entry->bmval0) 1522 ) 1523 ); 1524 1525 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1526 TP_PROTO( 1527 const stateid_t *stp, 1528 const struct rpc_task *task 1529 ), 1530 TP_ARGS(stp, task), 1531 TP_STRUCT__entry( 1532 __field(u32, cl_boot) 1533 __field(u32, cl_id) 1534 __field(u32, si_id) 1535 __field(u32, si_generation) 1536 __field(int, status) 1537 ), 1538 TP_fast_assign( 1539 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1540 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1541 __entry->si_id = stp->si_opaque.so_id; 1542 __entry->si_generation = stp->si_generation; 1543 __entry->status = task->tk_status; 1544 ), 1545 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1546 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1547 __entry->si_generation, __entry->status 1548 ) 1549 ); 1550 1551 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1552 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1553 TP_PROTO( \ 1554 const stateid_t *stp, \ 1555 const struct rpc_task *task \ 1556 ), \ 1557 TP_ARGS(stp, task)) 1558 1559 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1560 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1561 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1562 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1563 1564 TRACE_EVENT(nfsd_cb_recall_any_done, 1565 TP_PROTO( 1566 const struct nfsd4_callback *cb, 1567 const struct rpc_task *task 1568 ), 1569 TP_ARGS(cb, task), 1570 TP_STRUCT__entry( 1571 __field(u32, cl_boot) 1572 __field(u32, cl_id) 1573 __field(int, status) 1574 ), 1575 TP_fast_assign( 1576 __entry->status = task->tk_status; 1577 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1578 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1579 ), 1580 TP_printk("client %08x:%08x status=%d", 1581 __entry->cl_boot, __entry->cl_id, __entry->status 1582 ) 1583 ); 1584 1585 TRACE_EVENT(nfsd_ctl_unlock_ip, 1586 TP_PROTO( 1587 const struct net *net, 1588 const char *address 1589 ), 1590 TP_ARGS(net, address), 1591 TP_STRUCT__entry( 1592 __field(unsigned int, netns_ino) 1593 __string(address, address) 1594 ), 1595 TP_fast_assign( 1596 __entry->netns_ino = net->ns.inum; 1597 __assign_str(address, address); 1598 ), 1599 TP_printk("address=%s", 1600 __get_str(address) 1601 ) 1602 ); 1603 1604 TRACE_EVENT(nfsd_ctl_unlock_fs, 1605 TP_PROTO( 1606 const struct net *net, 1607 const char *path 1608 ), 1609 TP_ARGS(net, path), 1610 TP_STRUCT__entry( 1611 __field(unsigned int, netns_ino) 1612 __string(path, path) 1613 ), 1614 TP_fast_assign( 1615 __entry->netns_ino = net->ns.inum; 1616 __assign_str(path, path); 1617 ), 1618 TP_printk("path=%s", 1619 __get_str(path) 1620 ) 1621 ); 1622 1623 TRACE_EVENT(nfsd_ctl_filehandle, 1624 TP_PROTO( 1625 const struct net *net, 1626 const char *domain, 1627 const char *path, 1628 int maxsize 1629 ), 1630 TP_ARGS(net, domain, path, maxsize), 1631 TP_STRUCT__entry( 1632 __field(unsigned int, netns_ino) 1633 __field(int, maxsize) 1634 __string(domain, domain) 1635 __string(path, path) 1636 ), 1637 TP_fast_assign( 1638 __entry->netns_ino = net->ns.inum; 1639 __entry->maxsize = maxsize; 1640 __assign_str(domain, domain); 1641 __assign_str(path, path); 1642 ), 1643 TP_printk("domain=%s path=%s maxsize=%d", 1644 __get_str(domain), __get_str(path), __entry->maxsize 1645 ) 1646 ); 1647 1648 TRACE_EVENT(nfsd_ctl_threads, 1649 TP_PROTO( 1650 const struct net *net, 1651 int newthreads 1652 ), 1653 TP_ARGS(net, newthreads), 1654 TP_STRUCT__entry( 1655 __field(unsigned int, netns_ino) 1656 __field(int, newthreads) 1657 ), 1658 TP_fast_assign( 1659 __entry->netns_ino = net->ns.inum; 1660 __entry->newthreads = newthreads; 1661 ), 1662 TP_printk("newthreads=%d", 1663 __entry->newthreads 1664 ) 1665 ); 1666 1667 TRACE_EVENT(nfsd_ctl_pool_threads, 1668 TP_PROTO( 1669 const struct net *net, 1670 int pool, 1671 int nrthreads 1672 ), 1673 TP_ARGS(net, pool, nrthreads), 1674 TP_STRUCT__entry( 1675 __field(unsigned int, netns_ino) 1676 __field(int, pool) 1677 __field(int, nrthreads) 1678 ), 1679 TP_fast_assign( 1680 __entry->netns_ino = net->ns.inum; 1681 __entry->pool = pool; 1682 __entry->nrthreads = nrthreads; 1683 ), 1684 TP_printk("pool=%d nrthreads=%d", 1685 __entry->pool, __entry->nrthreads 1686 ) 1687 ); 1688 1689 TRACE_EVENT(nfsd_ctl_version, 1690 TP_PROTO( 1691 const struct net *net, 1692 const char *mesg 1693 ), 1694 TP_ARGS(net, mesg), 1695 TP_STRUCT__entry( 1696 __field(unsigned int, netns_ino) 1697 __string(mesg, mesg) 1698 ), 1699 TP_fast_assign( 1700 __entry->netns_ino = net->ns.inum; 1701 __assign_str(mesg, mesg); 1702 ), 1703 TP_printk("%s", 1704 __get_str(mesg) 1705 ) 1706 ); 1707 1708 TRACE_EVENT(nfsd_ctl_ports_addfd, 1709 TP_PROTO( 1710 const struct net *net, 1711 int fd 1712 ), 1713 TP_ARGS(net, fd), 1714 TP_STRUCT__entry( 1715 __field(unsigned int, netns_ino) 1716 __field(int, fd) 1717 ), 1718 TP_fast_assign( 1719 __entry->netns_ino = net->ns.inum; 1720 __entry->fd = fd; 1721 ), 1722 TP_printk("fd=%d", 1723 __entry->fd 1724 ) 1725 ); 1726 1727 TRACE_EVENT(nfsd_ctl_ports_addxprt, 1728 TP_PROTO( 1729 const struct net *net, 1730 const char *transport, 1731 int port 1732 ), 1733 TP_ARGS(net, transport, port), 1734 TP_STRUCT__entry( 1735 __field(unsigned int, netns_ino) 1736 __field(int, port) 1737 __string(transport, transport) 1738 ), 1739 TP_fast_assign( 1740 __entry->netns_ino = net->ns.inum; 1741 __entry->port = port; 1742 __assign_str(transport, transport); 1743 ), 1744 TP_printk("transport=%s port=%d", 1745 __get_str(transport), __entry->port 1746 ) 1747 ); 1748 1749 TRACE_EVENT(nfsd_ctl_maxblksize, 1750 TP_PROTO( 1751 const struct net *net, 1752 int bsize 1753 ), 1754 TP_ARGS(net, bsize), 1755 TP_STRUCT__entry( 1756 __field(unsigned int, netns_ino) 1757 __field(int, bsize) 1758 ), 1759 TP_fast_assign( 1760 __entry->netns_ino = net->ns.inum; 1761 __entry->bsize = bsize; 1762 ), 1763 TP_printk("bsize=%d", 1764 __entry->bsize 1765 ) 1766 ); 1767 1768 TRACE_EVENT(nfsd_ctl_maxconn, 1769 TP_PROTO( 1770 const struct net *net, 1771 int maxconn 1772 ), 1773 TP_ARGS(net, maxconn), 1774 TP_STRUCT__entry( 1775 __field(unsigned int, netns_ino) 1776 __field(int, maxconn) 1777 ), 1778 TP_fast_assign( 1779 __entry->netns_ino = net->ns.inum; 1780 __entry->maxconn = maxconn; 1781 ), 1782 TP_printk("maxconn=%d", 1783 __entry->maxconn 1784 ) 1785 ); 1786 1787 TRACE_EVENT(nfsd_ctl_time, 1788 TP_PROTO( 1789 const struct net *net, 1790 const char *name, 1791 size_t namelen, 1792 int time 1793 ), 1794 TP_ARGS(net, name, namelen, time), 1795 TP_STRUCT__entry( 1796 __field(unsigned int, netns_ino) 1797 __field(int, time) 1798 __string_len(name, name, namelen) 1799 ), 1800 TP_fast_assign( 1801 __entry->netns_ino = net->ns.inum; 1802 __entry->time = time; 1803 __assign_str_len(name, name, namelen); 1804 ), 1805 TP_printk("file=%s time=%d\n", 1806 __get_str(name), __entry->time 1807 ) 1808 ); 1809 1810 TRACE_EVENT(nfsd_ctl_recoverydir, 1811 TP_PROTO( 1812 const struct net *net, 1813 const char *recdir 1814 ), 1815 TP_ARGS(net, recdir), 1816 TP_STRUCT__entry( 1817 __field(unsigned int, netns_ino) 1818 __string(recdir, recdir) 1819 ), 1820 TP_fast_assign( 1821 __entry->netns_ino = net->ns.inum; 1822 __assign_str(recdir, recdir); 1823 ), 1824 TP_printk("recdir=%s", 1825 __get_str(recdir) 1826 ) 1827 ); 1828 1829 TRACE_EVENT(nfsd_end_grace, 1830 TP_PROTO( 1831 const struct net *net 1832 ), 1833 TP_ARGS(net), 1834 TP_STRUCT__entry( 1835 __field(unsigned int, netns_ino) 1836 ), 1837 TP_fast_assign( 1838 __entry->netns_ino = net->ns.inum; 1839 ), 1840 TP_printk("nn=%d", __entry->netns_ino 1841 ) 1842 ); 1843 1844 DECLARE_EVENT_CLASS(nfsd_copy_class, 1845 TP_PROTO( 1846 const struct nfsd4_copy *copy 1847 ), 1848 TP_ARGS(copy), 1849 TP_STRUCT__entry( 1850 __field(bool, intra) 1851 __field(bool, async) 1852 __field(u32, src_cl_boot) 1853 __field(u32, src_cl_id) 1854 __field(u32, src_so_id) 1855 __field(u32, src_si_generation) 1856 __field(u32, dst_cl_boot) 1857 __field(u32, dst_cl_id) 1858 __field(u32, dst_so_id) 1859 __field(u32, dst_si_generation) 1860 __field(u64, src_cp_pos) 1861 __field(u64, dst_cp_pos) 1862 __field(u64, cp_count) 1863 __sockaddr(addr, sizeof(struct sockaddr_in6)) 1864 ), 1865 TP_fast_assign( 1866 const stateid_t *src_stp = ©->cp_src_stateid; 1867 const stateid_t *dst_stp = ©->cp_dst_stateid; 1868 1869 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 1870 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 1871 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot; 1872 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id; 1873 __entry->src_so_id = src_stp->si_opaque.so_id; 1874 __entry->src_si_generation = src_stp->si_generation; 1875 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot; 1876 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id; 1877 __entry->dst_so_id = dst_stp->si_opaque.so_id; 1878 __entry->dst_si_generation = dst_stp->si_generation; 1879 __entry->src_cp_pos = copy->cp_src_pos; 1880 __entry->dst_cp_pos = copy->cp_dst_pos; 1881 __entry->cp_count = copy->cp_count; 1882 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 1883 sizeof(struct sockaddr_in6)); 1884 ), 1885 TP_printk("client=%pISpc intra=%d async=%d " 1886 "src_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] " 1887 "dst_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] " 1888 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu", 1889 __get_sockaddr(addr), __entry->intra, __entry->async, 1890 __entry->src_si_generation, __entry->src_cl_boot, 1891 __entry->src_cl_id, __entry->src_so_id, 1892 __entry->dst_si_generation, __entry->dst_cl_boot, 1893 __entry->dst_cl_id, __entry->dst_so_id, 1894 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count 1895 ) 1896 ); 1897 1898 #define DEFINE_COPY_EVENT(name) \ 1899 DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \ 1900 TP_PROTO(const struct nfsd4_copy *copy), \ 1901 TP_ARGS(copy)) 1902 1903 DEFINE_COPY_EVENT(inter); 1904 DEFINE_COPY_EVENT(intra); 1905 DEFINE_COPY_EVENT(do_async); 1906 1907 TRACE_EVENT(nfsd_copy_done, 1908 TP_PROTO( 1909 const struct nfsd4_copy *copy, 1910 __be32 status 1911 ), 1912 TP_ARGS(copy, status), 1913 TP_STRUCT__entry( 1914 __field(int, status) 1915 __field(bool, intra) 1916 __field(bool, async) 1917 __sockaddr(addr, sizeof(struct sockaddr_in6)) 1918 ), 1919 TP_fast_assign( 1920 __entry->status = be32_to_cpu(status); 1921 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); 1922 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags); 1923 __assign_sockaddr(addr, ©->cp_clp->cl_addr, 1924 sizeof(struct sockaddr_in6)); 1925 ), 1926 TP_printk("addr=%pISpc status=%d intra=%d async=%d ", 1927 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async 1928 ) 1929 ); 1930 1931 #endif /* _NFSD_TRACE_H */ 1932 1933 #undef TRACE_INCLUDE_PATH 1934 #define TRACE_INCLUDE_PATH . 1935 #define TRACE_INCLUDE_FILE trace 1936 #include <trace/define_trace.h> 1937