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_return); 611 DEFINE_STATEID_EVENT(deleg_recall); 612 613 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 614 TP_PROTO(u32 seqid, const stateid_t *stp), 615 TP_ARGS(seqid, stp), 616 TP_STRUCT__entry( 617 __field(u32, seqid) 618 __field(u32, cl_boot) 619 __field(u32, cl_id) 620 __field(u32, si_id) 621 __field(u32, si_generation) 622 ), 623 TP_fast_assign( 624 __entry->seqid = seqid; 625 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 626 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 627 __entry->si_id = stp->si_opaque.so_id; 628 __entry->si_generation = stp->si_generation; 629 ), 630 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 631 __entry->seqid, __entry->cl_boot, __entry->cl_id, 632 __entry->si_id, __entry->si_generation) 633 ) 634 635 #define DEFINE_STATESEQID_EVENT(name) \ 636 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 637 TP_PROTO(u32 seqid, const stateid_t *stp), \ 638 TP_ARGS(seqid, stp)) 639 640 DEFINE_STATESEQID_EVENT(preprocess); 641 DEFINE_STATESEQID_EVENT(open_confirm); 642 643 TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 644 TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 645 TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 646 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 647 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 648 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 649 TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 650 651 #define show_stid_type(x) \ 652 __print_flags(x, "|", \ 653 { NFS4_OPEN_STID, "OPEN" }, \ 654 { NFS4_LOCK_STID, "LOCK" }, \ 655 { NFS4_DELEG_STID, "DELEG" }, \ 656 { NFS4_CLOSED_STID, "CLOSED" }, \ 657 { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 658 { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 659 { NFS4_LAYOUT_STID, "LAYOUT" }) 660 661 DECLARE_EVENT_CLASS(nfsd_stid_class, 662 TP_PROTO( 663 const struct nfs4_stid *stid 664 ), 665 TP_ARGS(stid), 666 TP_STRUCT__entry( 667 __field(unsigned long, sc_type) 668 __field(int, sc_count) 669 __field(u32, cl_boot) 670 __field(u32, cl_id) 671 __field(u32, si_id) 672 __field(u32, si_generation) 673 ), 674 TP_fast_assign( 675 const stateid_t *stp = &stid->sc_stateid; 676 677 __entry->sc_type = stid->sc_type; 678 __entry->sc_count = refcount_read(&stid->sc_count); 679 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 680 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 681 __entry->si_id = stp->si_opaque.so_id; 682 __entry->si_generation = stp->si_generation; 683 ), 684 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 685 __entry->cl_boot, __entry->cl_id, 686 __entry->si_id, __entry->si_generation, 687 __entry->sc_count, show_stid_type(__entry->sc_type) 688 ) 689 ); 690 691 #define DEFINE_STID_EVENT(name) \ 692 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 693 TP_PROTO(const struct nfs4_stid *stid), \ 694 TP_ARGS(stid)) 695 696 DEFINE_STID_EVENT(revoke); 697 698 DECLARE_EVENT_CLASS(nfsd_clientid_class, 699 TP_PROTO(const clientid_t *clid), 700 TP_ARGS(clid), 701 TP_STRUCT__entry( 702 __field(u32, cl_boot) 703 __field(u32, cl_id) 704 ), 705 TP_fast_assign( 706 __entry->cl_boot = clid->cl_boot; 707 __entry->cl_id = clid->cl_id; 708 ), 709 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 710 ) 711 712 #define DEFINE_CLIENTID_EVENT(name) \ 713 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 714 TP_PROTO(const clientid_t *clid), \ 715 TP_ARGS(clid)) 716 717 DEFINE_CLIENTID_EVENT(expire_unconf); 718 DEFINE_CLIENTID_EVENT(reclaim_complete); 719 DEFINE_CLIENTID_EVENT(confirmed); 720 DEFINE_CLIENTID_EVENT(destroyed); 721 DEFINE_CLIENTID_EVENT(admin_expired); 722 DEFINE_CLIENTID_EVENT(replaced); 723 DEFINE_CLIENTID_EVENT(purged); 724 DEFINE_CLIENTID_EVENT(renew); 725 DEFINE_CLIENTID_EVENT(stale); 726 727 DECLARE_EVENT_CLASS(nfsd_net_class, 728 TP_PROTO(const struct nfsd_net *nn), 729 TP_ARGS(nn), 730 TP_STRUCT__entry( 731 __field(unsigned long long, boot_time) 732 ), 733 TP_fast_assign( 734 __entry->boot_time = nn->boot_time; 735 ), 736 TP_printk("boot_time=%16llx", __entry->boot_time) 737 ) 738 739 #define DEFINE_NET_EVENT(name) \ 740 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 741 TP_PROTO(const struct nfsd_net *nn), \ 742 TP_ARGS(nn)) 743 744 DEFINE_NET_EVENT(grace_start); 745 DEFINE_NET_EVENT(grace_complete); 746 747 TRACE_EVENT(nfsd_writeverf_reset, 748 TP_PROTO( 749 const struct nfsd_net *nn, 750 const struct svc_rqst *rqstp, 751 int error 752 ), 753 TP_ARGS(nn, rqstp, error), 754 TP_STRUCT__entry( 755 __field(unsigned long long, boot_time) 756 __field(u32, xid) 757 __field(int, error) 758 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 759 ), 760 TP_fast_assign( 761 __entry->boot_time = nn->boot_time; 762 __entry->xid = be32_to_cpu(rqstp->rq_xid); 763 __entry->error = error; 764 765 /* avoid seqlock inside TP_fast_assign */ 766 memcpy(__entry->verifier, nn->writeverf, 767 NFS4_VERIFIER_SIZE); 768 ), 769 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 770 __entry->boot_time, __entry->xid, __entry->error, 771 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 772 ) 773 ); 774 775 TRACE_EVENT(nfsd_clid_cred_mismatch, 776 TP_PROTO( 777 const struct nfs4_client *clp, 778 const struct svc_rqst *rqstp 779 ), 780 TP_ARGS(clp, rqstp), 781 TP_STRUCT__entry( 782 __field(u32, cl_boot) 783 __field(u32, cl_id) 784 __field(unsigned long, cl_flavor) 785 __field(unsigned long, new_flavor) 786 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 787 ), 788 TP_fast_assign( 789 __entry->cl_boot = clp->cl_clientid.cl_boot; 790 __entry->cl_id = clp->cl_clientid.cl_id; 791 __entry->cl_flavor = clp->cl_cred.cr_flavor; 792 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 793 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 794 rqstp->rq_xprt->xpt_remotelen); 795 ), 796 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 797 __entry->cl_boot, __entry->cl_id, 798 show_nfsd_authflavor(__entry->cl_flavor), 799 show_nfsd_authflavor(__entry->new_flavor), 800 __get_sockaddr(addr) 801 ) 802 ) 803 804 TRACE_EVENT(nfsd_clid_verf_mismatch, 805 TP_PROTO( 806 const struct nfs4_client *clp, 807 const struct svc_rqst *rqstp, 808 const nfs4_verifier *verf 809 ), 810 TP_ARGS(clp, rqstp, verf), 811 TP_STRUCT__entry( 812 __field(u32, cl_boot) 813 __field(u32, cl_id) 814 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 815 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 816 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 817 ), 818 TP_fast_assign( 819 __entry->cl_boot = clp->cl_clientid.cl_boot; 820 __entry->cl_id = clp->cl_clientid.cl_id; 821 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 822 NFS4_VERIFIER_SIZE); 823 memcpy(__entry->new_verifier, (void *)verf, 824 NFS4_VERIFIER_SIZE); 825 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 826 rqstp->rq_xprt->xpt_remotelen); 827 ), 828 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 829 __entry->cl_boot, __entry->cl_id, 830 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 831 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 832 __get_sockaddr(addr) 833 ) 834 ); 835 836 DECLARE_EVENT_CLASS(nfsd_clid_class, 837 TP_PROTO(const struct nfs4_client *clp), 838 TP_ARGS(clp), 839 TP_STRUCT__entry( 840 __field(u32, cl_boot) 841 __field(u32, cl_id) 842 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 843 __field(unsigned long, flavor) 844 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 845 __string_len(name, name, clp->cl_name.len) 846 ), 847 TP_fast_assign( 848 __entry->cl_boot = clp->cl_clientid.cl_boot; 849 __entry->cl_id = clp->cl_clientid.cl_id; 850 memcpy(__entry->addr, &clp->cl_addr, 851 sizeof(struct sockaddr_in6)); 852 __entry->flavor = clp->cl_cred.cr_flavor; 853 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 854 NFS4_VERIFIER_SIZE); 855 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 856 ), 857 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 858 __entry->addr, __get_str(name), 859 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 860 show_nfsd_authflavor(__entry->flavor), 861 __entry->cl_boot, __entry->cl_id) 862 ); 863 864 #define DEFINE_CLID_EVENT(name) \ 865 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 866 TP_PROTO(const struct nfs4_client *clp), \ 867 TP_ARGS(clp)) 868 869 DEFINE_CLID_EVENT(fresh); 870 DEFINE_CLID_EVENT(confirmed_r); 871 872 /* 873 * from fs/nfsd/filecache.h 874 */ 875 #define show_nf_flags(val) \ 876 __print_flags(val, "|", \ 877 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 878 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 879 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \ 880 { 1 << NFSD_FILE_GC, "GC" }) 881 882 DECLARE_EVENT_CLASS(nfsd_file_class, 883 TP_PROTO(struct nfsd_file *nf), 884 TP_ARGS(nf), 885 TP_STRUCT__entry( 886 __field(void *, nf_inode) 887 __field(int, nf_ref) 888 __field(unsigned long, nf_flags) 889 __field(unsigned char, nf_may) 890 __field(struct file *, nf_file) 891 ), 892 TP_fast_assign( 893 __entry->nf_inode = nf->nf_inode; 894 __entry->nf_ref = refcount_read(&nf->nf_ref); 895 __entry->nf_flags = nf->nf_flags; 896 __entry->nf_may = nf->nf_may; 897 __entry->nf_file = nf->nf_file; 898 ), 899 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 900 __entry->nf_inode, 901 __entry->nf_ref, 902 show_nf_flags(__entry->nf_flags), 903 show_nfsd_may_flags(__entry->nf_may), 904 __entry->nf_file) 905 ) 906 907 #define DEFINE_NFSD_FILE_EVENT(name) \ 908 DEFINE_EVENT(nfsd_file_class, name, \ 909 TP_PROTO(struct nfsd_file *nf), \ 910 TP_ARGS(nf)) 911 912 DEFINE_NFSD_FILE_EVENT(nfsd_file_free); 913 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 914 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 915 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing); 916 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue); 917 918 TRACE_EVENT(nfsd_file_alloc, 919 TP_PROTO( 920 const struct nfsd_file *nf 921 ), 922 TP_ARGS(nf), 923 TP_STRUCT__entry( 924 __field(const void *, nf_inode) 925 __field(unsigned long, nf_flags) 926 __field(unsigned long, nf_may) 927 __field(unsigned int, nf_ref) 928 ), 929 TP_fast_assign( 930 __entry->nf_inode = nf->nf_inode; 931 __entry->nf_flags = nf->nf_flags; 932 __entry->nf_ref = refcount_read(&nf->nf_ref); 933 __entry->nf_may = nf->nf_may; 934 ), 935 TP_printk("inode=%p ref=%u flags=%s may=%s", 936 __entry->nf_inode, __entry->nf_ref, 937 show_nf_flags(__entry->nf_flags), 938 show_nfsd_may_flags(__entry->nf_may) 939 ) 940 ); 941 942 TRACE_EVENT(nfsd_file_acquire, 943 TP_PROTO( 944 const struct svc_rqst *rqstp, 945 const struct inode *inode, 946 unsigned int may_flags, 947 const struct nfsd_file *nf, 948 __be32 status 949 ), 950 951 TP_ARGS(rqstp, inode, may_flags, nf, status), 952 953 TP_STRUCT__entry( 954 __field(u32, xid) 955 __field(const void *, inode) 956 __field(unsigned long, may_flags) 957 __field(unsigned int, nf_ref) 958 __field(unsigned long, nf_flags) 959 __field(unsigned long, nf_may) 960 __field(const void *, nf_file) 961 __field(u32, status) 962 ), 963 964 TP_fast_assign( 965 __entry->xid = be32_to_cpu(rqstp->rq_xid); 966 __entry->inode = inode; 967 __entry->may_flags = may_flags; 968 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 969 __entry->nf_flags = nf ? nf->nf_flags : 0; 970 __entry->nf_may = nf ? nf->nf_may : 0; 971 __entry->nf_file = nf ? nf->nf_file : NULL; 972 __entry->status = be32_to_cpu(status); 973 ), 974 975 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 976 __entry->xid, __entry->inode, 977 show_nfsd_may_flags(__entry->may_flags), 978 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 979 show_nfsd_may_flags(__entry->nf_may), 980 __entry->nf_file, __entry->status 981 ) 982 ); 983 984 TRACE_EVENT(nfsd_file_create, 985 TP_PROTO( 986 const struct svc_rqst *rqstp, 987 unsigned int may_flags, 988 const struct nfsd_file *nf 989 ), 990 991 TP_ARGS(rqstp, may_flags, nf), 992 993 TP_STRUCT__entry( 994 __field(const void *, nf_inode) 995 __field(const void *, nf_file) 996 __field(unsigned long, may_flags) 997 __field(unsigned long, nf_flags) 998 __field(unsigned long, nf_may) 999 __field(unsigned int, nf_ref) 1000 __field(u32, xid) 1001 ), 1002 1003 TP_fast_assign( 1004 __entry->nf_inode = nf->nf_inode; 1005 __entry->nf_file = nf->nf_file; 1006 __entry->may_flags = may_flags; 1007 __entry->nf_flags = nf->nf_flags; 1008 __entry->nf_may = nf->nf_may; 1009 __entry->nf_ref = refcount_read(&nf->nf_ref); 1010 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1011 ), 1012 1013 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1014 __entry->xid, __entry->nf_inode, 1015 show_nfsd_may_flags(__entry->may_flags), 1016 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1017 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1018 ) 1019 ); 1020 1021 TRACE_EVENT(nfsd_file_insert_err, 1022 TP_PROTO( 1023 const struct svc_rqst *rqstp, 1024 const struct inode *inode, 1025 unsigned int may_flags, 1026 long error 1027 ), 1028 TP_ARGS(rqstp, inode, may_flags, error), 1029 TP_STRUCT__entry( 1030 __field(u32, xid) 1031 __field(const void *, inode) 1032 __field(unsigned long, may_flags) 1033 __field(long, error) 1034 ), 1035 TP_fast_assign( 1036 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1037 __entry->inode = inode; 1038 __entry->may_flags = may_flags; 1039 __entry->error = error; 1040 ), 1041 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1042 __entry->xid, __entry->inode, 1043 show_nfsd_may_flags(__entry->may_flags), 1044 __entry->error 1045 ) 1046 ); 1047 1048 TRACE_EVENT(nfsd_file_cons_err, 1049 TP_PROTO( 1050 const struct svc_rqst *rqstp, 1051 const struct inode *inode, 1052 unsigned int may_flags, 1053 const struct nfsd_file *nf 1054 ), 1055 TP_ARGS(rqstp, inode, may_flags, nf), 1056 TP_STRUCT__entry( 1057 __field(u32, xid) 1058 __field(const void *, inode) 1059 __field(unsigned long, may_flags) 1060 __field(unsigned int, nf_ref) 1061 __field(unsigned long, nf_flags) 1062 __field(unsigned long, nf_may) 1063 __field(const void *, nf_file) 1064 ), 1065 TP_fast_assign( 1066 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1067 __entry->inode = inode; 1068 __entry->may_flags = may_flags; 1069 __entry->nf_ref = refcount_read(&nf->nf_ref); 1070 __entry->nf_flags = nf->nf_flags; 1071 __entry->nf_may = nf->nf_may; 1072 __entry->nf_file = nf->nf_file; 1073 ), 1074 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1075 __entry->xid, __entry->inode, 1076 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1077 show_nf_flags(__entry->nf_flags), 1078 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1079 ) 1080 ); 1081 1082 TRACE_EVENT(nfsd_file_open, 1083 TP_PROTO(struct nfsd_file *nf, __be32 status), 1084 TP_ARGS(nf, status), 1085 TP_STRUCT__entry( 1086 __field(void *, nf_inode) /* cannot be dereferenced */ 1087 __field(int, nf_ref) 1088 __field(unsigned long, nf_flags) 1089 __field(unsigned long, nf_may) 1090 __field(void *, nf_file) /* cannot be dereferenced */ 1091 ), 1092 TP_fast_assign( 1093 __entry->nf_inode = nf->nf_inode; 1094 __entry->nf_ref = refcount_read(&nf->nf_ref); 1095 __entry->nf_flags = nf->nf_flags; 1096 __entry->nf_may = nf->nf_may; 1097 __entry->nf_file = nf->nf_file; 1098 ), 1099 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1100 __entry->nf_inode, 1101 __entry->nf_ref, 1102 show_nf_flags(__entry->nf_flags), 1103 show_nfsd_may_flags(__entry->nf_may), 1104 __entry->nf_file) 1105 ) 1106 1107 TRACE_EVENT(nfsd_file_is_cached, 1108 TP_PROTO( 1109 const struct inode *inode, 1110 int found 1111 ), 1112 TP_ARGS(inode, found), 1113 TP_STRUCT__entry( 1114 __field(const struct inode *, inode) 1115 __field(int, found) 1116 ), 1117 TP_fast_assign( 1118 __entry->inode = inode; 1119 __entry->found = found; 1120 ), 1121 TP_printk("inode=%p is %scached", 1122 __entry->inode, 1123 __entry->found ? "" : "not " 1124 ) 1125 ); 1126 1127 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1128 TP_PROTO(struct inode *inode, u32 mask), 1129 TP_ARGS(inode, mask), 1130 TP_STRUCT__entry( 1131 __field(struct inode *, inode) 1132 __field(unsigned int, nlink) 1133 __field(umode_t, mode) 1134 __field(u32, mask) 1135 ), 1136 TP_fast_assign( 1137 __entry->inode = inode; 1138 __entry->nlink = inode->i_nlink; 1139 __entry->mode = inode->i_mode; 1140 __entry->mask = mask; 1141 ), 1142 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1143 __entry->nlink, __entry->mode, __entry->mask) 1144 ); 1145 1146 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1147 TP_PROTO( 1148 const struct nfsd_file *nf 1149 ), 1150 TP_ARGS(nf), 1151 TP_STRUCT__entry( 1152 __field(void *, nf_inode) 1153 __field(void *, nf_file) 1154 __field(int, nf_ref) 1155 __field(unsigned long, nf_flags) 1156 ), 1157 TP_fast_assign( 1158 __entry->nf_inode = nf->nf_inode; 1159 __entry->nf_file = nf->nf_file; 1160 __entry->nf_ref = refcount_read(&nf->nf_ref); 1161 __entry->nf_flags = nf->nf_flags; 1162 ), 1163 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1164 __entry->nf_inode, __entry->nf_ref, 1165 show_nf_flags(__entry->nf_flags), 1166 __entry->nf_file 1167 ) 1168 ); 1169 1170 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1171 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1172 TP_PROTO( \ 1173 const struct nfsd_file *nf \ 1174 ), \ 1175 TP_ARGS(nf)) 1176 1177 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1178 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1179 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1180 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1181 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1182 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1183 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1184 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1185 1186 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1187 TP_PROTO( 1188 unsigned long removed, 1189 unsigned long remaining 1190 ), 1191 TP_ARGS(removed, remaining), 1192 TP_STRUCT__entry( 1193 __field(unsigned long, removed) 1194 __field(unsigned long, remaining) 1195 ), 1196 TP_fast_assign( 1197 __entry->removed = removed; 1198 __entry->remaining = remaining; 1199 ), 1200 TP_printk("%lu entries removed, %lu remaining", 1201 __entry->removed, __entry->remaining) 1202 ); 1203 1204 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1205 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1206 TP_PROTO( \ 1207 unsigned long removed, \ 1208 unsigned long remaining \ 1209 ), \ 1210 TP_ARGS(removed, remaining)) 1211 1212 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1213 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1214 1215 TRACE_EVENT(nfsd_file_close, 1216 TP_PROTO( 1217 const struct inode *inode 1218 ), 1219 TP_ARGS(inode), 1220 TP_STRUCT__entry( 1221 __field(const void *, inode) 1222 ), 1223 TP_fast_assign( 1224 __entry->inode = inode; 1225 ), 1226 TP_printk("inode=%p", 1227 __entry->inode 1228 ) 1229 ); 1230 1231 TRACE_EVENT(nfsd_file_fsync, 1232 TP_PROTO( 1233 const struct nfsd_file *nf, 1234 int ret 1235 ), 1236 TP_ARGS(nf, ret), 1237 TP_STRUCT__entry( 1238 __field(void *, nf_inode) 1239 __field(int, nf_ref) 1240 __field(int, ret) 1241 __field(unsigned long, nf_flags) 1242 __field(unsigned char, nf_may) 1243 __field(struct file *, nf_file) 1244 ), 1245 TP_fast_assign( 1246 __entry->nf_inode = nf->nf_inode; 1247 __entry->nf_ref = refcount_read(&nf->nf_ref); 1248 __entry->ret = ret; 1249 __entry->nf_flags = nf->nf_flags; 1250 __entry->nf_may = nf->nf_may; 1251 __entry->nf_file = nf->nf_file; 1252 ), 1253 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p ret=%d", 1254 __entry->nf_inode, 1255 __entry->nf_ref, 1256 show_nf_flags(__entry->nf_flags), 1257 show_nfsd_may_flags(__entry->nf_may), 1258 __entry->nf_file, __entry->ret 1259 ) 1260 ); 1261 1262 #include "cache.h" 1263 1264 TRACE_DEFINE_ENUM(RC_DROPIT); 1265 TRACE_DEFINE_ENUM(RC_REPLY); 1266 TRACE_DEFINE_ENUM(RC_DOIT); 1267 1268 #define show_drc_retval(x) \ 1269 __print_symbolic(x, \ 1270 { RC_DROPIT, "DROPIT" }, \ 1271 { RC_REPLY, "REPLY" }, \ 1272 { RC_DOIT, "DOIT" }) 1273 1274 TRACE_EVENT(nfsd_drc_found, 1275 TP_PROTO( 1276 const struct nfsd_net *nn, 1277 const struct svc_rqst *rqstp, 1278 int result 1279 ), 1280 TP_ARGS(nn, rqstp, result), 1281 TP_STRUCT__entry( 1282 __field(unsigned long long, boot_time) 1283 __field(unsigned long, result) 1284 __field(u32, xid) 1285 ), 1286 TP_fast_assign( 1287 __entry->boot_time = nn->boot_time; 1288 __entry->result = result; 1289 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1290 ), 1291 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1292 __entry->boot_time, __entry->xid, 1293 show_drc_retval(__entry->result)) 1294 1295 ); 1296 1297 TRACE_EVENT(nfsd_drc_mismatch, 1298 TP_PROTO( 1299 const struct nfsd_net *nn, 1300 const struct svc_cacherep *key, 1301 const struct svc_cacherep *rp 1302 ), 1303 TP_ARGS(nn, key, rp), 1304 TP_STRUCT__entry( 1305 __field(unsigned long long, boot_time) 1306 __field(u32, xid) 1307 __field(u32, cached) 1308 __field(u32, ingress) 1309 ), 1310 TP_fast_assign( 1311 __entry->boot_time = nn->boot_time; 1312 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1313 __entry->cached = (__force u32)key->c_key.k_csum; 1314 __entry->ingress = (__force u32)rp->c_key.k_csum; 1315 ), 1316 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1317 __entry->boot_time, __entry->xid, __entry->cached, 1318 __entry->ingress) 1319 ); 1320 1321 TRACE_EVENT(nfsd_cb_args, 1322 TP_PROTO( 1323 const struct nfs4_client *clp, 1324 const struct nfs4_cb_conn *conn 1325 ), 1326 TP_ARGS(clp, conn), 1327 TP_STRUCT__entry( 1328 __field(u32, cl_boot) 1329 __field(u32, cl_id) 1330 __field(u32, prog) 1331 __field(u32, ident) 1332 __sockaddr(addr, conn->cb_addrlen) 1333 ), 1334 TP_fast_assign( 1335 __entry->cl_boot = clp->cl_clientid.cl_boot; 1336 __entry->cl_id = clp->cl_clientid.cl_id; 1337 __entry->prog = conn->cb_prog; 1338 __entry->ident = conn->cb_ident; 1339 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1340 ), 1341 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1342 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1343 __entry->prog, __entry->ident) 1344 ); 1345 1346 TRACE_EVENT(nfsd_cb_nodelegs, 1347 TP_PROTO(const struct nfs4_client *clp), 1348 TP_ARGS(clp), 1349 TP_STRUCT__entry( 1350 __field(u32, cl_boot) 1351 __field(u32, cl_id) 1352 ), 1353 TP_fast_assign( 1354 __entry->cl_boot = clp->cl_clientid.cl_boot; 1355 __entry->cl_id = clp->cl_clientid.cl_id; 1356 ), 1357 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1358 ) 1359 1360 #define show_cb_state(val) \ 1361 __print_symbolic(val, \ 1362 { NFSD4_CB_UP, "UP" }, \ 1363 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1364 { NFSD4_CB_DOWN, "DOWN" }, \ 1365 { NFSD4_CB_FAULT, "FAULT"}) 1366 1367 DECLARE_EVENT_CLASS(nfsd_cb_class, 1368 TP_PROTO(const struct nfs4_client *clp), 1369 TP_ARGS(clp), 1370 TP_STRUCT__entry( 1371 __field(unsigned long, state) 1372 __field(u32, cl_boot) 1373 __field(u32, cl_id) 1374 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1375 ), 1376 TP_fast_assign( 1377 __entry->state = clp->cl_cb_state; 1378 __entry->cl_boot = clp->cl_clientid.cl_boot; 1379 __entry->cl_id = clp->cl_clientid.cl_id; 1380 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1381 clp->cl_cb_conn.cb_addrlen) 1382 ), 1383 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1384 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1385 show_cb_state(__entry->state)) 1386 ); 1387 1388 #define DEFINE_NFSD_CB_EVENT(name) \ 1389 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1390 TP_PROTO(const struct nfs4_client *clp), \ 1391 TP_ARGS(clp)) 1392 1393 DEFINE_NFSD_CB_EVENT(state); 1394 DEFINE_NFSD_CB_EVENT(probe); 1395 DEFINE_NFSD_CB_EVENT(lost); 1396 DEFINE_NFSD_CB_EVENT(shutdown); 1397 1398 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1399 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1400 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1401 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1402 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1403 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1404 1405 #define show_nfsd_authflavor(val) \ 1406 __print_symbolic(val, \ 1407 { RPC_AUTH_NULL, "none" }, \ 1408 { RPC_AUTH_UNIX, "sys" }, \ 1409 { RPC_AUTH_GSS, "gss" }, \ 1410 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1411 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1412 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1413 1414 TRACE_EVENT(nfsd_cb_setup, 1415 TP_PROTO(const struct nfs4_client *clp, 1416 const char *netid, 1417 rpc_authflavor_t authflavor 1418 ), 1419 TP_ARGS(clp, netid, authflavor), 1420 TP_STRUCT__entry( 1421 __field(u32, cl_boot) 1422 __field(u32, cl_id) 1423 __field(unsigned long, authflavor) 1424 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1425 __array(unsigned char, netid, 8) 1426 ), 1427 TP_fast_assign( 1428 __entry->cl_boot = clp->cl_clientid.cl_boot; 1429 __entry->cl_id = clp->cl_clientid.cl_id; 1430 strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 1431 __entry->authflavor = authflavor; 1432 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1433 clp->cl_cb_conn.cb_addrlen) 1434 ), 1435 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1436 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1437 __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 1438 ); 1439 1440 TRACE_EVENT(nfsd_cb_setup_err, 1441 TP_PROTO( 1442 const struct nfs4_client *clp, 1443 long error 1444 ), 1445 TP_ARGS(clp, error), 1446 TP_STRUCT__entry( 1447 __field(long, error) 1448 __field(u32, cl_boot) 1449 __field(u32, cl_id) 1450 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1451 ), 1452 TP_fast_assign( 1453 __entry->error = error; 1454 __entry->cl_boot = clp->cl_clientid.cl_boot; 1455 __entry->cl_id = clp->cl_clientid.cl_id; 1456 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1457 clp->cl_cb_conn.cb_addrlen) 1458 ), 1459 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1460 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1461 __entry->error) 1462 ); 1463 1464 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1465 TP_PROTO( 1466 const struct nfs4_stid *stid 1467 ), 1468 TP_ARGS(stid), 1469 TP_CONDITION(stid->sc_client), 1470 TP_STRUCT__entry( 1471 __field(u32, cl_boot) 1472 __field(u32, cl_id) 1473 __field(u32, si_id) 1474 __field(u32, si_generation) 1475 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1476 ), 1477 TP_fast_assign( 1478 const stateid_t *stp = &stid->sc_stateid; 1479 const struct nfs4_client *clp = stid->sc_client; 1480 1481 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1482 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1483 __entry->si_id = stp->si_opaque.so_id; 1484 __entry->si_generation = stp->si_generation; 1485 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1486 clp->cl_cb_conn.cb_addrlen) 1487 ), 1488 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1489 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1490 __entry->si_id, __entry->si_generation) 1491 ); 1492 1493 TRACE_EVENT(nfsd_cb_notify_lock, 1494 TP_PROTO( 1495 const struct nfs4_lockowner *lo, 1496 const struct nfsd4_blocked_lock *nbl 1497 ), 1498 TP_ARGS(lo, nbl), 1499 TP_STRUCT__entry( 1500 __field(u32, cl_boot) 1501 __field(u32, cl_id) 1502 __field(u32, fh_hash) 1503 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1504 ), 1505 TP_fast_assign( 1506 const struct nfs4_client *clp = lo->lo_owner.so_client; 1507 1508 __entry->cl_boot = clp->cl_clientid.cl_boot; 1509 __entry->cl_id = clp->cl_clientid.cl_id; 1510 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1511 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1512 clp->cl_cb_conn.cb_addrlen) 1513 ), 1514 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1515 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1516 __entry->fh_hash) 1517 ); 1518 1519 TRACE_EVENT(nfsd_cb_offload, 1520 TP_PROTO( 1521 const struct nfs4_client *clp, 1522 const stateid_t *stp, 1523 const struct knfsd_fh *fh, 1524 u64 count, 1525 __be32 status 1526 ), 1527 TP_ARGS(clp, stp, fh, count, status), 1528 TP_STRUCT__entry( 1529 __field(u32, cl_boot) 1530 __field(u32, cl_id) 1531 __field(u32, si_id) 1532 __field(u32, si_generation) 1533 __field(u32, fh_hash) 1534 __field(int, status) 1535 __field(u64, count) 1536 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 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->fh_hash = knfsd_fh_hash(fh); 1544 __entry->status = be32_to_cpu(status); 1545 __entry->count = count; 1546 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1547 clp->cl_cb_conn.cb_addrlen) 1548 ), 1549 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1550 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1551 __entry->si_id, __entry->si_generation, 1552 __entry->fh_hash, __entry->count, __entry->status) 1553 ); 1554 1555 TRACE_EVENT(nfsd_cb_recall_any, 1556 TP_PROTO( 1557 const struct nfsd4_cb_recall_any *ra 1558 ), 1559 TP_ARGS(ra), 1560 TP_STRUCT__entry( 1561 __field(u32, cl_boot) 1562 __field(u32, cl_id) 1563 __field(u32, keep) 1564 __field(unsigned long, bmval0) 1565 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen) 1566 ), 1567 TP_fast_assign( 1568 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot; 1569 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id; 1570 __entry->keep = ra->ra_keep; 1571 __entry->bmval0 = ra->ra_bmval[0]; 1572 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr, 1573 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen); 1574 ), 1575 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s", 1576 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1577 __entry->keep, show_rca_mask(__entry->bmval0) 1578 ) 1579 ); 1580 1581 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1582 TP_PROTO( 1583 const stateid_t *stp, 1584 const struct rpc_task *task 1585 ), 1586 TP_ARGS(stp, task), 1587 TP_STRUCT__entry( 1588 __field(u32, cl_boot) 1589 __field(u32, cl_id) 1590 __field(u32, si_id) 1591 __field(u32, si_generation) 1592 __field(int, status) 1593 ), 1594 TP_fast_assign( 1595 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1596 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1597 __entry->si_id = stp->si_opaque.so_id; 1598 __entry->si_generation = stp->si_generation; 1599 __entry->status = task->tk_status; 1600 ), 1601 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1602 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1603 __entry->si_generation, __entry->status 1604 ) 1605 ); 1606 1607 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1608 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1609 TP_PROTO( \ 1610 const stateid_t *stp, \ 1611 const struct rpc_task *task \ 1612 ), \ 1613 TP_ARGS(stp, task)) 1614 1615 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1616 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1617 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1618 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1619 1620 TRACE_EVENT(nfsd_cb_recall_any_done, 1621 TP_PROTO( 1622 const struct nfsd4_callback *cb, 1623 const struct rpc_task *task 1624 ), 1625 TP_ARGS(cb, task), 1626 TP_STRUCT__entry( 1627 __field(u32, cl_boot) 1628 __field(u32, cl_id) 1629 __field(int, status) 1630 ), 1631 TP_fast_assign( 1632 __entry->status = task->tk_status; 1633 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot; 1634 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id; 1635 ), 1636 TP_printk("client %08x:%08x status=%d", 1637 __entry->cl_boot, __entry->cl_id, __entry->status 1638 ) 1639 ); 1640 1641 #endif /* _NFSD_TRACE_H */ 1642 1643 #undef TRACE_INCLUDE_PATH 1644 #define TRACE_INCLUDE_PATH . 1645 #define TRACE_INCLUDE_FILE trace 1646 #include <trace/define_trace.h> 1647