1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (c) 2014 Christoph Hellwig. 4 */ 5 #undef TRACE_SYSTEM 6 #define TRACE_SYSTEM nfsd 7 8 #if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) 9 #define _NFSD_TRACE_H 10 11 #include <linux/tracepoint.h> 12 13 #include "export.h" 14 #include "nfsfh.h" 15 16 #define NFSD_TRACE_PROC_RES_FIELDS \ 17 __field(unsigned int, netns_ino) \ 18 __field(u32, xid) \ 19 __field(unsigned long, status) \ 20 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \ 21 __array(unsigned char, client, sizeof(struct sockaddr_in6)) 22 23 #define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \ 24 do { \ 25 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \ 26 __entry->xid = be32_to_cpu(rqstp->rq_xid); \ 27 __entry->status = be32_to_cpu(error); \ 28 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \ 29 rqstp->rq_xprt->xpt_locallen); \ 30 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \ 31 rqstp->rq_xprt->xpt_remotelen); \ 32 } while (0); 33 34 DECLARE_EVENT_CLASS(nfsd_xdr_err_class, 35 TP_PROTO( 36 const struct svc_rqst *rqstp 37 ), 38 TP_ARGS(rqstp), 39 TP_STRUCT__entry( 40 __field(unsigned int, netns_ino) 41 __field(u32, xid) 42 __field(u32, vers) 43 __field(u32, proc) 44 __sockaddr(server, rqstp->rq_xprt->xpt_locallen) 45 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 46 ), 47 TP_fast_assign( 48 const struct svc_xprt *xprt = rqstp->rq_xprt; 49 50 __entry->netns_ino = xprt->xpt_net->ns.inum; 51 __entry->xid = be32_to_cpu(rqstp->rq_xid); 52 __entry->vers = rqstp->rq_vers; 53 __entry->proc = rqstp->rq_proc; 54 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen); 55 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen); 56 ), 57 TP_printk("xid=0x%08x vers=%u proc=%u", 58 __entry->xid, __entry->vers, __entry->proc 59 ) 60 ); 61 62 #define DEFINE_NFSD_XDR_ERR_EVENT(name) \ 63 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \ 64 TP_PROTO(const struct svc_rqst *rqstp), \ 65 TP_ARGS(rqstp)) 66 67 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args); 68 DEFINE_NFSD_XDR_ERR_EVENT(cant_encode); 69 70 #define show_nfsd_may_flags(x) \ 71 __print_flags(x, "|", \ 72 { NFSD_MAY_EXEC, "EXEC" }, \ 73 { NFSD_MAY_WRITE, "WRITE" }, \ 74 { NFSD_MAY_READ, "READ" }, \ 75 { NFSD_MAY_SATTR, "SATTR" }, \ 76 { NFSD_MAY_TRUNC, "TRUNC" }, \ 77 { NFSD_MAY_LOCK, "LOCK" }, \ 78 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \ 79 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \ 80 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \ 81 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \ 82 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \ 83 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \ 84 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" }) 85 86 TRACE_EVENT(nfsd_compound, 87 TP_PROTO( 88 const struct svc_rqst *rqst, 89 const char *tag, 90 u32 taglen, 91 u32 opcnt 92 ), 93 TP_ARGS(rqst, tag, taglen, opcnt), 94 TP_STRUCT__entry( 95 __field(u32, xid) 96 __field(u32, opcnt) 97 __string_len(tag, tag, taglen) 98 ), 99 TP_fast_assign( 100 __entry->xid = be32_to_cpu(rqst->rq_xid); 101 __entry->opcnt = opcnt; 102 __assign_str_len(tag, tag, taglen); 103 ), 104 TP_printk("xid=0x%08x opcnt=%u tag=%s", 105 __entry->xid, __entry->opcnt, __get_str(tag) 106 ) 107 ) 108 109 TRACE_EVENT(nfsd_compound_status, 110 TP_PROTO(u32 args_opcnt, 111 u32 resp_opcnt, 112 __be32 status, 113 const char *name), 114 TP_ARGS(args_opcnt, resp_opcnt, status, name), 115 TP_STRUCT__entry( 116 __field(u32, args_opcnt) 117 __field(u32, resp_opcnt) 118 __field(int, status) 119 __string(name, name) 120 ), 121 TP_fast_assign( 122 __entry->args_opcnt = args_opcnt; 123 __entry->resp_opcnt = resp_opcnt; 124 __entry->status = be32_to_cpu(status); 125 __assign_str(name, name); 126 ), 127 TP_printk("op=%u/%u %s status=%d", 128 __entry->resp_opcnt, __entry->args_opcnt, 129 __get_str(name), __entry->status) 130 ) 131 132 TRACE_EVENT(nfsd_compound_decode_err, 133 TP_PROTO( 134 const struct svc_rqst *rqstp, 135 u32 args_opcnt, 136 u32 resp_opcnt, 137 u32 opnum, 138 __be32 status 139 ), 140 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status), 141 TP_STRUCT__entry( 142 NFSD_TRACE_PROC_RES_FIELDS 143 144 __field(u32, args_opcnt) 145 __field(u32, resp_opcnt) 146 __field(u32, opnum) 147 ), 148 TP_fast_assign( 149 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 150 151 __entry->args_opcnt = args_opcnt; 152 __entry->resp_opcnt = resp_opcnt; 153 __entry->opnum = opnum; 154 ), 155 TP_printk("op=%u/%u opnum=%u status=%lu", 156 __entry->resp_opcnt, __entry->args_opcnt, 157 __entry->opnum, __entry->status) 158 ); 159 160 TRACE_EVENT(nfsd_compound_encode_err, 161 TP_PROTO( 162 const struct svc_rqst *rqstp, 163 u32 opnum, 164 __be32 status 165 ), 166 TP_ARGS(rqstp, opnum, status), 167 TP_STRUCT__entry( 168 NFSD_TRACE_PROC_RES_FIELDS 169 170 __field(u32, opnum) 171 ), 172 TP_fast_assign( 173 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status) 174 175 __entry->opnum = opnum; 176 ), 177 TP_printk("opnum=%u status=%lu", 178 __entry->opnum, __entry->status) 179 ); 180 181 #define show_fs_file_type(x) \ 182 __print_symbolic(x, \ 183 { S_IFLNK, "LNK" }, \ 184 { S_IFREG, "REG" }, \ 185 { S_IFDIR, "DIR" }, \ 186 { S_IFCHR, "CHR" }, \ 187 { S_IFBLK, "BLK" }, \ 188 { S_IFIFO, "FIFO" }, \ 189 { S_IFSOCK, "SOCK" }) 190 191 TRACE_EVENT(nfsd_fh_verify, 192 TP_PROTO( 193 const struct svc_rqst *rqstp, 194 const struct svc_fh *fhp, 195 umode_t type, 196 int access 197 ), 198 TP_ARGS(rqstp, fhp, type, access), 199 TP_STRUCT__entry( 200 __field(unsigned int, netns_ino) 201 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 202 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 203 __field(u32, xid) 204 __field(u32, fh_hash) 205 __field(const void *, inode) 206 __field(unsigned long, type) 207 __field(unsigned long, access) 208 ), 209 TP_fast_assign( 210 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 211 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 212 rqstp->rq_xprt->xpt_locallen); 213 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 214 rqstp->rq_xprt->xpt_remotelen); 215 __entry->xid = be32_to_cpu(rqstp->rq_xid); 216 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 217 __entry->inode = d_inode(fhp->fh_dentry); 218 __entry->type = type; 219 __entry->access = access; 220 ), 221 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s", 222 __entry->xid, __entry->fh_hash, 223 show_fs_file_type(__entry->type), 224 show_nfsd_may_flags(__entry->access) 225 ) 226 ); 227 228 TRACE_EVENT_CONDITION(nfsd_fh_verify_err, 229 TP_PROTO( 230 const struct svc_rqst *rqstp, 231 const struct svc_fh *fhp, 232 umode_t type, 233 int access, 234 __be32 error 235 ), 236 TP_ARGS(rqstp, fhp, type, access, error), 237 TP_CONDITION(error), 238 TP_STRUCT__entry( 239 __field(unsigned int, netns_ino) 240 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen) 241 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen) 242 __field(u32, xid) 243 __field(u32, fh_hash) 244 __field(const void *, inode) 245 __field(unsigned long, type) 246 __field(unsigned long, access) 247 __field(int, error) 248 ), 249 TP_fast_assign( 250 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; 251 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local, 252 rqstp->rq_xprt->xpt_locallen); 253 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote, 254 rqstp->rq_xprt->xpt_remotelen); 255 __entry->xid = be32_to_cpu(rqstp->rq_xid); 256 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 257 __entry->inode = d_inode(fhp->fh_dentry); 258 __entry->type = type; 259 __entry->access = access; 260 __entry->error = be32_to_cpu(error); 261 ), 262 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 263 __entry->xid, __entry->fh_hash, 264 show_fs_file_type(__entry->type), 265 show_nfsd_may_flags(__entry->access), 266 __entry->error 267 ) 268 ); 269 270 DECLARE_EVENT_CLASS(nfsd_fh_err_class, 271 TP_PROTO(struct svc_rqst *rqstp, 272 struct svc_fh *fhp, 273 int status), 274 TP_ARGS(rqstp, fhp, status), 275 TP_STRUCT__entry( 276 __field(u32, xid) 277 __field(u32, fh_hash) 278 __field(int, status) 279 ), 280 TP_fast_assign( 281 __entry->xid = be32_to_cpu(rqstp->rq_xid); 282 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 283 __entry->status = status; 284 ), 285 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 286 __entry->xid, __entry->fh_hash, 287 __entry->status) 288 ) 289 290 #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 291 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 292 TP_PROTO(struct svc_rqst *rqstp, \ 293 struct svc_fh *fhp, \ 294 int status), \ 295 TP_ARGS(rqstp, fhp, status)) 296 297 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 298 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 299 300 TRACE_EVENT(nfsd_exp_find_key, 301 TP_PROTO(const struct svc_expkey *key, 302 int status), 303 TP_ARGS(key, status), 304 TP_STRUCT__entry( 305 __field(int, fsidtype) 306 __array(u32, fsid, 6) 307 __string(auth_domain, key->ek_client->name) 308 __field(int, status) 309 ), 310 TP_fast_assign( 311 __entry->fsidtype = key->ek_fsidtype; 312 memcpy(__entry->fsid, key->ek_fsid, 4*6); 313 __assign_str(auth_domain, key->ek_client->name); 314 __entry->status = status; 315 ), 316 TP_printk("fsid=%x::%s domain=%s status=%d", 317 __entry->fsidtype, 318 __print_array(__entry->fsid, 6, 4), 319 __get_str(auth_domain), 320 __entry->status 321 ) 322 ); 323 324 TRACE_EVENT(nfsd_expkey_update, 325 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 326 TP_ARGS(key, exp_path), 327 TP_STRUCT__entry( 328 __field(int, fsidtype) 329 __array(u32, fsid, 6) 330 __string(auth_domain, key->ek_client->name) 331 __string(path, exp_path) 332 __field(bool, cache) 333 ), 334 TP_fast_assign( 335 __entry->fsidtype = key->ek_fsidtype; 336 memcpy(__entry->fsid, key->ek_fsid, 4*6); 337 __assign_str(auth_domain, key->ek_client->name); 338 __assign_str(path, exp_path); 339 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 340 ), 341 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 342 __entry->fsidtype, 343 __print_array(__entry->fsid, 6, 4), 344 __get_str(auth_domain), 345 __get_str(path), 346 __entry->cache ? "pos" : "neg" 347 ) 348 ); 349 350 TRACE_EVENT(nfsd_exp_get_by_name, 351 TP_PROTO(const struct svc_export *key, 352 int status), 353 TP_ARGS(key, status), 354 TP_STRUCT__entry( 355 __string(path, key->ex_path.dentry->d_name.name) 356 __string(auth_domain, key->ex_client->name) 357 __field(int, status) 358 ), 359 TP_fast_assign( 360 __assign_str(path, key->ex_path.dentry->d_name.name); 361 __assign_str(auth_domain, key->ex_client->name); 362 __entry->status = status; 363 ), 364 TP_printk("path=%s domain=%s status=%d", 365 __get_str(path), 366 __get_str(auth_domain), 367 __entry->status 368 ) 369 ); 370 371 TRACE_EVENT(nfsd_export_update, 372 TP_PROTO(const struct svc_export *key), 373 TP_ARGS(key), 374 TP_STRUCT__entry( 375 __string(path, key->ex_path.dentry->d_name.name) 376 __string(auth_domain, key->ex_client->name) 377 __field(bool, cache) 378 ), 379 TP_fast_assign( 380 __assign_str(path, key->ex_path.dentry->d_name.name); 381 __assign_str(auth_domain, key->ex_client->name); 382 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 383 ), 384 TP_printk("path=%s domain=%s cache=%s", 385 __get_str(path), 386 __get_str(auth_domain), 387 __entry->cache ? "pos" : "neg" 388 ) 389 ); 390 391 DECLARE_EVENT_CLASS(nfsd_io_class, 392 TP_PROTO(struct svc_rqst *rqstp, 393 struct svc_fh *fhp, 394 u64 offset, 395 u32 len), 396 TP_ARGS(rqstp, fhp, offset, len), 397 TP_STRUCT__entry( 398 __field(u32, xid) 399 __field(u32, fh_hash) 400 __field(u64, offset) 401 __field(u32, len) 402 ), 403 TP_fast_assign( 404 __entry->xid = be32_to_cpu(rqstp->rq_xid); 405 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 406 __entry->offset = offset; 407 __entry->len = len; 408 ), 409 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 410 __entry->xid, __entry->fh_hash, 411 __entry->offset, __entry->len) 412 ) 413 414 #define DEFINE_NFSD_IO_EVENT(name) \ 415 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 416 TP_PROTO(struct svc_rqst *rqstp, \ 417 struct svc_fh *fhp, \ 418 u64 offset, \ 419 u32 len), \ 420 TP_ARGS(rqstp, fhp, offset, len)) 421 422 DEFINE_NFSD_IO_EVENT(read_start); 423 DEFINE_NFSD_IO_EVENT(read_splice); 424 DEFINE_NFSD_IO_EVENT(read_vector); 425 DEFINE_NFSD_IO_EVENT(read_io_done); 426 DEFINE_NFSD_IO_EVENT(read_done); 427 DEFINE_NFSD_IO_EVENT(write_start); 428 DEFINE_NFSD_IO_EVENT(write_opened); 429 DEFINE_NFSD_IO_EVENT(write_io_done); 430 DEFINE_NFSD_IO_EVENT(write_done); 431 432 DECLARE_EVENT_CLASS(nfsd_err_class, 433 TP_PROTO(struct svc_rqst *rqstp, 434 struct svc_fh *fhp, 435 loff_t offset, 436 int status), 437 TP_ARGS(rqstp, fhp, offset, status), 438 TP_STRUCT__entry( 439 __field(u32, xid) 440 __field(u32, fh_hash) 441 __field(loff_t, offset) 442 __field(int, status) 443 ), 444 TP_fast_assign( 445 __entry->xid = be32_to_cpu(rqstp->rq_xid); 446 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 447 __entry->offset = offset; 448 __entry->status = status; 449 ), 450 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 451 __entry->xid, __entry->fh_hash, 452 __entry->offset, __entry->status) 453 ) 454 455 #define DEFINE_NFSD_ERR_EVENT(name) \ 456 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 457 TP_PROTO(struct svc_rqst *rqstp, \ 458 struct svc_fh *fhp, \ 459 loff_t offset, \ 460 int len), \ 461 TP_ARGS(rqstp, fhp, offset, len)) 462 463 DEFINE_NFSD_ERR_EVENT(read_err); 464 DEFINE_NFSD_ERR_EVENT(write_err); 465 466 TRACE_EVENT(nfsd_dirent, 467 TP_PROTO(struct svc_fh *fhp, 468 u64 ino, 469 const char *name, 470 int namlen), 471 TP_ARGS(fhp, ino, name, namlen), 472 TP_STRUCT__entry( 473 __field(u32, fh_hash) 474 __field(u64, ino) 475 __string_len(name, name, namlen) 476 ), 477 TP_fast_assign( 478 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 479 __entry->ino = ino; 480 __assign_str_len(name, name, namlen) 481 ), 482 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 483 __entry->fh_hash, __entry->ino, __get_str(name) 484 ) 485 ) 486 487 DECLARE_EVENT_CLASS(nfsd_copy_err_class, 488 TP_PROTO(struct svc_rqst *rqstp, 489 struct svc_fh *src_fhp, 490 loff_t src_offset, 491 struct svc_fh *dst_fhp, 492 loff_t dst_offset, 493 u64 count, 494 int status), 495 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 496 TP_STRUCT__entry( 497 __field(u32, xid) 498 __field(u32, src_fh_hash) 499 __field(loff_t, src_offset) 500 __field(u32, dst_fh_hash) 501 __field(loff_t, dst_offset) 502 __field(u64, count) 503 __field(int, status) 504 ), 505 TP_fast_assign( 506 __entry->xid = be32_to_cpu(rqstp->rq_xid); 507 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 508 __entry->src_offset = src_offset; 509 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 510 __entry->dst_offset = dst_offset; 511 __entry->count = count; 512 __entry->status = status; 513 ), 514 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 515 "dst_fh_hash=0x%08x dst_offset=%lld " 516 "count=%llu status=%d", 517 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 518 __entry->dst_fh_hash, __entry->dst_offset, 519 (unsigned long long)__entry->count, 520 __entry->status) 521 ) 522 523 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 524 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 525 TP_PROTO(struct svc_rqst *rqstp, \ 526 struct svc_fh *src_fhp, \ 527 loff_t src_offset, \ 528 struct svc_fh *dst_fhp, \ 529 loff_t dst_offset, \ 530 u64 count, \ 531 int status), \ 532 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 533 count, status)) 534 535 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 536 537 #include "state.h" 538 #include "filecache.h" 539 #include "vfs.h" 540 541 TRACE_EVENT(nfsd_delegret_wakeup, 542 TP_PROTO( 543 const struct svc_rqst *rqstp, 544 const struct inode *inode, 545 long timeo 546 ), 547 TP_ARGS(rqstp, inode, timeo), 548 TP_STRUCT__entry( 549 __field(u32, xid) 550 __field(const void *, inode) 551 __field(long, timeo) 552 ), 553 TP_fast_assign( 554 __entry->xid = be32_to_cpu(rqstp->rq_xid); 555 __entry->inode = inode; 556 __entry->timeo = timeo; 557 ), 558 TP_printk("xid=0x%08x inode=%p%s", 559 __entry->xid, __entry->inode, 560 __entry->timeo == 0 ? " (timed out)" : "" 561 ) 562 ); 563 564 DECLARE_EVENT_CLASS(nfsd_stateid_class, 565 TP_PROTO(stateid_t *stp), 566 TP_ARGS(stp), 567 TP_STRUCT__entry( 568 __field(u32, cl_boot) 569 __field(u32, cl_id) 570 __field(u32, si_id) 571 __field(u32, si_generation) 572 ), 573 TP_fast_assign( 574 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 575 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 576 __entry->si_id = stp->si_opaque.so_id; 577 __entry->si_generation = stp->si_generation; 578 ), 579 TP_printk("client %08x:%08x stateid %08x:%08x", 580 __entry->cl_boot, 581 __entry->cl_id, 582 __entry->si_id, 583 __entry->si_generation) 584 ) 585 586 #define DEFINE_STATEID_EVENT(name) \ 587 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 588 TP_PROTO(stateid_t *stp), \ 589 TP_ARGS(stp)) 590 591 DEFINE_STATEID_EVENT(layoutstate_alloc); 592 DEFINE_STATEID_EVENT(layoutstate_unhash); 593 DEFINE_STATEID_EVENT(layoutstate_free); 594 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 595 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 596 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 597 DEFINE_STATEID_EVENT(layout_recall); 598 DEFINE_STATEID_EVENT(layout_recall_done); 599 DEFINE_STATEID_EVENT(layout_recall_fail); 600 DEFINE_STATEID_EVENT(layout_recall_release); 601 602 DEFINE_STATEID_EVENT(open); 603 DEFINE_STATEID_EVENT(deleg_read); 604 DEFINE_STATEID_EVENT(deleg_recall); 605 606 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 607 TP_PROTO(u32 seqid, const stateid_t *stp), 608 TP_ARGS(seqid, stp), 609 TP_STRUCT__entry( 610 __field(u32, seqid) 611 __field(u32, cl_boot) 612 __field(u32, cl_id) 613 __field(u32, si_id) 614 __field(u32, si_generation) 615 ), 616 TP_fast_assign( 617 __entry->seqid = seqid; 618 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 619 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 620 __entry->si_id = stp->si_opaque.so_id; 621 __entry->si_generation = stp->si_generation; 622 ), 623 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 624 __entry->seqid, __entry->cl_boot, __entry->cl_id, 625 __entry->si_id, __entry->si_generation) 626 ) 627 628 #define DEFINE_STATESEQID_EVENT(name) \ 629 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 630 TP_PROTO(u32 seqid, const stateid_t *stp), \ 631 TP_ARGS(seqid, stp)) 632 633 DEFINE_STATESEQID_EVENT(preprocess); 634 DEFINE_STATESEQID_EVENT(open_confirm); 635 636 DECLARE_EVENT_CLASS(nfsd_clientid_class, 637 TP_PROTO(const clientid_t *clid), 638 TP_ARGS(clid), 639 TP_STRUCT__entry( 640 __field(u32, cl_boot) 641 __field(u32, cl_id) 642 ), 643 TP_fast_assign( 644 __entry->cl_boot = clid->cl_boot; 645 __entry->cl_id = clid->cl_id; 646 ), 647 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 648 ) 649 650 #define DEFINE_CLIENTID_EVENT(name) \ 651 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 652 TP_PROTO(const clientid_t *clid), \ 653 TP_ARGS(clid)) 654 655 DEFINE_CLIENTID_EVENT(expire_unconf); 656 DEFINE_CLIENTID_EVENT(reclaim_complete); 657 DEFINE_CLIENTID_EVENT(confirmed); 658 DEFINE_CLIENTID_EVENT(destroyed); 659 DEFINE_CLIENTID_EVENT(admin_expired); 660 DEFINE_CLIENTID_EVENT(replaced); 661 DEFINE_CLIENTID_EVENT(purged); 662 DEFINE_CLIENTID_EVENT(renew); 663 DEFINE_CLIENTID_EVENT(stale); 664 665 DECLARE_EVENT_CLASS(nfsd_net_class, 666 TP_PROTO(const struct nfsd_net *nn), 667 TP_ARGS(nn), 668 TP_STRUCT__entry( 669 __field(unsigned long long, boot_time) 670 ), 671 TP_fast_assign( 672 __entry->boot_time = nn->boot_time; 673 ), 674 TP_printk("boot_time=%16llx", __entry->boot_time) 675 ) 676 677 #define DEFINE_NET_EVENT(name) \ 678 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 679 TP_PROTO(const struct nfsd_net *nn), \ 680 TP_ARGS(nn)) 681 682 DEFINE_NET_EVENT(grace_start); 683 DEFINE_NET_EVENT(grace_complete); 684 685 TRACE_EVENT(nfsd_writeverf_reset, 686 TP_PROTO( 687 const struct nfsd_net *nn, 688 const struct svc_rqst *rqstp, 689 int error 690 ), 691 TP_ARGS(nn, rqstp, error), 692 TP_STRUCT__entry( 693 __field(unsigned long long, boot_time) 694 __field(u32, xid) 695 __field(int, error) 696 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 697 ), 698 TP_fast_assign( 699 __entry->boot_time = nn->boot_time; 700 __entry->xid = be32_to_cpu(rqstp->rq_xid); 701 __entry->error = error; 702 703 /* avoid seqlock inside TP_fast_assign */ 704 memcpy(__entry->verifier, nn->writeverf, 705 NFS4_VERIFIER_SIZE); 706 ), 707 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 708 __entry->boot_time, __entry->xid, __entry->error, 709 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 710 ) 711 ); 712 713 TRACE_EVENT(nfsd_clid_cred_mismatch, 714 TP_PROTO( 715 const struct nfs4_client *clp, 716 const struct svc_rqst *rqstp 717 ), 718 TP_ARGS(clp, rqstp), 719 TP_STRUCT__entry( 720 __field(u32, cl_boot) 721 __field(u32, cl_id) 722 __field(unsigned long, cl_flavor) 723 __field(unsigned long, new_flavor) 724 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 725 ), 726 TP_fast_assign( 727 __entry->cl_boot = clp->cl_clientid.cl_boot; 728 __entry->cl_id = clp->cl_clientid.cl_id; 729 __entry->cl_flavor = clp->cl_cred.cr_flavor; 730 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 731 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 732 rqstp->rq_xprt->xpt_remotelen); 733 ), 734 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 735 __entry->cl_boot, __entry->cl_id, 736 show_nfsd_authflavor(__entry->cl_flavor), 737 show_nfsd_authflavor(__entry->new_flavor), 738 __get_sockaddr(addr) 739 ) 740 ) 741 742 TRACE_EVENT(nfsd_clid_verf_mismatch, 743 TP_PROTO( 744 const struct nfs4_client *clp, 745 const struct svc_rqst *rqstp, 746 const nfs4_verifier *verf 747 ), 748 TP_ARGS(clp, rqstp, verf), 749 TP_STRUCT__entry( 750 __field(u32, cl_boot) 751 __field(u32, cl_id) 752 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 753 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 754 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 755 ), 756 TP_fast_assign( 757 __entry->cl_boot = clp->cl_clientid.cl_boot; 758 __entry->cl_id = clp->cl_clientid.cl_id; 759 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 760 NFS4_VERIFIER_SIZE); 761 memcpy(__entry->new_verifier, (void *)verf, 762 NFS4_VERIFIER_SIZE); 763 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 764 rqstp->rq_xprt->xpt_remotelen); 765 ), 766 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 767 __entry->cl_boot, __entry->cl_id, 768 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 769 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 770 __get_sockaddr(addr) 771 ) 772 ); 773 774 DECLARE_EVENT_CLASS(nfsd_clid_class, 775 TP_PROTO(const struct nfs4_client *clp), 776 TP_ARGS(clp), 777 TP_STRUCT__entry( 778 __field(u32, cl_boot) 779 __field(u32, cl_id) 780 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 781 __field(unsigned long, flavor) 782 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 783 __string_len(name, name, clp->cl_name.len) 784 ), 785 TP_fast_assign( 786 __entry->cl_boot = clp->cl_clientid.cl_boot; 787 __entry->cl_id = clp->cl_clientid.cl_id; 788 memcpy(__entry->addr, &clp->cl_addr, 789 sizeof(struct sockaddr_in6)); 790 __entry->flavor = clp->cl_cred.cr_flavor; 791 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 792 NFS4_VERIFIER_SIZE); 793 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 794 ), 795 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 796 __entry->addr, __get_str(name), 797 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 798 show_nfsd_authflavor(__entry->flavor), 799 __entry->cl_boot, __entry->cl_id) 800 ); 801 802 #define DEFINE_CLID_EVENT(name) \ 803 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 804 TP_PROTO(const struct nfs4_client *clp), \ 805 TP_ARGS(clp)) 806 807 DEFINE_CLID_EVENT(fresh); 808 DEFINE_CLID_EVENT(confirmed_r); 809 810 /* 811 * from fs/nfsd/filecache.h 812 */ 813 #define show_nf_flags(val) \ 814 __print_flags(val, "|", \ 815 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 816 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 817 { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}) 818 819 DECLARE_EVENT_CLASS(nfsd_file_class, 820 TP_PROTO(struct nfsd_file *nf), 821 TP_ARGS(nf), 822 TP_STRUCT__entry( 823 __field(void *, nf_inode) 824 __field(int, nf_ref) 825 __field(unsigned long, nf_flags) 826 __field(unsigned char, nf_may) 827 __field(struct file *, nf_file) 828 ), 829 TP_fast_assign( 830 __entry->nf_inode = nf->nf_inode; 831 __entry->nf_ref = refcount_read(&nf->nf_ref); 832 __entry->nf_flags = nf->nf_flags; 833 __entry->nf_may = nf->nf_may; 834 __entry->nf_file = nf->nf_file; 835 ), 836 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 837 __entry->nf_inode, 838 __entry->nf_ref, 839 show_nf_flags(__entry->nf_flags), 840 show_nfsd_may_flags(__entry->nf_may), 841 __entry->nf_file) 842 ) 843 844 #define DEFINE_NFSD_FILE_EVENT(name) \ 845 DEFINE_EVENT(nfsd_file_class, name, \ 846 TP_PROTO(struct nfsd_file *nf), \ 847 TP_ARGS(nf)) 848 849 DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 850 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 851 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 852 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_dispose); 853 854 TRACE_EVENT(nfsd_file_alloc, 855 TP_PROTO( 856 const struct nfsd_file *nf 857 ), 858 TP_ARGS(nf), 859 TP_STRUCT__entry( 860 __field(const void *, nf_inode) 861 __field(unsigned long, nf_flags) 862 __field(unsigned long, nf_may) 863 __field(unsigned int, nf_ref) 864 ), 865 TP_fast_assign( 866 __entry->nf_inode = nf->nf_inode; 867 __entry->nf_flags = nf->nf_flags; 868 __entry->nf_ref = refcount_read(&nf->nf_ref); 869 __entry->nf_may = nf->nf_may; 870 ), 871 TP_printk("inode=%p ref=%u flags=%s may=%s", 872 __entry->nf_inode, __entry->nf_ref, 873 show_nf_flags(__entry->nf_flags), 874 show_nfsd_may_flags(__entry->nf_may) 875 ) 876 ); 877 878 TRACE_EVENT(nfsd_file_acquire, 879 TP_PROTO( 880 const struct svc_rqst *rqstp, 881 const struct inode *inode, 882 unsigned int may_flags, 883 const struct nfsd_file *nf, 884 __be32 status 885 ), 886 887 TP_ARGS(rqstp, inode, may_flags, nf, status), 888 889 TP_STRUCT__entry( 890 __field(u32, xid) 891 __field(const void *, inode) 892 __field(unsigned long, may_flags) 893 __field(unsigned int, nf_ref) 894 __field(unsigned long, nf_flags) 895 __field(unsigned long, nf_may) 896 __field(const void *, nf_file) 897 __field(u32, status) 898 ), 899 900 TP_fast_assign( 901 __entry->xid = be32_to_cpu(rqstp->rq_xid); 902 __entry->inode = inode; 903 __entry->may_flags = may_flags; 904 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 905 __entry->nf_flags = nf ? nf->nf_flags : 0; 906 __entry->nf_may = nf ? nf->nf_may : 0; 907 __entry->nf_file = nf ? nf->nf_file : NULL; 908 __entry->status = be32_to_cpu(status); 909 ), 910 911 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 912 __entry->xid, __entry->inode, 913 show_nfsd_may_flags(__entry->may_flags), 914 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 915 show_nfsd_may_flags(__entry->nf_may), 916 __entry->nf_file, __entry->status 917 ) 918 ); 919 920 TRACE_EVENT(nfsd_file_create, 921 TP_PROTO( 922 const struct svc_rqst *rqstp, 923 unsigned int may_flags, 924 const struct nfsd_file *nf 925 ), 926 927 TP_ARGS(rqstp, may_flags, nf), 928 929 TP_STRUCT__entry( 930 __field(const void *, nf_inode) 931 __field(const void *, nf_file) 932 __field(unsigned long, may_flags) 933 __field(unsigned long, nf_flags) 934 __field(unsigned long, nf_may) 935 __field(unsigned int, nf_ref) 936 __field(u32, xid) 937 ), 938 939 TP_fast_assign( 940 __entry->nf_inode = nf->nf_inode; 941 __entry->nf_file = nf->nf_file; 942 __entry->may_flags = may_flags; 943 __entry->nf_flags = nf->nf_flags; 944 __entry->nf_may = nf->nf_may; 945 __entry->nf_ref = refcount_read(&nf->nf_ref); 946 __entry->xid = be32_to_cpu(rqstp->rq_xid); 947 ), 948 949 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 950 __entry->xid, __entry->nf_inode, 951 show_nfsd_may_flags(__entry->may_flags), 952 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 953 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 954 ) 955 ); 956 957 TRACE_EVENT(nfsd_file_insert_err, 958 TP_PROTO( 959 const struct svc_rqst *rqstp, 960 const struct inode *inode, 961 unsigned int may_flags, 962 long error 963 ), 964 TP_ARGS(rqstp, inode, may_flags, error), 965 TP_STRUCT__entry( 966 __field(u32, xid) 967 __field(const void *, inode) 968 __field(unsigned long, may_flags) 969 __field(long, error) 970 ), 971 TP_fast_assign( 972 __entry->xid = be32_to_cpu(rqstp->rq_xid); 973 __entry->inode = inode; 974 __entry->may_flags = may_flags; 975 __entry->error = error; 976 ), 977 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 978 __entry->xid, __entry->inode, 979 show_nfsd_may_flags(__entry->may_flags), 980 __entry->error 981 ) 982 ); 983 984 TRACE_EVENT(nfsd_file_cons_err, 985 TP_PROTO( 986 const struct svc_rqst *rqstp, 987 const struct inode *inode, 988 unsigned int may_flags, 989 const struct nfsd_file *nf 990 ), 991 TP_ARGS(rqstp, inode, may_flags, nf), 992 TP_STRUCT__entry( 993 __field(u32, xid) 994 __field(const void *, inode) 995 __field(unsigned long, may_flags) 996 __field(unsigned int, nf_ref) 997 __field(unsigned long, nf_flags) 998 __field(unsigned long, nf_may) 999 __field(const void *, nf_file) 1000 ), 1001 TP_fast_assign( 1002 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1003 __entry->inode = inode; 1004 __entry->may_flags = may_flags; 1005 __entry->nf_ref = refcount_read(&nf->nf_ref); 1006 __entry->nf_flags = nf->nf_flags; 1007 __entry->nf_may = nf->nf_may; 1008 __entry->nf_file = nf->nf_file; 1009 ), 1010 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1011 __entry->xid, __entry->inode, 1012 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1013 show_nf_flags(__entry->nf_flags), 1014 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1015 ) 1016 ); 1017 1018 TRACE_EVENT(nfsd_file_open, 1019 TP_PROTO(struct nfsd_file *nf, __be32 status), 1020 TP_ARGS(nf, status), 1021 TP_STRUCT__entry( 1022 __field(void *, nf_inode) /* cannot be dereferenced */ 1023 __field(int, nf_ref) 1024 __field(unsigned long, nf_flags) 1025 __field(unsigned long, nf_may) 1026 __field(void *, nf_file) /* cannot be dereferenced */ 1027 ), 1028 TP_fast_assign( 1029 __entry->nf_inode = nf->nf_inode; 1030 __entry->nf_ref = refcount_read(&nf->nf_ref); 1031 __entry->nf_flags = nf->nf_flags; 1032 __entry->nf_may = nf->nf_may; 1033 __entry->nf_file = nf->nf_file; 1034 ), 1035 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1036 __entry->nf_inode, 1037 __entry->nf_ref, 1038 show_nf_flags(__entry->nf_flags), 1039 show_nfsd_may_flags(__entry->nf_may), 1040 __entry->nf_file) 1041 ) 1042 1043 DECLARE_EVENT_CLASS(nfsd_file_search_class, 1044 TP_PROTO( 1045 const struct inode *inode, 1046 unsigned int count 1047 ), 1048 TP_ARGS(inode, count), 1049 TP_STRUCT__entry( 1050 __field(const struct inode *, inode) 1051 __field(unsigned int, count) 1052 ), 1053 TP_fast_assign( 1054 __entry->inode = inode; 1055 __entry->count = count; 1056 ), 1057 TP_printk("inode=%p count=%u", 1058 __entry->inode, __entry->count) 1059 ); 1060 1061 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 1062 DEFINE_EVENT(nfsd_file_search_class, name, \ 1063 TP_PROTO( \ 1064 const struct inode *inode, \ 1065 unsigned int count \ 1066 ), \ 1067 TP_ARGS(inode, count)) 1068 1069 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 1070 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 1071 1072 TRACE_EVENT(nfsd_file_is_cached, 1073 TP_PROTO( 1074 const struct inode *inode, 1075 int found 1076 ), 1077 TP_ARGS(inode, found), 1078 TP_STRUCT__entry( 1079 __field(const struct inode *, inode) 1080 __field(int, found) 1081 ), 1082 TP_fast_assign( 1083 __entry->inode = inode; 1084 __entry->found = found; 1085 ), 1086 TP_printk("inode=%p is %scached", 1087 __entry->inode, 1088 __entry->found ? "" : "not " 1089 ) 1090 ); 1091 1092 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1093 TP_PROTO(struct inode *inode, u32 mask), 1094 TP_ARGS(inode, mask), 1095 TP_STRUCT__entry( 1096 __field(struct inode *, inode) 1097 __field(unsigned int, nlink) 1098 __field(umode_t, mode) 1099 __field(u32, mask) 1100 ), 1101 TP_fast_assign( 1102 __entry->inode = inode; 1103 __entry->nlink = inode->i_nlink; 1104 __entry->mode = inode->i_mode; 1105 __entry->mask = mask; 1106 ), 1107 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1108 __entry->nlink, __entry->mode, __entry->mask) 1109 ); 1110 1111 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1112 TP_PROTO( 1113 const struct nfsd_file *nf 1114 ), 1115 TP_ARGS(nf), 1116 TP_STRUCT__entry( 1117 __field(void *, nf_inode) 1118 __field(void *, nf_file) 1119 __field(int, nf_ref) 1120 __field(unsigned long, nf_flags) 1121 ), 1122 TP_fast_assign( 1123 __entry->nf_inode = nf->nf_inode; 1124 __entry->nf_file = nf->nf_file; 1125 __entry->nf_ref = refcount_read(&nf->nf_ref); 1126 __entry->nf_flags = nf->nf_flags; 1127 ), 1128 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1129 __entry->nf_inode, __entry->nf_ref, 1130 show_nf_flags(__entry->nf_flags), 1131 __entry->nf_file 1132 ) 1133 ); 1134 1135 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1136 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1137 TP_PROTO( \ 1138 const struct nfsd_file *nf \ 1139 ), \ 1140 TP_ARGS(nf)) 1141 1142 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1143 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1144 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1145 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1146 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1147 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1148 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1149 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed); 1150 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1151 1152 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1153 TP_PROTO( 1154 unsigned long removed, 1155 unsigned long remaining 1156 ), 1157 TP_ARGS(removed, remaining), 1158 TP_STRUCT__entry( 1159 __field(unsigned long, removed) 1160 __field(unsigned long, remaining) 1161 ), 1162 TP_fast_assign( 1163 __entry->removed = removed; 1164 __entry->remaining = remaining; 1165 ), 1166 TP_printk("%lu entries removed, %lu remaining", 1167 __entry->removed, __entry->remaining) 1168 ); 1169 1170 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1171 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1172 TP_PROTO( \ 1173 unsigned long removed, \ 1174 unsigned long remaining \ 1175 ), \ 1176 TP_ARGS(removed, remaining)) 1177 1178 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1179 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1180 1181 #include "cache.h" 1182 1183 TRACE_DEFINE_ENUM(RC_DROPIT); 1184 TRACE_DEFINE_ENUM(RC_REPLY); 1185 TRACE_DEFINE_ENUM(RC_DOIT); 1186 1187 #define show_drc_retval(x) \ 1188 __print_symbolic(x, \ 1189 { RC_DROPIT, "DROPIT" }, \ 1190 { RC_REPLY, "REPLY" }, \ 1191 { RC_DOIT, "DOIT" }) 1192 1193 TRACE_EVENT(nfsd_drc_found, 1194 TP_PROTO( 1195 const struct nfsd_net *nn, 1196 const struct svc_rqst *rqstp, 1197 int result 1198 ), 1199 TP_ARGS(nn, rqstp, result), 1200 TP_STRUCT__entry( 1201 __field(unsigned long long, boot_time) 1202 __field(unsigned long, result) 1203 __field(u32, xid) 1204 ), 1205 TP_fast_assign( 1206 __entry->boot_time = nn->boot_time; 1207 __entry->result = result; 1208 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1209 ), 1210 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1211 __entry->boot_time, __entry->xid, 1212 show_drc_retval(__entry->result)) 1213 1214 ); 1215 1216 TRACE_EVENT(nfsd_drc_mismatch, 1217 TP_PROTO( 1218 const struct nfsd_net *nn, 1219 const struct svc_cacherep *key, 1220 const struct svc_cacherep *rp 1221 ), 1222 TP_ARGS(nn, key, rp), 1223 TP_STRUCT__entry( 1224 __field(unsigned long long, boot_time) 1225 __field(u32, xid) 1226 __field(u32, cached) 1227 __field(u32, ingress) 1228 ), 1229 TP_fast_assign( 1230 __entry->boot_time = nn->boot_time; 1231 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1232 __entry->cached = (__force u32)key->c_key.k_csum; 1233 __entry->ingress = (__force u32)rp->c_key.k_csum; 1234 ), 1235 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1236 __entry->boot_time, __entry->xid, __entry->cached, 1237 __entry->ingress) 1238 ); 1239 1240 TRACE_EVENT(nfsd_cb_args, 1241 TP_PROTO( 1242 const struct nfs4_client *clp, 1243 const struct nfs4_cb_conn *conn 1244 ), 1245 TP_ARGS(clp, conn), 1246 TP_STRUCT__entry( 1247 __field(u32, cl_boot) 1248 __field(u32, cl_id) 1249 __field(u32, prog) 1250 __field(u32, ident) 1251 __sockaddr(addr, conn->cb_addrlen) 1252 ), 1253 TP_fast_assign( 1254 __entry->cl_boot = clp->cl_clientid.cl_boot; 1255 __entry->cl_id = clp->cl_clientid.cl_id; 1256 __entry->prog = conn->cb_prog; 1257 __entry->ident = conn->cb_ident; 1258 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1259 ), 1260 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1261 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1262 __entry->prog, __entry->ident) 1263 ); 1264 1265 TRACE_EVENT(nfsd_cb_nodelegs, 1266 TP_PROTO(const struct nfs4_client *clp), 1267 TP_ARGS(clp), 1268 TP_STRUCT__entry( 1269 __field(u32, cl_boot) 1270 __field(u32, cl_id) 1271 ), 1272 TP_fast_assign( 1273 __entry->cl_boot = clp->cl_clientid.cl_boot; 1274 __entry->cl_id = clp->cl_clientid.cl_id; 1275 ), 1276 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1277 ) 1278 1279 #define show_cb_state(val) \ 1280 __print_symbolic(val, \ 1281 { NFSD4_CB_UP, "UP" }, \ 1282 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1283 { NFSD4_CB_DOWN, "DOWN" }, \ 1284 { NFSD4_CB_FAULT, "FAULT"}) 1285 1286 DECLARE_EVENT_CLASS(nfsd_cb_class, 1287 TP_PROTO(const struct nfs4_client *clp), 1288 TP_ARGS(clp), 1289 TP_STRUCT__entry( 1290 __field(unsigned long, state) 1291 __field(u32, cl_boot) 1292 __field(u32, cl_id) 1293 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1294 ), 1295 TP_fast_assign( 1296 __entry->state = clp->cl_cb_state; 1297 __entry->cl_boot = clp->cl_clientid.cl_boot; 1298 __entry->cl_id = clp->cl_clientid.cl_id; 1299 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1300 clp->cl_cb_conn.cb_addrlen) 1301 ), 1302 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1303 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1304 show_cb_state(__entry->state)) 1305 ); 1306 1307 #define DEFINE_NFSD_CB_EVENT(name) \ 1308 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1309 TP_PROTO(const struct nfs4_client *clp), \ 1310 TP_ARGS(clp)) 1311 1312 DEFINE_NFSD_CB_EVENT(state); 1313 DEFINE_NFSD_CB_EVENT(probe); 1314 DEFINE_NFSD_CB_EVENT(lost); 1315 DEFINE_NFSD_CB_EVENT(shutdown); 1316 1317 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1318 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1319 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1320 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1321 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1322 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1323 1324 #define show_nfsd_authflavor(val) \ 1325 __print_symbolic(val, \ 1326 { RPC_AUTH_NULL, "none" }, \ 1327 { RPC_AUTH_UNIX, "sys" }, \ 1328 { RPC_AUTH_GSS, "gss" }, \ 1329 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1330 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1331 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1332 1333 TRACE_EVENT(nfsd_cb_setup, 1334 TP_PROTO(const struct nfs4_client *clp, 1335 const char *netid, 1336 rpc_authflavor_t authflavor 1337 ), 1338 TP_ARGS(clp, netid, authflavor), 1339 TP_STRUCT__entry( 1340 __field(u32, cl_boot) 1341 __field(u32, cl_id) 1342 __field(unsigned long, authflavor) 1343 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1344 __array(unsigned char, netid, 8) 1345 ), 1346 TP_fast_assign( 1347 __entry->cl_boot = clp->cl_clientid.cl_boot; 1348 __entry->cl_id = clp->cl_clientid.cl_id; 1349 strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 1350 __entry->authflavor = authflavor; 1351 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1352 clp->cl_cb_conn.cb_addrlen) 1353 ), 1354 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1355 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1356 __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 1357 ); 1358 1359 TRACE_EVENT(nfsd_cb_setup_err, 1360 TP_PROTO( 1361 const struct nfs4_client *clp, 1362 long error 1363 ), 1364 TP_ARGS(clp, error), 1365 TP_STRUCT__entry( 1366 __field(long, error) 1367 __field(u32, cl_boot) 1368 __field(u32, cl_id) 1369 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1370 ), 1371 TP_fast_assign( 1372 __entry->error = error; 1373 __entry->cl_boot = clp->cl_clientid.cl_boot; 1374 __entry->cl_id = clp->cl_clientid.cl_id; 1375 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1376 clp->cl_cb_conn.cb_addrlen) 1377 ), 1378 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1379 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1380 __entry->error) 1381 ); 1382 1383 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1384 TP_PROTO( 1385 const struct nfs4_stid *stid 1386 ), 1387 TP_ARGS(stid), 1388 TP_CONDITION(stid->sc_client), 1389 TP_STRUCT__entry( 1390 __field(u32, cl_boot) 1391 __field(u32, cl_id) 1392 __field(u32, si_id) 1393 __field(u32, si_generation) 1394 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1395 ), 1396 TP_fast_assign( 1397 const stateid_t *stp = &stid->sc_stateid; 1398 const struct nfs4_client *clp = stid->sc_client; 1399 1400 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1401 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1402 __entry->si_id = stp->si_opaque.so_id; 1403 __entry->si_generation = stp->si_generation; 1404 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1405 clp->cl_cb_conn.cb_addrlen) 1406 ), 1407 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1408 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1409 __entry->si_id, __entry->si_generation) 1410 ); 1411 1412 TRACE_EVENT(nfsd_cb_notify_lock, 1413 TP_PROTO( 1414 const struct nfs4_lockowner *lo, 1415 const struct nfsd4_blocked_lock *nbl 1416 ), 1417 TP_ARGS(lo, nbl), 1418 TP_STRUCT__entry( 1419 __field(u32, cl_boot) 1420 __field(u32, cl_id) 1421 __field(u32, fh_hash) 1422 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1423 ), 1424 TP_fast_assign( 1425 const struct nfs4_client *clp = lo->lo_owner.so_client; 1426 1427 __entry->cl_boot = clp->cl_clientid.cl_boot; 1428 __entry->cl_id = clp->cl_clientid.cl_id; 1429 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1430 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1431 clp->cl_cb_conn.cb_addrlen) 1432 ), 1433 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1434 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1435 __entry->fh_hash) 1436 ); 1437 1438 TRACE_EVENT(nfsd_cb_offload, 1439 TP_PROTO( 1440 const struct nfs4_client *clp, 1441 const stateid_t *stp, 1442 const struct knfsd_fh *fh, 1443 u64 count, 1444 __be32 status 1445 ), 1446 TP_ARGS(clp, stp, fh, count, status), 1447 TP_STRUCT__entry( 1448 __field(u32, cl_boot) 1449 __field(u32, cl_id) 1450 __field(u32, si_id) 1451 __field(u32, si_generation) 1452 __field(u32, fh_hash) 1453 __field(int, status) 1454 __field(u64, count) 1455 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1456 ), 1457 TP_fast_assign( 1458 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1459 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1460 __entry->si_id = stp->si_opaque.so_id; 1461 __entry->si_generation = stp->si_generation; 1462 __entry->fh_hash = knfsd_fh_hash(fh); 1463 __entry->status = be32_to_cpu(status); 1464 __entry->count = count; 1465 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1466 clp->cl_cb_conn.cb_addrlen) 1467 ), 1468 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1469 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1470 __entry->si_id, __entry->si_generation, 1471 __entry->fh_hash, __entry->count, __entry->status) 1472 ); 1473 1474 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1475 TP_PROTO( 1476 const stateid_t *stp, 1477 const struct rpc_task *task 1478 ), 1479 TP_ARGS(stp, task), 1480 TP_STRUCT__entry( 1481 __field(u32, cl_boot) 1482 __field(u32, cl_id) 1483 __field(u32, si_id) 1484 __field(u32, si_generation) 1485 __field(int, status) 1486 ), 1487 TP_fast_assign( 1488 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1489 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1490 __entry->si_id = stp->si_opaque.so_id; 1491 __entry->si_generation = stp->si_generation; 1492 __entry->status = task->tk_status; 1493 ), 1494 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1495 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1496 __entry->si_generation, __entry->status 1497 ) 1498 ); 1499 1500 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1501 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1502 TP_PROTO( \ 1503 const stateid_t *stp, \ 1504 const struct rpc_task *task \ 1505 ), \ 1506 TP_ARGS(stp, task)) 1507 1508 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1509 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1510 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1511 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1512 1513 #endif /* _NFSD_TRACE_H */ 1514 1515 #undef TRACE_INCLUDE_PATH 1516 #define TRACE_INCLUDE_PATH . 1517 #define TRACE_INCLUDE_FILE trace 1518 #include <trace/define_trace.h> 1519