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 if (fhp->fh_dentry) 258 __entry->inode = d_inode(fhp->fh_dentry); 259 else 260 __entry->inode = NULL; 261 __entry->type = type; 262 __entry->access = access; 263 __entry->error = be32_to_cpu(error); 264 ), 265 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d", 266 __entry->xid, __entry->fh_hash, 267 show_fs_file_type(__entry->type), 268 show_nfsd_may_flags(__entry->access), 269 __entry->error 270 ) 271 ); 272 273 DECLARE_EVENT_CLASS(nfsd_fh_err_class, 274 TP_PROTO(struct svc_rqst *rqstp, 275 struct svc_fh *fhp, 276 int status), 277 TP_ARGS(rqstp, fhp, status), 278 TP_STRUCT__entry( 279 __field(u32, xid) 280 __field(u32, fh_hash) 281 __field(int, status) 282 ), 283 TP_fast_assign( 284 __entry->xid = be32_to_cpu(rqstp->rq_xid); 285 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 286 __entry->status = status; 287 ), 288 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d", 289 __entry->xid, __entry->fh_hash, 290 __entry->status) 291 ) 292 293 #define DEFINE_NFSD_FH_ERR_EVENT(name) \ 294 DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \ 295 TP_PROTO(struct svc_rqst *rqstp, \ 296 struct svc_fh *fhp, \ 297 int status), \ 298 TP_ARGS(rqstp, fhp, status)) 299 300 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport); 301 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle); 302 303 TRACE_EVENT(nfsd_exp_find_key, 304 TP_PROTO(const struct svc_expkey *key, 305 int status), 306 TP_ARGS(key, status), 307 TP_STRUCT__entry( 308 __field(int, fsidtype) 309 __array(u32, fsid, 6) 310 __string(auth_domain, key->ek_client->name) 311 __field(int, status) 312 ), 313 TP_fast_assign( 314 __entry->fsidtype = key->ek_fsidtype; 315 memcpy(__entry->fsid, key->ek_fsid, 4*6); 316 __assign_str(auth_domain, key->ek_client->name); 317 __entry->status = status; 318 ), 319 TP_printk("fsid=%x::%s domain=%s status=%d", 320 __entry->fsidtype, 321 __print_array(__entry->fsid, 6, 4), 322 __get_str(auth_domain), 323 __entry->status 324 ) 325 ); 326 327 TRACE_EVENT(nfsd_expkey_update, 328 TP_PROTO(const struct svc_expkey *key, const char *exp_path), 329 TP_ARGS(key, exp_path), 330 TP_STRUCT__entry( 331 __field(int, fsidtype) 332 __array(u32, fsid, 6) 333 __string(auth_domain, key->ek_client->name) 334 __string(path, exp_path) 335 __field(bool, cache) 336 ), 337 TP_fast_assign( 338 __entry->fsidtype = key->ek_fsidtype; 339 memcpy(__entry->fsid, key->ek_fsid, 4*6); 340 __assign_str(auth_domain, key->ek_client->name); 341 __assign_str(path, exp_path); 342 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 343 ), 344 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s", 345 __entry->fsidtype, 346 __print_array(__entry->fsid, 6, 4), 347 __get_str(auth_domain), 348 __get_str(path), 349 __entry->cache ? "pos" : "neg" 350 ) 351 ); 352 353 TRACE_EVENT(nfsd_exp_get_by_name, 354 TP_PROTO(const struct svc_export *key, 355 int status), 356 TP_ARGS(key, status), 357 TP_STRUCT__entry( 358 __string(path, key->ex_path.dentry->d_name.name) 359 __string(auth_domain, key->ex_client->name) 360 __field(int, status) 361 ), 362 TP_fast_assign( 363 __assign_str(path, key->ex_path.dentry->d_name.name); 364 __assign_str(auth_domain, key->ex_client->name); 365 __entry->status = status; 366 ), 367 TP_printk("path=%s domain=%s status=%d", 368 __get_str(path), 369 __get_str(auth_domain), 370 __entry->status 371 ) 372 ); 373 374 TRACE_EVENT(nfsd_export_update, 375 TP_PROTO(const struct svc_export *key), 376 TP_ARGS(key), 377 TP_STRUCT__entry( 378 __string(path, key->ex_path.dentry->d_name.name) 379 __string(auth_domain, key->ex_client->name) 380 __field(bool, cache) 381 ), 382 TP_fast_assign( 383 __assign_str(path, key->ex_path.dentry->d_name.name); 384 __assign_str(auth_domain, key->ex_client->name); 385 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags); 386 ), 387 TP_printk("path=%s domain=%s cache=%s", 388 __get_str(path), 389 __get_str(auth_domain), 390 __entry->cache ? "pos" : "neg" 391 ) 392 ); 393 394 DECLARE_EVENT_CLASS(nfsd_io_class, 395 TP_PROTO(struct svc_rqst *rqstp, 396 struct svc_fh *fhp, 397 u64 offset, 398 u32 len), 399 TP_ARGS(rqstp, fhp, offset, len), 400 TP_STRUCT__entry( 401 __field(u32, xid) 402 __field(u32, fh_hash) 403 __field(u64, offset) 404 __field(u32, len) 405 ), 406 TP_fast_assign( 407 __entry->xid = be32_to_cpu(rqstp->rq_xid); 408 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 409 __entry->offset = offset; 410 __entry->len = len; 411 ), 412 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u", 413 __entry->xid, __entry->fh_hash, 414 __entry->offset, __entry->len) 415 ) 416 417 #define DEFINE_NFSD_IO_EVENT(name) \ 418 DEFINE_EVENT(nfsd_io_class, nfsd_##name, \ 419 TP_PROTO(struct svc_rqst *rqstp, \ 420 struct svc_fh *fhp, \ 421 u64 offset, \ 422 u32 len), \ 423 TP_ARGS(rqstp, fhp, offset, len)) 424 425 DEFINE_NFSD_IO_EVENT(read_start); 426 DEFINE_NFSD_IO_EVENT(read_splice); 427 DEFINE_NFSD_IO_EVENT(read_vector); 428 DEFINE_NFSD_IO_EVENT(read_io_done); 429 DEFINE_NFSD_IO_EVENT(read_done); 430 DEFINE_NFSD_IO_EVENT(write_start); 431 DEFINE_NFSD_IO_EVENT(write_opened); 432 DEFINE_NFSD_IO_EVENT(write_io_done); 433 DEFINE_NFSD_IO_EVENT(write_done); 434 435 DECLARE_EVENT_CLASS(nfsd_err_class, 436 TP_PROTO(struct svc_rqst *rqstp, 437 struct svc_fh *fhp, 438 loff_t offset, 439 int status), 440 TP_ARGS(rqstp, fhp, offset, status), 441 TP_STRUCT__entry( 442 __field(u32, xid) 443 __field(u32, fh_hash) 444 __field(loff_t, offset) 445 __field(int, status) 446 ), 447 TP_fast_assign( 448 __entry->xid = be32_to_cpu(rqstp->rq_xid); 449 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle); 450 __entry->offset = offset; 451 __entry->status = status; 452 ), 453 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d", 454 __entry->xid, __entry->fh_hash, 455 __entry->offset, __entry->status) 456 ) 457 458 #define DEFINE_NFSD_ERR_EVENT(name) \ 459 DEFINE_EVENT(nfsd_err_class, nfsd_##name, \ 460 TP_PROTO(struct svc_rqst *rqstp, \ 461 struct svc_fh *fhp, \ 462 loff_t offset, \ 463 int len), \ 464 TP_ARGS(rqstp, fhp, offset, len)) 465 466 DEFINE_NFSD_ERR_EVENT(read_err); 467 DEFINE_NFSD_ERR_EVENT(write_err); 468 469 TRACE_EVENT(nfsd_dirent, 470 TP_PROTO(struct svc_fh *fhp, 471 u64 ino, 472 const char *name, 473 int namlen), 474 TP_ARGS(fhp, ino, name, namlen), 475 TP_STRUCT__entry( 476 __field(u32, fh_hash) 477 __field(u64, ino) 478 __string_len(name, name, namlen) 479 ), 480 TP_fast_assign( 481 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0; 482 __entry->ino = ino; 483 __assign_str_len(name, name, namlen) 484 ), 485 TP_printk("fh_hash=0x%08x ino=%llu name=%s", 486 __entry->fh_hash, __entry->ino, __get_str(name) 487 ) 488 ) 489 490 DECLARE_EVENT_CLASS(nfsd_copy_err_class, 491 TP_PROTO(struct svc_rqst *rqstp, 492 struct svc_fh *src_fhp, 493 loff_t src_offset, 494 struct svc_fh *dst_fhp, 495 loff_t dst_offset, 496 u64 count, 497 int status), 498 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status), 499 TP_STRUCT__entry( 500 __field(u32, xid) 501 __field(u32, src_fh_hash) 502 __field(loff_t, src_offset) 503 __field(u32, dst_fh_hash) 504 __field(loff_t, dst_offset) 505 __field(u64, count) 506 __field(int, status) 507 ), 508 TP_fast_assign( 509 __entry->xid = be32_to_cpu(rqstp->rq_xid); 510 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle); 511 __entry->src_offset = src_offset; 512 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle); 513 __entry->dst_offset = dst_offset; 514 __entry->count = count; 515 __entry->status = status; 516 ), 517 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld " 518 "dst_fh_hash=0x%08x dst_offset=%lld " 519 "count=%llu status=%d", 520 __entry->xid, __entry->src_fh_hash, __entry->src_offset, 521 __entry->dst_fh_hash, __entry->dst_offset, 522 (unsigned long long)__entry->count, 523 __entry->status) 524 ) 525 526 #define DEFINE_NFSD_COPY_ERR_EVENT(name) \ 527 DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \ 528 TP_PROTO(struct svc_rqst *rqstp, \ 529 struct svc_fh *src_fhp, \ 530 loff_t src_offset, \ 531 struct svc_fh *dst_fhp, \ 532 loff_t dst_offset, \ 533 u64 count, \ 534 int status), \ 535 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \ 536 count, status)) 537 538 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err); 539 540 #include "state.h" 541 #include "filecache.h" 542 #include "vfs.h" 543 544 TRACE_EVENT(nfsd_delegret_wakeup, 545 TP_PROTO( 546 const struct svc_rqst *rqstp, 547 const struct inode *inode, 548 long timeo 549 ), 550 TP_ARGS(rqstp, inode, timeo), 551 TP_STRUCT__entry( 552 __field(u32, xid) 553 __field(const void *, inode) 554 __field(long, timeo) 555 ), 556 TP_fast_assign( 557 __entry->xid = be32_to_cpu(rqstp->rq_xid); 558 __entry->inode = inode; 559 __entry->timeo = timeo; 560 ), 561 TP_printk("xid=0x%08x inode=%p%s", 562 __entry->xid, __entry->inode, 563 __entry->timeo == 0 ? " (timed out)" : "" 564 ) 565 ); 566 567 DECLARE_EVENT_CLASS(nfsd_stateid_class, 568 TP_PROTO(stateid_t *stp), 569 TP_ARGS(stp), 570 TP_STRUCT__entry( 571 __field(u32, cl_boot) 572 __field(u32, cl_id) 573 __field(u32, si_id) 574 __field(u32, si_generation) 575 ), 576 TP_fast_assign( 577 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 578 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 579 __entry->si_id = stp->si_opaque.so_id; 580 __entry->si_generation = stp->si_generation; 581 ), 582 TP_printk("client %08x:%08x stateid %08x:%08x", 583 __entry->cl_boot, 584 __entry->cl_id, 585 __entry->si_id, 586 __entry->si_generation) 587 ) 588 589 #define DEFINE_STATEID_EVENT(name) \ 590 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \ 591 TP_PROTO(stateid_t *stp), \ 592 TP_ARGS(stp)) 593 594 DEFINE_STATEID_EVENT(layoutstate_alloc); 595 DEFINE_STATEID_EVENT(layoutstate_unhash); 596 DEFINE_STATEID_EVENT(layoutstate_free); 597 DEFINE_STATEID_EVENT(layout_get_lookup_fail); 598 DEFINE_STATEID_EVENT(layout_commit_lookup_fail); 599 DEFINE_STATEID_EVENT(layout_return_lookup_fail); 600 DEFINE_STATEID_EVENT(layout_recall); 601 DEFINE_STATEID_EVENT(layout_recall_done); 602 DEFINE_STATEID_EVENT(layout_recall_fail); 603 DEFINE_STATEID_EVENT(layout_recall_release); 604 605 DEFINE_STATEID_EVENT(open); 606 DEFINE_STATEID_EVENT(deleg_read); 607 DEFINE_STATEID_EVENT(deleg_return); 608 DEFINE_STATEID_EVENT(deleg_recall); 609 610 DECLARE_EVENT_CLASS(nfsd_stateseqid_class, 611 TP_PROTO(u32 seqid, const stateid_t *stp), 612 TP_ARGS(seqid, stp), 613 TP_STRUCT__entry( 614 __field(u32, seqid) 615 __field(u32, cl_boot) 616 __field(u32, cl_id) 617 __field(u32, si_id) 618 __field(u32, si_generation) 619 ), 620 TP_fast_assign( 621 __entry->seqid = seqid; 622 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 623 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 624 __entry->si_id = stp->si_opaque.so_id; 625 __entry->si_generation = stp->si_generation; 626 ), 627 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x", 628 __entry->seqid, __entry->cl_boot, __entry->cl_id, 629 __entry->si_id, __entry->si_generation) 630 ) 631 632 #define DEFINE_STATESEQID_EVENT(name) \ 633 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \ 634 TP_PROTO(u32 seqid, const stateid_t *stp), \ 635 TP_ARGS(seqid, stp)) 636 637 DEFINE_STATESEQID_EVENT(preprocess); 638 DEFINE_STATESEQID_EVENT(open_confirm); 639 640 TRACE_DEFINE_ENUM(NFS4_OPEN_STID); 641 TRACE_DEFINE_ENUM(NFS4_LOCK_STID); 642 TRACE_DEFINE_ENUM(NFS4_DELEG_STID); 643 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID); 644 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID); 645 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID); 646 TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID); 647 648 #define show_stid_type(x) \ 649 __print_flags(x, "|", \ 650 { NFS4_OPEN_STID, "OPEN" }, \ 651 { NFS4_LOCK_STID, "LOCK" }, \ 652 { NFS4_DELEG_STID, "DELEG" }, \ 653 { NFS4_CLOSED_STID, "CLOSED" }, \ 654 { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \ 655 { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \ 656 { NFS4_LAYOUT_STID, "LAYOUT" }) 657 658 DECLARE_EVENT_CLASS(nfsd_stid_class, 659 TP_PROTO( 660 const struct nfs4_stid *stid 661 ), 662 TP_ARGS(stid), 663 TP_STRUCT__entry( 664 __field(unsigned long, sc_type) 665 __field(int, sc_count) 666 __field(u32, cl_boot) 667 __field(u32, cl_id) 668 __field(u32, si_id) 669 __field(u32, si_generation) 670 ), 671 TP_fast_assign( 672 const stateid_t *stp = &stid->sc_stateid; 673 674 __entry->sc_type = stid->sc_type; 675 __entry->sc_count = refcount_read(&stid->sc_count); 676 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 677 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 678 __entry->si_id = stp->si_opaque.so_id; 679 __entry->si_generation = stp->si_generation; 680 ), 681 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s", 682 __entry->cl_boot, __entry->cl_id, 683 __entry->si_id, __entry->si_generation, 684 __entry->sc_count, show_stid_type(__entry->sc_type) 685 ) 686 ); 687 688 #define DEFINE_STID_EVENT(name) \ 689 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \ 690 TP_PROTO(const struct nfs4_stid *stid), \ 691 TP_ARGS(stid)) 692 693 DEFINE_STID_EVENT(revoke); 694 695 DECLARE_EVENT_CLASS(nfsd_clientid_class, 696 TP_PROTO(const clientid_t *clid), 697 TP_ARGS(clid), 698 TP_STRUCT__entry( 699 __field(u32, cl_boot) 700 __field(u32, cl_id) 701 ), 702 TP_fast_assign( 703 __entry->cl_boot = clid->cl_boot; 704 __entry->cl_id = clid->cl_id; 705 ), 706 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 707 ) 708 709 #define DEFINE_CLIENTID_EVENT(name) \ 710 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \ 711 TP_PROTO(const clientid_t *clid), \ 712 TP_ARGS(clid)) 713 714 DEFINE_CLIENTID_EVENT(expire_unconf); 715 DEFINE_CLIENTID_EVENT(reclaim_complete); 716 DEFINE_CLIENTID_EVENT(confirmed); 717 DEFINE_CLIENTID_EVENT(destroyed); 718 DEFINE_CLIENTID_EVENT(admin_expired); 719 DEFINE_CLIENTID_EVENT(replaced); 720 DEFINE_CLIENTID_EVENT(purged); 721 DEFINE_CLIENTID_EVENT(renew); 722 DEFINE_CLIENTID_EVENT(stale); 723 724 DECLARE_EVENT_CLASS(nfsd_net_class, 725 TP_PROTO(const struct nfsd_net *nn), 726 TP_ARGS(nn), 727 TP_STRUCT__entry( 728 __field(unsigned long long, boot_time) 729 ), 730 TP_fast_assign( 731 __entry->boot_time = nn->boot_time; 732 ), 733 TP_printk("boot_time=%16llx", __entry->boot_time) 734 ) 735 736 #define DEFINE_NET_EVENT(name) \ 737 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ 738 TP_PROTO(const struct nfsd_net *nn), \ 739 TP_ARGS(nn)) 740 741 DEFINE_NET_EVENT(grace_start); 742 DEFINE_NET_EVENT(grace_complete); 743 744 TRACE_EVENT(nfsd_writeverf_reset, 745 TP_PROTO( 746 const struct nfsd_net *nn, 747 const struct svc_rqst *rqstp, 748 int error 749 ), 750 TP_ARGS(nn, rqstp, error), 751 TP_STRUCT__entry( 752 __field(unsigned long long, boot_time) 753 __field(u32, xid) 754 __field(int, error) 755 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 756 ), 757 TP_fast_assign( 758 __entry->boot_time = nn->boot_time; 759 __entry->xid = be32_to_cpu(rqstp->rq_xid); 760 __entry->error = error; 761 762 /* avoid seqlock inside TP_fast_assign */ 763 memcpy(__entry->verifier, nn->writeverf, 764 NFS4_VERIFIER_SIZE); 765 ), 766 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s", 767 __entry->boot_time, __entry->xid, __entry->error, 768 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 769 ) 770 ); 771 772 TRACE_EVENT(nfsd_clid_cred_mismatch, 773 TP_PROTO( 774 const struct nfs4_client *clp, 775 const struct svc_rqst *rqstp 776 ), 777 TP_ARGS(clp, rqstp), 778 TP_STRUCT__entry( 779 __field(u32, cl_boot) 780 __field(u32, cl_id) 781 __field(unsigned long, cl_flavor) 782 __field(unsigned long, new_flavor) 783 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 784 ), 785 TP_fast_assign( 786 __entry->cl_boot = clp->cl_clientid.cl_boot; 787 __entry->cl_id = clp->cl_clientid.cl_id; 788 __entry->cl_flavor = clp->cl_cred.cr_flavor; 789 __entry->new_flavor = rqstp->rq_cred.cr_flavor; 790 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 791 rqstp->rq_xprt->xpt_remotelen); 792 ), 793 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc", 794 __entry->cl_boot, __entry->cl_id, 795 show_nfsd_authflavor(__entry->cl_flavor), 796 show_nfsd_authflavor(__entry->new_flavor), 797 __get_sockaddr(addr) 798 ) 799 ) 800 801 TRACE_EVENT(nfsd_clid_verf_mismatch, 802 TP_PROTO( 803 const struct nfs4_client *clp, 804 const struct svc_rqst *rqstp, 805 const nfs4_verifier *verf 806 ), 807 TP_ARGS(clp, rqstp, verf), 808 TP_STRUCT__entry( 809 __field(u32, cl_boot) 810 __field(u32, cl_id) 811 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE) 812 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE) 813 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen) 814 ), 815 TP_fast_assign( 816 __entry->cl_boot = clp->cl_clientid.cl_boot; 817 __entry->cl_id = clp->cl_clientid.cl_id; 818 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier, 819 NFS4_VERIFIER_SIZE); 820 memcpy(__entry->new_verifier, (void *)verf, 821 NFS4_VERIFIER_SIZE); 822 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote, 823 rqstp->rq_xprt->xpt_remotelen); 824 ), 825 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc", 826 __entry->cl_boot, __entry->cl_id, 827 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE), 828 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE), 829 __get_sockaddr(addr) 830 ) 831 ); 832 833 DECLARE_EVENT_CLASS(nfsd_clid_class, 834 TP_PROTO(const struct nfs4_client *clp), 835 TP_ARGS(clp), 836 TP_STRUCT__entry( 837 __field(u32, cl_boot) 838 __field(u32, cl_id) 839 __array(unsigned char, addr, sizeof(struct sockaddr_in6)) 840 __field(unsigned long, flavor) 841 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE) 842 __string_len(name, name, clp->cl_name.len) 843 ), 844 TP_fast_assign( 845 __entry->cl_boot = clp->cl_clientid.cl_boot; 846 __entry->cl_id = clp->cl_clientid.cl_id; 847 memcpy(__entry->addr, &clp->cl_addr, 848 sizeof(struct sockaddr_in6)); 849 __entry->flavor = clp->cl_cred.cr_flavor; 850 memcpy(__entry->verifier, (void *)&clp->cl_verifier, 851 NFS4_VERIFIER_SIZE); 852 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len); 853 ), 854 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x", 855 __entry->addr, __get_str(name), 856 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE), 857 show_nfsd_authflavor(__entry->flavor), 858 __entry->cl_boot, __entry->cl_id) 859 ); 860 861 #define DEFINE_CLID_EVENT(name) \ 862 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ 863 TP_PROTO(const struct nfs4_client *clp), \ 864 TP_ARGS(clp)) 865 866 DEFINE_CLID_EVENT(fresh); 867 DEFINE_CLID_EVENT(confirmed_r); 868 869 /* 870 * from fs/nfsd/filecache.h 871 */ 872 #define show_nf_flags(val) \ 873 __print_flags(val, "|", \ 874 { 1 << NFSD_FILE_HASHED, "HASHED" }, \ 875 { 1 << NFSD_FILE_PENDING, "PENDING" }, \ 876 { 1 << NFSD_FILE_REFERENCED, "REFERENCED"}, \ 877 { 1 << NFSD_FILE_GC, "GC"}) 878 879 DECLARE_EVENT_CLASS(nfsd_file_class, 880 TP_PROTO(struct nfsd_file *nf), 881 TP_ARGS(nf), 882 TP_STRUCT__entry( 883 __field(void *, nf_inode) 884 __field(int, nf_ref) 885 __field(unsigned long, nf_flags) 886 __field(unsigned char, nf_may) 887 __field(struct file *, nf_file) 888 ), 889 TP_fast_assign( 890 __entry->nf_inode = nf->nf_inode; 891 __entry->nf_ref = refcount_read(&nf->nf_ref); 892 __entry->nf_flags = nf->nf_flags; 893 __entry->nf_may = nf->nf_may; 894 __entry->nf_file = nf->nf_file; 895 ), 896 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p", 897 __entry->nf_inode, 898 __entry->nf_ref, 899 show_nf_flags(__entry->nf_flags), 900 show_nfsd_may_flags(__entry->nf_may), 901 __entry->nf_file) 902 ) 903 904 #define DEFINE_NFSD_FILE_EVENT(name) \ 905 DEFINE_EVENT(nfsd_file_class, name, \ 906 TP_PROTO(struct nfsd_file *nf), \ 907 TP_ARGS(nf)) 908 909 DEFINE_NFSD_FILE_EVENT(nfsd_file_put_final); 910 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash); 911 DEFINE_NFSD_FILE_EVENT(nfsd_file_put); 912 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_dispose); 913 914 TRACE_EVENT(nfsd_file_alloc, 915 TP_PROTO( 916 const struct nfsd_file *nf 917 ), 918 TP_ARGS(nf), 919 TP_STRUCT__entry( 920 __field(const void *, nf_inode) 921 __field(unsigned long, nf_flags) 922 __field(unsigned long, nf_may) 923 __field(unsigned int, nf_ref) 924 ), 925 TP_fast_assign( 926 __entry->nf_inode = nf->nf_inode; 927 __entry->nf_flags = nf->nf_flags; 928 __entry->nf_ref = refcount_read(&nf->nf_ref); 929 __entry->nf_may = nf->nf_may; 930 ), 931 TP_printk("inode=%p ref=%u flags=%s may=%s", 932 __entry->nf_inode, __entry->nf_ref, 933 show_nf_flags(__entry->nf_flags), 934 show_nfsd_may_flags(__entry->nf_may) 935 ) 936 ); 937 938 TRACE_EVENT(nfsd_file_acquire, 939 TP_PROTO( 940 const struct svc_rqst *rqstp, 941 const struct inode *inode, 942 unsigned int may_flags, 943 const struct nfsd_file *nf, 944 __be32 status 945 ), 946 947 TP_ARGS(rqstp, inode, may_flags, nf, status), 948 949 TP_STRUCT__entry( 950 __field(u32, xid) 951 __field(const void *, inode) 952 __field(unsigned long, may_flags) 953 __field(unsigned int, nf_ref) 954 __field(unsigned long, nf_flags) 955 __field(unsigned long, nf_may) 956 __field(const void *, nf_file) 957 __field(u32, status) 958 ), 959 960 TP_fast_assign( 961 __entry->xid = be32_to_cpu(rqstp->rq_xid); 962 __entry->inode = inode; 963 __entry->may_flags = may_flags; 964 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0; 965 __entry->nf_flags = nf ? nf->nf_flags : 0; 966 __entry->nf_may = nf ? nf->nf_may : 0; 967 __entry->nf_file = nf ? nf->nf_file : NULL; 968 __entry->status = be32_to_cpu(status); 969 ), 970 971 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u", 972 __entry->xid, __entry->inode, 973 show_nfsd_may_flags(__entry->may_flags), 974 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 975 show_nfsd_may_flags(__entry->nf_may), 976 __entry->nf_file, __entry->status 977 ) 978 ); 979 980 TRACE_EVENT(nfsd_file_create, 981 TP_PROTO( 982 const struct svc_rqst *rqstp, 983 unsigned int may_flags, 984 const struct nfsd_file *nf 985 ), 986 987 TP_ARGS(rqstp, may_flags, nf), 988 989 TP_STRUCT__entry( 990 __field(const void *, nf_inode) 991 __field(const void *, nf_file) 992 __field(unsigned long, may_flags) 993 __field(unsigned long, nf_flags) 994 __field(unsigned long, nf_may) 995 __field(unsigned int, nf_ref) 996 __field(u32, xid) 997 ), 998 999 TP_fast_assign( 1000 __entry->nf_inode = nf->nf_inode; 1001 __entry->nf_file = nf->nf_file; 1002 __entry->may_flags = may_flags; 1003 __entry->nf_flags = nf->nf_flags; 1004 __entry->nf_may = nf->nf_may; 1005 __entry->nf_ref = refcount_read(&nf->nf_ref); 1006 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1007 ), 1008 1009 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1010 __entry->xid, __entry->nf_inode, 1011 show_nfsd_may_flags(__entry->may_flags), 1012 __entry->nf_ref, show_nf_flags(__entry->nf_flags), 1013 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1014 ) 1015 ); 1016 1017 TRACE_EVENT(nfsd_file_insert_err, 1018 TP_PROTO( 1019 const struct svc_rqst *rqstp, 1020 const struct inode *inode, 1021 unsigned int may_flags, 1022 long error 1023 ), 1024 TP_ARGS(rqstp, inode, may_flags, error), 1025 TP_STRUCT__entry( 1026 __field(u32, xid) 1027 __field(const void *, inode) 1028 __field(unsigned long, may_flags) 1029 __field(long, error) 1030 ), 1031 TP_fast_assign( 1032 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1033 __entry->inode = inode; 1034 __entry->may_flags = may_flags; 1035 __entry->error = error; 1036 ), 1037 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld", 1038 __entry->xid, __entry->inode, 1039 show_nfsd_may_flags(__entry->may_flags), 1040 __entry->error 1041 ) 1042 ); 1043 1044 TRACE_EVENT(nfsd_file_cons_err, 1045 TP_PROTO( 1046 const struct svc_rqst *rqstp, 1047 const struct inode *inode, 1048 unsigned int may_flags, 1049 const struct nfsd_file *nf 1050 ), 1051 TP_ARGS(rqstp, inode, may_flags, nf), 1052 TP_STRUCT__entry( 1053 __field(u32, xid) 1054 __field(const void *, inode) 1055 __field(unsigned long, may_flags) 1056 __field(unsigned int, nf_ref) 1057 __field(unsigned long, nf_flags) 1058 __field(unsigned long, nf_may) 1059 __field(const void *, nf_file) 1060 ), 1061 TP_fast_assign( 1062 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1063 __entry->inode = inode; 1064 __entry->may_flags = may_flags; 1065 __entry->nf_ref = refcount_read(&nf->nf_ref); 1066 __entry->nf_flags = nf->nf_flags; 1067 __entry->nf_may = nf->nf_may; 1068 __entry->nf_file = nf->nf_file; 1069 ), 1070 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p", 1071 __entry->xid, __entry->inode, 1072 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref, 1073 show_nf_flags(__entry->nf_flags), 1074 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file 1075 ) 1076 ); 1077 1078 TRACE_EVENT(nfsd_file_open, 1079 TP_PROTO(struct nfsd_file *nf, __be32 status), 1080 TP_ARGS(nf, status), 1081 TP_STRUCT__entry( 1082 __field(void *, nf_inode) /* cannot be dereferenced */ 1083 __field(int, nf_ref) 1084 __field(unsigned long, nf_flags) 1085 __field(unsigned long, nf_may) 1086 __field(void *, nf_file) /* cannot be dereferenced */ 1087 ), 1088 TP_fast_assign( 1089 __entry->nf_inode = nf->nf_inode; 1090 __entry->nf_ref = refcount_read(&nf->nf_ref); 1091 __entry->nf_flags = nf->nf_flags; 1092 __entry->nf_may = nf->nf_may; 1093 __entry->nf_file = nf->nf_file; 1094 ), 1095 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p", 1096 __entry->nf_inode, 1097 __entry->nf_ref, 1098 show_nf_flags(__entry->nf_flags), 1099 show_nfsd_may_flags(__entry->nf_may), 1100 __entry->nf_file) 1101 ) 1102 1103 DECLARE_EVENT_CLASS(nfsd_file_search_class, 1104 TP_PROTO( 1105 const struct inode *inode, 1106 unsigned int count 1107 ), 1108 TP_ARGS(inode, count), 1109 TP_STRUCT__entry( 1110 __field(const struct inode *, inode) 1111 __field(unsigned int, count) 1112 ), 1113 TP_fast_assign( 1114 __entry->inode = inode; 1115 __entry->count = count; 1116 ), 1117 TP_printk("inode=%p count=%u", 1118 __entry->inode, __entry->count) 1119 ); 1120 1121 #define DEFINE_NFSD_FILE_SEARCH_EVENT(name) \ 1122 DEFINE_EVENT(nfsd_file_search_class, name, \ 1123 TP_PROTO( \ 1124 const struct inode *inode, \ 1125 unsigned int count \ 1126 ), \ 1127 TP_ARGS(inode, count)) 1128 1129 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode_sync); 1130 DEFINE_NFSD_FILE_SEARCH_EVENT(nfsd_file_close_inode); 1131 1132 TRACE_EVENT(nfsd_file_is_cached, 1133 TP_PROTO( 1134 const struct inode *inode, 1135 int found 1136 ), 1137 TP_ARGS(inode, found), 1138 TP_STRUCT__entry( 1139 __field(const struct inode *, inode) 1140 __field(int, found) 1141 ), 1142 TP_fast_assign( 1143 __entry->inode = inode; 1144 __entry->found = found; 1145 ), 1146 TP_printk("inode=%p is %scached", 1147 __entry->inode, 1148 __entry->found ? "" : "not " 1149 ) 1150 ); 1151 1152 TRACE_EVENT(nfsd_file_fsnotify_handle_event, 1153 TP_PROTO(struct inode *inode, u32 mask), 1154 TP_ARGS(inode, mask), 1155 TP_STRUCT__entry( 1156 __field(struct inode *, inode) 1157 __field(unsigned int, nlink) 1158 __field(umode_t, mode) 1159 __field(u32, mask) 1160 ), 1161 TP_fast_assign( 1162 __entry->inode = inode; 1163 __entry->nlink = inode->i_nlink; 1164 __entry->mode = inode->i_mode; 1165 __entry->mask = mask; 1166 ), 1167 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode, 1168 __entry->nlink, __entry->mode, __entry->mask) 1169 ); 1170 1171 DECLARE_EVENT_CLASS(nfsd_file_gc_class, 1172 TP_PROTO( 1173 const struct nfsd_file *nf 1174 ), 1175 TP_ARGS(nf), 1176 TP_STRUCT__entry( 1177 __field(void *, nf_inode) 1178 __field(void *, nf_file) 1179 __field(int, nf_ref) 1180 __field(unsigned long, nf_flags) 1181 ), 1182 TP_fast_assign( 1183 __entry->nf_inode = nf->nf_inode; 1184 __entry->nf_file = nf->nf_file; 1185 __entry->nf_ref = refcount_read(&nf->nf_ref); 1186 __entry->nf_flags = nf->nf_flags; 1187 ), 1188 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p", 1189 __entry->nf_inode, __entry->nf_ref, 1190 show_nf_flags(__entry->nf_flags), 1191 __entry->nf_file 1192 ) 1193 ); 1194 1195 #define DEFINE_NFSD_FILE_GC_EVENT(name) \ 1196 DEFINE_EVENT(nfsd_file_gc_class, name, \ 1197 TP_PROTO( \ 1198 const struct nfsd_file *nf \ 1199 ), \ 1200 TP_ARGS(nf)) 1201 1202 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add); 1203 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed); 1204 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del); 1205 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed); 1206 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use); 1207 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback); 1208 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced); 1209 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_hashed); 1210 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed); 1211 1212 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class, 1213 TP_PROTO( 1214 unsigned long removed, 1215 unsigned long remaining 1216 ), 1217 TP_ARGS(removed, remaining), 1218 TP_STRUCT__entry( 1219 __field(unsigned long, removed) 1220 __field(unsigned long, remaining) 1221 ), 1222 TP_fast_assign( 1223 __entry->removed = removed; 1224 __entry->remaining = remaining; 1225 ), 1226 TP_printk("%lu entries removed, %lu remaining", 1227 __entry->removed, __entry->remaining) 1228 ); 1229 1230 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \ 1231 DEFINE_EVENT(nfsd_file_lruwalk_class, name, \ 1232 TP_PROTO( \ 1233 unsigned long removed, \ 1234 unsigned long remaining \ 1235 ), \ 1236 TP_ARGS(removed, remaining)) 1237 1238 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed); 1239 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed); 1240 1241 #include "cache.h" 1242 1243 TRACE_DEFINE_ENUM(RC_DROPIT); 1244 TRACE_DEFINE_ENUM(RC_REPLY); 1245 TRACE_DEFINE_ENUM(RC_DOIT); 1246 1247 #define show_drc_retval(x) \ 1248 __print_symbolic(x, \ 1249 { RC_DROPIT, "DROPIT" }, \ 1250 { RC_REPLY, "REPLY" }, \ 1251 { RC_DOIT, "DOIT" }) 1252 1253 TRACE_EVENT(nfsd_drc_found, 1254 TP_PROTO( 1255 const struct nfsd_net *nn, 1256 const struct svc_rqst *rqstp, 1257 int result 1258 ), 1259 TP_ARGS(nn, rqstp, result), 1260 TP_STRUCT__entry( 1261 __field(unsigned long long, boot_time) 1262 __field(unsigned long, result) 1263 __field(u32, xid) 1264 ), 1265 TP_fast_assign( 1266 __entry->boot_time = nn->boot_time; 1267 __entry->result = result; 1268 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1269 ), 1270 TP_printk("boot_time=%16llx xid=0x%08x result=%s", 1271 __entry->boot_time, __entry->xid, 1272 show_drc_retval(__entry->result)) 1273 1274 ); 1275 1276 TRACE_EVENT(nfsd_drc_mismatch, 1277 TP_PROTO( 1278 const struct nfsd_net *nn, 1279 const struct svc_cacherep *key, 1280 const struct svc_cacherep *rp 1281 ), 1282 TP_ARGS(nn, key, rp), 1283 TP_STRUCT__entry( 1284 __field(unsigned long long, boot_time) 1285 __field(u32, xid) 1286 __field(u32, cached) 1287 __field(u32, ingress) 1288 ), 1289 TP_fast_assign( 1290 __entry->boot_time = nn->boot_time; 1291 __entry->xid = be32_to_cpu(key->c_key.k_xid); 1292 __entry->cached = (__force u32)key->c_key.k_csum; 1293 __entry->ingress = (__force u32)rp->c_key.k_csum; 1294 ), 1295 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x", 1296 __entry->boot_time, __entry->xid, __entry->cached, 1297 __entry->ingress) 1298 ); 1299 1300 TRACE_EVENT(nfsd_cb_args, 1301 TP_PROTO( 1302 const struct nfs4_client *clp, 1303 const struct nfs4_cb_conn *conn 1304 ), 1305 TP_ARGS(clp, conn), 1306 TP_STRUCT__entry( 1307 __field(u32, cl_boot) 1308 __field(u32, cl_id) 1309 __field(u32, prog) 1310 __field(u32, ident) 1311 __sockaddr(addr, conn->cb_addrlen) 1312 ), 1313 TP_fast_assign( 1314 __entry->cl_boot = clp->cl_clientid.cl_boot; 1315 __entry->cl_id = clp->cl_clientid.cl_id; 1316 __entry->prog = conn->cb_prog; 1317 __entry->ident = conn->cb_ident; 1318 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen); 1319 ), 1320 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u", 1321 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1322 __entry->prog, __entry->ident) 1323 ); 1324 1325 TRACE_EVENT(nfsd_cb_nodelegs, 1326 TP_PROTO(const struct nfs4_client *clp), 1327 TP_ARGS(clp), 1328 TP_STRUCT__entry( 1329 __field(u32, cl_boot) 1330 __field(u32, cl_id) 1331 ), 1332 TP_fast_assign( 1333 __entry->cl_boot = clp->cl_clientid.cl_boot; 1334 __entry->cl_id = clp->cl_clientid.cl_id; 1335 ), 1336 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id) 1337 ) 1338 1339 #define show_cb_state(val) \ 1340 __print_symbolic(val, \ 1341 { NFSD4_CB_UP, "UP" }, \ 1342 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \ 1343 { NFSD4_CB_DOWN, "DOWN" }, \ 1344 { NFSD4_CB_FAULT, "FAULT"}) 1345 1346 DECLARE_EVENT_CLASS(nfsd_cb_class, 1347 TP_PROTO(const struct nfs4_client *clp), 1348 TP_ARGS(clp), 1349 TP_STRUCT__entry( 1350 __field(unsigned long, state) 1351 __field(u32, cl_boot) 1352 __field(u32, cl_id) 1353 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1354 ), 1355 TP_fast_assign( 1356 __entry->state = clp->cl_cb_state; 1357 __entry->cl_boot = clp->cl_clientid.cl_boot; 1358 __entry->cl_id = clp->cl_clientid.cl_id; 1359 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1360 clp->cl_cb_conn.cb_addrlen) 1361 ), 1362 TP_printk("addr=%pISpc client %08x:%08x state=%s", 1363 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1364 show_cb_state(__entry->state)) 1365 ); 1366 1367 #define DEFINE_NFSD_CB_EVENT(name) \ 1368 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \ 1369 TP_PROTO(const struct nfs4_client *clp), \ 1370 TP_ARGS(clp)) 1371 1372 DEFINE_NFSD_CB_EVENT(state); 1373 DEFINE_NFSD_CB_EVENT(probe); 1374 DEFINE_NFSD_CB_EVENT(lost); 1375 DEFINE_NFSD_CB_EVENT(shutdown); 1376 1377 TRACE_DEFINE_ENUM(RPC_AUTH_NULL); 1378 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX); 1379 TRACE_DEFINE_ENUM(RPC_AUTH_GSS); 1380 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5); 1381 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I); 1382 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P); 1383 1384 #define show_nfsd_authflavor(val) \ 1385 __print_symbolic(val, \ 1386 { RPC_AUTH_NULL, "none" }, \ 1387 { RPC_AUTH_UNIX, "sys" }, \ 1388 { RPC_AUTH_GSS, "gss" }, \ 1389 { RPC_AUTH_GSS_KRB5, "krb5" }, \ 1390 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \ 1391 { RPC_AUTH_GSS_KRB5P, "krb5p" }) 1392 1393 TRACE_EVENT(nfsd_cb_setup, 1394 TP_PROTO(const struct nfs4_client *clp, 1395 const char *netid, 1396 rpc_authflavor_t authflavor 1397 ), 1398 TP_ARGS(clp, netid, authflavor), 1399 TP_STRUCT__entry( 1400 __field(u32, cl_boot) 1401 __field(u32, cl_id) 1402 __field(unsigned long, authflavor) 1403 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1404 __array(unsigned char, netid, 8) 1405 ), 1406 TP_fast_assign( 1407 __entry->cl_boot = clp->cl_clientid.cl_boot; 1408 __entry->cl_id = clp->cl_clientid.cl_id; 1409 strlcpy(__entry->netid, netid, sizeof(__entry->netid)); 1410 __entry->authflavor = authflavor; 1411 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1412 clp->cl_cb_conn.cb_addrlen) 1413 ), 1414 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s", 1415 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1416 __entry->netid, show_nfsd_authflavor(__entry->authflavor)) 1417 ); 1418 1419 TRACE_EVENT(nfsd_cb_setup_err, 1420 TP_PROTO( 1421 const struct nfs4_client *clp, 1422 long error 1423 ), 1424 TP_ARGS(clp, error), 1425 TP_STRUCT__entry( 1426 __field(long, error) 1427 __field(u32, cl_boot) 1428 __field(u32, cl_id) 1429 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1430 ), 1431 TP_fast_assign( 1432 __entry->error = error; 1433 __entry->cl_boot = clp->cl_clientid.cl_boot; 1434 __entry->cl_id = clp->cl_clientid.cl_id; 1435 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1436 clp->cl_cb_conn.cb_addrlen) 1437 ), 1438 TP_printk("addr=%pISpc client %08x:%08x error=%ld", 1439 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1440 __entry->error) 1441 ); 1442 1443 TRACE_EVENT_CONDITION(nfsd_cb_recall, 1444 TP_PROTO( 1445 const struct nfs4_stid *stid 1446 ), 1447 TP_ARGS(stid), 1448 TP_CONDITION(stid->sc_client), 1449 TP_STRUCT__entry( 1450 __field(u32, cl_boot) 1451 __field(u32, cl_id) 1452 __field(u32, si_id) 1453 __field(u32, si_generation) 1454 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen) 1455 ), 1456 TP_fast_assign( 1457 const stateid_t *stp = &stid->sc_stateid; 1458 const struct nfs4_client *clp = stid->sc_client; 1459 1460 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1461 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1462 __entry->si_id = stp->si_opaque.so_id; 1463 __entry->si_generation = stp->si_generation; 1464 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1465 clp->cl_cb_conn.cb_addrlen) 1466 ), 1467 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x", 1468 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1469 __entry->si_id, __entry->si_generation) 1470 ); 1471 1472 TRACE_EVENT(nfsd_cb_notify_lock, 1473 TP_PROTO( 1474 const struct nfs4_lockowner *lo, 1475 const struct nfsd4_blocked_lock *nbl 1476 ), 1477 TP_ARGS(lo, nbl), 1478 TP_STRUCT__entry( 1479 __field(u32, cl_boot) 1480 __field(u32, cl_id) 1481 __field(u32, fh_hash) 1482 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen) 1483 ), 1484 TP_fast_assign( 1485 const struct nfs4_client *clp = lo->lo_owner.so_client; 1486 1487 __entry->cl_boot = clp->cl_clientid.cl_boot; 1488 __entry->cl_id = clp->cl_clientid.cl_id; 1489 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh); 1490 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1491 clp->cl_cb_conn.cb_addrlen) 1492 ), 1493 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x", 1494 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1495 __entry->fh_hash) 1496 ); 1497 1498 TRACE_EVENT(nfsd_cb_offload, 1499 TP_PROTO( 1500 const struct nfs4_client *clp, 1501 const stateid_t *stp, 1502 const struct knfsd_fh *fh, 1503 u64 count, 1504 __be32 status 1505 ), 1506 TP_ARGS(clp, stp, fh, count, status), 1507 TP_STRUCT__entry( 1508 __field(u32, cl_boot) 1509 __field(u32, cl_id) 1510 __field(u32, si_id) 1511 __field(u32, si_generation) 1512 __field(u32, fh_hash) 1513 __field(int, status) 1514 __field(u64, count) 1515 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen) 1516 ), 1517 TP_fast_assign( 1518 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1519 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1520 __entry->si_id = stp->si_opaque.so_id; 1521 __entry->si_generation = stp->si_generation; 1522 __entry->fh_hash = knfsd_fh_hash(fh); 1523 __entry->status = be32_to_cpu(status); 1524 __entry->count = count; 1525 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr, 1526 clp->cl_cb_conn.cb_addrlen) 1527 ), 1528 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d", 1529 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id, 1530 __entry->si_id, __entry->si_generation, 1531 __entry->fh_hash, __entry->count, __entry->status) 1532 ); 1533 1534 DECLARE_EVENT_CLASS(nfsd_cb_done_class, 1535 TP_PROTO( 1536 const stateid_t *stp, 1537 const struct rpc_task *task 1538 ), 1539 TP_ARGS(stp, task), 1540 TP_STRUCT__entry( 1541 __field(u32, cl_boot) 1542 __field(u32, cl_id) 1543 __field(u32, si_id) 1544 __field(u32, si_generation) 1545 __field(int, status) 1546 ), 1547 TP_fast_assign( 1548 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot; 1549 __entry->cl_id = stp->si_opaque.so_clid.cl_id; 1550 __entry->si_id = stp->si_opaque.so_id; 1551 __entry->si_generation = stp->si_generation; 1552 __entry->status = task->tk_status; 1553 ), 1554 TP_printk("client %08x:%08x stateid %08x:%08x status=%d", 1555 __entry->cl_boot, __entry->cl_id, __entry->si_id, 1556 __entry->si_generation, __entry->status 1557 ) 1558 ); 1559 1560 #define DEFINE_NFSD_CB_DONE_EVENT(name) \ 1561 DEFINE_EVENT(nfsd_cb_done_class, name, \ 1562 TP_PROTO( \ 1563 const stateid_t *stp, \ 1564 const struct rpc_task *task \ 1565 ), \ 1566 TP_ARGS(stp, task)) 1567 1568 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done); 1569 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done); 1570 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done); 1571 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done); 1572 1573 #endif /* _NFSD_TRACE_H */ 1574 1575 #undef TRACE_INCLUDE_PATH 1576 #define TRACE_INCLUDE_PATH . 1577 #define TRACE_INCLUDE_FILE trace 1578 #include <trace/define_trace.h> 1579