1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2009, Christoph Hellwig 4 * All Rights Reserved. 5 * 6 * NOTE: none of these tracepoints shall be considered a stable kernel ABI 7 * as they can change at any time. 8 * 9 * Current conventions for printing numbers measuring specific units: 10 * 11 * agno: allocation group number 12 * 13 * agino: per-AG inode number 14 * ino: filesystem inode number 15 * 16 * agbno: per-AG block number in fs blocks 17 * startblock: physical block number for file mappings. This is either a 18 * segmented fsblock for data device mappings, or a rfsblock 19 * for realtime device mappings 20 * fsbcount: number of blocks in an extent, in fs blocks 21 * 22 * daddr: physical block number in 512b blocks 23 * bbcount: number of blocks in a physical extent, in 512b blocks 24 * 25 * rtx: physical rt extent number for extent mappings 26 * rtxcount: number of rt extents in an extent mapping 27 * 28 * owner: reverse-mapping owner, usually inodes 29 * 30 * fileoff: file offset, in fs blocks 31 * pos: file offset, in bytes 32 * bytecount: number of bytes 33 * 34 * disize: ondisk file size, in bytes 35 * isize: incore file size, in bytes 36 * 37 * forkoff: inode fork offset, in bytes 38 * 39 * ireccount: number of inode records 40 * 41 * Numbers describing space allocations (blocks, extents, inodes) should be 42 * formatted in hexadecimal. 43 */ 44 #undef TRACE_SYSTEM 45 #define TRACE_SYSTEM xfs 46 47 #if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ) 48 #define _TRACE_XFS_H 49 50 #include <linux/tracepoint.h> 51 52 struct xfs_agf; 53 struct xfs_alloc_arg; 54 struct xfs_attr_list_context; 55 struct xfs_buf_log_item; 56 struct xfs_da_args; 57 struct xfs_da_node_entry; 58 struct xfs_dquot; 59 struct xfs_log_item; 60 struct xlog; 61 struct xlog_ticket; 62 struct xlog_recover; 63 struct xlog_recover_item; 64 struct xlog_rec_header; 65 struct xlog_in_core; 66 struct xfs_buf_log_format; 67 struct xfs_inode_log_format; 68 struct xfs_bmbt_irec; 69 struct xfs_btree_cur; 70 struct xfs_defer_op_type; 71 struct xfs_refcount_irec; 72 struct xfs_fsmap; 73 struct xfs_rmap_irec; 74 struct xfs_icreate_log; 75 struct xfs_owner_info; 76 struct xfs_trans_res; 77 struct xfs_inobt_rec_incore; 78 union xfs_btree_ptr; 79 struct xfs_dqtrx; 80 struct xfs_icwalk; 81 struct xfs_perag; 82 83 #define XFS_ATTR_FILTER_FLAGS \ 84 { XFS_ATTR_ROOT, "ROOT" }, \ 85 { XFS_ATTR_SECURE, "SECURE" }, \ 86 { XFS_ATTR_INCOMPLETE, "INCOMPLETE" } 87 88 DECLARE_EVENT_CLASS(xfs_attr_list_class, 89 TP_PROTO(struct xfs_attr_list_context *ctx), 90 TP_ARGS(ctx), 91 TP_STRUCT__entry( 92 __field(dev_t, dev) 93 __field(xfs_ino_t, ino) 94 __field(u32, hashval) 95 __field(u32, blkno) 96 __field(u32, offset) 97 __field(void *, buffer) 98 __field(int, bufsize) 99 __field(int, count) 100 __field(int, firstu) 101 __field(int, dupcnt) 102 __field(unsigned int, attr_filter) 103 ), 104 TP_fast_assign( 105 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 106 __entry->ino = ctx->dp->i_ino; 107 __entry->hashval = ctx->cursor.hashval; 108 __entry->blkno = ctx->cursor.blkno; 109 __entry->offset = ctx->cursor.offset; 110 __entry->buffer = ctx->buffer; 111 __entry->bufsize = ctx->bufsize; 112 __entry->count = ctx->count; 113 __entry->firstu = ctx->firstu; 114 __entry->attr_filter = ctx->attr_filter; 115 ), 116 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 117 "buffer %p size %u count %u firstu %u filter %s", 118 MAJOR(__entry->dev), MINOR(__entry->dev), 119 __entry->ino, 120 __entry->hashval, 121 __entry->blkno, 122 __entry->offset, 123 __entry->dupcnt, 124 __entry->buffer, 125 __entry->bufsize, 126 __entry->count, 127 __entry->firstu, 128 __print_flags(__entry->attr_filter, "|", 129 XFS_ATTR_FILTER_FLAGS) 130 ) 131 ) 132 133 #define DEFINE_ATTR_LIST_EVENT(name) \ 134 DEFINE_EVENT(xfs_attr_list_class, name, \ 135 TP_PROTO(struct xfs_attr_list_context *ctx), \ 136 TP_ARGS(ctx)) 137 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf); 138 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all); 139 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf); 140 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end); 141 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full); 142 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add); 143 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk); 144 DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound); 145 DEFINE_ATTR_LIST_EVENT(xfs_attr_leaf_list); 146 DEFINE_ATTR_LIST_EVENT(xfs_attr_node_list); 147 148 TRACE_EVENT(xlog_intent_recovery_failed, 149 TP_PROTO(struct xfs_mount *mp, const struct xfs_defer_op_type *ops, 150 int error), 151 TP_ARGS(mp, ops, error), 152 TP_STRUCT__entry( 153 __field(dev_t, dev) 154 __string(name, ops->name) 155 __field(int, error) 156 ), 157 TP_fast_assign( 158 __entry->dev = mp->m_super->s_dev; 159 __assign_str(name, ops->name); 160 __entry->error = error; 161 ), 162 TP_printk("dev %d:%d optype %s error %d", 163 MAJOR(__entry->dev), MINOR(__entry->dev), 164 __get_str(name), 165 __entry->error) 166 ); 167 168 DECLARE_EVENT_CLASS(xfs_perag_class, 169 TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), 170 TP_ARGS(pag, caller_ip), 171 TP_STRUCT__entry( 172 __field(dev_t, dev) 173 __field(xfs_agnumber_t, agno) 174 __field(int, refcount) 175 __field(int, active_refcount) 176 __field(unsigned long, caller_ip) 177 ), 178 TP_fast_assign( 179 __entry->dev = pag->pag_mount->m_super->s_dev; 180 __entry->agno = pag->pag_agno; 181 __entry->refcount = atomic_read(&pag->pag_ref); 182 __entry->active_refcount = atomic_read(&pag->pag_active_ref); 183 __entry->caller_ip = caller_ip; 184 ), 185 TP_printk("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS", 186 MAJOR(__entry->dev), MINOR(__entry->dev), 187 __entry->agno, 188 __entry->refcount, 189 __entry->active_refcount, 190 (char *)__entry->caller_ip) 191 ); 192 193 #define DEFINE_PERAG_REF_EVENT(name) \ 194 DEFINE_EVENT(xfs_perag_class, name, \ 195 TP_PROTO(struct xfs_perag *pag, unsigned long caller_ip), \ 196 TP_ARGS(pag, caller_ip)) 197 DEFINE_PERAG_REF_EVENT(xfs_perag_get); 198 DEFINE_PERAG_REF_EVENT(xfs_perag_get_tag); 199 DEFINE_PERAG_REF_EVENT(xfs_perag_hold); 200 DEFINE_PERAG_REF_EVENT(xfs_perag_put); 201 DEFINE_PERAG_REF_EVENT(xfs_perag_grab); 202 DEFINE_PERAG_REF_EVENT(xfs_perag_grab_tag); 203 DEFINE_PERAG_REF_EVENT(xfs_perag_rele); 204 DEFINE_PERAG_REF_EVENT(xfs_perag_set_inode_tag); 205 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_inode_tag); 206 207 TRACE_EVENT(xfs_inodegc_worker, 208 TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits), 209 TP_ARGS(mp, shrinker_hits), 210 TP_STRUCT__entry( 211 __field(dev_t, dev) 212 __field(unsigned int, shrinker_hits) 213 ), 214 TP_fast_assign( 215 __entry->dev = mp->m_super->s_dev; 216 __entry->shrinker_hits = shrinker_hits; 217 ), 218 TP_printk("dev %d:%d shrinker_hits %u", 219 MAJOR(__entry->dev), MINOR(__entry->dev), 220 __entry->shrinker_hits) 221 ); 222 223 DECLARE_EVENT_CLASS(xfs_fs_class, 224 TP_PROTO(struct xfs_mount *mp, void *caller_ip), 225 TP_ARGS(mp, caller_ip), 226 TP_STRUCT__entry( 227 __field(dev_t, dev) 228 __field(unsigned long long, mflags) 229 __field(unsigned long, opstate) 230 __field(unsigned long, sbflags) 231 __field(void *, caller_ip) 232 ), 233 TP_fast_assign( 234 if (mp) { 235 __entry->dev = mp->m_super->s_dev; 236 __entry->mflags = mp->m_features; 237 __entry->opstate = mp->m_opstate; 238 __entry->sbflags = mp->m_super->s_flags; 239 } 240 __entry->caller_ip = caller_ip; 241 ), 242 TP_printk("dev %d:%d m_features 0x%llx opstate (%s) s_flags 0x%lx caller %pS", 243 MAJOR(__entry->dev), MINOR(__entry->dev), 244 __entry->mflags, 245 __print_flags(__entry->opstate, "|", XFS_OPSTATE_STRINGS), 246 __entry->sbflags, 247 __entry->caller_ip) 248 ); 249 250 #define DEFINE_FS_EVENT(name) \ 251 DEFINE_EVENT(xfs_fs_class, name, \ 252 TP_PROTO(struct xfs_mount *mp, void *caller_ip), \ 253 TP_ARGS(mp, caller_ip)) 254 DEFINE_FS_EVENT(xfs_inodegc_flush); 255 DEFINE_FS_EVENT(xfs_inodegc_push); 256 DEFINE_FS_EVENT(xfs_inodegc_start); 257 DEFINE_FS_EVENT(xfs_inodegc_stop); 258 DEFINE_FS_EVENT(xfs_inodegc_queue); 259 DEFINE_FS_EVENT(xfs_inodegc_throttle); 260 DEFINE_FS_EVENT(xfs_fs_sync_fs); 261 DEFINE_FS_EVENT(xfs_blockgc_start); 262 DEFINE_FS_EVENT(xfs_blockgc_stop); 263 DEFINE_FS_EVENT(xfs_blockgc_worker); 264 DEFINE_FS_EVENT(xfs_blockgc_flush_all); 265 266 TRACE_EVENT(xfs_inodegc_shrinker_scan, 267 TP_PROTO(struct xfs_mount *mp, struct shrink_control *sc, 268 void *caller_ip), 269 TP_ARGS(mp, sc, caller_ip), 270 TP_STRUCT__entry( 271 __field(dev_t, dev) 272 __field(unsigned long, nr_to_scan) 273 __field(void *, caller_ip) 274 ), 275 TP_fast_assign( 276 __entry->dev = mp->m_super->s_dev; 277 __entry->nr_to_scan = sc->nr_to_scan; 278 __entry->caller_ip = caller_ip; 279 ), 280 TP_printk("dev %d:%d nr_to_scan %lu caller %pS", 281 MAJOR(__entry->dev), MINOR(__entry->dev), 282 __entry->nr_to_scan, 283 __entry->caller_ip) 284 ); 285 286 DECLARE_EVENT_CLASS(xfs_ag_class, 287 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno), 288 TP_ARGS(mp, agno), 289 TP_STRUCT__entry( 290 __field(dev_t, dev) 291 __field(xfs_agnumber_t, agno) 292 ), 293 TP_fast_assign( 294 __entry->dev = mp->m_super->s_dev; 295 __entry->agno = agno; 296 ), 297 TP_printk("dev %d:%d agno 0x%x", 298 MAJOR(__entry->dev), MINOR(__entry->dev), 299 __entry->agno) 300 ); 301 #define DEFINE_AG_EVENT(name) \ 302 DEFINE_EVENT(xfs_ag_class, name, \ 303 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno), \ 304 TP_ARGS(mp, agno)) 305 306 DEFINE_AG_EVENT(xfs_read_agf); 307 DEFINE_AG_EVENT(xfs_alloc_read_agf); 308 DEFINE_AG_EVENT(xfs_read_agi); 309 DEFINE_AG_EVENT(xfs_ialloc_read_agi); 310 311 TRACE_EVENT(xfs_attr_list_node_descend, 312 TP_PROTO(struct xfs_attr_list_context *ctx, 313 struct xfs_da_node_entry *btree), 314 TP_ARGS(ctx, btree), 315 TP_STRUCT__entry( 316 __field(dev_t, dev) 317 __field(xfs_ino_t, ino) 318 __field(u32, hashval) 319 __field(u32, blkno) 320 __field(u32, offset) 321 __field(void *, buffer) 322 __field(int, bufsize) 323 __field(int, count) 324 __field(int, firstu) 325 __field(int, dupcnt) 326 __field(unsigned int, attr_filter) 327 __field(u32, bt_hashval) 328 __field(u32, bt_before) 329 ), 330 TP_fast_assign( 331 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 332 __entry->ino = ctx->dp->i_ino; 333 __entry->hashval = ctx->cursor.hashval; 334 __entry->blkno = ctx->cursor.blkno; 335 __entry->offset = ctx->cursor.offset; 336 __entry->buffer = ctx->buffer; 337 __entry->bufsize = ctx->bufsize; 338 __entry->count = ctx->count; 339 __entry->firstu = ctx->firstu; 340 __entry->attr_filter = ctx->attr_filter; 341 __entry->bt_hashval = be32_to_cpu(btree->hashval); 342 __entry->bt_before = be32_to_cpu(btree->before); 343 ), 344 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 345 "buffer %p size %u count %u firstu %u filter %s " 346 "node hashval %u, node before %u", 347 MAJOR(__entry->dev), MINOR(__entry->dev), 348 __entry->ino, 349 __entry->hashval, 350 __entry->blkno, 351 __entry->offset, 352 __entry->dupcnt, 353 __entry->buffer, 354 __entry->bufsize, 355 __entry->count, 356 __entry->firstu, 357 __print_flags(__entry->attr_filter, "|", 358 XFS_ATTR_FILTER_FLAGS), 359 __entry->bt_hashval, 360 __entry->bt_before) 361 ); 362 363 DECLARE_EVENT_CLASS(xfs_bmap_class, 364 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, 365 unsigned long caller_ip), 366 TP_ARGS(ip, cur, state, caller_ip), 367 TP_STRUCT__entry( 368 __field(dev_t, dev) 369 __field(xfs_ino_t, ino) 370 __field(void *, leaf) 371 __field(int, pos) 372 __field(xfs_fileoff_t, startoff) 373 __field(xfs_fsblock_t, startblock) 374 __field(xfs_filblks_t, blockcount) 375 __field(xfs_exntst_t, state) 376 __field(int, bmap_state) 377 __field(unsigned long, caller_ip) 378 ), 379 TP_fast_assign( 380 struct xfs_ifork *ifp; 381 struct xfs_bmbt_irec r; 382 383 ifp = xfs_iext_state_to_fork(ip, state); 384 xfs_iext_get_extent(ifp, cur, &r); 385 __entry->dev = VFS_I(ip)->i_sb->s_dev; 386 __entry->ino = ip->i_ino; 387 __entry->leaf = cur->leaf; 388 __entry->pos = cur->pos; 389 __entry->startoff = r.br_startoff; 390 __entry->startblock = r.br_startblock; 391 __entry->blockcount = r.br_blockcount; 392 __entry->state = r.br_state; 393 __entry->bmap_state = state; 394 __entry->caller_ip = caller_ip; 395 ), 396 TP_printk("dev %d:%d ino 0x%llx state %s cur %p/%d " 397 "fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx flag %d caller %pS", 398 MAJOR(__entry->dev), MINOR(__entry->dev), 399 __entry->ino, 400 __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS), 401 __entry->leaf, 402 __entry->pos, 403 __entry->startoff, 404 (int64_t)__entry->startblock, 405 __entry->blockcount, 406 __entry->state, 407 (char *)__entry->caller_ip) 408 ) 409 410 #define DEFINE_BMAP_EVENT(name) \ 411 DEFINE_EVENT(xfs_bmap_class, name, \ 412 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, \ 413 unsigned long caller_ip), \ 414 TP_ARGS(ip, cur, state, caller_ip)) 415 DEFINE_BMAP_EVENT(xfs_iext_insert); 416 DEFINE_BMAP_EVENT(xfs_iext_remove); 417 DEFINE_BMAP_EVENT(xfs_bmap_pre_update); 418 DEFINE_BMAP_EVENT(xfs_bmap_post_update); 419 DEFINE_BMAP_EVENT(xfs_read_extent); 420 DEFINE_BMAP_EVENT(xfs_write_extent); 421 422 DECLARE_EVENT_CLASS(xfs_buf_class, 423 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), 424 TP_ARGS(bp, caller_ip), 425 TP_STRUCT__entry( 426 __field(dev_t, dev) 427 __field(xfs_daddr_t, bno) 428 __field(int, nblks) 429 __field(int, hold) 430 __field(int, pincount) 431 __field(unsigned, lockval) 432 __field(unsigned, flags) 433 __field(unsigned long, caller_ip) 434 __field(const void *, buf_ops) 435 ), 436 TP_fast_assign( 437 __entry->dev = bp->b_target->bt_dev; 438 __entry->bno = xfs_buf_daddr(bp); 439 __entry->nblks = bp->b_length; 440 __entry->hold = atomic_read(&bp->b_hold); 441 __entry->pincount = atomic_read(&bp->b_pin_count); 442 __entry->lockval = bp->b_sema.count; 443 __entry->flags = bp->b_flags; 444 __entry->caller_ip = caller_ip; 445 __entry->buf_ops = bp->b_ops; 446 ), 447 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 448 "lock %d flags %s bufops %pS caller %pS", 449 MAJOR(__entry->dev), MINOR(__entry->dev), 450 (unsigned long long)__entry->bno, 451 __entry->nblks, 452 __entry->hold, 453 __entry->pincount, 454 __entry->lockval, 455 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 456 __entry->buf_ops, 457 (void *)__entry->caller_ip) 458 ) 459 460 #define DEFINE_BUF_EVENT(name) \ 461 DEFINE_EVENT(xfs_buf_class, name, \ 462 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \ 463 TP_ARGS(bp, caller_ip)) 464 DEFINE_BUF_EVENT(xfs_buf_init); 465 DEFINE_BUF_EVENT(xfs_buf_free); 466 DEFINE_BUF_EVENT(xfs_buf_hold); 467 DEFINE_BUF_EVENT(xfs_buf_rele); 468 DEFINE_BUF_EVENT(xfs_buf_iodone); 469 DEFINE_BUF_EVENT(xfs_buf_submit); 470 DEFINE_BUF_EVENT(xfs_buf_lock); 471 DEFINE_BUF_EVENT(xfs_buf_lock_done); 472 DEFINE_BUF_EVENT(xfs_buf_trylock_fail); 473 DEFINE_BUF_EVENT(xfs_buf_trylock); 474 DEFINE_BUF_EVENT(xfs_buf_unlock); 475 DEFINE_BUF_EVENT(xfs_buf_iowait); 476 DEFINE_BUF_EVENT(xfs_buf_iowait_done); 477 DEFINE_BUF_EVENT(xfs_buf_delwri_queue); 478 DEFINE_BUF_EVENT(xfs_buf_delwri_queued); 479 DEFINE_BUF_EVENT(xfs_buf_delwri_split); 480 DEFINE_BUF_EVENT(xfs_buf_delwri_pushbuf); 481 DEFINE_BUF_EVENT(xfs_buf_get_uncached); 482 DEFINE_BUF_EVENT(xfs_buf_item_relse); 483 DEFINE_BUF_EVENT(xfs_buf_iodone_async); 484 DEFINE_BUF_EVENT(xfs_buf_error_relse); 485 DEFINE_BUF_EVENT(xfs_buf_drain_buftarg); 486 DEFINE_BUF_EVENT(xfs_trans_read_buf_shut); 487 488 /* not really buffer traces, but the buf provides useful information */ 489 DEFINE_BUF_EVENT(xfs_btree_corrupt); 490 DEFINE_BUF_EVENT(xfs_reset_dqcounts); 491 492 /* pass flags explicitly */ 493 DECLARE_EVENT_CLASS(xfs_buf_flags_class, 494 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), 495 TP_ARGS(bp, flags, caller_ip), 496 TP_STRUCT__entry( 497 __field(dev_t, dev) 498 __field(xfs_daddr_t, bno) 499 __field(unsigned int, length) 500 __field(int, hold) 501 __field(int, pincount) 502 __field(unsigned, lockval) 503 __field(unsigned, flags) 504 __field(unsigned long, caller_ip) 505 ), 506 TP_fast_assign( 507 __entry->dev = bp->b_target->bt_dev; 508 __entry->bno = xfs_buf_daddr(bp); 509 __entry->length = bp->b_length; 510 __entry->flags = flags; 511 __entry->hold = atomic_read(&bp->b_hold); 512 __entry->pincount = atomic_read(&bp->b_pin_count); 513 __entry->lockval = bp->b_sema.count; 514 __entry->caller_ip = caller_ip; 515 ), 516 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 517 "lock %d flags %s caller %pS", 518 MAJOR(__entry->dev), MINOR(__entry->dev), 519 (unsigned long long)__entry->bno, 520 __entry->length, 521 __entry->hold, 522 __entry->pincount, 523 __entry->lockval, 524 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 525 (void *)__entry->caller_ip) 526 ) 527 528 #define DEFINE_BUF_FLAGS_EVENT(name) \ 529 DEFINE_EVENT(xfs_buf_flags_class, name, \ 530 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \ 531 TP_ARGS(bp, flags, caller_ip)) 532 DEFINE_BUF_FLAGS_EVENT(xfs_buf_find); 533 DEFINE_BUF_FLAGS_EVENT(xfs_buf_get); 534 DEFINE_BUF_FLAGS_EVENT(xfs_buf_read); 535 536 TRACE_EVENT(xfs_buf_ioerror, 537 TP_PROTO(struct xfs_buf *bp, int error, xfs_failaddr_t caller_ip), 538 TP_ARGS(bp, error, caller_ip), 539 TP_STRUCT__entry( 540 __field(dev_t, dev) 541 __field(xfs_daddr_t, bno) 542 __field(unsigned int, length) 543 __field(unsigned, flags) 544 __field(int, hold) 545 __field(int, pincount) 546 __field(unsigned, lockval) 547 __field(int, error) 548 __field(xfs_failaddr_t, caller_ip) 549 ), 550 TP_fast_assign( 551 __entry->dev = bp->b_target->bt_dev; 552 __entry->bno = xfs_buf_daddr(bp); 553 __entry->length = bp->b_length; 554 __entry->hold = atomic_read(&bp->b_hold); 555 __entry->pincount = atomic_read(&bp->b_pin_count); 556 __entry->lockval = bp->b_sema.count; 557 __entry->error = error; 558 __entry->flags = bp->b_flags; 559 __entry->caller_ip = caller_ip; 560 ), 561 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 562 "lock %d error %d flags %s caller %pS", 563 MAJOR(__entry->dev), MINOR(__entry->dev), 564 (unsigned long long)__entry->bno, 565 __entry->length, 566 __entry->hold, 567 __entry->pincount, 568 __entry->lockval, 569 __entry->error, 570 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 571 (void *)__entry->caller_ip) 572 ); 573 574 DECLARE_EVENT_CLASS(xfs_buf_item_class, 575 TP_PROTO(struct xfs_buf_log_item *bip), 576 TP_ARGS(bip), 577 TP_STRUCT__entry( 578 __field(dev_t, dev) 579 __field(xfs_daddr_t, buf_bno) 580 __field(unsigned int, buf_len) 581 __field(int, buf_hold) 582 __field(int, buf_pincount) 583 __field(int, buf_lockval) 584 __field(unsigned, buf_flags) 585 __field(unsigned, bli_recur) 586 __field(int, bli_refcount) 587 __field(unsigned, bli_flags) 588 __field(unsigned long, li_flags) 589 ), 590 TP_fast_assign( 591 __entry->dev = bip->bli_buf->b_target->bt_dev; 592 __entry->bli_flags = bip->bli_flags; 593 __entry->bli_recur = bip->bli_recur; 594 __entry->bli_refcount = atomic_read(&bip->bli_refcount); 595 __entry->buf_bno = xfs_buf_daddr(bip->bli_buf); 596 __entry->buf_len = bip->bli_buf->b_length; 597 __entry->buf_flags = bip->bli_buf->b_flags; 598 __entry->buf_hold = atomic_read(&bip->bli_buf->b_hold); 599 __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count); 600 __entry->buf_lockval = bip->bli_buf->b_sema.count; 601 __entry->li_flags = bip->bli_item.li_flags; 602 ), 603 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 604 "lock %d flags %s recur %d refcount %d bliflags %s " 605 "liflags %s", 606 MAJOR(__entry->dev), MINOR(__entry->dev), 607 (unsigned long long)__entry->buf_bno, 608 __entry->buf_len, 609 __entry->buf_hold, 610 __entry->buf_pincount, 611 __entry->buf_lockval, 612 __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS), 613 __entry->bli_recur, 614 __entry->bli_refcount, 615 __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS), 616 __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS)) 617 ) 618 619 #define DEFINE_BUF_ITEM_EVENT(name) \ 620 DEFINE_EVENT(xfs_buf_item_class, name, \ 621 TP_PROTO(struct xfs_buf_log_item *bip), \ 622 TP_ARGS(bip)) 623 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size); 624 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered); 625 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale); 626 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format); 627 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale); 628 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered); 629 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin); 630 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin); 631 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale); 632 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_release); 633 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed); 634 DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push); 635 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf); 636 DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur); 637 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb); 638 DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur); 639 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf); 640 DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur); 641 DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf); 642 DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse); 643 DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin); 644 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold); 645 DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release); 646 DEFINE_BUF_ITEM_EVENT(xfs_trans_binval); 647 648 DECLARE_EVENT_CLASS(xfs_filestream_class, 649 TP_PROTO(struct xfs_perag *pag, xfs_ino_t ino), 650 TP_ARGS(pag, ino), 651 TP_STRUCT__entry( 652 __field(dev_t, dev) 653 __field(xfs_ino_t, ino) 654 __field(xfs_agnumber_t, agno) 655 __field(int, streams) 656 ), 657 TP_fast_assign( 658 __entry->dev = pag->pag_mount->m_super->s_dev; 659 __entry->ino = ino; 660 __entry->agno = pag->pag_agno; 661 __entry->streams = atomic_read(&pag->pagf_fstrms); 662 ), 663 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d", 664 MAJOR(__entry->dev), MINOR(__entry->dev), 665 __entry->ino, 666 __entry->agno, 667 __entry->streams) 668 ) 669 #define DEFINE_FILESTREAM_EVENT(name) \ 670 DEFINE_EVENT(xfs_filestream_class, name, \ 671 TP_PROTO(struct xfs_perag *pag, xfs_ino_t ino), \ 672 TP_ARGS(pag, ino)) 673 DEFINE_FILESTREAM_EVENT(xfs_filestream_free); 674 DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup); 675 DEFINE_FILESTREAM_EVENT(xfs_filestream_scan); 676 677 TRACE_EVENT(xfs_filestream_pick, 678 TP_PROTO(struct xfs_perag *pag, xfs_ino_t ino, xfs_extlen_t free), 679 TP_ARGS(pag, ino, free), 680 TP_STRUCT__entry( 681 __field(dev_t, dev) 682 __field(xfs_ino_t, ino) 683 __field(xfs_agnumber_t, agno) 684 __field(int, streams) 685 __field(xfs_extlen_t, free) 686 ), 687 TP_fast_assign( 688 __entry->dev = pag->pag_mount->m_super->s_dev; 689 __entry->ino = ino; 690 if (pag) { 691 __entry->agno = pag->pag_agno; 692 __entry->streams = atomic_read(&pag->pagf_fstrms); 693 } else { 694 __entry->agno = NULLAGNUMBER; 695 __entry->streams = 0; 696 } 697 __entry->free = free; 698 ), 699 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d free %d", 700 MAJOR(__entry->dev), MINOR(__entry->dev), 701 __entry->ino, 702 __entry->agno, 703 __entry->streams, 704 __entry->free) 705 ); 706 707 DECLARE_EVENT_CLASS(xfs_lock_class, 708 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, 709 unsigned long caller_ip), 710 TP_ARGS(ip, lock_flags, caller_ip), 711 TP_STRUCT__entry( 712 __field(dev_t, dev) 713 __field(xfs_ino_t, ino) 714 __field(int, lock_flags) 715 __field(unsigned long, caller_ip) 716 ), 717 TP_fast_assign( 718 __entry->dev = VFS_I(ip)->i_sb->s_dev; 719 __entry->ino = ip->i_ino; 720 __entry->lock_flags = lock_flags; 721 __entry->caller_ip = caller_ip; 722 ), 723 TP_printk("dev %d:%d ino 0x%llx flags %s caller %pS", 724 MAJOR(__entry->dev), MINOR(__entry->dev), 725 __entry->ino, 726 __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS), 727 (void *)__entry->caller_ip) 728 ) 729 730 #define DEFINE_LOCK_EVENT(name) \ 731 DEFINE_EVENT(xfs_lock_class, name, \ 732 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \ 733 unsigned long caller_ip), \ 734 TP_ARGS(ip, lock_flags, caller_ip)) 735 DEFINE_LOCK_EVENT(xfs_ilock); 736 DEFINE_LOCK_EVENT(xfs_ilock_nowait); 737 DEFINE_LOCK_EVENT(xfs_ilock_demote); 738 DEFINE_LOCK_EVENT(xfs_iunlock); 739 740 DECLARE_EVENT_CLASS(xfs_inode_class, 741 TP_PROTO(struct xfs_inode *ip), 742 TP_ARGS(ip), 743 TP_STRUCT__entry( 744 __field(dev_t, dev) 745 __field(xfs_ino_t, ino) 746 __field(unsigned long, iflags) 747 ), 748 TP_fast_assign( 749 __entry->dev = VFS_I(ip)->i_sb->s_dev; 750 __entry->ino = ip->i_ino; 751 __entry->iflags = ip->i_flags; 752 ), 753 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx", 754 MAJOR(__entry->dev), MINOR(__entry->dev), 755 __entry->ino, 756 __entry->iflags) 757 ) 758 759 #define DEFINE_INODE_EVENT(name) \ 760 DEFINE_EVENT(xfs_inode_class, name, \ 761 TP_PROTO(struct xfs_inode *ip), \ 762 TP_ARGS(ip)) 763 DEFINE_INODE_EVENT(xfs_iget_skip); 764 DEFINE_INODE_EVENT(xfs_iget_recycle); 765 DEFINE_INODE_EVENT(xfs_iget_recycle_fail); 766 DEFINE_INODE_EVENT(xfs_iget_hit); 767 DEFINE_INODE_EVENT(xfs_iget_miss); 768 769 DEFINE_INODE_EVENT(xfs_getattr); 770 DEFINE_INODE_EVENT(xfs_setattr); 771 DEFINE_INODE_EVENT(xfs_readlink); 772 DEFINE_INODE_EVENT(xfs_inactive_symlink); 773 DEFINE_INODE_EVENT(xfs_alloc_file_space); 774 DEFINE_INODE_EVENT(xfs_free_file_space); 775 DEFINE_INODE_EVENT(xfs_zero_file_space); 776 DEFINE_INODE_EVENT(xfs_collapse_file_space); 777 DEFINE_INODE_EVENT(xfs_insert_file_space); 778 DEFINE_INODE_EVENT(xfs_readdir); 779 #ifdef CONFIG_XFS_POSIX_ACL 780 DEFINE_INODE_EVENT(xfs_get_acl); 781 #endif 782 DEFINE_INODE_EVENT(xfs_vm_bmap); 783 DEFINE_INODE_EVENT(xfs_file_ioctl); 784 DEFINE_INODE_EVENT(xfs_file_compat_ioctl); 785 DEFINE_INODE_EVENT(xfs_ioctl_setattr); 786 DEFINE_INODE_EVENT(xfs_dir_fsync); 787 DEFINE_INODE_EVENT(xfs_file_fsync); 788 DEFINE_INODE_EVENT(xfs_destroy_inode); 789 DEFINE_INODE_EVENT(xfs_update_time); 790 791 DEFINE_INODE_EVENT(xfs_dquot_dqalloc); 792 DEFINE_INODE_EVENT(xfs_dquot_dqdetach); 793 794 DEFINE_INODE_EVENT(xfs_inode_set_eofblocks_tag); 795 DEFINE_INODE_EVENT(xfs_inode_clear_eofblocks_tag); 796 DEFINE_INODE_EVENT(xfs_inode_free_eofblocks_invalid); 797 DEFINE_INODE_EVENT(xfs_inode_set_cowblocks_tag); 798 DEFINE_INODE_EVENT(xfs_inode_clear_cowblocks_tag); 799 DEFINE_INODE_EVENT(xfs_inode_free_cowblocks_invalid); 800 DEFINE_INODE_EVENT(xfs_inode_set_reclaimable); 801 DEFINE_INODE_EVENT(xfs_inode_reclaiming); 802 DEFINE_INODE_EVENT(xfs_inode_set_need_inactive); 803 DEFINE_INODE_EVENT(xfs_inode_inactivating); 804 805 /* 806 * ftrace's __print_symbolic requires that all enum values be wrapped in the 807 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace 808 * ring buffer. Somehow this was only worth mentioning in the ftrace sample 809 * code. 810 */ 811 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED); 812 TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW); 813 814 TRACE_EVENT(xfs_filemap_fault, 815 TP_PROTO(struct xfs_inode *ip, unsigned int order, bool write_fault), 816 TP_ARGS(ip, order, write_fault), 817 TP_STRUCT__entry( 818 __field(dev_t, dev) 819 __field(xfs_ino_t, ino) 820 __field(unsigned int, order) 821 __field(bool, write_fault) 822 ), 823 TP_fast_assign( 824 __entry->dev = VFS_I(ip)->i_sb->s_dev; 825 __entry->ino = ip->i_ino; 826 __entry->order = order; 827 __entry->write_fault = write_fault; 828 ), 829 TP_printk("dev %d:%d ino 0x%llx order %u write_fault %d", 830 MAJOR(__entry->dev), MINOR(__entry->dev), 831 __entry->ino, 832 __entry->order, 833 __entry->write_fault) 834 ) 835 836 DECLARE_EVENT_CLASS(xfs_iref_class, 837 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), 838 TP_ARGS(ip, caller_ip), 839 TP_STRUCT__entry( 840 __field(dev_t, dev) 841 __field(xfs_ino_t, ino) 842 __field(int, count) 843 __field(int, pincount) 844 __field(unsigned long, caller_ip) 845 ), 846 TP_fast_assign( 847 __entry->dev = VFS_I(ip)->i_sb->s_dev; 848 __entry->ino = ip->i_ino; 849 __entry->count = atomic_read(&VFS_I(ip)->i_count); 850 __entry->pincount = atomic_read(&ip->i_pincount); 851 __entry->caller_ip = caller_ip; 852 ), 853 TP_printk("dev %d:%d ino 0x%llx count %d pincount %d caller %pS", 854 MAJOR(__entry->dev), MINOR(__entry->dev), 855 __entry->ino, 856 __entry->count, 857 __entry->pincount, 858 (char *)__entry->caller_ip) 859 ) 860 861 TRACE_EVENT(xfs_iomap_prealloc_size, 862 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t blocks, int shift, 863 unsigned int writeio_blocks), 864 TP_ARGS(ip, blocks, shift, writeio_blocks), 865 TP_STRUCT__entry( 866 __field(dev_t, dev) 867 __field(xfs_ino_t, ino) 868 __field(xfs_fsblock_t, blocks) 869 __field(int, shift) 870 __field(unsigned int, writeio_blocks) 871 ), 872 TP_fast_assign( 873 __entry->dev = VFS_I(ip)->i_sb->s_dev; 874 __entry->ino = ip->i_ino; 875 __entry->blocks = blocks; 876 __entry->shift = shift; 877 __entry->writeio_blocks = writeio_blocks; 878 ), 879 TP_printk("dev %d:%d ino 0x%llx prealloc blocks %llu shift %d " 880 "m_allocsize_blocks %u", 881 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, 882 __entry->blocks, __entry->shift, __entry->writeio_blocks) 883 ) 884 885 TRACE_EVENT(xfs_irec_merge_pre, 886 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino, 887 uint16_t holemask, xfs_agino_t nagino, uint16_t nholemask), 888 TP_ARGS(mp, agno, agino, holemask, nagino, nholemask), 889 TP_STRUCT__entry( 890 __field(dev_t, dev) 891 __field(xfs_agnumber_t, agno) 892 __field(xfs_agino_t, agino) 893 __field(uint16_t, holemask) 894 __field(xfs_agino_t, nagino) 895 __field(uint16_t, nholemask) 896 ), 897 TP_fast_assign( 898 __entry->dev = mp->m_super->s_dev; 899 __entry->agno = agno; 900 __entry->agino = agino; 901 __entry->holemask = holemask; 902 __entry->nagino = nagino; 903 __entry->nholemask = holemask; 904 ), 905 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x new_agino 0x%x new_holemask 0x%x", 906 MAJOR(__entry->dev), MINOR(__entry->dev), 907 __entry->agno, 908 __entry->agino, 909 __entry->holemask, 910 __entry->nagino, 911 __entry->nholemask) 912 ) 913 914 TRACE_EVENT(xfs_irec_merge_post, 915 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino, 916 uint16_t holemask), 917 TP_ARGS(mp, agno, agino, holemask), 918 TP_STRUCT__entry( 919 __field(dev_t, dev) 920 __field(xfs_agnumber_t, agno) 921 __field(xfs_agino_t, agino) 922 __field(uint16_t, holemask) 923 ), 924 TP_fast_assign( 925 __entry->dev = mp->m_super->s_dev; 926 __entry->agno = agno; 927 __entry->agino = agino; 928 __entry->holemask = holemask; 929 ), 930 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x", 931 MAJOR(__entry->dev), 932 MINOR(__entry->dev), 933 __entry->agno, 934 __entry->agino, 935 __entry->holemask) 936 ) 937 938 #define DEFINE_IREF_EVENT(name) \ 939 DEFINE_EVENT(xfs_iref_class, name, \ 940 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \ 941 TP_ARGS(ip, caller_ip)) 942 DEFINE_IREF_EVENT(xfs_irele); 943 DEFINE_IREF_EVENT(xfs_inode_pin); 944 DEFINE_IREF_EVENT(xfs_inode_unpin); 945 DEFINE_IREF_EVENT(xfs_inode_unpin_nowait); 946 947 DECLARE_EVENT_CLASS(xfs_namespace_class, 948 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), 949 TP_ARGS(dp, name), 950 TP_STRUCT__entry( 951 __field(dev_t, dev) 952 __field(xfs_ino_t, dp_ino) 953 __field(int, namelen) 954 __dynamic_array(char, name, name->len) 955 ), 956 TP_fast_assign( 957 __entry->dev = VFS_I(dp)->i_sb->s_dev; 958 __entry->dp_ino = dp->i_ino; 959 __entry->namelen = name->len; 960 memcpy(__get_str(name), name->name, name->len); 961 ), 962 TP_printk("dev %d:%d dp ino 0x%llx name %.*s", 963 MAJOR(__entry->dev), MINOR(__entry->dev), 964 __entry->dp_ino, 965 __entry->namelen, 966 __get_str(name)) 967 ) 968 969 #define DEFINE_NAMESPACE_EVENT(name) \ 970 DEFINE_EVENT(xfs_namespace_class, name, \ 971 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), \ 972 TP_ARGS(dp, name)) 973 DEFINE_NAMESPACE_EVENT(xfs_remove); 974 DEFINE_NAMESPACE_EVENT(xfs_link); 975 DEFINE_NAMESPACE_EVENT(xfs_lookup); 976 DEFINE_NAMESPACE_EVENT(xfs_create); 977 DEFINE_NAMESPACE_EVENT(xfs_symlink); 978 979 TRACE_EVENT(xfs_rename, 980 TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp, 981 struct xfs_name *src_name, struct xfs_name *target_name), 982 TP_ARGS(src_dp, target_dp, src_name, target_name), 983 TP_STRUCT__entry( 984 __field(dev_t, dev) 985 __field(xfs_ino_t, src_dp_ino) 986 __field(xfs_ino_t, target_dp_ino) 987 __field(int, src_namelen) 988 __field(int, target_namelen) 989 __dynamic_array(char, src_name, src_name->len) 990 __dynamic_array(char, target_name, target_name->len) 991 ), 992 TP_fast_assign( 993 __entry->dev = VFS_I(src_dp)->i_sb->s_dev; 994 __entry->src_dp_ino = src_dp->i_ino; 995 __entry->target_dp_ino = target_dp->i_ino; 996 __entry->src_namelen = src_name->len; 997 __entry->target_namelen = target_name->len; 998 memcpy(__get_str(src_name), src_name->name, src_name->len); 999 memcpy(__get_str(target_name), target_name->name, 1000 target_name->len); 1001 ), 1002 TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx" 1003 " src name %.*s target name %.*s", 1004 MAJOR(__entry->dev), MINOR(__entry->dev), 1005 __entry->src_dp_ino, 1006 __entry->target_dp_ino, 1007 __entry->src_namelen, 1008 __get_str(src_name), 1009 __entry->target_namelen, 1010 __get_str(target_name)) 1011 ) 1012 1013 DECLARE_EVENT_CLASS(xfs_dquot_class, 1014 TP_PROTO(struct xfs_dquot *dqp), 1015 TP_ARGS(dqp), 1016 TP_STRUCT__entry( 1017 __field(dev_t, dev) 1018 __field(u32, id) 1019 __field(xfs_dqtype_t, type) 1020 __field(unsigned, flags) 1021 __field(unsigned, nrefs) 1022 __field(unsigned long long, res_bcount) 1023 __field(unsigned long long, res_rtbcount) 1024 __field(unsigned long long, res_icount) 1025 1026 __field(unsigned long long, bcount) 1027 __field(unsigned long long, rtbcount) 1028 __field(unsigned long long, icount) 1029 1030 __field(unsigned long long, blk_hardlimit) 1031 __field(unsigned long long, blk_softlimit) 1032 __field(unsigned long long, rtb_hardlimit) 1033 __field(unsigned long long, rtb_softlimit) 1034 __field(unsigned long long, ino_hardlimit) 1035 __field(unsigned long long, ino_softlimit) 1036 ), 1037 TP_fast_assign( 1038 __entry->dev = dqp->q_mount->m_super->s_dev; 1039 __entry->id = dqp->q_id; 1040 __entry->type = dqp->q_type; 1041 __entry->flags = dqp->q_flags; 1042 __entry->nrefs = dqp->q_nrefs; 1043 1044 __entry->res_bcount = dqp->q_blk.reserved; 1045 __entry->res_rtbcount = dqp->q_rtb.reserved; 1046 __entry->res_icount = dqp->q_ino.reserved; 1047 1048 __entry->bcount = dqp->q_blk.count; 1049 __entry->rtbcount = dqp->q_rtb.count; 1050 __entry->icount = dqp->q_ino.count; 1051 1052 __entry->blk_hardlimit = dqp->q_blk.hardlimit; 1053 __entry->blk_softlimit = dqp->q_blk.softlimit; 1054 __entry->rtb_hardlimit = dqp->q_rtb.hardlimit; 1055 __entry->rtb_softlimit = dqp->q_rtb.softlimit; 1056 __entry->ino_hardlimit = dqp->q_ino.hardlimit; 1057 __entry->ino_softlimit = dqp->q_ino.softlimit; 1058 ), 1059 TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u " 1060 "res_bc 0x%llx res_rtbc 0x%llx res_ic 0x%llx " 1061 "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx " 1062 "rtbcnt 0x%llx rtbhardlimit 0x%llx rtbsoftlimit 0x%llx " 1063 "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]", 1064 MAJOR(__entry->dev), MINOR(__entry->dev), 1065 __entry->id, 1066 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1067 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1068 __entry->nrefs, 1069 __entry->res_bcount, 1070 __entry->res_rtbcount, 1071 __entry->res_icount, 1072 __entry->bcount, 1073 __entry->blk_hardlimit, 1074 __entry->blk_softlimit, 1075 __entry->rtbcount, 1076 __entry->rtb_hardlimit, 1077 __entry->rtb_softlimit, 1078 __entry->icount, 1079 __entry->ino_hardlimit, 1080 __entry->ino_softlimit) 1081 ) 1082 1083 #define DEFINE_DQUOT_EVENT(name) \ 1084 DEFINE_EVENT(xfs_dquot_class, name, \ 1085 TP_PROTO(struct xfs_dquot *dqp), \ 1086 TP_ARGS(dqp)) 1087 DEFINE_DQUOT_EVENT(xfs_dqadjust); 1088 DEFINE_DQUOT_EVENT(xfs_dqreclaim_want); 1089 DEFINE_DQUOT_EVENT(xfs_dqreclaim_dirty); 1090 DEFINE_DQUOT_EVENT(xfs_dqreclaim_busy); 1091 DEFINE_DQUOT_EVENT(xfs_dqreclaim_done); 1092 DEFINE_DQUOT_EVENT(xfs_dqattach_found); 1093 DEFINE_DQUOT_EVENT(xfs_dqattach_get); 1094 DEFINE_DQUOT_EVENT(xfs_dqalloc); 1095 DEFINE_DQUOT_EVENT(xfs_dqtobp_read); 1096 DEFINE_DQUOT_EVENT(xfs_dqread); 1097 DEFINE_DQUOT_EVENT(xfs_dqread_fail); 1098 DEFINE_DQUOT_EVENT(xfs_dqget_hit); 1099 DEFINE_DQUOT_EVENT(xfs_dqget_miss); 1100 DEFINE_DQUOT_EVENT(xfs_dqget_freeing); 1101 DEFINE_DQUOT_EVENT(xfs_dqget_dup); 1102 DEFINE_DQUOT_EVENT(xfs_dqput); 1103 DEFINE_DQUOT_EVENT(xfs_dqput_free); 1104 DEFINE_DQUOT_EVENT(xfs_dqrele); 1105 DEFINE_DQUOT_EVENT(xfs_dqflush); 1106 DEFINE_DQUOT_EVENT(xfs_dqflush_force); 1107 DEFINE_DQUOT_EVENT(xfs_dqflush_done); 1108 DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_before); 1109 DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_after); 1110 1111 TRACE_EVENT(xfs_trans_mod_dquot, 1112 TP_PROTO(struct xfs_trans *tp, struct xfs_dquot *dqp, 1113 unsigned int field, int64_t delta), 1114 TP_ARGS(tp, dqp, field, delta), 1115 TP_STRUCT__entry( 1116 __field(dev_t, dev) 1117 __field(xfs_dqtype_t, type) 1118 __field(unsigned int, flags) 1119 __field(unsigned int, dqid) 1120 __field(unsigned int, field) 1121 __field(int64_t, delta) 1122 ), 1123 TP_fast_assign( 1124 __entry->dev = tp->t_mountp->m_super->s_dev; 1125 __entry->type = dqp->q_type; 1126 __entry->flags = dqp->q_flags; 1127 __entry->dqid = dqp->q_id; 1128 __entry->field = field; 1129 __entry->delta = delta; 1130 ), 1131 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s field %s delta %lld", 1132 MAJOR(__entry->dev), MINOR(__entry->dev), 1133 __entry->dqid, 1134 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1135 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1136 __print_flags(__entry->field, "|", XFS_QMOPT_FLAGS), 1137 __entry->delta) 1138 ); 1139 1140 DECLARE_EVENT_CLASS(xfs_dqtrx_class, 1141 TP_PROTO(struct xfs_dqtrx *qtrx), 1142 TP_ARGS(qtrx), 1143 TP_STRUCT__entry( 1144 __field(dev_t, dev) 1145 __field(xfs_dqtype_t, type) 1146 __field(unsigned int, flags) 1147 __field(u32, dqid) 1148 1149 __field(uint64_t, blk_res) 1150 __field(int64_t, bcount_delta) 1151 __field(int64_t, delbcnt_delta) 1152 1153 __field(uint64_t, rtblk_res) 1154 __field(uint64_t, rtblk_res_used) 1155 __field(int64_t, rtbcount_delta) 1156 __field(int64_t, delrtb_delta) 1157 1158 __field(uint64_t, ino_res) 1159 __field(uint64_t, ino_res_used) 1160 __field(int64_t, icount_delta) 1161 ), 1162 TP_fast_assign( 1163 __entry->dev = qtrx->qt_dquot->q_mount->m_super->s_dev; 1164 __entry->type = qtrx->qt_dquot->q_type; 1165 __entry->flags = qtrx->qt_dquot->q_flags; 1166 __entry->dqid = qtrx->qt_dquot->q_id; 1167 1168 __entry->blk_res = qtrx->qt_blk_res; 1169 __entry->bcount_delta = qtrx->qt_bcount_delta; 1170 __entry->delbcnt_delta = qtrx->qt_delbcnt_delta; 1171 1172 __entry->rtblk_res = qtrx->qt_rtblk_res; 1173 __entry->rtblk_res_used = qtrx->qt_rtblk_res_used; 1174 __entry->rtbcount_delta = qtrx->qt_rtbcount_delta; 1175 __entry->delrtb_delta = qtrx->qt_delrtb_delta; 1176 1177 __entry->ino_res = qtrx->qt_ino_res; 1178 __entry->ino_res_used = qtrx->qt_ino_res_used; 1179 __entry->icount_delta = qtrx->qt_icount_delta; 1180 ), 1181 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s " 1182 "blk_res %llu bcount_delta %lld delbcnt_delta %lld " 1183 "rtblk_res %llu rtblk_res_used %llu rtbcount_delta %lld delrtb_delta %lld " 1184 "ino_res %llu ino_res_used %llu icount_delta %lld", 1185 MAJOR(__entry->dev), MINOR(__entry->dev), 1186 __entry->dqid, 1187 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1188 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1189 1190 __entry->blk_res, 1191 __entry->bcount_delta, 1192 __entry->delbcnt_delta, 1193 1194 __entry->rtblk_res, 1195 __entry->rtblk_res_used, 1196 __entry->rtbcount_delta, 1197 __entry->delrtb_delta, 1198 1199 __entry->ino_res, 1200 __entry->ino_res_used, 1201 __entry->icount_delta) 1202 ) 1203 1204 #define DEFINE_DQTRX_EVENT(name) \ 1205 DEFINE_EVENT(xfs_dqtrx_class, name, \ 1206 TP_PROTO(struct xfs_dqtrx *qtrx), \ 1207 TP_ARGS(qtrx)) 1208 DEFINE_DQTRX_EVENT(xfs_trans_apply_dquot_deltas); 1209 DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_before); 1210 DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_after); 1211 1212 DECLARE_EVENT_CLASS(xfs_loggrant_class, 1213 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), 1214 TP_ARGS(log, tic), 1215 TP_STRUCT__entry( 1216 __field(dev_t, dev) 1217 __field(char, ocnt) 1218 __field(char, cnt) 1219 __field(int, curr_res) 1220 __field(int, unit_res) 1221 __field(unsigned int, flags) 1222 __field(int, reserveq) 1223 __field(int, writeq) 1224 __field(int, grant_reserve_cycle) 1225 __field(int, grant_reserve_bytes) 1226 __field(int, grant_write_cycle) 1227 __field(int, grant_write_bytes) 1228 __field(int, curr_cycle) 1229 __field(int, curr_block) 1230 __field(xfs_lsn_t, tail_lsn) 1231 ), 1232 TP_fast_assign( 1233 __entry->dev = log->l_mp->m_super->s_dev; 1234 __entry->ocnt = tic->t_ocnt; 1235 __entry->cnt = tic->t_cnt; 1236 __entry->curr_res = tic->t_curr_res; 1237 __entry->unit_res = tic->t_unit_res; 1238 __entry->flags = tic->t_flags; 1239 __entry->reserveq = list_empty(&log->l_reserve_head.waiters); 1240 __entry->writeq = list_empty(&log->l_write_head.waiters); 1241 xlog_crack_grant_head(&log->l_reserve_head.grant, 1242 &__entry->grant_reserve_cycle, 1243 &__entry->grant_reserve_bytes); 1244 xlog_crack_grant_head(&log->l_write_head.grant, 1245 &__entry->grant_write_cycle, 1246 &__entry->grant_write_bytes); 1247 __entry->curr_cycle = log->l_curr_cycle; 1248 __entry->curr_block = log->l_curr_block; 1249 __entry->tail_lsn = atomic64_read(&log->l_tail_lsn); 1250 ), 1251 TP_printk("dev %d:%d t_ocnt %u t_cnt %u t_curr_res %u " 1252 "t_unit_res %u t_flags %s reserveq %s " 1253 "writeq %s grant_reserve_cycle %d " 1254 "grant_reserve_bytes %d grant_write_cycle %d " 1255 "grant_write_bytes %d curr_cycle %d curr_block %d " 1256 "tail_cycle %d tail_block %d", 1257 MAJOR(__entry->dev), MINOR(__entry->dev), 1258 __entry->ocnt, 1259 __entry->cnt, 1260 __entry->curr_res, 1261 __entry->unit_res, 1262 __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS), 1263 __entry->reserveq ? "empty" : "active", 1264 __entry->writeq ? "empty" : "active", 1265 __entry->grant_reserve_cycle, 1266 __entry->grant_reserve_bytes, 1267 __entry->grant_write_cycle, 1268 __entry->grant_write_bytes, 1269 __entry->curr_cycle, 1270 __entry->curr_block, 1271 CYCLE_LSN(__entry->tail_lsn), 1272 BLOCK_LSN(__entry->tail_lsn) 1273 ) 1274 ) 1275 1276 #define DEFINE_LOGGRANT_EVENT(name) \ 1277 DEFINE_EVENT(xfs_loggrant_class, name, \ 1278 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \ 1279 TP_ARGS(log, tic)) 1280 DEFINE_LOGGRANT_EVENT(xfs_log_umount_write); 1281 DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep); 1282 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake); 1283 DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake_up); 1284 DEFINE_LOGGRANT_EVENT(xfs_log_reserve); 1285 DEFINE_LOGGRANT_EVENT(xfs_log_reserve_exit); 1286 DEFINE_LOGGRANT_EVENT(xfs_log_regrant); 1287 DEFINE_LOGGRANT_EVENT(xfs_log_regrant_exit); 1288 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant); 1289 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_exit); 1290 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_sub); 1291 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant); 1292 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_sub); 1293 DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_exit); 1294 DEFINE_LOGGRANT_EVENT(xfs_log_cil_wait); 1295 1296 DECLARE_EVENT_CLASS(xfs_log_item_class, 1297 TP_PROTO(struct xfs_log_item *lip), 1298 TP_ARGS(lip), 1299 TP_STRUCT__entry( 1300 __field(dev_t, dev) 1301 __field(void *, lip) 1302 __field(uint, type) 1303 __field(unsigned long, flags) 1304 __field(xfs_lsn_t, lsn) 1305 ), 1306 TP_fast_assign( 1307 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1308 __entry->lip = lip; 1309 __entry->type = lip->li_type; 1310 __entry->flags = lip->li_flags; 1311 __entry->lsn = lip->li_lsn; 1312 ), 1313 TP_printk("dev %d:%d lip %p lsn %d/%d type %s flags %s", 1314 MAJOR(__entry->dev), MINOR(__entry->dev), 1315 __entry->lip, 1316 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn), 1317 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1318 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1319 ) 1320 1321 TRACE_EVENT(xfs_log_force, 1322 TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn, unsigned long caller_ip), 1323 TP_ARGS(mp, lsn, caller_ip), 1324 TP_STRUCT__entry( 1325 __field(dev_t, dev) 1326 __field(xfs_lsn_t, lsn) 1327 __field(unsigned long, caller_ip) 1328 ), 1329 TP_fast_assign( 1330 __entry->dev = mp->m_super->s_dev; 1331 __entry->lsn = lsn; 1332 __entry->caller_ip = caller_ip; 1333 ), 1334 TP_printk("dev %d:%d lsn 0x%llx caller %pS", 1335 MAJOR(__entry->dev), MINOR(__entry->dev), 1336 __entry->lsn, (void *)__entry->caller_ip) 1337 ) 1338 1339 #define DEFINE_LOG_ITEM_EVENT(name) \ 1340 DEFINE_EVENT(xfs_log_item_class, name, \ 1341 TP_PROTO(struct xfs_log_item *lip), \ 1342 TP_ARGS(lip)) 1343 DEFINE_LOG_ITEM_EVENT(xfs_ail_push); 1344 DEFINE_LOG_ITEM_EVENT(xfs_ail_pinned); 1345 DEFINE_LOG_ITEM_EVENT(xfs_ail_locked); 1346 DEFINE_LOG_ITEM_EVENT(xfs_ail_flushing); 1347 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_mark); 1348 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_skip); 1349 DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_unpin); 1350 1351 DECLARE_EVENT_CLASS(xfs_ail_class, 1352 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), 1353 TP_ARGS(lip, old_lsn, new_lsn), 1354 TP_STRUCT__entry( 1355 __field(dev_t, dev) 1356 __field(void *, lip) 1357 __field(uint, type) 1358 __field(unsigned long, flags) 1359 __field(xfs_lsn_t, old_lsn) 1360 __field(xfs_lsn_t, new_lsn) 1361 ), 1362 TP_fast_assign( 1363 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1364 __entry->lip = lip; 1365 __entry->type = lip->li_type; 1366 __entry->flags = lip->li_flags; 1367 __entry->old_lsn = old_lsn; 1368 __entry->new_lsn = new_lsn; 1369 ), 1370 TP_printk("dev %d:%d lip %p old lsn %d/%d new lsn %d/%d type %s flags %s", 1371 MAJOR(__entry->dev), MINOR(__entry->dev), 1372 __entry->lip, 1373 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1374 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1375 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1376 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1377 ) 1378 1379 #define DEFINE_AIL_EVENT(name) \ 1380 DEFINE_EVENT(xfs_ail_class, name, \ 1381 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \ 1382 TP_ARGS(lip, old_lsn, new_lsn)) 1383 DEFINE_AIL_EVENT(xfs_ail_insert); 1384 DEFINE_AIL_EVENT(xfs_ail_move); 1385 DEFINE_AIL_EVENT(xfs_ail_delete); 1386 1387 TRACE_EVENT(xfs_log_assign_tail_lsn, 1388 TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn), 1389 TP_ARGS(log, new_lsn), 1390 TP_STRUCT__entry( 1391 __field(dev_t, dev) 1392 __field(xfs_lsn_t, new_lsn) 1393 __field(xfs_lsn_t, old_lsn) 1394 __field(xfs_lsn_t, last_sync_lsn) 1395 ), 1396 TP_fast_assign( 1397 __entry->dev = log->l_mp->m_super->s_dev; 1398 __entry->new_lsn = new_lsn; 1399 __entry->old_lsn = atomic64_read(&log->l_tail_lsn); 1400 __entry->last_sync_lsn = atomic64_read(&log->l_last_sync_lsn); 1401 ), 1402 TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, last sync %d/%d", 1403 MAJOR(__entry->dev), MINOR(__entry->dev), 1404 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1405 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1406 CYCLE_LSN(__entry->last_sync_lsn), BLOCK_LSN(__entry->last_sync_lsn)) 1407 ) 1408 1409 DECLARE_EVENT_CLASS(xfs_file_class, 1410 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), 1411 TP_ARGS(iocb, iter), 1412 TP_STRUCT__entry( 1413 __field(dev_t, dev) 1414 __field(xfs_ino_t, ino) 1415 __field(xfs_fsize_t, size) 1416 __field(loff_t, offset) 1417 __field(size_t, count) 1418 ), 1419 TP_fast_assign( 1420 __entry->dev = file_inode(iocb->ki_filp)->i_sb->s_dev; 1421 __entry->ino = XFS_I(file_inode(iocb->ki_filp))->i_ino; 1422 __entry->size = XFS_I(file_inode(iocb->ki_filp))->i_disk_size; 1423 __entry->offset = iocb->ki_pos; 1424 __entry->count = iov_iter_count(iter); 1425 ), 1426 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx", 1427 MAJOR(__entry->dev), MINOR(__entry->dev), 1428 __entry->ino, 1429 __entry->size, 1430 __entry->offset, 1431 __entry->count) 1432 ) 1433 1434 #define DEFINE_RW_EVENT(name) \ 1435 DEFINE_EVENT(xfs_file_class, name, \ 1436 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \ 1437 TP_ARGS(iocb, iter)) 1438 DEFINE_RW_EVENT(xfs_file_buffered_read); 1439 DEFINE_RW_EVENT(xfs_file_direct_read); 1440 DEFINE_RW_EVENT(xfs_file_dax_read); 1441 DEFINE_RW_EVENT(xfs_file_buffered_write); 1442 DEFINE_RW_EVENT(xfs_file_direct_write); 1443 DEFINE_RW_EVENT(xfs_file_dax_write); 1444 DEFINE_RW_EVENT(xfs_reflink_bounce_dio_write); 1445 1446 DECLARE_EVENT_CLASS(xfs_imap_class, 1447 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, 1448 int whichfork, struct xfs_bmbt_irec *irec), 1449 TP_ARGS(ip, offset, count, whichfork, irec), 1450 TP_STRUCT__entry( 1451 __field(dev_t, dev) 1452 __field(xfs_ino_t, ino) 1453 __field(loff_t, size) 1454 __field(loff_t, offset) 1455 __field(size_t, count) 1456 __field(int, whichfork) 1457 __field(xfs_fileoff_t, startoff) 1458 __field(xfs_fsblock_t, startblock) 1459 __field(xfs_filblks_t, blockcount) 1460 ), 1461 TP_fast_assign( 1462 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1463 __entry->ino = ip->i_ino; 1464 __entry->size = ip->i_disk_size; 1465 __entry->offset = offset; 1466 __entry->count = count; 1467 __entry->whichfork = whichfork; 1468 __entry->startoff = irec ? irec->br_startoff : 0; 1469 __entry->startblock = irec ? irec->br_startblock : 0; 1470 __entry->blockcount = irec ? irec->br_blockcount : 0; 1471 ), 1472 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx " 1473 "fork %s startoff 0x%llx startblock 0x%llx fsbcount 0x%llx", 1474 MAJOR(__entry->dev), MINOR(__entry->dev), 1475 __entry->ino, 1476 __entry->size, 1477 __entry->offset, 1478 __entry->count, 1479 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 1480 __entry->startoff, 1481 (int64_t)__entry->startblock, 1482 __entry->blockcount) 1483 ) 1484 1485 #define DEFINE_IMAP_EVENT(name) \ 1486 DEFINE_EVENT(xfs_imap_class, name, \ 1487 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \ 1488 int whichfork, struct xfs_bmbt_irec *irec), \ 1489 TP_ARGS(ip, offset, count, whichfork, irec)) 1490 DEFINE_IMAP_EVENT(xfs_map_blocks_found); 1491 DEFINE_IMAP_EVENT(xfs_map_blocks_alloc); 1492 DEFINE_IMAP_EVENT(xfs_iomap_alloc); 1493 DEFINE_IMAP_EVENT(xfs_iomap_found); 1494 1495 DECLARE_EVENT_CLASS(xfs_simple_io_class, 1496 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), 1497 TP_ARGS(ip, offset, count), 1498 TP_STRUCT__entry( 1499 __field(dev_t, dev) 1500 __field(xfs_ino_t, ino) 1501 __field(loff_t, isize) 1502 __field(loff_t, disize) 1503 __field(loff_t, offset) 1504 __field(size_t, count) 1505 ), 1506 TP_fast_assign( 1507 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1508 __entry->ino = ip->i_ino; 1509 __entry->isize = VFS_I(ip)->i_size; 1510 __entry->disize = ip->i_disk_size; 1511 __entry->offset = offset; 1512 __entry->count = count; 1513 ), 1514 TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx " 1515 "pos 0x%llx bytecount 0x%zx", 1516 MAJOR(__entry->dev), MINOR(__entry->dev), 1517 __entry->ino, 1518 __entry->isize, 1519 __entry->disize, 1520 __entry->offset, 1521 __entry->count) 1522 ); 1523 1524 #define DEFINE_SIMPLE_IO_EVENT(name) \ 1525 DEFINE_EVENT(xfs_simple_io_class, name, \ 1526 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \ 1527 TP_ARGS(ip, offset, count)) 1528 DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc); 1529 DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert); 1530 DEFINE_SIMPLE_IO_EVENT(xfs_setfilesize); 1531 DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof); 1532 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write); 1533 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write_unwritten); 1534 DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write_append); 1535 DEFINE_SIMPLE_IO_EVENT(xfs_file_splice_read); 1536 1537 DECLARE_EVENT_CLASS(xfs_itrunc_class, 1538 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), 1539 TP_ARGS(ip, new_size), 1540 TP_STRUCT__entry( 1541 __field(dev_t, dev) 1542 __field(xfs_ino_t, ino) 1543 __field(xfs_fsize_t, size) 1544 __field(xfs_fsize_t, new_size) 1545 ), 1546 TP_fast_assign( 1547 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1548 __entry->ino = ip->i_ino; 1549 __entry->size = ip->i_disk_size; 1550 __entry->new_size = new_size; 1551 ), 1552 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx new_size 0x%llx", 1553 MAJOR(__entry->dev), MINOR(__entry->dev), 1554 __entry->ino, 1555 __entry->size, 1556 __entry->new_size) 1557 ) 1558 1559 #define DEFINE_ITRUNC_EVENT(name) \ 1560 DEFINE_EVENT(xfs_itrunc_class, name, \ 1561 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \ 1562 TP_ARGS(ip, new_size)) 1563 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_start); 1564 DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_end); 1565 1566 TRACE_EVENT(xfs_pagecache_inval, 1567 TP_PROTO(struct xfs_inode *ip, xfs_off_t start, xfs_off_t finish), 1568 TP_ARGS(ip, start, finish), 1569 TP_STRUCT__entry( 1570 __field(dev_t, dev) 1571 __field(xfs_ino_t, ino) 1572 __field(xfs_fsize_t, size) 1573 __field(xfs_off_t, start) 1574 __field(xfs_off_t, finish) 1575 ), 1576 TP_fast_assign( 1577 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1578 __entry->ino = ip->i_ino; 1579 __entry->size = ip->i_disk_size; 1580 __entry->start = start; 1581 __entry->finish = finish; 1582 ), 1583 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx start 0x%llx finish 0x%llx", 1584 MAJOR(__entry->dev), MINOR(__entry->dev), 1585 __entry->ino, 1586 __entry->size, 1587 __entry->start, 1588 __entry->finish) 1589 ); 1590 1591 TRACE_EVENT(xfs_bunmap, 1592 TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t fileoff, xfs_filblks_t len, 1593 int flags, unsigned long caller_ip), 1594 TP_ARGS(ip, fileoff, len, flags, caller_ip), 1595 TP_STRUCT__entry( 1596 __field(dev_t, dev) 1597 __field(xfs_ino_t, ino) 1598 __field(xfs_fsize_t, size) 1599 __field(xfs_fileoff_t, fileoff) 1600 __field(xfs_filblks_t, len) 1601 __field(unsigned long, caller_ip) 1602 __field(int, flags) 1603 ), 1604 TP_fast_assign( 1605 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1606 __entry->ino = ip->i_ino; 1607 __entry->size = ip->i_disk_size; 1608 __entry->fileoff = fileoff; 1609 __entry->len = len; 1610 __entry->caller_ip = caller_ip; 1611 __entry->flags = flags; 1612 ), 1613 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx fileoff 0x%llx fsbcount 0x%llx " 1614 "flags %s caller %pS", 1615 MAJOR(__entry->dev), MINOR(__entry->dev), 1616 __entry->ino, 1617 __entry->size, 1618 __entry->fileoff, 1619 __entry->len, 1620 __print_flags(__entry->flags, "|", XFS_BMAPI_FLAGS), 1621 (void *)__entry->caller_ip) 1622 1623 ); 1624 1625 DECLARE_EVENT_CLASS(xfs_extent_busy_class, 1626 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1627 xfs_agblock_t agbno, xfs_extlen_t len), 1628 TP_ARGS(mp, agno, agbno, len), 1629 TP_STRUCT__entry( 1630 __field(dev_t, dev) 1631 __field(xfs_agnumber_t, agno) 1632 __field(xfs_agblock_t, agbno) 1633 __field(xfs_extlen_t, len) 1634 ), 1635 TP_fast_assign( 1636 __entry->dev = mp->m_super->s_dev; 1637 __entry->agno = agno; 1638 __entry->agbno = agbno; 1639 __entry->len = len; 1640 ), 1641 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 1642 MAJOR(__entry->dev), MINOR(__entry->dev), 1643 __entry->agno, 1644 __entry->agbno, 1645 __entry->len) 1646 ); 1647 #define DEFINE_BUSY_EVENT(name) \ 1648 DEFINE_EVENT(xfs_extent_busy_class, name, \ 1649 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 1650 xfs_agblock_t agbno, xfs_extlen_t len), \ 1651 TP_ARGS(mp, agno, agbno, len)) 1652 DEFINE_BUSY_EVENT(xfs_extent_busy); 1653 DEFINE_BUSY_EVENT(xfs_extent_busy_enomem); 1654 DEFINE_BUSY_EVENT(xfs_extent_busy_force); 1655 DEFINE_BUSY_EVENT(xfs_extent_busy_reuse); 1656 DEFINE_BUSY_EVENT(xfs_extent_busy_clear); 1657 1658 TRACE_EVENT(xfs_extent_busy_trim, 1659 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 1660 xfs_agblock_t agbno, xfs_extlen_t len, 1661 xfs_agblock_t tbno, xfs_extlen_t tlen), 1662 TP_ARGS(mp, agno, agbno, len, tbno, tlen), 1663 TP_STRUCT__entry( 1664 __field(dev_t, dev) 1665 __field(xfs_agnumber_t, agno) 1666 __field(xfs_agblock_t, agbno) 1667 __field(xfs_extlen_t, len) 1668 __field(xfs_agblock_t, tbno) 1669 __field(xfs_extlen_t, tlen) 1670 ), 1671 TP_fast_assign( 1672 __entry->dev = mp->m_super->s_dev; 1673 __entry->agno = agno; 1674 __entry->agbno = agbno; 1675 __entry->len = len; 1676 __entry->tbno = tbno; 1677 __entry->tlen = tlen; 1678 ), 1679 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x found_agbno 0x%x found_fsbcount 0x%x", 1680 MAJOR(__entry->dev), MINOR(__entry->dev), 1681 __entry->agno, 1682 __entry->agbno, 1683 __entry->len, 1684 __entry->tbno, 1685 __entry->tlen) 1686 ); 1687 1688 DECLARE_EVENT_CLASS(xfs_agf_class, 1689 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, 1690 unsigned long caller_ip), 1691 TP_ARGS(mp, agf, flags, caller_ip), 1692 TP_STRUCT__entry( 1693 __field(dev_t, dev) 1694 __field(xfs_agnumber_t, agno) 1695 __field(int, flags) 1696 __field(__u32, length) 1697 __field(__u32, bno_root) 1698 __field(__u32, cnt_root) 1699 __field(__u32, bno_level) 1700 __field(__u32, cnt_level) 1701 __field(__u32, flfirst) 1702 __field(__u32, fllast) 1703 __field(__u32, flcount) 1704 __field(__u32, freeblks) 1705 __field(__u32, longest) 1706 __field(unsigned long, caller_ip) 1707 ), 1708 TP_fast_assign( 1709 __entry->dev = mp->m_super->s_dev; 1710 __entry->agno = be32_to_cpu(agf->agf_seqno), 1711 __entry->flags = flags; 1712 __entry->length = be32_to_cpu(agf->agf_length), 1713 __entry->bno_root = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]), 1714 __entry->cnt_root = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]), 1715 __entry->bno_level = 1716 be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]), 1717 __entry->cnt_level = 1718 be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]), 1719 __entry->flfirst = be32_to_cpu(agf->agf_flfirst), 1720 __entry->fllast = be32_to_cpu(agf->agf_fllast), 1721 __entry->flcount = be32_to_cpu(agf->agf_flcount), 1722 __entry->freeblks = be32_to_cpu(agf->agf_freeblks), 1723 __entry->longest = be32_to_cpu(agf->agf_longest); 1724 __entry->caller_ip = caller_ip; 1725 ), 1726 TP_printk("dev %d:%d agno 0x%x flags %s length %u roots b %u c %u " 1727 "levels b %u c %u flfirst %u fllast %u flcount %u " 1728 "freeblks %u longest %u caller %pS", 1729 MAJOR(__entry->dev), MINOR(__entry->dev), 1730 __entry->agno, 1731 __print_flags(__entry->flags, "|", XFS_AGF_FLAGS), 1732 __entry->length, 1733 __entry->bno_root, 1734 __entry->cnt_root, 1735 __entry->bno_level, 1736 __entry->cnt_level, 1737 __entry->flfirst, 1738 __entry->fllast, 1739 __entry->flcount, 1740 __entry->freeblks, 1741 __entry->longest, 1742 (void *)__entry->caller_ip) 1743 ); 1744 #define DEFINE_AGF_EVENT(name) \ 1745 DEFINE_EVENT(xfs_agf_class, name, \ 1746 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, \ 1747 unsigned long caller_ip), \ 1748 TP_ARGS(mp, agf, flags, caller_ip)) 1749 DEFINE_AGF_EVENT(xfs_agf); 1750 DEFINE_AGF_EVENT(xfs_agfl_reset); 1751 1752 TRACE_EVENT(xfs_free_extent, 1753 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, 1754 xfs_extlen_t len, enum xfs_ag_resv_type resv, int haveleft, 1755 int haveright), 1756 TP_ARGS(mp, agno, agbno, len, resv, haveleft, haveright), 1757 TP_STRUCT__entry( 1758 __field(dev_t, dev) 1759 __field(xfs_agnumber_t, agno) 1760 __field(xfs_agblock_t, agbno) 1761 __field(xfs_extlen_t, len) 1762 __field(int, resv) 1763 __field(int, haveleft) 1764 __field(int, haveright) 1765 ), 1766 TP_fast_assign( 1767 __entry->dev = mp->m_super->s_dev; 1768 __entry->agno = agno; 1769 __entry->agbno = agbno; 1770 __entry->len = len; 1771 __entry->resv = resv; 1772 __entry->haveleft = haveleft; 1773 __entry->haveright = haveright; 1774 ), 1775 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x resv %d %s", 1776 MAJOR(__entry->dev), MINOR(__entry->dev), 1777 __entry->agno, 1778 __entry->agbno, 1779 __entry->len, 1780 __entry->resv, 1781 __entry->haveleft ? 1782 (__entry->haveright ? "both" : "left") : 1783 (__entry->haveright ? "right" : "none")) 1784 1785 ); 1786 1787 DECLARE_EVENT_CLASS(xfs_alloc_class, 1788 TP_PROTO(struct xfs_alloc_arg *args), 1789 TP_ARGS(args), 1790 TP_STRUCT__entry( 1791 __field(dev_t, dev) 1792 __field(xfs_agnumber_t, agno) 1793 __field(xfs_agblock_t, agbno) 1794 __field(xfs_extlen_t, minlen) 1795 __field(xfs_extlen_t, maxlen) 1796 __field(xfs_extlen_t, mod) 1797 __field(xfs_extlen_t, prod) 1798 __field(xfs_extlen_t, minleft) 1799 __field(xfs_extlen_t, total) 1800 __field(xfs_extlen_t, alignment) 1801 __field(xfs_extlen_t, minalignslop) 1802 __field(xfs_extlen_t, len) 1803 __field(char, wasdel) 1804 __field(char, wasfromfl) 1805 __field(int, resv) 1806 __field(int, datatype) 1807 __field(xfs_agnumber_t, highest_agno) 1808 ), 1809 TP_fast_assign( 1810 __entry->dev = args->mp->m_super->s_dev; 1811 __entry->agno = args->agno; 1812 __entry->agbno = args->agbno; 1813 __entry->minlen = args->minlen; 1814 __entry->maxlen = args->maxlen; 1815 __entry->mod = args->mod; 1816 __entry->prod = args->prod; 1817 __entry->minleft = args->minleft; 1818 __entry->total = args->total; 1819 __entry->alignment = args->alignment; 1820 __entry->minalignslop = args->minalignslop; 1821 __entry->len = args->len; 1822 __entry->wasdel = args->wasdel; 1823 __entry->wasfromfl = args->wasfromfl; 1824 __entry->resv = args->resv; 1825 __entry->datatype = args->datatype; 1826 __entry->highest_agno = args->tp->t_highest_agno; 1827 ), 1828 TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u " 1829 "prod %u minleft %u total %u alignment %u minalignslop %u " 1830 "len %u wasdel %d wasfromfl %d resv %d " 1831 "datatype 0x%x highest_agno 0x%x", 1832 MAJOR(__entry->dev), MINOR(__entry->dev), 1833 __entry->agno, 1834 __entry->agbno, 1835 __entry->minlen, 1836 __entry->maxlen, 1837 __entry->mod, 1838 __entry->prod, 1839 __entry->minleft, 1840 __entry->total, 1841 __entry->alignment, 1842 __entry->minalignslop, 1843 __entry->len, 1844 __entry->wasdel, 1845 __entry->wasfromfl, 1846 __entry->resv, 1847 __entry->datatype, 1848 __entry->highest_agno) 1849 ) 1850 1851 #define DEFINE_ALLOC_EVENT(name) \ 1852 DEFINE_EVENT(xfs_alloc_class, name, \ 1853 TP_PROTO(struct xfs_alloc_arg *args), \ 1854 TP_ARGS(args)) 1855 DEFINE_ALLOC_EVENT(xfs_alloc_exact_done); 1856 DEFINE_ALLOC_EVENT(xfs_alloc_exact_notfound); 1857 DEFINE_ALLOC_EVENT(xfs_alloc_exact_error); 1858 DEFINE_ALLOC_EVENT(xfs_alloc_near_nominleft); 1859 DEFINE_ALLOC_EVENT(xfs_alloc_near_first); 1860 DEFINE_ALLOC_EVENT(xfs_alloc_cur); 1861 DEFINE_ALLOC_EVENT(xfs_alloc_cur_right); 1862 DEFINE_ALLOC_EVENT(xfs_alloc_cur_left); 1863 DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup); 1864 DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup_done); 1865 DEFINE_ALLOC_EVENT(xfs_alloc_near_error); 1866 DEFINE_ALLOC_EVENT(xfs_alloc_near_noentry); 1867 DEFINE_ALLOC_EVENT(xfs_alloc_near_busy); 1868 DEFINE_ALLOC_EVENT(xfs_alloc_size_neither); 1869 DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry); 1870 DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft); 1871 DEFINE_ALLOC_EVENT(xfs_alloc_size_done); 1872 DEFINE_ALLOC_EVENT(xfs_alloc_size_error); 1873 DEFINE_ALLOC_EVENT(xfs_alloc_size_busy); 1874 DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist); 1875 DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough); 1876 DEFINE_ALLOC_EVENT(xfs_alloc_small_done); 1877 DEFINE_ALLOC_EVENT(xfs_alloc_small_error); 1878 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs); 1879 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_skip_deadlock); 1880 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix); 1881 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp); 1882 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed); 1883 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed); 1884 1885 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_this_ag); 1886 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_start_ag); 1887 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_first_ag); 1888 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_exact_bno); 1889 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_near_bno); 1890 DEFINE_ALLOC_EVENT(xfs_alloc_vextent_finish); 1891 1892 TRACE_EVENT(xfs_alloc_cur_check, 1893 TP_PROTO(struct xfs_mount *mp, xfs_btnum_t btnum, xfs_agblock_t bno, 1894 xfs_extlen_t len, xfs_extlen_t diff, bool new), 1895 TP_ARGS(mp, btnum, bno, len, diff, new), 1896 TP_STRUCT__entry( 1897 __field(dev_t, dev) 1898 __field(xfs_btnum_t, btnum) 1899 __field(xfs_agblock_t, bno) 1900 __field(xfs_extlen_t, len) 1901 __field(xfs_extlen_t, diff) 1902 __field(bool, new) 1903 ), 1904 TP_fast_assign( 1905 __entry->dev = mp->m_super->s_dev; 1906 __entry->btnum = btnum; 1907 __entry->bno = bno; 1908 __entry->len = len; 1909 __entry->diff = diff; 1910 __entry->new = new; 1911 ), 1912 TP_printk("dev %d:%d btree %s agbno 0x%x fsbcount 0x%x diff 0x%x new %d", 1913 MAJOR(__entry->dev), MINOR(__entry->dev), 1914 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 1915 __entry->bno, __entry->len, __entry->diff, __entry->new) 1916 ) 1917 1918 DECLARE_EVENT_CLASS(xfs_da_class, 1919 TP_PROTO(struct xfs_da_args *args), 1920 TP_ARGS(args), 1921 TP_STRUCT__entry( 1922 __field(dev_t, dev) 1923 __field(xfs_ino_t, ino) 1924 __dynamic_array(char, name, args->namelen) 1925 __field(int, namelen) 1926 __field(xfs_dahash_t, hashval) 1927 __field(xfs_ino_t, inumber) 1928 __field(uint32_t, op_flags) 1929 ), 1930 TP_fast_assign( 1931 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 1932 __entry->ino = args->dp->i_ino; 1933 if (args->namelen) 1934 memcpy(__get_str(name), args->name, args->namelen); 1935 __entry->namelen = args->namelen; 1936 __entry->hashval = args->hashval; 1937 __entry->inumber = args->inumber; 1938 __entry->op_flags = args->op_flags; 1939 ), 1940 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " 1941 "inumber 0x%llx op_flags %s", 1942 MAJOR(__entry->dev), MINOR(__entry->dev), 1943 __entry->ino, 1944 __entry->namelen, 1945 __entry->namelen ? __get_str(name) : NULL, 1946 __entry->namelen, 1947 __entry->hashval, 1948 __entry->inumber, 1949 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) 1950 ) 1951 1952 #define DEFINE_DIR2_EVENT(name) \ 1953 DEFINE_EVENT(xfs_da_class, name, \ 1954 TP_PROTO(struct xfs_da_args *args), \ 1955 TP_ARGS(args)) 1956 DEFINE_DIR2_EVENT(xfs_dir2_sf_addname); 1957 DEFINE_DIR2_EVENT(xfs_dir2_sf_create); 1958 DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup); 1959 DEFINE_DIR2_EVENT(xfs_dir2_sf_replace); 1960 DEFINE_DIR2_EVENT(xfs_dir2_sf_removename); 1961 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4); 1962 DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8); 1963 DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block); 1964 DEFINE_DIR2_EVENT(xfs_dir2_block_addname); 1965 DEFINE_DIR2_EVENT(xfs_dir2_block_lookup); 1966 DEFINE_DIR2_EVENT(xfs_dir2_block_replace); 1967 DEFINE_DIR2_EVENT(xfs_dir2_block_removename); 1968 DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf); 1969 DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf); 1970 DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname); 1971 DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup); 1972 DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace); 1973 DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename); 1974 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block); 1975 DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node); 1976 DEFINE_DIR2_EVENT(xfs_dir2_node_addname); 1977 DEFINE_DIR2_EVENT(xfs_dir2_node_lookup); 1978 DEFINE_DIR2_EVENT(xfs_dir2_node_replace); 1979 DEFINE_DIR2_EVENT(xfs_dir2_node_removename); 1980 DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf); 1981 1982 DECLARE_EVENT_CLASS(xfs_attr_class, 1983 TP_PROTO(struct xfs_da_args *args), 1984 TP_ARGS(args), 1985 TP_STRUCT__entry( 1986 __field(dev_t, dev) 1987 __field(xfs_ino_t, ino) 1988 __dynamic_array(char, name, args->namelen) 1989 __field(int, namelen) 1990 __field(int, valuelen) 1991 __field(xfs_dahash_t, hashval) 1992 __field(unsigned int, attr_filter) 1993 __field(unsigned int, attr_flags) 1994 __field(uint32_t, op_flags) 1995 ), 1996 TP_fast_assign( 1997 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 1998 __entry->ino = args->dp->i_ino; 1999 if (args->namelen) 2000 memcpy(__get_str(name), args->name, args->namelen); 2001 __entry->namelen = args->namelen; 2002 __entry->valuelen = args->valuelen; 2003 __entry->hashval = args->hashval; 2004 __entry->attr_filter = args->attr_filter; 2005 __entry->attr_flags = args->attr_flags; 2006 __entry->op_flags = args->op_flags; 2007 ), 2008 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d " 2009 "hashval 0x%x filter %s flags %s op_flags %s", 2010 MAJOR(__entry->dev), MINOR(__entry->dev), 2011 __entry->ino, 2012 __entry->namelen, 2013 __entry->namelen ? __get_str(name) : NULL, 2014 __entry->namelen, 2015 __entry->valuelen, 2016 __entry->hashval, 2017 __print_flags(__entry->attr_filter, "|", 2018 XFS_ATTR_FILTER_FLAGS), 2019 __print_flags(__entry->attr_flags, "|", 2020 { XATTR_CREATE, "CREATE" }, 2021 { XATTR_REPLACE, "REPLACE" }), 2022 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) 2023 ) 2024 2025 #define DEFINE_ATTR_EVENT(name) \ 2026 DEFINE_EVENT(xfs_attr_class, name, \ 2027 TP_PROTO(struct xfs_da_args *args), \ 2028 TP_ARGS(args)) 2029 DEFINE_ATTR_EVENT(xfs_attr_sf_add); 2030 DEFINE_ATTR_EVENT(xfs_attr_sf_addname); 2031 DEFINE_ATTR_EVENT(xfs_attr_sf_create); 2032 DEFINE_ATTR_EVENT(xfs_attr_sf_lookup); 2033 DEFINE_ATTR_EVENT(xfs_attr_sf_remove); 2034 DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf); 2035 2036 DEFINE_ATTR_EVENT(xfs_attr_leaf_add); 2037 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_old); 2038 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_new); 2039 DEFINE_ATTR_EVENT(xfs_attr_leaf_add_work); 2040 DEFINE_ATTR_EVENT(xfs_attr_leaf_create); 2041 DEFINE_ATTR_EVENT(xfs_attr_leaf_compact); 2042 DEFINE_ATTR_EVENT(xfs_attr_leaf_get); 2043 DEFINE_ATTR_EVENT(xfs_attr_leaf_lookup); 2044 DEFINE_ATTR_EVENT(xfs_attr_leaf_replace); 2045 DEFINE_ATTR_EVENT(xfs_attr_leaf_remove); 2046 DEFINE_ATTR_EVENT(xfs_attr_leaf_removename); 2047 DEFINE_ATTR_EVENT(xfs_attr_leaf_split); 2048 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_before); 2049 DEFINE_ATTR_EVENT(xfs_attr_leaf_split_after); 2050 DEFINE_ATTR_EVENT(xfs_attr_leaf_clearflag); 2051 DEFINE_ATTR_EVENT(xfs_attr_leaf_setflag); 2052 DEFINE_ATTR_EVENT(xfs_attr_leaf_flipflags); 2053 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_sf); 2054 DEFINE_ATTR_EVENT(xfs_attr_leaf_to_node); 2055 DEFINE_ATTR_EVENT(xfs_attr_leaf_rebalance); 2056 DEFINE_ATTR_EVENT(xfs_attr_leaf_unbalance); 2057 DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall); 2058 2059 DEFINE_ATTR_EVENT(xfs_attr_node_addname); 2060 DEFINE_ATTR_EVENT(xfs_attr_node_get); 2061 DEFINE_ATTR_EVENT(xfs_attr_node_replace); 2062 DEFINE_ATTR_EVENT(xfs_attr_node_removename); 2063 2064 DEFINE_ATTR_EVENT(xfs_attr_fillstate); 2065 DEFINE_ATTR_EVENT(xfs_attr_refillstate); 2066 2067 DEFINE_ATTR_EVENT(xfs_attr_rmtval_get); 2068 DEFINE_ATTR_EVENT(xfs_attr_rmtval_set); 2069 2070 #define DEFINE_DA_EVENT(name) \ 2071 DEFINE_EVENT(xfs_da_class, name, \ 2072 TP_PROTO(struct xfs_da_args *args), \ 2073 TP_ARGS(args)) 2074 DEFINE_DA_EVENT(xfs_da_split); 2075 DEFINE_DA_EVENT(xfs_da_join); 2076 DEFINE_DA_EVENT(xfs_da_link_before); 2077 DEFINE_DA_EVENT(xfs_da_link_after); 2078 DEFINE_DA_EVENT(xfs_da_unlink_back); 2079 DEFINE_DA_EVENT(xfs_da_unlink_forward); 2080 DEFINE_DA_EVENT(xfs_da_root_split); 2081 DEFINE_DA_EVENT(xfs_da_root_join); 2082 DEFINE_DA_EVENT(xfs_da_node_add); 2083 DEFINE_DA_EVENT(xfs_da_node_create); 2084 DEFINE_DA_EVENT(xfs_da_node_split); 2085 DEFINE_DA_EVENT(xfs_da_node_remove); 2086 DEFINE_DA_EVENT(xfs_da_node_rebalance); 2087 DEFINE_DA_EVENT(xfs_da_node_unbalance); 2088 DEFINE_DA_EVENT(xfs_da_node_toosmall); 2089 DEFINE_DA_EVENT(xfs_da_swap_lastblock); 2090 DEFINE_DA_EVENT(xfs_da_grow_inode); 2091 DEFINE_DA_EVENT(xfs_da_shrink_inode); 2092 DEFINE_DA_EVENT(xfs_da_fixhashpath); 2093 DEFINE_DA_EVENT(xfs_da_path_shift); 2094 2095 DECLARE_EVENT_CLASS(xfs_dir2_space_class, 2096 TP_PROTO(struct xfs_da_args *args, int idx), 2097 TP_ARGS(args, idx), 2098 TP_STRUCT__entry( 2099 __field(dev_t, dev) 2100 __field(xfs_ino_t, ino) 2101 __field(uint32_t, op_flags) 2102 __field(int, idx) 2103 ), 2104 TP_fast_assign( 2105 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2106 __entry->ino = args->dp->i_ino; 2107 __entry->op_flags = args->op_flags; 2108 __entry->idx = idx; 2109 ), 2110 TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d", 2111 MAJOR(__entry->dev), MINOR(__entry->dev), 2112 __entry->ino, 2113 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2114 __entry->idx) 2115 ) 2116 2117 #define DEFINE_DIR2_SPACE_EVENT(name) \ 2118 DEFINE_EVENT(xfs_dir2_space_class, name, \ 2119 TP_PROTO(struct xfs_da_args *args, int idx), \ 2120 TP_ARGS(args, idx)) 2121 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add); 2122 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove); 2123 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode); 2124 DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode); 2125 2126 TRACE_EVENT(xfs_dir2_leafn_moveents, 2127 TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count), 2128 TP_ARGS(args, src_idx, dst_idx, count), 2129 TP_STRUCT__entry( 2130 __field(dev_t, dev) 2131 __field(xfs_ino_t, ino) 2132 __field(uint32_t, op_flags) 2133 __field(int, src_idx) 2134 __field(int, dst_idx) 2135 __field(int, count) 2136 ), 2137 TP_fast_assign( 2138 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2139 __entry->ino = args->dp->i_ino; 2140 __entry->op_flags = args->op_flags; 2141 __entry->src_idx = src_idx; 2142 __entry->dst_idx = dst_idx; 2143 __entry->count = count; 2144 ), 2145 TP_printk("dev %d:%d ino 0x%llx op_flags %s " 2146 "src_idx %d dst_idx %d count %d", 2147 MAJOR(__entry->dev), MINOR(__entry->dev), 2148 __entry->ino, 2149 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2150 __entry->src_idx, 2151 __entry->dst_idx, 2152 __entry->count) 2153 ); 2154 2155 #define XFS_SWAPEXT_INODES \ 2156 { 0, "target" }, \ 2157 { 1, "temp" } 2158 2159 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_DEV); 2160 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_LOCAL); 2161 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_EXTENTS); 2162 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_BTREE); 2163 TRACE_DEFINE_ENUM(XFS_DINODE_FMT_UUID); 2164 2165 DECLARE_EVENT_CLASS(xfs_swap_extent_class, 2166 TP_PROTO(struct xfs_inode *ip, int which), 2167 TP_ARGS(ip, which), 2168 TP_STRUCT__entry( 2169 __field(dev_t, dev) 2170 __field(int, which) 2171 __field(xfs_ino_t, ino) 2172 __field(int, format) 2173 __field(xfs_extnum_t, nex) 2174 __field(int, broot_size) 2175 __field(int, fork_off) 2176 ), 2177 TP_fast_assign( 2178 __entry->dev = VFS_I(ip)->i_sb->s_dev; 2179 __entry->which = which; 2180 __entry->ino = ip->i_ino; 2181 __entry->format = ip->i_df.if_format; 2182 __entry->nex = ip->i_df.if_nextents; 2183 __entry->broot_size = ip->i_df.if_broot_bytes; 2184 __entry->fork_off = xfs_inode_fork_boff(ip); 2185 ), 2186 TP_printk("dev %d:%d ino 0x%llx (%s), %s format, num_extents %llu, " 2187 "broot size %d, forkoff 0x%x", 2188 MAJOR(__entry->dev), MINOR(__entry->dev), 2189 __entry->ino, 2190 __print_symbolic(__entry->which, XFS_SWAPEXT_INODES), 2191 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR), 2192 __entry->nex, 2193 __entry->broot_size, 2194 __entry->fork_off) 2195 ) 2196 2197 #define DEFINE_SWAPEXT_EVENT(name) \ 2198 DEFINE_EVENT(xfs_swap_extent_class, name, \ 2199 TP_PROTO(struct xfs_inode *ip, int which), \ 2200 TP_ARGS(ip, which)) 2201 2202 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before); 2203 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after); 2204 2205 TRACE_EVENT(xfs_log_recover, 2206 TP_PROTO(struct xlog *log, xfs_daddr_t headblk, xfs_daddr_t tailblk), 2207 TP_ARGS(log, headblk, tailblk), 2208 TP_STRUCT__entry( 2209 __field(dev_t, dev) 2210 __field(xfs_daddr_t, headblk) 2211 __field(xfs_daddr_t, tailblk) 2212 ), 2213 TP_fast_assign( 2214 __entry->dev = log->l_mp->m_super->s_dev; 2215 __entry->headblk = headblk; 2216 __entry->tailblk = tailblk; 2217 ), 2218 TP_printk("dev %d:%d headblk 0x%llx tailblk 0x%llx", 2219 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->headblk, 2220 __entry->tailblk) 2221 ) 2222 2223 TRACE_EVENT(xfs_log_recover_record, 2224 TP_PROTO(struct xlog *log, struct xlog_rec_header *rhead, int pass), 2225 TP_ARGS(log, rhead, pass), 2226 TP_STRUCT__entry( 2227 __field(dev_t, dev) 2228 __field(xfs_lsn_t, lsn) 2229 __field(int, len) 2230 __field(int, num_logops) 2231 __field(int, pass) 2232 ), 2233 TP_fast_assign( 2234 __entry->dev = log->l_mp->m_super->s_dev; 2235 __entry->lsn = be64_to_cpu(rhead->h_lsn); 2236 __entry->len = be32_to_cpu(rhead->h_len); 2237 __entry->num_logops = be32_to_cpu(rhead->h_num_logops); 2238 __entry->pass = pass; 2239 ), 2240 TP_printk("dev %d:%d lsn 0x%llx len 0x%x num_logops 0x%x pass %d", 2241 MAJOR(__entry->dev), MINOR(__entry->dev), 2242 __entry->lsn, __entry->len, __entry->num_logops, 2243 __entry->pass) 2244 ) 2245 2246 DECLARE_EVENT_CLASS(xfs_log_recover_item_class, 2247 TP_PROTO(struct xlog *log, struct xlog_recover *trans, 2248 struct xlog_recover_item *item, int pass), 2249 TP_ARGS(log, trans, item, pass), 2250 TP_STRUCT__entry( 2251 __field(dev_t, dev) 2252 __field(unsigned long, item) 2253 __field(xlog_tid_t, tid) 2254 __field(xfs_lsn_t, lsn) 2255 __field(int, type) 2256 __field(int, pass) 2257 __field(int, count) 2258 __field(int, total) 2259 ), 2260 TP_fast_assign( 2261 __entry->dev = log->l_mp->m_super->s_dev; 2262 __entry->item = (unsigned long)item; 2263 __entry->tid = trans->r_log_tid; 2264 __entry->lsn = trans->r_lsn; 2265 __entry->type = ITEM_TYPE(item); 2266 __entry->pass = pass; 2267 __entry->count = item->ri_cnt; 2268 __entry->total = item->ri_total; 2269 ), 2270 TP_printk("dev %d:%d tid 0x%x lsn 0x%llx, pass %d, item %p, " 2271 "item type %s item region count/total %d/%d", 2272 MAJOR(__entry->dev), MINOR(__entry->dev), 2273 __entry->tid, 2274 __entry->lsn, 2275 __entry->pass, 2276 (void *)__entry->item, 2277 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 2278 __entry->count, 2279 __entry->total) 2280 ) 2281 2282 #define DEFINE_LOG_RECOVER_ITEM(name) \ 2283 DEFINE_EVENT(xfs_log_recover_item_class, name, \ 2284 TP_PROTO(struct xlog *log, struct xlog_recover *trans, \ 2285 struct xlog_recover_item *item, int pass), \ 2286 TP_ARGS(log, trans, item, pass)) 2287 2288 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add); 2289 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add_cont); 2290 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_head); 2291 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail); 2292 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover); 2293 2294 DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class, 2295 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), 2296 TP_ARGS(log, buf_f), 2297 TP_STRUCT__entry( 2298 __field(dev_t, dev) 2299 __field(int64_t, blkno) 2300 __field(unsigned short, len) 2301 __field(unsigned short, flags) 2302 __field(unsigned short, size) 2303 __field(unsigned int, map_size) 2304 ), 2305 TP_fast_assign( 2306 __entry->dev = log->l_mp->m_super->s_dev; 2307 __entry->blkno = buf_f->blf_blkno; 2308 __entry->len = buf_f->blf_len; 2309 __entry->flags = buf_f->blf_flags; 2310 __entry->size = buf_f->blf_size; 2311 __entry->map_size = buf_f->blf_map_size; 2312 ), 2313 TP_printk("dev %d:%d daddr 0x%llx, bbcount 0x%x, flags 0x%x, size %d, " 2314 "map_size %d", 2315 MAJOR(__entry->dev), MINOR(__entry->dev), 2316 __entry->blkno, 2317 __entry->len, 2318 __entry->flags, 2319 __entry->size, 2320 __entry->map_size) 2321 ) 2322 2323 #define DEFINE_LOG_RECOVER_BUF_ITEM(name) \ 2324 DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \ 2325 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \ 2326 TP_ARGS(log, buf_f)) 2327 2328 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel); 2329 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel); 2330 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_add); 2331 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_ref_inc); 2332 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_recover); 2333 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_skip); 2334 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_inode_buf); 2335 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf); 2336 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf); 2337 2338 DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class, 2339 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), 2340 TP_ARGS(log, in_f), 2341 TP_STRUCT__entry( 2342 __field(dev_t, dev) 2343 __field(xfs_ino_t, ino) 2344 __field(unsigned short, size) 2345 __field(int, fields) 2346 __field(unsigned short, asize) 2347 __field(unsigned short, dsize) 2348 __field(int64_t, blkno) 2349 __field(int, len) 2350 __field(int, boffset) 2351 ), 2352 TP_fast_assign( 2353 __entry->dev = log->l_mp->m_super->s_dev; 2354 __entry->ino = in_f->ilf_ino; 2355 __entry->size = in_f->ilf_size; 2356 __entry->fields = in_f->ilf_fields; 2357 __entry->asize = in_f->ilf_asize; 2358 __entry->dsize = in_f->ilf_dsize; 2359 __entry->blkno = in_f->ilf_blkno; 2360 __entry->len = in_f->ilf_len; 2361 __entry->boffset = in_f->ilf_boffset; 2362 ), 2363 TP_printk("dev %d:%d ino 0x%llx, size %u, fields 0x%x, asize %d, " 2364 "dsize %d, daddr 0x%llx, bbcount 0x%x, boffset %d", 2365 MAJOR(__entry->dev), MINOR(__entry->dev), 2366 __entry->ino, 2367 __entry->size, 2368 __entry->fields, 2369 __entry->asize, 2370 __entry->dsize, 2371 __entry->blkno, 2372 __entry->len, 2373 __entry->boffset) 2374 ) 2375 #define DEFINE_LOG_RECOVER_INO_ITEM(name) \ 2376 DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \ 2377 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \ 2378 TP_ARGS(log, in_f)) 2379 2380 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover); 2381 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_cancel); 2382 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_skip); 2383 2384 DECLARE_EVENT_CLASS(xfs_log_recover_icreate_item_class, 2385 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), 2386 TP_ARGS(log, in_f), 2387 TP_STRUCT__entry( 2388 __field(dev_t, dev) 2389 __field(xfs_agnumber_t, agno) 2390 __field(xfs_agblock_t, agbno) 2391 __field(unsigned int, count) 2392 __field(unsigned int, isize) 2393 __field(xfs_agblock_t, length) 2394 __field(unsigned int, gen) 2395 ), 2396 TP_fast_assign( 2397 __entry->dev = log->l_mp->m_super->s_dev; 2398 __entry->agno = be32_to_cpu(in_f->icl_ag); 2399 __entry->agbno = be32_to_cpu(in_f->icl_agbno); 2400 __entry->count = be32_to_cpu(in_f->icl_count); 2401 __entry->isize = be32_to_cpu(in_f->icl_isize); 2402 __entry->length = be32_to_cpu(in_f->icl_length); 2403 __entry->gen = be32_to_cpu(in_f->icl_gen); 2404 ), 2405 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x ireccount %u isize %u gen 0x%x", 2406 MAJOR(__entry->dev), MINOR(__entry->dev), 2407 __entry->agno, 2408 __entry->agbno, 2409 __entry->length, 2410 __entry->count, 2411 __entry->isize, 2412 __entry->gen) 2413 ) 2414 #define DEFINE_LOG_RECOVER_ICREATE_ITEM(name) \ 2415 DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \ 2416 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \ 2417 TP_ARGS(log, in_f)) 2418 2419 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_cancel); 2420 DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_recover); 2421 2422 DECLARE_EVENT_CLASS(xfs_discard_class, 2423 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2424 xfs_agblock_t agbno, xfs_extlen_t len), 2425 TP_ARGS(mp, agno, agbno, len), 2426 TP_STRUCT__entry( 2427 __field(dev_t, dev) 2428 __field(xfs_agnumber_t, agno) 2429 __field(xfs_agblock_t, agbno) 2430 __field(xfs_extlen_t, len) 2431 ), 2432 TP_fast_assign( 2433 __entry->dev = mp->m_super->s_dev; 2434 __entry->agno = agno; 2435 __entry->agbno = agbno; 2436 __entry->len = len; 2437 ), 2438 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x", 2439 MAJOR(__entry->dev), MINOR(__entry->dev), 2440 __entry->agno, 2441 __entry->agbno, 2442 __entry->len) 2443 ) 2444 2445 #define DEFINE_DISCARD_EVENT(name) \ 2446 DEFINE_EVENT(xfs_discard_class, name, \ 2447 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2448 xfs_agblock_t agbno, xfs_extlen_t len), \ 2449 TP_ARGS(mp, agno, agbno, len)) 2450 DEFINE_DISCARD_EVENT(xfs_discard_extent); 2451 DEFINE_DISCARD_EVENT(xfs_discard_toosmall); 2452 DEFINE_DISCARD_EVENT(xfs_discard_exclude); 2453 DEFINE_DISCARD_EVENT(xfs_discard_busy); 2454 2455 /* btree cursor events */ 2456 TRACE_DEFINE_ENUM(XFS_BTNUM_BNOi); 2457 TRACE_DEFINE_ENUM(XFS_BTNUM_CNTi); 2458 TRACE_DEFINE_ENUM(XFS_BTNUM_BMAPi); 2459 TRACE_DEFINE_ENUM(XFS_BTNUM_INOi); 2460 TRACE_DEFINE_ENUM(XFS_BTNUM_FINOi); 2461 TRACE_DEFINE_ENUM(XFS_BTNUM_RMAPi); 2462 TRACE_DEFINE_ENUM(XFS_BTNUM_REFCi); 2463 2464 DECLARE_EVENT_CLASS(xfs_btree_cur_class, 2465 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), 2466 TP_ARGS(cur, level, bp), 2467 TP_STRUCT__entry( 2468 __field(dev_t, dev) 2469 __field(xfs_btnum_t, btnum) 2470 __field(int, level) 2471 __field(int, nlevels) 2472 __field(int, ptr) 2473 __field(xfs_daddr_t, daddr) 2474 ), 2475 TP_fast_assign( 2476 __entry->dev = cur->bc_mp->m_super->s_dev; 2477 __entry->btnum = cur->bc_btnum; 2478 __entry->level = level; 2479 __entry->nlevels = cur->bc_nlevels; 2480 __entry->ptr = cur->bc_levels[level].ptr; 2481 __entry->daddr = bp ? xfs_buf_daddr(bp) : -1; 2482 ), 2483 TP_printk("dev %d:%d btree %s level %d/%d ptr %d daddr 0x%llx", 2484 MAJOR(__entry->dev), MINOR(__entry->dev), 2485 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 2486 __entry->level, 2487 __entry->nlevels, 2488 __entry->ptr, 2489 (unsigned long long)__entry->daddr) 2490 ) 2491 2492 #define DEFINE_BTREE_CUR_EVENT(name) \ 2493 DEFINE_EVENT(xfs_btree_cur_class, name, \ 2494 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), \ 2495 TP_ARGS(cur, level, bp)) 2496 DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys); 2497 DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range); 2498 2499 /* deferred ops */ 2500 struct xfs_defer_pending; 2501 2502 DECLARE_EVENT_CLASS(xfs_defer_class, 2503 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 2504 TP_ARGS(tp, caller_ip), 2505 TP_STRUCT__entry( 2506 __field(dev_t, dev) 2507 __field(struct xfs_trans *, tp) 2508 __field(char, committed) 2509 __field(unsigned long, caller_ip) 2510 ), 2511 TP_fast_assign( 2512 __entry->dev = tp->t_mountp->m_super->s_dev; 2513 __entry->tp = tp; 2514 __entry->caller_ip = caller_ip; 2515 ), 2516 TP_printk("dev %d:%d tp %p caller %pS", 2517 MAJOR(__entry->dev), MINOR(__entry->dev), 2518 __entry->tp, 2519 (char *)__entry->caller_ip) 2520 ) 2521 #define DEFINE_DEFER_EVENT(name) \ 2522 DEFINE_EVENT(xfs_defer_class, name, \ 2523 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 2524 TP_ARGS(tp, caller_ip)) 2525 2526 DECLARE_EVENT_CLASS(xfs_defer_error_class, 2527 TP_PROTO(struct xfs_trans *tp, int error), 2528 TP_ARGS(tp, error), 2529 TP_STRUCT__entry( 2530 __field(dev_t, dev) 2531 __field(struct xfs_trans *, tp) 2532 __field(char, committed) 2533 __field(int, error) 2534 ), 2535 TP_fast_assign( 2536 __entry->dev = tp->t_mountp->m_super->s_dev; 2537 __entry->tp = tp; 2538 __entry->error = error; 2539 ), 2540 TP_printk("dev %d:%d tp %p err %d", 2541 MAJOR(__entry->dev), MINOR(__entry->dev), 2542 __entry->tp, 2543 __entry->error) 2544 ) 2545 #define DEFINE_DEFER_ERROR_EVENT(name) \ 2546 DEFINE_EVENT(xfs_defer_error_class, name, \ 2547 TP_PROTO(struct xfs_trans *tp, int error), \ 2548 TP_ARGS(tp, error)) 2549 2550 DECLARE_EVENT_CLASS(xfs_defer_pending_class, 2551 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), 2552 TP_ARGS(mp, dfp), 2553 TP_STRUCT__entry( 2554 __field(dev_t, dev) 2555 __string(name, dfp->dfp_ops->name) 2556 __field(void *, intent) 2557 __field(unsigned int, flags) 2558 __field(char, committed) 2559 __field(int, nr) 2560 ), 2561 TP_fast_assign( 2562 __entry->dev = mp ? mp->m_super->s_dev : 0; 2563 __assign_str(name, dfp->dfp_ops->name); 2564 __entry->intent = dfp->dfp_intent; 2565 __entry->flags = dfp->dfp_flags; 2566 __entry->committed = dfp->dfp_done != NULL; 2567 __entry->nr = dfp->dfp_count; 2568 ), 2569 TP_printk("dev %d:%d optype %s intent %p flags %s committed %d nr %d", 2570 MAJOR(__entry->dev), MINOR(__entry->dev), 2571 __get_str(name), 2572 __entry->intent, 2573 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 2574 __entry->committed, 2575 __entry->nr) 2576 ) 2577 #define DEFINE_DEFER_PENDING_EVENT(name) \ 2578 DEFINE_EVENT(xfs_defer_pending_class, name, \ 2579 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \ 2580 TP_ARGS(mp, dfp)) 2581 2582 DECLARE_EVENT_CLASS(xfs_phys_extent_deferred_class, 2583 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2584 int type, xfs_agblock_t agbno, xfs_extlen_t len), 2585 TP_ARGS(mp, agno, type, agbno, len), 2586 TP_STRUCT__entry( 2587 __field(dev_t, dev) 2588 __field(xfs_agnumber_t, agno) 2589 __field(int, type) 2590 __field(xfs_agblock_t, agbno) 2591 __field(xfs_extlen_t, len) 2592 ), 2593 TP_fast_assign( 2594 __entry->dev = mp->m_super->s_dev; 2595 __entry->agno = agno; 2596 __entry->type = type; 2597 __entry->agbno = agbno; 2598 __entry->len = len; 2599 ), 2600 TP_printk("dev %d:%d op %d agno 0x%x agbno 0x%x fsbcount 0x%x", 2601 MAJOR(__entry->dev), MINOR(__entry->dev), 2602 __entry->type, 2603 __entry->agno, 2604 __entry->agbno, 2605 __entry->len) 2606 ); 2607 #define DEFINE_PHYS_EXTENT_DEFERRED_EVENT(name) \ 2608 DEFINE_EVENT(xfs_phys_extent_deferred_class, name, \ 2609 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2610 int type, \ 2611 xfs_agblock_t bno, \ 2612 xfs_extlen_t len), \ 2613 TP_ARGS(mp, agno, type, bno, len)) 2614 2615 DECLARE_EVENT_CLASS(xfs_map_extent_deferred_class, 2616 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2617 int op, 2618 xfs_agblock_t agbno, 2619 xfs_ino_t ino, 2620 int whichfork, 2621 xfs_fileoff_t offset, 2622 xfs_filblks_t len, 2623 xfs_exntst_t state), 2624 TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state), 2625 TP_STRUCT__entry( 2626 __field(dev_t, dev) 2627 __field(xfs_agnumber_t, agno) 2628 __field(xfs_ino_t, ino) 2629 __field(xfs_agblock_t, agbno) 2630 __field(int, whichfork) 2631 __field(xfs_fileoff_t, l_loff) 2632 __field(xfs_filblks_t, l_len) 2633 __field(xfs_exntst_t, l_state) 2634 __field(int, op) 2635 ), 2636 TP_fast_assign( 2637 __entry->dev = mp->m_super->s_dev; 2638 __entry->agno = agno; 2639 __entry->ino = ino; 2640 __entry->agbno = agbno; 2641 __entry->whichfork = whichfork; 2642 __entry->l_loff = offset; 2643 __entry->l_len = len; 2644 __entry->l_state = state; 2645 __entry->op = op; 2646 ), 2647 TP_printk("dev %d:%d op %d agno 0x%x agbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", 2648 MAJOR(__entry->dev), MINOR(__entry->dev), 2649 __entry->op, 2650 __entry->agno, 2651 __entry->agbno, 2652 __entry->ino, 2653 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 2654 __entry->l_loff, 2655 __entry->l_len, 2656 __entry->l_state) 2657 ); 2658 #define DEFINE_MAP_EXTENT_DEFERRED_EVENT(name) \ 2659 DEFINE_EVENT(xfs_map_extent_deferred_class, name, \ 2660 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2661 int op, \ 2662 xfs_agblock_t agbno, \ 2663 xfs_ino_t ino, \ 2664 int whichfork, \ 2665 xfs_fileoff_t offset, \ 2666 xfs_filblks_t len, \ 2667 xfs_exntst_t state), \ 2668 TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state)) 2669 2670 DEFINE_DEFER_EVENT(xfs_defer_cancel); 2671 DEFINE_DEFER_EVENT(xfs_defer_trans_roll); 2672 DEFINE_DEFER_EVENT(xfs_defer_trans_abort); 2673 DEFINE_DEFER_EVENT(xfs_defer_finish); 2674 DEFINE_DEFER_EVENT(xfs_defer_finish_done); 2675 2676 DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error); 2677 DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error); 2678 2679 DEFINE_DEFER_PENDING_EVENT(xfs_defer_create_intent); 2680 DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list); 2681 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish); 2682 DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort); 2683 DEFINE_DEFER_PENDING_EVENT(xfs_defer_relog_intent); 2684 DEFINE_DEFER_PENDING_EVENT(xfs_defer_isolate_paused); 2685 DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_pause); 2686 DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_unpause); 2687 2688 #define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT 2689 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_defer); 2690 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_deferred); 2691 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_agfl_free_defer); 2692 DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_agfl_free_deferred); 2693 2694 DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, 2695 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, 2696 void *item), 2697 TP_ARGS(mp, dfp, item), 2698 TP_STRUCT__entry( 2699 __field(dev_t, dev) 2700 __string(name, dfp->dfp_ops->name) 2701 __field(void *, intent) 2702 __field(void *, item) 2703 __field(char, committed) 2704 __field(unsigned int, flags) 2705 __field(int, nr) 2706 ), 2707 TP_fast_assign( 2708 __entry->dev = mp ? mp->m_super->s_dev : 0; 2709 __assign_str(name, dfp->dfp_ops->name); 2710 __entry->intent = dfp->dfp_intent; 2711 __entry->item = item; 2712 __entry->committed = dfp->dfp_done != NULL; 2713 __entry->flags = dfp->dfp_flags; 2714 __entry->nr = dfp->dfp_count; 2715 ), 2716 TP_printk("dev %d:%d optype %s intent %p item %p flags %s committed %d nr %d", 2717 MAJOR(__entry->dev), MINOR(__entry->dev), 2718 __get_str(name), 2719 __entry->intent, 2720 __entry->item, 2721 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 2722 __entry->committed, 2723 __entry->nr) 2724 ) 2725 #define DEFINE_DEFER_PENDING_ITEM_EVENT(name) \ 2726 DEFINE_EVENT(xfs_defer_pending_item_class, name, \ 2727 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, \ 2728 void *item), \ 2729 TP_ARGS(mp, dfp, item)) 2730 2731 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_add_item); 2732 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_cancel_item); 2733 DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_finish_item); 2734 2735 /* rmap tracepoints */ 2736 DECLARE_EVENT_CLASS(xfs_rmap_class, 2737 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2738 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten, 2739 const struct xfs_owner_info *oinfo), 2740 TP_ARGS(mp, agno, agbno, len, unwritten, oinfo), 2741 TP_STRUCT__entry( 2742 __field(dev_t, dev) 2743 __field(xfs_agnumber_t, agno) 2744 __field(xfs_agblock_t, agbno) 2745 __field(xfs_extlen_t, len) 2746 __field(uint64_t, owner) 2747 __field(uint64_t, offset) 2748 __field(unsigned long, flags) 2749 ), 2750 TP_fast_assign( 2751 __entry->dev = mp->m_super->s_dev; 2752 __entry->agno = agno; 2753 __entry->agbno = agbno; 2754 __entry->len = len; 2755 __entry->owner = oinfo->oi_owner; 2756 __entry->offset = oinfo->oi_offset; 2757 __entry->flags = oinfo->oi_flags; 2758 if (unwritten) 2759 __entry->flags |= XFS_RMAP_UNWRITTEN; 2760 ), 2761 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%lx", 2762 MAJOR(__entry->dev), MINOR(__entry->dev), 2763 __entry->agno, 2764 __entry->agbno, 2765 __entry->len, 2766 __entry->owner, 2767 __entry->offset, 2768 __entry->flags) 2769 ); 2770 #define DEFINE_RMAP_EVENT(name) \ 2771 DEFINE_EVENT(xfs_rmap_class, name, \ 2772 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2773 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten, \ 2774 const struct xfs_owner_info *oinfo), \ 2775 TP_ARGS(mp, agno, agbno, len, unwritten, oinfo)) 2776 2777 /* simple AG-based error/%ip tracepoint class */ 2778 DECLARE_EVENT_CLASS(xfs_ag_error_class, 2779 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error, 2780 unsigned long caller_ip), 2781 TP_ARGS(mp, agno, error, caller_ip), 2782 TP_STRUCT__entry( 2783 __field(dev_t, dev) 2784 __field(xfs_agnumber_t, agno) 2785 __field(int, error) 2786 __field(unsigned long, caller_ip) 2787 ), 2788 TP_fast_assign( 2789 __entry->dev = mp->m_super->s_dev; 2790 __entry->agno = agno; 2791 __entry->error = error; 2792 __entry->caller_ip = caller_ip; 2793 ), 2794 TP_printk("dev %d:%d agno 0x%x error %d caller %pS", 2795 MAJOR(__entry->dev), MINOR(__entry->dev), 2796 __entry->agno, 2797 __entry->error, 2798 (char *)__entry->caller_ip) 2799 ); 2800 2801 #define DEFINE_AG_ERROR_EVENT(name) \ 2802 DEFINE_EVENT(xfs_ag_error_class, name, \ 2803 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error, \ 2804 unsigned long caller_ip), \ 2805 TP_ARGS(mp, agno, error, caller_ip)) 2806 2807 DEFINE_RMAP_EVENT(xfs_rmap_unmap); 2808 DEFINE_RMAP_EVENT(xfs_rmap_unmap_done); 2809 DEFINE_AG_ERROR_EVENT(xfs_rmap_unmap_error); 2810 DEFINE_RMAP_EVENT(xfs_rmap_map); 2811 DEFINE_RMAP_EVENT(xfs_rmap_map_done); 2812 DEFINE_AG_ERROR_EVENT(xfs_rmap_map_error); 2813 DEFINE_RMAP_EVENT(xfs_rmap_convert); 2814 DEFINE_RMAP_EVENT(xfs_rmap_convert_done); 2815 DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_error); 2816 DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_state); 2817 2818 DECLARE_EVENT_CLASS(xfs_rmapbt_class, 2819 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2820 xfs_agblock_t agbno, xfs_extlen_t len, 2821 uint64_t owner, uint64_t offset, unsigned int flags), 2822 TP_ARGS(mp, agno, agbno, len, owner, offset, flags), 2823 TP_STRUCT__entry( 2824 __field(dev_t, dev) 2825 __field(xfs_agnumber_t, agno) 2826 __field(xfs_agblock_t, agbno) 2827 __field(xfs_extlen_t, len) 2828 __field(uint64_t, owner) 2829 __field(uint64_t, offset) 2830 __field(unsigned int, flags) 2831 ), 2832 TP_fast_assign( 2833 __entry->dev = mp->m_super->s_dev; 2834 __entry->agno = agno; 2835 __entry->agbno = agbno; 2836 __entry->len = len; 2837 __entry->owner = owner; 2838 __entry->offset = offset; 2839 __entry->flags = flags; 2840 ), 2841 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 2842 MAJOR(__entry->dev), MINOR(__entry->dev), 2843 __entry->agno, 2844 __entry->agbno, 2845 __entry->len, 2846 __entry->owner, 2847 __entry->offset, 2848 __entry->flags) 2849 ); 2850 #define DEFINE_RMAPBT_EVENT(name) \ 2851 DEFINE_EVENT(xfs_rmapbt_class, name, \ 2852 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2853 xfs_agblock_t agbno, xfs_extlen_t len, \ 2854 uint64_t owner, uint64_t offset, unsigned int flags), \ 2855 TP_ARGS(mp, agno, agbno, len, owner, offset, flags)) 2856 2857 #define DEFINE_RMAP_DEFERRED_EVENT DEFINE_MAP_EXTENT_DEFERRED_EVENT 2858 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer); 2859 DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred); 2860 2861 DEFINE_BUSY_EVENT(xfs_rmapbt_alloc_block); 2862 DEFINE_BUSY_EVENT(xfs_rmapbt_free_block); 2863 DEFINE_RMAPBT_EVENT(xfs_rmap_update); 2864 DEFINE_RMAPBT_EVENT(xfs_rmap_insert); 2865 DEFINE_RMAPBT_EVENT(xfs_rmap_delete); 2866 DEFINE_AG_ERROR_EVENT(xfs_rmap_insert_error); 2867 DEFINE_AG_ERROR_EVENT(xfs_rmap_delete_error); 2868 DEFINE_AG_ERROR_EVENT(xfs_rmap_update_error); 2869 2870 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_candidate); 2871 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_query); 2872 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_candidate); 2873 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range); 2874 DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_result); 2875 DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result); 2876 DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_result); 2877 2878 /* deferred bmbt updates */ 2879 #define DEFINE_BMAP_DEFERRED_EVENT DEFINE_RMAP_DEFERRED_EVENT 2880 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_defer); 2881 DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_deferred); 2882 2883 /* per-AG reservation */ 2884 DECLARE_EVENT_CLASS(xfs_ag_resv_class, 2885 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type resv, 2886 xfs_extlen_t len), 2887 TP_ARGS(pag, resv, len), 2888 TP_STRUCT__entry( 2889 __field(dev_t, dev) 2890 __field(xfs_agnumber_t, agno) 2891 __field(int, resv) 2892 __field(xfs_extlen_t, freeblks) 2893 __field(xfs_extlen_t, flcount) 2894 __field(xfs_extlen_t, reserved) 2895 __field(xfs_extlen_t, asked) 2896 __field(xfs_extlen_t, len) 2897 ), 2898 TP_fast_assign( 2899 struct xfs_ag_resv *r = xfs_perag_resv(pag, resv); 2900 2901 __entry->dev = pag->pag_mount->m_super->s_dev; 2902 __entry->agno = pag->pag_agno; 2903 __entry->resv = resv; 2904 __entry->freeblks = pag->pagf_freeblks; 2905 __entry->flcount = pag->pagf_flcount; 2906 __entry->reserved = r ? r->ar_reserved : 0; 2907 __entry->asked = r ? r->ar_asked : 0; 2908 __entry->len = len; 2909 ), 2910 TP_printk("dev %d:%d agno 0x%x resv %d freeblks %u flcount %u " 2911 "resv %u ask %u len %u", 2912 MAJOR(__entry->dev), MINOR(__entry->dev), 2913 __entry->agno, 2914 __entry->resv, 2915 __entry->freeblks, 2916 __entry->flcount, 2917 __entry->reserved, 2918 __entry->asked, 2919 __entry->len) 2920 ) 2921 #define DEFINE_AG_RESV_EVENT(name) \ 2922 DEFINE_EVENT(xfs_ag_resv_class, name, \ 2923 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type type, \ 2924 xfs_extlen_t len), \ 2925 TP_ARGS(pag, type, len)) 2926 2927 /* per-AG reservation tracepoints */ 2928 DEFINE_AG_RESV_EVENT(xfs_ag_resv_init); 2929 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free); 2930 DEFINE_AG_RESV_EVENT(xfs_ag_resv_alloc_extent); 2931 DEFINE_AG_RESV_EVENT(xfs_ag_resv_free_extent); 2932 DEFINE_AG_RESV_EVENT(xfs_ag_resv_critical); 2933 DEFINE_AG_RESV_EVENT(xfs_ag_resv_needed); 2934 2935 DEFINE_AG_ERROR_EVENT(xfs_ag_resv_free_error); 2936 DEFINE_AG_ERROR_EVENT(xfs_ag_resv_init_error); 2937 2938 /* refcount tracepoint classes */ 2939 2940 /* reuse the discard trace class for agbno/aglen-based traces */ 2941 #define DEFINE_AG_EXTENT_EVENT(name) DEFINE_DISCARD_EVENT(name) 2942 2943 /* ag btree lookup tracepoint class */ 2944 TRACE_DEFINE_ENUM(XFS_LOOKUP_EQi); 2945 TRACE_DEFINE_ENUM(XFS_LOOKUP_LEi); 2946 TRACE_DEFINE_ENUM(XFS_LOOKUP_GEi); 2947 DECLARE_EVENT_CLASS(xfs_ag_btree_lookup_class, 2948 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2949 xfs_agblock_t agbno, xfs_lookup_t dir), 2950 TP_ARGS(mp, agno, agbno, dir), 2951 TP_STRUCT__entry( 2952 __field(dev_t, dev) 2953 __field(xfs_agnumber_t, agno) 2954 __field(xfs_agblock_t, agbno) 2955 __field(xfs_lookup_t, dir) 2956 ), 2957 TP_fast_assign( 2958 __entry->dev = mp->m_super->s_dev; 2959 __entry->agno = agno; 2960 __entry->agbno = agbno; 2961 __entry->dir = dir; 2962 ), 2963 TP_printk("dev %d:%d agno 0x%x agbno 0x%x cmp %s(%d)", 2964 MAJOR(__entry->dev), MINOR(__entry->dev), 2965 __entry->agno, 2966 __entry->agbno, 2967 __print_symbolic(__entry->dir, XFS_AG_BTREE_CMP_FORMAT_STR), 2968 __entry->dir) 2969 ) 2970 2971 #define DEFINE_AG_BTREE_LOOKUP_EVENT(name) \ 2972 DEFINE_EVENT(xfs_ag_btree_lookup_class, name, \ 2973 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 2974 xfs_agblock_t agbno, xfs_lookup_t dir), \ 2975 TP_ARGS(mp, agno, agbno, dir)) 2976 2977 /* single-rcext tracepoint class */ 2978 DECLARE_EVENT_CLASS(xfs_refcount_extent_class, 2979 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 2980 struct xfs_refcount_irec *irec), 2981 TP_ARGS(mp, agno, irec), 2982 TP_STRUCT__entry( 2983 __field(dev_t, dev) 2984 __field(xfs_agnumber_t, agno) 2985 __field(enum xfs_refc_domain, domain) 2986 __field(xfs_agblock_t, startblock) 2987 __field(xfs_extlen_t, blockcount) 2988 __field(xfs_nlink_t, refcount) 2989 ), 2990 TP_fast_assign( 2991 __entry->dev = mp->m_super->s_dev; 2992 __entry->agno = agno; 2993 __entry->domain = irec->rc_domain; 2994 __entry->startblock = irec->rc_startblock; 2995 __entry->blockcount = irec->rc_blockcount; 2996 __entry->refcount = irec->rc_refcount; 2997 ), 2998 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u", 2999 MAJOR(__entry->dev), MINOR(__entry->dev), 3000 __entry->agno, 3001 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3002 __entry->startblock, 3003 __entry->blockcount, 3004 __entry->refcount) 3005 ) 3006 3007 #define DEFINE_REFCOUNT_EXTENT_EVENT(name) \ 3008 DEFINE_EVENT(xfs_refcount_extent_class, name, \ 3009 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3010 struct xfs_refcount_irec *irec), \ 3011 TP_ARGS(mp, agno, irec)) 3012 3013 /* single-rcext and an agbno tracepoint class */ 3014 DECLARE_EVENT_CLASS(xfs_refcount_extent_at_class, 3015 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3016 struct xfs_refcount_irec *irec, xfs_agblock_t agbno), 3017 TP_ARGS(mp, agno, irec, agbno), 3018 TP_STRUCT__entry( 3019 __field(dev_t, dev) 3020 __field(xfs_agnumber_t, agno) 3021 __field(enum xfs_refc_domain, domain) 3022 __field(xfs_agblock_t, startblock) 3023 __field(xfs_extlen_t, blockcount) 3024 __field(xfs_nlink_t, refcount) 3025 __field(xfs_agblock_t, agbno) 3026 ), 3027 TP_fast_assign( 3028 __entry->dev = mp->m_super->s_dev; 3029 __entry->agno = agno; 3030 __entry->domain = irec->rc_domain; 3031 __entry->startblock = irec->rc_startblock; 3032 __entry->blockcount = irec->rc_blockcount; 3033 __entry->refcount = irec->rc_refcount; 3034 __entry->agbno = agbno; 3035 ), 3036 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u @ agbno 0x%x", 3037 MAJOR(__entry->dev), MINOR(__entry->dev), 3038 __entry->agno, 3039 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3040 __entry->startblock, 3041 __entry->blockcount, 3042 __entry->refcount, 3043 __entry->agbno) 3044 ) 3045 3046 #define DEFINE_REFCOUNT_EXTENT_AT_EVENT(name) \ 3047 DEFINE_EVENT(xfs_refcount_extent_at_class, name, \ 3048 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3049 struct xfs_refcount_irec *irec, xfs_agblock_t agbno), \ 3050 TP_ARGS(mp, agno, irec, agbno)) 3051 3052 /* double-rcext tracepoint class */ 3053 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_class, 3054 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3055 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2), 3056 TP_ARGS(mp, agno, i1, i2), 3057 TP_STRUCT__entry( 3058 __field(dev_t, dev) 3059 __field(xfs_agnumber_t, agno) 3060 __field(enum xfs_refc_domain, i1_domain) 3061 __field(xfs_agblock_t, i1_startblock) 3062 __field(xfs_extlen_t, i1_blockcount) 3063 __field(xfs_nlink_t, i1_refcount) 3064 __field(enum xfs_refc_domain, i2_domain) 3065 __field(xfs_agblock_t, i2_startblock) 3066 __field(xfs_extlen_t, i2_blockcount) 3067 __field(xfs_nlink_t, i2_refcount) 3068 ), 3069 TP_fast_assign( 3070 __entry->dev = mp->m_super->s_dev; 3071 __entry->agno = agno; 3072 __entry->i1_domain = i1->rc_domain; 3073 __entry->i1_startblock = i1->rc_startblock; 3074 __entry->i1_blockcount = i1->rc_blockcount; 3075 __entry->i1_refcount = i1->rc_refcount; 3076 __entry->i2_domain = i2->rc_domain; 3077 __entry->i2_startblock = i2->rc_startblock; 3078 __entry->i2_blockcount = i2->rc_blockcount; 3079 __entry->i2_refcount = i2->rc_refcount; 3080 ), 3081 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u -- " 3082 "dom %s agbno 0x%x fsbcount 0x%x refcount %u", 3083 MAJOR(__entry->dev), MINOR(__entry->dev), 3084 __entry->agno, 3085 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3086 __entry->i1_startblock, 3087 __entry->i1_blockcount, 3088 __entry->i1_refcount, 3089 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3090 __entry->i2_startblock, 3091 __entry->i2_blockcount, 3092 __entry->i2_refcount) 3093 ) 3094 3095 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(name) \ 3096 DEFINE_EVENT(xfs_refcount_double_extent_class, name, \ 3097 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3098 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2), \ 3099 TP_ARGS(mp, agno, i1, i2)) 3100 3101 /* double-rcext and an agbno tracepoint class */ 3102 DECLARE_EVENT_CLASS(xfs_refcount_double_extent_at_class, 3103 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3104 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, 3105 xfs_agblock_t agbno), 3106 TP_ARGS(mp, agno, i1, i2, agbno), 3107 TP_STRUCT__entry( 3108 __field(dev_t, dev) 3109 __field(xfs_agnumber_t, agno) 3110 __field(enum xfs_refc_domain, i1_domain) 3111 __field(xfs_agblock_t, i1_startblock) 3112 __field(xfs_extlen_t, i1_blockcount) 3113 __field(xfs_nlink_t, i1_refcount) 3114 __field(enum xfs_refc_domain, i2_domain) 3115 __field(xfs_agblock_t, i2_startblock) 3116 __field(xfs_extlen_t, i2_blockcount) 3117 __field(xfs_nlink_t, i2_refcount) 3118 __field(xfs_agblock_t, agbno) 3119 ), 3120 TP_fast_assign( 3121 __entry->dev = mp->m_super->s_dev; 3122 __entry->agno = agno; 3123 __entry->i1_domain = i1->rc_domain; 3124 __entry->i1_startblock = i1->rc_startblock; 3125 __entry->i1_blockcount = i1->rc_blockcount; 3126 __entry->i1_refcount = i1->rc_refcount; 3127 __entry->i2_domain = i2->rc_domain; 3128 __entry->i2_startblock = i2->rc_startblock; 3129 __entry->i2_blockcount = i2->rc_blockcount; 3130 __entry->i2_refcount = i2->rc_refcount; 3131 __entry->agbno = agbno; 3132 ), 3133 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u -- " 3134 "dom %s agbno 0x%x fsbcount 0x%x refcount %u @ agbno 0x%x", 3135 MAJOR(__entry->dev), MINOR(__entry->dev), 3136 __entry->agno, 3137 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3138 __entry->i1_startblock, 3139 __entry->i1_blockcount, 3140 __entry->i1_refcount, 3141 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3142 __entry->i2_startblock, 3143 __entry->i2_blockcount, 3144 __entry->i2_refcount, 3145 __entry->agbno) 3146 ) 3147 3148 #define DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(name) \ 3149 DEFINE_EVENT(xfs_refcount_double_extent_at_class, name, \ 3150 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3151 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, \ 3152 xfs_agblock_t agbno), \ 3153 TP_ARGS(mp, agno, i1, i2, agbno)) 3154 3155 /* triple-rcext tracepoint class */ 3156 DECLARE_EVENT_CLASS(xfs_refcount_triple_extent_class, 3157 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3158 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, 3159 struct xfs_refcount_irec *i3), 3160 TP_ARGS(mp, agno, i1, i2, i3), 3161 TP_STRUCT__entry( 3162 __field(dev_t, dev) 3163 __field(xfs_agnumber_t, agno) 3164 __field(enum xfs_refc_domain, i1_domain) 3165 __field(xfs_agblock_t, i1_startblock) 3166 __field(xfs_extlen_t, i1_blockcount) 3167 __field(xfs_nlink_t, i1_refcount) 3168 __field(enum xfs_refc_domain, i2_domain) 3169 __field(xfs_agblock_t, i2_startblock) 3170 __field(xfs_extlen_t, i2_blockcount) 3171 __field(xfs_nlink_t, i2_refcount) 3172 __field(enum xfs_refc_domain, i3_domain) 3173 __field(xfs_agblock_t, i3_startblock) 3174 __field(xfs_extlen_t, i3_blockcount) 3175 __field(xfs_nlink_t, i3_refcount) 3176 ), 3177 TP_fast_assign( 3178 __entry->dev = mp->m_super->s_dev; 3179 __entry->agno = agno; 3180 __entry->i1_domain = i1->rc_domain; 3181 __entry->i1_startblock = i1->rc_startblock; 3182 __entry->i1_blockcount = i1->rc_blockcount; 3183 __entry->i1_refcount = i1->rc_refcount; 3184 __entry->i2_domain = i2->rc_domain; 3185 __entry->i2_startblock = i2->rc_startblock; 3186 __entry->i2_blockcount = i2->rc_blockcount; 3187 __entry->i2_refcount = i2->rc_refcount; 3188 __entry->i3_domain = i3->rc_domain; 3189 __entry->i3_startblock = i3->rc_startblock; 3190 __entry->i3_blockcount = i3->rc_blockcount; 3191 __entry->i3_refcount = i3->rc_refcount; 3192 ), 3193 TP_printk("dev %d:%d agno 0x%x dom %s agbno 0x%x fsbcount 0x%x refcount %u -- " 3194 "dom %s agbno 0x%x fsbcount 0x%x refcount %u -- " 3195 "dom %s agbno 0x%x fsbcount 0x%x refcount %u", 3196 MAJOR(__entry->dev), MINOR(__entry->dev), 3197 __entry->agno, 3198 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3199 __entry->i1_startblock, 3200 __entry->i1_blockcount, 3201 __entry->i1_refcount, 3202 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3203 __entry->i2_startblock, 3204 __entry->i2_blockcount, 3205 __entry->i2_refcount, 3206 __print_symbolic(__entry->i3_domain, XFS_REFC_DOMAIN_STRINGS), 3207 __entry->i3_startblock, 3208 __entry->i3_blockcount, 3209 __entry->i3_refcount) 3210 ); 3211 3212 #define DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(name) \ 3213 DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \ 3214 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3215 struct xfs_refcount_irec *i1, struct xfs_refcount_irec *i2, \ 3216 struct xfs_refcount_irec *i3), \ 3217 TP_ARGS(mp, agno, i1, i2, i3)) 3218 3219 /* refcount btree tracepoints */ 3220 DEFINE_BUSY_EVENT(xfs_refcountbt_alloc_block); 3221 DEFINE_BUSY_EVENT(xfs_refcountbt_free_block); 3222 DEFINE_AG_BTREE_LOOKUP_EVENT(xfs_refcount_lookup); 3223 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_get); 3224 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_update); 3225 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_insert); 3226 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_delete); 3227 DEFINE_AG_ERROR_EVENT(xfs_refcount_insert_error); 3228 DEFINE_AG_ERROR_EVENT(xfs_refcount_delete_error); 3229 DEFINE_AG_ERROR_EVENT(xfs_refcount_update_error); 3230 3231 /* refcount adjustment tracepoints */ 3232 DEFINE_AG_EXTENT_EVENT(xfs_refcount_increase); 3233 DEFINE_AG_EXTENT_EVENT(xfs_refcount_decrease); 3234 DEFINE_AG_EXTENT_EVENT(xfs_refcount_cow_increase); 3235 DEFINE_AG_EXTENT_EVENT(xfs_refcount_cow_decrease); 3236 DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(xfs_refcount_merge_center_extents); 3237 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_modify_extent); 3238 DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_recover_extent); 3239 DEFINE_REFCOUNT_EXTENT_AT_EVENT(xfs_refcount_split_extent); 3240 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_left_extent); 3241 DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_right_extent); 3242 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_left_extent); 3243 DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_right_extent); 3244 DEFINE_AG_ERROR_EVENT(xfs_refcount_adjust_error); 3245 DEFINE_AG_ERROR_EVENT(xfs_refcount_adjust_cow_error); 3246 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_center_extents_error); 3247 DEFINE_AG_ERROR_EVENT(xfs_refcount_modify_extent_error); 3248 DEFINE_AG_ERROR_EVENT(xfs_refcount_split_extent_error); 3249 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_left_extent_error); 3250 DEFINE_AG_ERROR_EVENT(xfs_refcount_merge_right_extent_error); 3251 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_left_extent_error); 3252 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_right_extent_error); 3253 3254 /* reflink helpers */ 3255 DEFINE_AG_EXTENT_EVENT(xfs_refcount_find_shared); 3256 DEFINE_AG_EXTENT_EVENT(xfs_refcount_find_shared_result); 3257 DEFINE_AG_ERROR_EVENT(xfs_refcount_find_shared_error); 3258 #define DEFINE_REFCOUNT_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT 3259 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_defer); 3260 DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_deferred); 3261 3262 TRACE_EVENT(xfs_refcount_finish_one_leftover, 3263 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3264 int type, xfs_agblock_t agbno, xfs_extlen_t len), 3265 TP_ARGS(mp, agno, type, agbno, len), 3266 TP_STRUCT__entry( 3267 __field(dev_t, dev) 3268 __field(xfs_agnumber_t, agno) 3269 __field(int, type) 3270 __field(xfs_agblock_t, agbno) 3271 __field(xfs_extlen_t, len) 3272 ), 3273 TP_fast_assign( 3274 __entry->dev = mp->m_super->s_dev; 3275 __entry->agno = agno; 3276 __entry->type = type; 3277 __entry->agbno = agbno; 3278 __entry->len = len; 3279 ), 3280 TP_printk("dev %d:%d type %d agno 0x%x agbno 0x%x fsbcount 0x%x", 3281 MAJOR(__entry->dev), MINOR(__entry->dev), 3282 __entry->type, 3283 __entry->agno, 3284 __entry->agbno, 3285 __entry->len) 3286 ); 3287 3288 /* simple inode-based error/%ip tracepoint class */ 3289 DECLARE_EVENT_CLASS(xfs_inode_error_class, 3290 TP_PROTO(struct xfs_inode *ip, int error, unsigned long caller_ip), 3291 TP_ARGS(ip, error, caller_ip), 3292 TP_STRUCT__entry( 3293 __field(dev_t, dev) 3294 __field(xfs_ino_t, ino) 3295 __field(int, error) 3296 __field(unsigned long, caller_ip) 3297 ), 3298 TP_fast_assign( 3299 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3300 __entry->ino = ip->i_ino; 3301 __entry->error = error; 3302 __entry->caller_ip = caller_ip; 3303 ), 3304 TP_printk("dev %d:%d ino 0x%llx error %d caller %pS", 3305 MAJOR(__entry->dev), MINOR(__entry->dev), 3306 __entry->ino, 3307 __entry->error, 3308 (char *)__entry->caller_ip) 3309 ); 3310 3311 #define DEFINE_INODE_ERROR_EVENT(name) \ 3312 DEFINE_EVENT(xfs_inode_error_class, name, \ 3313 TP_PROTO(struct xfs_inode *ip, int error, \ 3314 unsigned long caller_ip), \ 3315 TP_ARGS(ip, error, caller_ip)) 3316 3317 /* reflink tracepoint classes */ 3318 3319 /* two-file io tracepoint class */ 3320 DECLARE_EVENT_CLASS(xfs_double_io_class, 3321 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, 3322 struct xfs_inode *dest, xfs_off_t doffset), 3323 TP_ARGS(src, soffset, len, dest, doffset), 3324 TP_STRUCT__entry( 3325 __field(dev_t, dev) 3326 __field(xfs_ino_t, src_ino) 3327 __field(loff_t, src_isize) 3328 __field(loff_t, src_disize) 3329 __field(loff_t, src_offset) 3330 __field(long long, len) 3331 __field(xfs_ino_t, dest_ino) 3332 __field(loff_t, dest_isize) 3333 __field(loff_t, dest_disize) 3334 __field(loff_t, dest_offset) 3335 ), 3336 TP_fast_assign( 3337 __entry->dev = VFS_I(src)->i_sb->s_dev; 3338 __entry->src_ino = src->i_ino; 3339 __entry->src_isize = VFS_I(src)->i_size; 3340 __entry->src_disize = src->i_disk_size; 3341 __entry->src_offset = soffset; 3342 __entry->len = len; 3343 __entry->dest_ino = dest->i_ino; 3344 __entry->dest_isize = VFS_I(dest)->i_size; 3345 __entry->dest_disize = dest->i_disk_size; 3346 __entry->dest_offset = doffset; 3347 ), 3348 TP_printk("dev %d:%d bytecount 0x%llx " 3349 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx -> " 3350 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx", 3351 MAJOR(__entry->dev), MINOR(__entry->dev), 3352 __entry->len, 3353 __entry->src_ino, 3354 __entry->src_isize, 3355 __entry->src_disize, 3356 __entry->src_offset, 3357 __entry->dest_ino, 3358 __entry->dest_isize, 3359 __entry->dest_disize, 3360 __entry->dest_offset) 3361 ) 3362 3363 #define DEFINE_DOUBLE_IO_EVENT(name) \ 3364 DEFINE_EVENT(xfs_double_io_class, name, \ 3365 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, \ 3366 struct xfs_inode *dest, xfs_off_t doffset), \ 3367 TP_ARGS(src, soffset, len, dest, doffset)) 3368 3369 /* inode/irec events */ 3370 DECLARE_EVENT_CLASS(xfs_inode_irec_class, 3371 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), 3372 TP_ARGS(ip, irec), 3373 TP_STRUCT__entry( 3374 __field(dev_t, dev) 3375 __field(xfs_ino_t, ino) 3376 __field(xfs_fileoff_t, lblk) 3377 __field(xfs_extlen_t, len) 3378 __field(xfs_fsblock_t, pblk) 3379 __field(int, state) 3380 ), 3381 TP_fast_assign( 3382 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3383 __entry->ino = ip->i_ino; 3384 __entry->lblk = irec->br_startoff; 3385 __entry->len = irec->br_blockcount; 3386 __entry->pblk = irec->br_startblock; 3387 __entry->state = irec->br_state; 3388 ), 3389 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx fsbcount 0x%x startblock 0x%llx st %d", 3390 MAJOR(__entry->dev), MINOR(__entry->dev), 3391 __entry->ino, 3392 __entry->lblk, 3393 __entry->len, 3394 __entry->pblk, 3395 __entry->state) 3396 ); 3397 #define DEFINE_INODE_IREC_EVENT(name) \ 3398 DEFINE_EVENT(xfs_inode_irec_class, name, \ 3399 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), \ 3400 TP_ARGS(ip, irec)) 3401 3402 /* inode iomap invalidation events */ 3403 DECLARE_EVENT_CLASS(xfs_wb_invalid_class, 3404 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), 3405 TP_ARGS(ip, iomap, wpcseq, whichfork), 3406 TP_STRUCT__entry( 3407 __field(dev_t, dev) 3408 __field(xfs_ino_t, ino) 3409 __field(u64, addr) 3410 __field(loff_t, pos) 3411 __field(u64, len) 3412 __field(u16, type) 3413 __field(u16, flags) 3414 __field(u32, wpcseq) 3415 __field(u32, forkseq) 3416 ), 3417 TP_fast_assign( 3418 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3419 __entry->ino = ip->i_ino; 3420 __entry->addr = iomap->addr; 3421 __entry->pos = iomap->offset; 3422 __entry->len = iomap->length; 3423 __entry->type = iomap->type; 3424 __entry->flags = iomap->flags; 3425 __entry->wpcseq = wpcseq; 3426 __entry->forkseq = READ_ONCE(xfs_ifork_ptr(ip, whichfork)->if_seq); 3427 ), 3428 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx addr 0x%llx bytecount 0x%llx type 0x%x flags 0x%x wpcseq 0x%x forkseq 0x%x", 3429 MAJOR(__entry->dev), MINOR(__entry->dev), 3430 __entry->ino, 3431 __entry->pos, 3432 __entry->addr, 3433 __entry->len, 3434 __entry->type, 3435 __entry->flags, 3436 __entry->wpcseq, 3437 __entry->forkseq) 3438 ); 3439 #define DEFINE_WB_INVALID_EVENT(name) \ 3440 DEFINE_EVENT(xfs_wb_invalid_class, name, \ 3441 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), \ 3442 TP_ARGS(ip, iomap, wpcseq, whichfork)) 3443 DEFINE_WB_INVALID_EVENT(xfs_wb_cow_iomap_invalid); 3444 DEFINE_WB_INVALID_EVENT(xfs_wb_data_iomap_invalid); 3445 3446 DECLARE_EVENT_CLASS(xfs_iomap_invalid_class, 3447 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), 3448 TP_ARGS(ip, iomap), 3449 TP_STRUCT__entry( 3450 __field(dev_t, dev) 3451 __field(xfs_ino_t, ino) 3452 __field(u64, addr) 3453 __field(loff_t, pos) 3454 __field(u64, len) 3455 __field(u64, validity_cookie) 3456 __field(u64, inodeseq) 3457 __field(u16, type) 3458 __field(u16, flags) 3459 ), 3460 TP_fast_assign( 3461 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3462 __entry->ino = ip->i_ino; 3463 __entry->addr = iomap->addr; 3464 __entry->pos = iomap->offset; 3465 __entry->len = iomap->length; 3466 __entry->validity_cookie = iomap->validity_cookie; 3467 __entry->type = iomap->type; 3468 __entry->flags = iomap->flags; 3469 __entry->inodeseq = xfs_iomap_inode_sequence(ip, iomap->flags); 3470 ), 3471 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx addr 0x%llx bytecount 0x%llx type 0x%x flags 0x%x validity_cookie 0x%llx inodeseq 0x%llx", 3472 MAJOR(__entry->dev), MINOR(__entry->dev), 3473 __entry->ino, 3474 __entry->pos, 3475 __entry->addr, 3476 __entry->len, 3477 __entry->type, 3478 __entry->flags, 3479 __entry->validity_cookie, 3480 __entry->inodeseq) 3481 ); 3482 #define DEFINE_IOMAP_INVALID_EVENT(name) \ 3483 DEFINE_EVENT(xfs_iomap_invalid_class, name, \ 3484 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), \ 3485 TP_ARGS(ip, iomap)) 3486 DEFINE_IOMAP_INVALID_EVENT(xfs_iomap_invalid); 3487 3488 /* refcount/reflink tracepoint definitions */ 3489 3490 /* reflink tracepoints */ 3491 DEFINE_INODE_EVENT(xfs_reflink_set_inode_flag); 3492 DEFINE_INODE_EVENT(xfs_reflink_unset_inode_flag); 3493 DEFINE_ITRUNC_EVENT(xfs_reflink_update_inode_size); 3494 TRACE_EVENT(xfs_reflink_remap_blocks, 3495 TP_PROTO(struct xfs_inode *src, xfs_fileoff_t soffset, 3496 xfs_filblks_t len, struct xfs_inode *dest, 3497 xfs_fileoff_t doffset), 3498 TP_ARGS(src, soffset, len, dest, doffset), 3499 TP_STRUCT__entry( 3500 __field(dev_t, dev) 3501 __field(xfs_ino_t, src_ino) 3502 __field(xfs_fileoff_t, src_lblk) 3503 __field(xfs_filblks_t, len) 3504 __field(xfs_ino_t, dest_ino) 3505 __field(xfs_fileoff_t, dest_lblk) 3506 ), 3507 TP_fast_assign( 3508 __entry->dev = VFS_I(src)->i_sb->s_dev; 3509 __entry->src_ino = src->i_ino; 3510 __entry->src_lblk = soffset; 3511 __entry->len = len; 3512 __entry->dest_ino = dest->i_ino; 3513 __entry->dest_lblk = doffset; 3514 ), 3515 TP_printk("dev %d:%d fsbcount 0x%llx " 3516 "ino 0x%llx fileoff 0x%llx -> ino 0x%llx fileoff 0x%llx", 3517 MAJOR(__entry->dev), MINOR(__entry->dev), 3518 __entry->len, 3519 __entry->src_ino, 3520 __entry->src_lblk, 3521 __entry->dest_ino, 3522 __entry->dest_lblk) 3523 ); 3524 DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range); 3525 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error); 3526 DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error); 3527 DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error); 3528 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error); 3529 DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error); 3530 DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_src); 3531 DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_dest); 3532 3533 /* dedupe tracepoints */ 3534 DEFINE_DOUBLE_IO_EVENT(xfs_reflink_compare_extents); 3535 DEFINE_INODE_ERROR_EVENT(xfs_reflink_compare_extents_error); 3536 3537 /* ioctl tracepoints */ 3538 TRACE_EVENT(xfs_ioctl_clone, 3539 TP_PROTO(struct inode *src, struct inode *dest), 3540 TP_ARGS(src, dest), 3541 TP_STRUCT__entry( 3542 __field(dev_t, dev) 3543 __field(unsigned long, src_ino) 3544 __field(loff_t, src_isize) 3545 __field(unsigned long, dest_ino) 3546 __field(loff_t, dest_isize) 3547 ), 3548 TP_fast_assign( 3549 __entry->dev = src->i_sb->s_dev; 3550 __entry->src_ino = src->i_ino; 3551 __entry->src_isize = i_size_read(src); 3552 __entry->dest_ino = dest->i_ino; 3553 __entry->dest_isize = i_size_read(dest); 3554 ), 3555 TP_printk("dev %d:%d ino 0x%lx isize 0x%llx -> ino 0x%lx isize 0x%llx", 3556 MAJOR(__entry->dev), MINOR(__entry->dev), 3557 __entry->src_ino, 3558 __entry->src_isize, 3559 __entry->dest_ino, 3560 __entry->dest_isize) 3561 ); 3562 3563 /* unshare tracepoints */ 3564 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_unshare); 3565 DEFINE_INODE_ERROR_EVENT(xfs_reflink_unshare_error); 3566 3567 /* copy on write */ 3568 DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared); 3569 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found); 3570 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_enospc); 3571 DEFINE_INODE_IREC_EVENT(xfs_reflink_convert_cow); 3572 3573 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cancel_cow_range); 3574 DEFINE_SIMPLE_IO_EVENT(xfs_reflink_end_cow); 3575 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_from); 3576 DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_to); 3577 3578 DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error); 3579 DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error); 3580 3581 3582 DEFINE_INODE_IREC_EVENT(xfs_reflink_cancel_cow); 3583 3584 /* rmap swapext tracepoints */ 3585 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap); 3586 DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap_piece); 3587 DEFINE_INODE_ERROR_EVENT(xfs_swap_extent_rmap_error); 3588 3589 /* fsmap traces */ 3590 DECLARE_EVENT_CLASS(xfs_fsmap_class, 3591 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, 3592 const struct xfs_rmap_irec *rmap), 3593 TP_ARGS(mp, keydev, agno, rmap), 3594 TP_STRUCT__entry( 3595 __field(dev_t, dev) 3596 __field(dev_t, keydev) 3597 __field(xfs_agnumber_t, agno) 3598 __field(xfs_fsblock_t, bno) 3599 __field(xfs_filblks_t, len) 3600 __field(uint64_t, owner) 3601 __field(uint64_t, offset) 3602 __field(unsigned int, flags) 3603 ), 3604 TP_fast_assign( 3605 __entry->dev = mp->m_super->s_dev; 3606 __entry->keydev = new_decode_dev(keydev); 3607 __entry->agno = agno; 3608 __entry->bno = rmap->rm_startblock; 3609 __entry->len = rmap->rm_blockcount; 3610 __entry->owner = rmap->rm_owner; 3611 __entry->offset = rmap->rm_offset; 3612 __entry->flags = rmap->rm_flags; 3613 ), 3614 TP_printk("dev %d:%d keydev %d:%d agno 0x%x startblock 0x%llx fsbcount 0x%llx owner 0x%llx fileoff 0x%llx flags 0x%x", 3615 MAJOR(__entry->dev), MINOR(__entry->dev), 3616 MAJOR(__entry->keydev), MINOR(__entry->keydev), 3617 __entry->agno, 3618 __entry->bno, 3619 __entry->len, 3620 __entry->owner, 3621 __entry->offset, 3622 __entry->flags) 3623 ) 3624 #define DEFINE_FSMAP_EVENT(name) \ 3625 DEFINE_EVENT(xfs_fsmap_class, name, \ 3626 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, \ 3627 const struct xfs_rmap_irec *rmap), \ 3628 TP_ARGS(mp, keydev, agno, rmap)) 3629 DEFINE_FSMAP_EVENT(xfs_fsmap_low_key); 3630 DEFINE_FSMAP_EVENT(xfs_fsmap_high_key); 3631 DEFINE_FSMAP_EVENT(xfs_fsmap_mapping); 3632 3633 DECLARE_EVENT_CLASS(xfs_fsmap_linear_class, 3634 TP_PROTO(struct xfs_mount *mp, u32 keydev, uint64_t bno), 3635 TP_ARGS(mp, keydev, bno), 3636 TP_STRUCT__entry( 3637 __field(dev_t, dev) 3638 __field(dev_t, keydev) 3639 __field(xfs_fsblock_t, bno) 3640 ), 3641 TP_fast_assign( 3642 __entry->dev = mp->m_super->s_dev; 3643 __entry->keydev = new_decode_dev(keydev); 3644 __entry->bno = bno; 3645 ), 3646 TP_printk("dev %d:%d keydev %d:%d bno 0x%llx", 3647 MAJOR(__entry->dev), MINOR(__entry->dev), 3648 MAJOR(__entry->keydev), MINOR(__entry->keydev), 3649 __entry->bno) 3650 ) 3651 #define DEFINE_FSMAP_LINEAR_EVENT(name) \ 3652 DEFINE_EVENT(xfs_fsmap_linear_class, name, \ 3653 TP_PROTO(struct xfs_mount *mp, u32 keydev, uint64_t bno), \ 3654 TP_ARGS(mp, keydev, bno)) 3655 DEFINE_FSMAP_LINEAR_EVENT(xfs_fsmap_low_key_linear); 3656 DEFINE_FSMAP_LINEAR_EVENT(xfs_fsmap_high_key_linear); 3657 3658 DECLARE_EVENT_CLASS(xfs_getfsmap_class, 3659 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), 3660 TP_ARGS(mp, fsmap), 3661 TP_STRUCT__entry( 3662 __field(dev_t, dev) 3663 __field(dev_t, keydev) 3664 __field(xfs_daddr_t, block) 3665 __field(xfs_daddr_t, len) 3666 __field(uint64_t, owner) 3667 __field(uint64_t, offset) 3668 __field(uint64_t, flags) 3669 ), 3670 TP_fast_assign( 3671 __entry->dev = mp->m_super->s_dev; 3672 __entry->keydev = new_decode_dev(fsmap->fmr_device); 3673 __entry->block = fsmap->fmr_physical; 3674 __entry->len = fsmap->fmr_length; 3675 __entry->owner = fsmap->fmr_owner; 3676 __entry->offset = fsmap->fmr_offset; 3677 __entry->flags = fsmap->fmr_flags; 3678 ), 3679 TP_printk("dev %d:%d keydev %d:%d daddr 0x%llx bbcount 0x%llx owner 0x%llx fileoff_daddr 0x%llx flags 0x%llx", 3680 MAJOR(__entry->dev), MINOR(__entry->dev), 3681 MAJOR(__entry->keydev), MINOR(__entry->keydev), 3682 __entry->block, 3683 __entry->len, 3684 __entry->owner, 3685 __entry->offset, 3686 __entry->flags) 3687 ) 3688 #define DEFINE_GETFSMAP_EVENT(name) \ 3689 DEFINE_EVENT(xfs_getfsmap_class, name, \ 3690 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), \ 3691 TP_ARGS(mp, fsmap)) 3692 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_low_key); 3693 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_high_key); 3694 DEFINE_GETFSMAP_EVENT(xfs_getfsmap_mapping); 3695 3696 DECLARE_EVENT_CLASS(xfs_trans_resv_class, 3697 TP_PROTO(struct xfs_mount *mp, unsigned int type, 3698 struct xfs_trans_res *res), 3699 TP_ARGS(mp, type, res), 3700 TP_STRUCT__entry( 3701 __field(dev_t, dev) 3702 __field(int, type) 3703 __field(uint, logres) 3704 __field(int, logcount) 3705 __field(int, logflags) 3706 ), 3707 TP_fast_assign( 3708 __entry->dev = mp->m_super->s_dev; 3709 __entry->type = type; 3710 __entry->logres = res->tr_logres; 3711 __entry->logcount = res->tr_logcount; 3712 __entry->logflags = res->tr_logflags; 3713 ), 3714 TP_printk("dev %d:%d type %d logres %u logcount %d flags 0x%x", 3715 MAJOR(__entry->dev), MINOR(__entry->dev), 3716 __entry->type, 3717 __entry->logres, 3718 __entry->logcount, 3719 __entry->logflags) 3720 ) 3721 3722 #define DEFINE_TRANS_RESV_EVENT(name) \ 3723 DEFINE_EVENT(xfs_trans_resv_class, name, \ 3724 TP_PROTO(struct xfs_mount *mp, unsigned int type, \ 3725 struct xfs_trans_res *res), \ 3726 TP_ARGS(mp, type, res)) 3727 DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc); 3728 DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc_minlogsize); 3729 3730 TRACE_EVENT(xfs_log_get_max_trans_res, 3731 TP_PROTO(struct xfs_mount *mp, const struct xfs_trans_res *res), 3732 TP_ARGS(mp, res), 3733 TP_STRUCT__entry( 3734 __field(dev_t, dev) 3735 __field(uint, logres) 3736 __field(int, logcount) 3737 ), 3738 TP_fast_assign( 3739 __entry->dev = mp->m_super->s_dev; 3740 __entry->logres = res->tr_logres; 3741 __entry->logcount = res->tr_logcount; 3742 ), 3743 TP_printk("dev %d:%d logres %u logcount %d", 3744 MAJOR(__entry->dev), MINOR(__entry->dev), 3745 __entry->logres, 3746 __entry->logcount) 3747 ); 3748 3749 DECLARE_EVENT_CLASS(xfs_trans_class, 3750 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 3751 TP_ARGS(tp, caller_ip), 3752 TP_STRUCT__entry( 3753 __field(dev_t, dev) 3754 __field(uint32_t, tid) 3755 __field(uint32_t, flags) 3756 __field(unsigned long, caller_ip) 3757 ), 3758 TP_fast_assign( 3759 __entry->dev = tp->t_mountp->m_super->s_dev; 3760 __entry->tid = 0; 3761 if (tp->t_ticket) 3762 __entry->tid = tp->t_ticket->t_tid; 3763 __entry->flags = tp->t_flags; 3764 __entry->caller_ip = caller_ip; 3765 ), 3766 TP_printk("dev %d:%d trans %x flags 0x%x caller %pS", 3767 MAJOR(__entry->dev), MINOR(__entry->dev), 3768 __entry->tid, 3769 __entry->flags, 3770 (char *)__entry->caller_ip) 3771 ) 3772 3773 #define DEFINE_TRANS_EVENT(name) \ 3774 DEFINE_EVENT(xfs_trans_class, name, \ 3775 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 3776 TP_ARGS(tp, caller_ip)) 3777 DEFINE_TRANS_EVENT(xfs_trans_alloc); 3778 DEFINE_TRANS_EVENT(xfs_trans_cancel); 3779 DEFINE_TRANS_EVENT(xfs_trans_commit); 3780 DEFINE_TRANS_EVENT(xfs_trans_dup); 3781 DEFINE_TRANS_EVENT(xfs_trans_free); 3782 DEFINE_TRANS_EVENT(xfs_trans_roll); 3783 DEFINE_TRANS_EVENT(xfs_trans_add_item); 3784 DEFINE_TRANS_EVENT(xfs_trans_commit_items); 3785 DEFINE_TRANS_EVENT(xfs_trans_free_items); 3786 3787 TRACE_EVENT(xfs_iunlink_update_bucket, 3788 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, unsigned int bucket, 3789 xfs_agino_t old_ptr, xfs_agino_t new_ptr), 3790 TP_ARGS(mp, agno, bucket, old_ptr, new_ptr), 3791 TP_STRUCT__entry( 3792 __field(dev_t, dev) 3793 __field(xfs_agnumber_t, agno) 3794 __field(unsigned int, bucket) 3795 __field(xfs_agino_t, old_ptr) 3796 __field(xfs_agino_t, new_ptr) 3797 ), 3798 TP_fast_assign( 3799 __entry->dev = mp->m_super->s_dev; 3800 __entry->agno = agno; 3801 __entry->bucket = bucket; 3802 __entry->old_ptr = old_ptr; 3803 __entry->new_ptr = new_ptr; 3804 ), 3805 TP_printk("dev %d:%d agno 0x%x bucket %u old 0x%x new 0x%x", 3806 MAJOR(__entry->dev), MINOR(__entry->dev), 3807 __entry->agno, 3808 __entry->bucket, 3809 __entry->old_ptr, 3810 __entry->new_ptr) 3811 ); 3812 3813 TRACE_EVENT(xfs_iunlink_update_dinode, 3814 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agino_t agino, 3815 xfs_agino_t old_ptr, xfs_agino_t new_ptr), 3816 TP_ARGS(mp, agno, agino, old_ptr, new_ptr), 3817 TP_STRUCT__entry( 3818 __field(dev_t, dev) 3819 __field(xfs_agnumber_t, agno) 3820 __field(xfs_agino_t, agino) 3821 __field(xfs_agino_t, old_ptr) 3822 __field(xfs_agino_t, new_ptr) 3823 ), 3824 TP_fast_assign( 3825 __entry->dev = mp->m_super->s_dev; 3826 __entry->agno = agno; 3827 __entry->agino = agino; 3828 __entry->old_ptr = old_ptr; 3829 __entry->new_ptr = new_ptr; 3830 ), 3831 TP_printk("dev %d:%d agno 0x%x agino 0x%x old 0x%x new 0x%x", 3832 MAJOR(__entry->dev), MINOR(__entry->dev), 3833 __entry->agno, 3834 __entry->agino, 3835 __entry->old_ptr, 3836 __entry->new_ptr) 3837 ); 3838 3839 TRACE_EVENT(xfs_iunlink_reload_next, 3840 TP_PROTO(struct xfs_inode *ip), 3841 TP_ARGS(ip), 3842 TP_STRUCT__entry( 3843 __field(dev_t, dev) 3844 __field(xfs_agnumber_t, agno) 3845 __field(xfs_agino_t, agino) 3846 __field(xfs_agino_t, prev_agino) 3847 __field(xfs_agino_t, next_agino) 3848 ), 3849 TP_fast_assign( 3850 __entry->dev = ip->i_mount->m_super->s_dev; 3851 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 3852 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 3853 __entry->prev_agino = ip->i_prev_unlinked; 3854 __entry->next_agino = ip->i_next_unlinked; 3855 ), 3856 TP_printk("dev %d:%d agno 0x%x agino 0x%x prev_unlinked 0x%x next_unlinked 0x%x", 3857 MAJOR(__entry->dev), MINOR(__entry->dev), 3858 __entry->agno, 3859 __entry->agino, 3860 __entry->prev_agino, 3861 __entry->next_agino) 3862 ); 3863 3864 TRACE_EVENT(xfs_inode_reload_unlinked_bucket, 3865 TP_PROTO(struct xfs_inode *ip), 3866 TP_ARGS(ip), 3867 TP_STRUCT__entry( 3868 __field(dev_t, dev) 3869 __field(xfs_agnumber_t, agno) 3870 __field(xfs_agino_t, agino) 3871 ), 3872 TP_fast_assign( 3873 __entry->dev = ip->i_mount->m_super->s_dev; 3874 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 3875 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 3876 ), 3877 TP_printk("dev %d:%d agno 0x%x agino 0x%x bucket %u", 3878 MAJOR(__entry->dev), MINOR(__entry->dev), 3879 __entry->agno, 3880 __entry->agino, 3881 __entry->agino % XFS_AGI_UNLINKED_BUCKETS) 3882 ); 3883 3884 DECLARE_EVENT_CLASS(xfs_ag_inode_class, 3885 TP_PROTO(struct xfs_inode *ip), 3886 TP_ARGS(ip), 3887 TP_STRUCT__entry( 3888 __field(dev_t, dev) 3889 __field(xfs_agnumber_t, agno) 3890 __field(xfs_agino_t, agino) 3891 ), 3892 TP_fast_assign( 3893 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3894 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 3895 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 3896 ), 3897 TP_printk("dev %d:%d agno 0x%x agino 0x%x", 3898 MAJOR(__entry->dev), MINOR(__entry->dev), 3899 __entry->agno, __entry->agino) 3900 ) 3901 3902 #define DEFINE_AGINODE_EVENT(name) \ 3903 DEFINE_EVENT(xfs_ag_inode_class, name, \ 3904 TP_PROTO(struct xfs_inode *ip), \ 3905 TP_ARGS(ip)) 3906 DEFINE_AGINODE_EVENT(xfs_iunlink); 3907 DEFINE_AGINODE_EVENT(xfs_iunlink_remove); 3908 3909 DECLARE_EVENT_CLASS(xfs_fs_corrupt_class, 3910 TP_PROTO(struct xfs_mount *mp, unsigned int flags), 3911 TP_ARGS(mp, flags), 3912 TP_STRUCT__entry( 3913 __field(dev_t, dev) 3914 __field(unsigned int, flags) 3915 ), 3916 TP_fast_assign( 3917 __entry->dev = mp->m_super->s_dev; 3918 __entry->flags = flags; 3919 ), 3920 TP_printk("dev %d:%d flags 0x%x", 3921 MAJOR(__entry->dev), MINOR(__entry->dev), 3922 __entry->flags) 3923 ); 3924 #define DEFINE_FS_CORRUPT_EVENT(name) \ 3925 DEFINE_EVENT(xfs_fs_corrupt_class, name, \ 3926 TP_PROTO(struct xfs_mount *mp, unsigned int flags), \ 3927 TP_ARGS(mp, flags)) 3928 DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_sick); 3929 DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_healthy); 3930 DEFINE_FS_CORRUPT_EVENT(xfs_fs_unfixed_corruption); 3931 DEFINE_FS_CORRUPT_EVENT(xfs_rt_mark_sick); 3932 DEFINE_FS_CORRUPT_EVENT(xfs_rt_mark_healthy); 3933 DEFINE_FS_CORRUPT_EVENT(xfs_rt_unfixed_corruption); 3934 3935 DECLARE_EVENT_CLASS(xfs_ag_corrupt_class, 3936 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, unsigned int flags), 3937 TP_ARGS(mp, agno, flags), 3938 TP_STRUCT__entry( 3939 __field(dev_t, dev) 3940 __field(xfs_agnumber_t, agno) 3941 __field(unsigned int, flags) 3942 ), 3943 TP_fast_assign( 3944 __entry->dev = mp->m_super->s_dev; 3945 __entry->agno = agno; 3946 __entry->flags = flags; 3947 ), 3948 TP_printk("dev %d:%d agno 0x%x flags 0x%x", 3949 MAJOR(__entry->dev), MINOR(__entry->dev), 3950 __entry->agno, __entry->flags) 3951 ); 3952 #define DEFINE_AG_CORRUPT_EVENT(name) \ 3953 DEFINE_EVENT(xfs_ag_corrupt_class, name, \ 3954 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \ 3955 unsigned int flags), \ 3956 TP_ARGS(mp, agno, flags)) 3957 DEFINE_AG_CORRUPT_EVENT(xfs_ag_mark_sick); 3958 DEFINE_AG_CORRUPT_EVENT(xfs_ag_mark_healthy); 3959 DEFINE_AG_CORRUPT_EVENT(xfs_ag_unfixed_corruption); 3960 3961 DECLARE_EVENT_CLASS(xfs_inode_corrupt_class, 3962 TP_PROTO(struct xfs_inode *ip, unsigned int flags), 3963 TP_ARGS(ip, flags), 3964 TP_STRUCT__entry( 3965 __field(dev_t, dev) 3966 __field(xfs_ino_t, ino) 3967 __field(unsigned int, flags) 3968 ), 3969 TP_fast_assign( 3970 __entry->dev = ip->i_mount->m_super->s_dev; 3971 __entry->ino = ip->i_ino; 3972 __entry->flags = flags; 3973 ), 3974 TP_printk("dev %d:%d ino 0x%llx flags 0x%x", 3975 MAJOR(__entry->dev), MINOR(__entry->dev), 3976 __entry->ino, __entry->flags) 3977 ); 3978 #define DEFINE_INODE_CORRUPT_EVENT(name) \ 3979 DEFINE_EVENT(xfs_inode_corrupt_class, name, \ 3980 TP_PROTO(struct xfs_inode *ip, unsigned int flags), \ 3981 TP_ARGS(ip, flags)) 3982 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_sick); 3983 DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_healthy); 3984 3985 TRACE_EVENT(xfs_iwalk_ag, 3986 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 3987 xfs_agino_t startino), 3988 TP_ARGS(mp, agno, startino), 3989 TP_STRUCT__entry( 3990 __field(dev_t, dev) 3991 __field(xfs_agnumber_t, agno) 3992 __field(xfs_agino_t, startino) 3993 ), 3994 TP_fast_assign( 3995 __entry->dev = mp->m_super->s_dev; 3996 __entry->agno = agno; 3997 __entry->startino = startino; 3998 ), 3999 TP_printk("dev %d:%d agno 0x%x startino 0x%x", 4000 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno, 4001 __entry->startino) 4002 ) 4003 4004 TRACE_EVENT(xfs_iwalk_ag_rec, 4005 TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, 4006 struct xfs_inobt_rec_incore *irec), 4007 TP_ARGS(mp, agno, irec), 4008 TP_STRUCT__entry( 4009 __field(dev_t, dev) 4010 __field(xfs_agnumber_t, agno) 4011 __field(xfs_agino_t, startino) 4012 __field(uint64_t, freemask) 4013 ), 4014 TP_fast_assign( 4015 __entry->dev = mp->m_super->s_dev; 4016 __entry->agno = agno; 4017 __entry->startino = irec->ir_startino; 4018 __entry->freemask = irec->ir_free; 4019 ), 4020 TP_printk("dev %d:%d agno 0x%x startino 0x%x freemask 0x%llx", 4021 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno, 4022 __entry->startino, __entry->freemask) 4023 ) 4024 4025 TRACE_EVENT(xfs_pwork_init, 4026 TP_PROTO(struct xfs_mount *mp, unsigned int nr_threads, pid_t pid), 4027 TP_ARGS(mp, nr_threads, pid), 4028 TP_STRUCT__entry( 4029 __field(dev_t, dev) 4030 __field(unsigned int, nr_threads) 4031 __field(pid_t, pid) 4032 ), 4033 TP_fast_assign( 4034 __entry->dev = mp->m_super->s_dev; 4035 __entry->nr_threads = nr_threads; 4036 __entry->pid = pid; 4037 ), 4038 TP_printk("dev %d:%d nr_threads %u pid %u", 4039 MAJOR(__entry->dev), MINOR(__entry->dev), 4040 __entry->nr_threads, __entry->pid) 4041 ) 4042 4043 DECLARE_EVENT_CLASS(xfs_kmem_class, 4044 TP_PROTO(ssize_t size, int flags, unsigned long caller_ip), 4045 TP_ARGS(size, flags, caller_ip), 4046 TP_STRUCT__entry( 4047 __field(ssize_t, size) 4048 __field(int, flags) 4049 __field(unsigned long, caller_ip) 4050 ), 4051 TP_fast_assign( 4052 __entry->size = size; 4053 __entry->flags = flags; 4054 __entry->caller_ip = caller_ip; 4055 ), 4056 TP_printk("size %zd flags 0x%x caller %pS", 4057 __entry->size, 4058 __entry->flags, 4059 (char *)__entry->caller_ip) 4060 ) 4061 4062 #define DEFINE_KMEM_EVENT(name) \ 4063 DEFINE_EVENT(xfs_kmem_class, name, \ 4064 TP_PROTO(ssize_t size, int flags, unsigned long caller_ip), \ 4065 TP_ARGS(size, flags, caller_ip)) 4066 DEFINE_KMEM_EVENT(kmem_alloc); 4067 4068 TRACE_EVENT(xfs_check_new_dalign, 4069 TP_PROTO(struct xfs_mount *mp, int new_dalign, xfs_ino_t calc_rootino), 4070 TP_ARGS(mp, new_dalign, calc_rootino), 4071 TP_STRUCT__entry( 4072 __field(dev_t, dev) 4073 __field(int, new_dalign) 4074 __field(xfs_ino_t, sb_rootino) 4075 __field(xfs_ino_t, calc_rootino) 4076 ), 4077 TP_fast_assign( 4078 __entry->dev = mp->m_super->s_dev; 4079 __entry->new_dalign = new_dalign; 4080 __entry->sb_rootino = mp->m_sb.sb_rootino; 4081 __entry->calc_rootino = calc_rootino; 4082 ), 4083 TP_printk("dev %d:%d new_dalign %d sb_rootino 0x%llx calc_rootino 0x%llx", 4084 MAJOR(__entry->dev), MINOR(__entry->dev), 4085 __entry->new_dalign, __entry->sb_rootino, 4086 __entry->calc_rootino) 4087 ) 4088 4089 TRACE_EVENT(xfs_btree_commit_afakeroot, 4090 TP_PROTO(struct xfs_btree_cur *cur), 4091 TP_ARGS(cur), 4092 TP_STRUCT__entry( 4093 __field(dev_t, dev) 4094 __field(xfs_btnum_t, btnum) 4095 __field(xfs_agnumber_t, agno) 4096 __field(xfs_agblock_t, agbno) 4097 __field(unsigned int, levels) 4098 __field(unsigned int, blocks) 4099 ), 4100 TP_fast_assign( 4101 __entry->dev = cur->bc_mp->m_super->s_dev; 4102 __entry->btnum = cur->bc_btnum; 4103 __entry->agno = cur->bc_ag.pag->pag_agno; 4104 __entry->agbno = cur->bc_ag.afake->af_root; 4105 __entry->levels = cur->bc_ag.afake->af_levels; 4106 __entry->blocks = cur->bc_ag.afake->af_blocks; 4107 ), 4108 TP_printk("dev %d:%d btree %s agno 0x%x levels %u blocks %u root %u", 4109 MAJOR(__entry->dev), MINOR(__entry->dev), 4110 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 4111 __entry->agno, 4112 __entry->levels, 4113 __entry->blocks, 4114 __entry->agbno) 4115 ) 4116 4117 TRACE_EVENT(xfs_btree_commit_ifakeroot, 4118 TP_PROTO(struct xfs_btree_cur *cur), 4119 TP_ARGS(cur), 4120 TP_STRUCT__entry( 4121 __field(dev_t, dev) 4122 __field(xfs_btnum_t, btnum) 4123 __field(xfs_agnumber_t, agno) 4124 __field(xfs_agino_t, agino) 4125 __field(unsigned int, levels) 4126 __field(unsigned int, blocks) 4127 __field(int, whichfork) 4128 ), 4129 TP_fast_assign( 4130 __entry->dev = cur->bc_mp->m_super->s_dev; 4131 __entry->btnum = cur->bc_btnum; 4132 __entry->agno = XFS_INO_TO_AGNO(cur->bc_mp, 4133 cur->bc_ino.ip->i_ino); 4134 __entry->agino = XFS_INO_TO_AGINO(cur->bc_mp, 4135 cur->bc_ino.ip->i_ino); 4136 __entry->levels = cur->bc_ino.ifake->if_levels; 4137 __entry->blocks = cur->bc_ino.ifake->if_blocks; 4138 __entry->whichfork = cur->bc_ino.whichfork; 4139 ), 4140 TP_printk("dev %d:%d btree %s agno 0x%x agino 0x%x whichfork %s levels %u blocks %u", 4141 MAJOR(__entry->dev), MINOR(__entry->dev), 4142 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 4143 __entry->agno, 4144 __entry->agino, 4145 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 4146 __entry->levels, 4147 __entry->blocks) 4148 ) 4149 4150 TRACE_EVENT(xfs_btree_bload_level_geometry, 4151 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4152 uint64_t nr_this_level, unsigned int nr_per_block, 4153 unsigned int desired_npb, uint64_t blocks, 4154 uint64_t blocks_with_extra), 4155 TP_ARGS(cur, level, nr_this_level, nr_per_block, desired_npb, blocks, 4156 blocks_with_extra), 4157 TP_STRUCT__entry( 4158 __field(dev_t, dev) 4159 __field(xfs_btnum_t, btnum) 4160 __field(unsigned int, level) 4161 __field(unsigned int, nlevels) 4162 __field(uint64_t, nr_this_level) 4163 __field(unsigned int, nr_per_block) 4164 __field(unsigned int, desired_npb) 4165 __field(unsigned long long, blocks) 4166 __field(unsigned long long, blocks_with_extra) 4167 ), 4168 TP_fast_assign( 4169 __entry->dev = cur->bc_mp->m_super->s_dev; 4170 __entry->btnum = cur->bc_btnum; 4171 __entry->level = level; 4172 __entry->nlevels = cur->bc_nlevels; 4173 __entry->nr_this_level = nr_this_level; 4174 __entry->nr_per_block = nr_per_block; 4175 __entry->desired_npb = desired_npb; 4176 __entry->blocks = blocks; 4177 __entry->blocks_with_extra = blocks_with_extra; 4178 ), 4179 TP_printk("dev %d:%d btree %s level %u/%u nr_this_level %llu nr_per_block %u desired_npb %u blocks %llu blocks_with_extra %llu", 4180 MAJOR(__entry->dev), MINOR(__entry->dev), 4181 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 4182 __entry->level, 4183 __entry->nlevels, 4184 __entry->nr_this_level, 4185 __entry->nr_per_block, 4186 __entry->desired_npb, 4187 __entry->blocks, 4188 __entry->blocks_with_extra) 4189 ) 4190 4191 TRACE_EVENT(xfs_btree_bload_block, 4192 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4193 uint64_t block_idx, uint64_t nr_blocks, 4194 union xfs_btree_ptr *ptr, unsigned int nr_records), 4195 TP_ARGS(cur, level, block_idx, nr_blocks, ptr, nr_records), 4196 TP_STRUCT__entry( 4197 __field(dev_t, dev) 4198 __field(xfs_btnum_t, btnum) 4199 __field(unsigned int, level) 4200 __field(unsigned long long, block_idx) 4201 __field(unsigned long long, nr_blocks) 4202 __field(xfs_agnumber_t, agno) 4203 __field(xfs_agblock_t, agbno) 4204 __field(unsigned int, nr_records) 4205 ), 4206 TP_fast_assign( 4207 __entry->dev = cur->bc_mp->m_super->s_dev; 4208 __entry->btnum = cur->bc_btnum; 4209 __entry->level = level; 4210 __entry->block_idx = block_idx; 4211 __entry->nr_blocks = nr_blocks; 4212 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) { 4213 xfs_fsblock_t fsb = be64_to_cpu(ptr->l); 4214 4215 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsb); 4216 __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsb); 4217 } else { 4218 __entry->agno = cur->bc_ag.pag->pag_agno; 4219 __entry->agbno = be32_to_cpu(ptr->s); 4220 } 4221 __entry->nr_records = nr_records; 4222 ), 4223 TP_printk("dev %d:%d btree %s level %u block %llu/%llu agno 0x%x agbno 0x%x recs %u", 4224 MAJOR(__entry->dev), MINOR(__entry->dev), 4225 __print_symbolic(__entry->btnum, XFS_BTNUM_STRINGS), 4226 __entry->level, 4227 __entry->block_idx, 4228 __entry->nr_blocks, 4229 __entry->agno, 4230 __entry->agbno, 4231 __entry->nr_records) 4232 ) 4233 4234 DECLARE_EVENT_CLASS(xfs_timestamp_range_class, 4235 TP_PROTO(struct xfs_mount *mp, time64_t min, time64_t max), 4236 TP_ARGS(mp, min, max), 4237 TP_STRUCT__entry( 4238 __field(dev_t, dev) 4239 __field(long long, min) 4240 __field(long long, max) 4241 ), 4242 TP_fast_assign( 4243 __entry->dev = mp->m_super->s_dev; 4244 __entry->min = min; 4245 __entry->max = max; 4246 ), 4247 TP_printk("dev %d:%d min %lld max %lld", 4248 MAJOR(__entry->dev), MINOR(__entry->dev), 4249 __entry->min, 4250 __entry->max) 4251 ) 4252 4253 #define DEFINE_TIMESTAMP_RANGE_EVENT(name) \ 4254 DEFINE_EVENT(xfs_timestamp_range_class, name, \ 4255 TP_PROTO(struct xfs_mount *mp, long long min, long long max), \ 4256 TP_ARGS(mp, min, max)) 4257 DEFINE_TIMESTAMP_RANGE_EVENT(xfs_inode_timestamp_range); 4258 DEFINE_TIMESTAMP_RANGE_EVENT(xfs_quota_expiry_range); 4259 4260 DECLARE_EVENT_CLASS(xfs_icwalk_class, 4261 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, 4262 unsigned long caller_ip), 4263 TP_ARGS(mp, icw, caller_ip), 4264 TP_STRUCT__entry( 4265 __field(dev_t, dev) 4266 __field(__u32, flags) 4267 __field(uint32_t, uid) 4268 __field(uint32_t, gid) 4269 __field(prid_t, prid) 4270 __field(__u64, min_file_size) 4271 __field(long, scan_limit) 4272 __field(unsigned long, caller_ip) 4273 ), 4274 TP_fast_assign( 4275 __entry->dev = mp->m_super->s_dev; 4276 __entry->flags = icw ? icw->icw_flags : 0; 4277 __entry->uid = icw ? from_kuid(mp->m_super->s_user_ns, 4278 icw->icw_uid) : 0; 4279 __entry->gid = icw ? from_kgid(mp->m_super->s_user_ns, 4280 icw->icw_gid) : 0; 4281 __entry->prid = icw ? icw->icw_prid : 0; 4282 __entry->min_file_size = icw ? icw->icw_min_file_size : 0; 4283 __entry->scan_limit = icw ? icw->icw_scan_limit : 0; 4284 __entry->caller_ip = caller_ip; 4285 ), 4286 TP_printk("dev %d:%d flags 0x%x uid %u gid %u prid %u minsize %llu scan_limit %ld caller %pS", 4287 MAJOR(__entry->dev), MINOR(__entry->dev), 4288 __entry->flags, 4289 __entry->uid, 4290 __entry->gid, 4291 __entry->prid, 4292 __entry->min_file_size, 4293 __entry->scan_limit, 4294 (char *)__entry->caller_ip) 4295 ); 4296 #define DEFINE_ICWALK_EVENT(name) \ 4297 DEFINE_EVENT(xfs_icwalk_class, name, \ 4298 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, \ 4299 unsigned long caller_ip), \ 4300 TP_ARGS(mp, icw, caller_ip)) 4301 DEFINE_ICWALK_EVENT(xfs_ioc_free_eofblocks); 4302 DEFINE_ICWALK_EVENT(xfs_blockgc_free_space); 4303 4304 TRACE_DEFINE_ENUM(XLOG_STATE_ACTIVE); 4305 TRACE_DEFINE_ENUM(XLOG_STATE_WANT_SYNC); 4306 TRACE_DEFINE_ENUM(XLOG_STATE_SYNCING); 4307 TRACE_DEFINE_ENUM(XLOG_STATE_DONE_SYNC); 4308 TRACE_DEFINE_ENUM(XLOG_STATE_CALLBACK); 4309 TRACE_DEFINE_ENUM(XLOG_STATE_DIRTY); 4310 4311 DECLARE_EVENT_CLASS(xlog_iclog_class, 4312 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), 4313 TP_ARGS(iclog, caller_ip), 4314 TP_STRUCT__entry( 4315 __field(dev_t, dev) 4316 __field(uint32_t, state) 4317 __field(int32_t, refcount) 4318 __field(uint32_t, offset) 4319 __field(uint32_t, flags) 4320 __field(unsigned long long, lsn) 4321 __field(unsigned long, caller_ip) 4322 ), 4323 TP_fast_assign( 4324 __entry->dev = iclog->ic_log->l_mp->m_super->s_dev; 4325 __entry->state = iclog->ic_state; 4326 __entry->refcount = atomic_read(&iclog->ic_refcnt); 4327 __entry->offset = iclog->ic_offset; 4328 __entry->flags = iclog->ic_flags; 4329 __entry->lsn = be64_to_cpu(iclog->ic_header.h_lsn); 4330 __entry->caller_ip = caller_ip; 4331 ), 4332 TP_printk("dev %d:%d state %s refcnt %d offset %u lsn 0x%llx flags %s caller %pS", 4333 MAJOR(__entry->dev), MINOR(__entry->dev), 4334 __print_symbolic(__entry->state, XLOG_STATE_STRINGS), 4335 __entry->refcount, 4336 __entry->offset, 4337 __entry->lsn, 4338 __print_flags(__entry->flags, "|", XLOG_ICL_STRINGS), 4339 (char *)__entry->caller_ip) 4340 4341 ); 4342 4343 #define DEFINE_ICLOG_EVENT(name) \ 4344 DEFINE_EVENT(xlog_iclog_class, name, \ 4345 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), \ 4346 TP_ARGS(iclog, caller_ip)) 4347 4348 DEFINE_ICLOG_EVENT(xlog_iclog_activate); 4349 DEFINE_ICLOG_EVENT(xlog_iclog_clean); 4350 DEFINE_ICLOG_EVENT(xlog_iclog_callback); 4351 DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_start); 4352 DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_done); 4353 DEFINE_ICLOG_EVENT(xlog_iclog_force); 4354 DEFINE_ICLOG_EVENT(xlog_iclog_force_lsn); 4355 DEFINE_ICLOG_EVENT(xlog_iclog_get_space); 4356 DEFINE_ICLOG_EVENT(xlog_iclog_release); 4357 DEFINE_ICLOG_EVENT(xlog_iclog_switch); 4358 DEFINE_ICLOG_EVENT(xlog_iclog_sync); 4359 DEFINE_ICLOG_EVENT(xlog_iclog_syncing); 4360 DEFINE_ICLOG_EVENT(xlog_iclog_sync_done); 4361 DEFINE_ICLOG_EVENT(xlog_iclog_want_sync); 4362 DEFINE_ICLOG_EVENT(xlog_iclog_wait_on); 4363 DEFINE_ICLOG_EVENT(xlog_iclog_write); 4364 4365 TRACE_DEFINE_ENUM(XFS_DAS_UNINIT); 4366 TRACE_DEFINE_ENUM(XFS_DAS_SF_ADD); 4367 TRACE_DEFINE_ENUM(XFS_DAS_SF_REMOVE); 4368 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ADD); 4369 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE); 4370 TRACE_DEFINE_ENUM(XFS_DAS_NODE_ADD); 4371 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE); 4372 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_SET_RMT); 4373 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ALLOC_RMT); 4374 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REPLACE); 4375 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_OLD); 4376 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_RMT); 4377 TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_ATTR); 4378 TRACE_DEFINE_ENUM(XFS_DAS_NODE_SET_RMT); 4379 TRACE_DEFINE_ENUM(XFS_DAS_NODE_ALLOC_RMT); 4380 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REPLACE); 4381 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_OLD); 4382 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_RMT); 4383 TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_ATTR); 4384 TRACE_DEFINE_ENUM(XFS_DAS_DONE); 4385 4386 DECLARE_EVENT_CLASS(xfs_das_state_class, 4387 TP_PROTO(int das, struct xfs_inode *ip), 4388 TP_ARGS(das, ip), 4389 TP_STRUCT__entry( 4390 __field(int, das) 4391 __field(xfs_ino_t, ino) 4392 ), 4393 TP_fast_assign( 4394 __entry->das = das; 4395 __entry->ino = ip->i_ino; 4396 ), 4397 TP_printk("state change %s ino 0x%llx", 4398 __print_symbolic(__entry->das, XFS_DAS_STRINGS), 4399 __entry->ino) 4400 ) 4401 4402 #define DEFINE_DAS_STATE_EVENT(name) \ 4403 DEFINE_EVENT(xfs_das_state_class, name, \ 4404 TP_PROTO(int das, struct xfs_inode *ip), \ 4405 TP_ARGS(das, ip)) 4406 DEFINE_DAS_STATE_EVENT(xfs_attr_sf_addname_return); 4407 DEFINE_DAS_STATE_EVENT(xfs_attr_set_iter_return); 4408 DEFINE_DAS_STATE_EVENT(xfs_attr_leaf_addname_return); 4409 DEFINE_DAS_STATE_EVENT(xfs_attr_node_addname_return); 4410 DEFINE_DAS_STATE_EVENT(xfs_attr_remove_iter_return); 4411 DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_alloc); 4412 DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_remove_return); 4413 DEFINE_DAS_STATE_EVENT(xfs_attr_defer_add); 4414 4415 4416 TRACE_EVENT(xfs_force_shutdown, 4417 TP_PROTO(struct xfs_mount *mp, int ptag, int flags, const char *fname, 4418 int line_num), 4419 TP_ARGS(mp, ptag, flags, fname, line_num), 4420 TP_STRUCT__entry( 4421 __field(dev_t, dev) 4422 __field(int, ptag) 4423 __field(int, flags) 4424 __string(fname, fname) 4425 __field(int, line_num) 4426 ), 4427 TP_fast_assign( 4428 __entry->dev = mp->m_super->s_dev; 4429 __entry->ptag = ptag; 4430 __entry->flags = flags; 4431 __assign_str(fname, fname); 4432 __entry->line_num = line_num; 4433 ), 4434 TP_printk("dev %d:%d tag %s flags %s file %s line_num %d", 4435 MAJOR(__entry->dev), MINOR(__entry->dev), 4436 __print_flags(__entry->ptag, "|", XFS_PTAG_STRINGS), 4437 __print_flags(__entry->flags, "|", XFS_SHUTDOWN_STRINGS), 4438 __get_str(fname), 4439 __entry->line_num) 4440 ); 4441 4442 #ifdef CONFIG_XFS_DRAIN_INTENTS 4443 DECLARE_EVENT_CLASS(xfs_perag_intents_class, 4444 TP_PROTO(struct xfs_perag *pag, void *caller_ip), 4445 TP_ARGS(pag, caller_ip), 4446 TP_STRUCT__entry( 4447 __field(dev_t, dev) 4448 __field(xfs_agnumber_t, agno) 4449 __field(long, nr_intents) 4450 __field(void *, caller_ip) 4451 ), 4452 TP_fast_assign( 4453 __entry->dev = pag->pag_mount->m_super->s_dev; 4454 __entry->agno = pag->pag_agno; 4455 __entry->nr_intents = atomic_read(&pag->pag_intents_drain.dr_count); 4456 __entry->caller_ip = caller_ip; 4457 ), 4458 TP_printk("dev %d:%d agno 0x%x intents %ld caller %pS", 4459 MAJOR(__entry->dev), MINOR(__entry->dev), 4460 __entry->agno, 4461 __entry->nr_intents, 4462 __entry->caller_ip) 4463 ); 4464 4465 #define DEFINE_PERAG_INTENTS_EVENT(name) \ 4466 DEFINE_EVENT(xfs_perag_intents_class, name, \ 4467 TP_PROTO(struct xfs_perag *pag, void *caller_ip), \ 4468 TP_ARGS(pag, caller_ip)) 4469 DEFINE_PERAG_INTENTS_EVENT(xfs_perag_intent_hold); 4470 DEFINE_PERAG_INTENTS_EVENT(xfs_perag_intent_rele); 4471 DEFINE_PERAG_INTENTS_EVENT(xfs_perag_wait_intents); 4472 4473 #endif /* CONFIG_XFS_DRAIN_INTENTS */ 4474 4475 #endif /* _TRACE_XFS_H */ 4476 4477 #undef TRACE_INCLUDE_PATH 4478 #define TRACE_INCLUDE_PATH . 4479 #define TRACE_INCLUDE_FILE xfs_trace 4480 #include <trace/define_trace.h> 4481