FILE
xfs_trace.h
File preview with syntax highlighting.
linux-6.19.14/fs/xfs/xfs_trace.h
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 * rgbno: per-rtgroup block number in fs blocks 18 * startblock: physical block number for file mappings. This is either a 19 * segmented fsblock for data device mappings, or a rfsblock 20 * for realtime device mappings 21 * fsbcount: number of blocks in an extent, in fs blocks 22 * 23 * gbno: generic allocation group block number. This is an agbno for 24 * space in a per-AG or a rgbno for space in a realtime group. 25 * 26 * daddr: physical block number in 512b blocks 27 * bbcount: number of blocks in a physical extent, in 512b blocks 28 * 29 * rtx: physical rt extent number for extent mappings 30 * rtxcount: number of rt extents in an extent mapping 31 * 32 * owner: reverse-mapping owner, usually inodes 33 * 34 * fileoff: file offset, in fs blocks 35 * pos: file offset, in bytes 36 * bytecount: number of bytes 37 * 38 * dablk: directory or xattr block offset, in filesystem blocks 39 * 40 * disize: ondisk file size, in bytes 41 * isize: incore file size, in bytes 42 * 43 * forkoff: inode fork offset, in bytes 44 * 45 * ireccount: number of inode records 46 * 47 * Numbers describing space allocations (blocks, extents, inodes) should be 48 * formatted in hexadecimal. 49 */ 50#undef TRACE_SYSTEM 51#define TRACE_SYSTEM xfs 52 53#if !defined(_TRACE_XFS_H) || defined(TRACE_HEADER_MULTI_READ) 54#define _TRACE_XFS_H 55 56#include <linux/tracepoint.h> 57 58struct xfs_agf; 59struct xfs_ail; 60struct xfs_alloc_arg; 61struct xfs_attr_list_context; 62struct xfs_buf_log_item; 63struct xfs_da_args; 64struct xfs_da_node_entry; 65struct xfs_dquot; 66struct xfs_log_item; 67struct xlog; 68struct xlog_ticket; 69struct xlog_recover; 70struct xlog_recover_item; 71struct xlog_rec_header; 72struct xlog_in_core; 73struct xfs_buf_log_format; 74struct xfs_inode_log_format; 75struct xfs_bmbt_irec; 76struct xfs_btree_cur; 77struct xfs_defer_op_type; 78struct xfs_refcount_irec; 79struct xfs_fsmap; 80struct xfs_fsmap_irec; 81struct xfs_group; 82struct xfs_rmap_irec; 83struct xfs_icreate_log; 84struct xfs_iunlink_item; 85struct xfs_owner_info; 86struct xfs_trans_res; 87struct xfs_inobt_rec_incore; 88union xfs_btree_ptr; 89struct xfs_dqtrx; 90struct xfs_icwalk; 91struct xfs_perag; 92struct xfbtree; 93struct xfs_btree_ops; 94struct xfs_bmap_intent; 95struct xfs_exchmaps_intent; 96struct xfs_exchmaps_req; 97struct xfs_exchrange; 98struct xfs_getparents; 99struct xfs_parent_irec; 100struct xfs_attrlist_cursor_kern; 101struct xfs_extent_free_item; 102struct xfs_rmap_intent; 103struct xfs_refcount_intent; 104struct xfs_metadir_update; 105struct xfs_rtgroup; 106struct xfs_open_zone; 107 108#define XFS_ATTR_FILTER_FLAGS \ 109 { XFS_ATTR_ROOT, "ROOT" }, \ 110 { XFS_ATTR_SECURE, "SECURE" }, \ 111 { XFS_ATTR_INCOMPLETE, "INCOMPLETE" }, \ 112 { XFS_ATTR_PARENT, "PARENT" } 113 114DECLARE_EVENT_CLASS(xfs_attr_list_class, 115 TP_PROTO(struct xfs_attr_list_context *ctx), 116 TP_ARGS(ctx), 117 TP_STRUCT__entry( 118 __field(dev_t, dev) 119 __field(xfs_ino_t, ino) 120 __field(u32, hashval) 121 __field(u32, blkno) 122 __field(u32, offset) 123 __field(void *, buffer) 124 __field(int, bufsize) 125 __field(int, count) 126 __field(int, firstu) 127 __field(int, dupcnt) 128 __field(unsigned int, attr_filter) 129 ), 130 TP_fast_assign( 131 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 132 __entry->ino = ctx->dp->i_ino; 133 __entry->hashval = ctx->cursor.hashval; 134 __entry->blkno = ctx->cursor.blkno; 135 __entry->offset = ctx->cursor.offset; 136 __entry->buffer = ctx->buffer; 137 __entry->bufsize = ctx->bufsize; 138 __entry->count = ctx->count; 139 __entry->firstu = ctx->firstu; 140 __entry->attr_filter = ctx->attr_filter; 141 ), 142 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 143 "buffer %p size %u count %u firstu %u filter %s", 144 MAJOR(__entry->dev), MINOR(__entry->dev), 145 __entry->ino, 146 __entry->hashval, 147 __entry->blkno, 148 __entry->offset, 149 __entry->dupcnt, 150 __entry->buffer, 151 __entry->bufsize, 152 __entry->count, 153 __entry->firstu, 154 __print_flags(__entry->attr_filter, "|", 155 XFS_ATTR_FILTER_FLAGS) 156 ) 157) 158 159#define DEFINE_ATTR_LIST_EVENT(name) \ 160DEFINE_EVENT(xfs_attr_list_class, name, \ 161 TP_PROTO(struct xfs_attr_list_context *ctx), \ 162 TP_ARGS(ctx)) 163DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf); 164DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all); 165DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf); 166DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf_end); 167DEFINE_ATTR_LIST_EVENT(xfs_attr_list_full); 168DEFINE_ATTR_LIST_EVENT(xfs_attr_list_add); 169DEFINE_ATTR_LIST_EVENT(xfs_attr_list_wrong_blk); 170DEFINE_ATTR_LIST_EVENT(xfs_attr_list_notfound); 171DEFINE_ATTR_LIST_EVENT(xfs_attr_leaf_list); 172DEFINE_ATTR_LIST_EVENT(xfs_attr_node_list); 173 174TRACE_EVENT(xfs_calc_atomic_write_unit_max, 175 TP_PROTO(struct xfs_mount *mp, enum xfs_group_type type, 176 unsigned int max_write, unsigned int max_ioend, 177 unsigned int max_gsize, unsigned int awu_max), 178 TP_ARGS(mp, type, max_write, max_ioend, max_gsize, awu_max), 179 TP_STRUCT__entry( 180 __field(dev_t, dev) 181 __field(enum xfs_group_type, type) 182 __field(unsigned int, max_write) 183 __field(unsigned int, max_ioend) 184 __field(unsigned int, max_gsize) 185 __field(unsigned int, awu_max) 186 ), 187 TP_fast_assign( 188 __entry->dev = mp->m_super->s_dev; 189 __entry->type = type; 190 __entry->max_write = max_write; 191 __entry->max_ioend = max_ioend; 192 __entry->max_gsize = max_gsize; 193 __entry->awu_max = awu_max; 194 ), 195 TP_printk("dev %d:%d %s max_write %u max_ioend %u max_gsize %u awu_max %u", 196 MAJOR(__entry->dev), MINOR(__entry->dev), 197 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 198 __entry->max_write, 199 __entry->max_ioend, 200 __entry->max_gsize, 201 __entry->awu_max) 202); 203 204TRACE_EVENT(xfs_calc_max_atomic_write_fsblocks, 205 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent, 206 unsigned int step_size, unsigned int logres, 207 unsigned int blockcount), 208 TP_ARGS(mp, per_intent, step_size, logres, blockcount), 209 TP_STRUCT__entry( 210 __field(dev_t, dev) 211 __field(unsigned int, per_intent) 212 __field(unsigned int, step_size) 213 __field(unsigned int, logres) 214 __field(unsigned int, blockcount) 215 ), 216 TP_fast_assign( 217 __entry->dev = mp->m_super->s_dev; 218 __entry->per_intent = per_intent; 219 __entry->step_size = step_size; 220 __entry->logres = logres; 221 __entry->blockcount = blockcount; 222 ), 223 TP_printk("dev %d:%d per_intent %u step_size %u logres %u blockcount %u", 224 MAJOR(__entry->dev), MINOR(__entry->dev), 225 __entry->per_intent, 226 __entry->step_size, 227 __entry->logres, 228 __entry->blockcount) 229); 230 231TRACE_EVENT(xfs_calc_max_atomic_write_log_geometry, 232 TP_PROTO(struct xfs_mount *mp, unsigned int per_intent, 233 unsigned int step_size, unsigned int blockcount, 234 unsigned int min_logblocks, unsigned int logres), 235 TP_ARGS(mp, per_intent, step_size, blockcount, min_logblocks, logres), 236 TP_STRUCT__entry( 237 __field(dev_t, dev) 238 __field(unsigned int, per_intent) 239 __field(unsigned int, step_size) 240 __field(unsigned int, blockcount) 241 __field(unsigned int, min_logblocks) 242 __field(unsigned int, cur_logblocks) 243 __field(unsigned int, logres) 244 ), 245 TP_fast_assign( 246 __entry->dev = mp->m_super->s_dev; 247 __entry->per_intent = per_intent; 248 __entry->step_size = step_size; 249 __entry->blockcount = blockcount; 250 __entry->min_logblocks = min_logblocks; 251 __entry->cur_logblocks = mp->m_sb.sb_logblocks; 252 __entry->logres = logres; 253 ), 254 TP_printk("dev %d:%d per_intent %u step_size %u blockcount %u min_logblocks %u logblocks %u logres %u", 255 MAJOR(__entry->dev), MINOR(__entry->dev), 256 __entry->per_intent, 257 __entry->step_size, 258 __entry->blockcount, 259 __entry->min_logblocks, 260 __entry->cur_logblocks, 261 __entry->logres) 262); 263 264TRACE_EVENT(xlog_intent_recovery_failed, 265 TP_PROTO(struct xfs_mount *mp, const struct xfs_defer_op_type *ops, 266 int error), 267 TP_ARGS(mp, ops, error), 268 TP_STRUCT__entry( 269 __field(dev_t, dev) 270 __string(name, ops->name) 271 __field(int, error) 272 ), 273 TP_fast_assign( 274 __entry->dev = mp->m_super->s_dev; 275 __assign_str(name); 276 __entry->error = error; 277 ), 278 TP_printk("dev %d:%d optype %s error %d", 279 MAJOR(__entry->dev), MINOR(__entry->dev), 280 __get_str(name), 281 __entry->error) 282); 283 284DECLARE_EVENT_CLASS(xfs_perag_class, 285 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip), 286 TP_ARGS(pag, caller_ip), 287 TP_STRUCT__entry( 288 __field(dev_t, dev) 289 __field(xfs_agnumber_t, agno) 290 __field(int, refcount) 291 __field(int, active_refcount) 292 __field(unsigned long, caller_ip) 293 ), 294 TP_fast_assign( 295 __entry->dev = pag_mount(pag)->m_super->s_dev; 296 __entry->agno = pag_agno(pag); 297 __entry->refcount = atomic_read(&pag->pag_group.xg_ref); 298 __entry->active_refcount = 299 atomic_read(&pag->pag_group.xg_active_ref); 300 __entry->caller_ip = caller_ip; 301 ), 302 TP_printk("dev %d:%d agno 0x%x passive refs %d active refs %d caller %pS", 303 MAJOR(__entry->dev), MINOR(__entry->dev), 304 __entry->agno, 305 __entry->refcount, 306 __entry->active_refcount, 307 (char *)__entry->caller_ip) 308); 309 310#define DEFINE_PERAG_REF_EVENT(name) \ 311DEFINE_EVENT(xfs_perag_class, name, \ 312 TP_PROTO(const struct xfs_perag *pag, unsigned long caller_ip), \ 313 TP_ARGS(pag, caller_ip)) 314DEFINE_PERAG_REF_EVENT(xfs_perag_set_inode_tag); 315DEFINE_PERAG_REF_EVENT(xfs_perag_clear_inode_tag); 316DEFINE_PERAG_REF_EVENT(xfs_reclaim_inodes_count); 317 318TRACE_DEFINE_ENUM(XG_TYPE_AG); 319TRACE_DEFINE_ENUM(XG_TYPE_RTG); 320 321DECLARE_EVENT_CLASS(xfs_group_class, 322 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip), 323 TP_ARGS(xg, caller_ip), 324 TP_STRUCT__entry( 325 __field(dev_t, dev) 326 __field(enum xfs_group_type, type) 327 __field(xfs_agnumber_t, agno) 328 __field(int, refcount) 329 __field(int, active_refcount) 330 __field(unsigned long, caller_ip) 331 ), 332 TP_fast_assign( 333 __entry->dev = xg->xg_mount->m_super->s_dev; 334 __entry->type = xg->xg_type; 335 __entry->agno = xg->xg_gno; 336 __entry->refcount = atomic_read(&xg->xg_ref); 337 __entry->active_refcount = atomic_read(&xg->xg_active_ref); 338 __entry->caller_ip = caller_ip; 339 ), 340 TP_printk("dev %d:%d %sno 0x%x passive refs %d active refs %d caller %pS", 341 MAJOR(__entry->dev), MINOR(__entry->dev), 342 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 343 __entry->agno, 344 __entry->refcount, 345 __entry->active_refcount, 346 (char *)__entry->caller_ip) 347); 348 349#define DEFINE_GROUP_REF_EVENT(name) \ 350DEFINE_EVENT(xfs_group_class, name, \ 351 TP_PROTO(struct xfs_group *xg, unsigned long caller_ip), \ 352 TP_ARGS(xg, caller_ip)) 353DEFINE_GROUP_REF_EVENT(xfs_group_get); 354DEFINE_GROUP_REF_EVENT(xfs_group_hold); 355DEFINE_GROUP_REF_EVENT(xfs_group_put); 356DEFINE_GROUP_REF_EVENT(xfs_group_grab); 357DEFINE_GROUP_REF_EVENT(xfs_group_grab_next_tag); 358DEFINE_GROUP_REF_EVENT(xfs_group_rele); 359 360#ifdef CONFIG_XFS_RT 361DECLARE_EVENT_CLASS(xfs_zone_class, 362 TP_PROTO(struct xfs_rtgroup *rtg), 363 TP_ARGS(rtg), 364 TP_STRUCT__entry( 365 __field(dev_t, dev) 366 __field(xfs_rgnumber_t, rgno) 367 __field(xfs_rgblock_t, used) 368 __field(unsigned int, nr_open) 369 ), 370 TP_fast_assign( 371 struct xfs_mount *mp = rtg_mount(rtg); 372 373 __entry->dev = mp->m_super->s_dev; 374 __entry->rgno = rtg_rgno(rtg); 375 __entry->used = rtg_rmap(rtg)->i_used_blocks; 376 __entry->nr_open = mp->m_zone_info->zi_nr_open_zones; 377 ), 378 TP_printk("dev %d:%d rgno 0x%x used 0x%x nr_open %u", 379 MAJOR(__entry->dev), MINOR(__entry->dev), 380 __entry->rgno, 381 __entry->used, 382 __entry->nr_open) 383); 384 385#define DEFINE_ZONE_EVENT(name) \ 386DEFINE_EVENT(xfs_zone_class, name, \ 387 TP_PROTO(struct xfs_rtgroup *rtg), \ 388 TP_ARGS(rtg)) 389DEFINE_ZONE_EVENT(xfs_zone_emptied); 390DEFINE_ZONE_EVENT(xfs_zone_full); 391DEFINE_ZONE_EVENT(xfs_zone_opened); 392DEFINE_ZONE_EVENT(xfs_zone_reset); 393DEFINE_ZONE_EVENT(xfs_zone_gc_target_opened); 394 395TRACE_EVENT(xfs_zone_free_blocks, 396 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rgblock_t rgbno, 397 xfs_extlen_t len), 398 TP_ARGS(rtg, rgbno, len), 399 TP_STRUCT__entry( 400 __field(dev_t, dev) 401 __field(xfs_rgnumber_t, rgno) 402 __field(xfs_rgblock_t, used) 403 __field(xfs_rgblock_t, rgbno) 404 __field(xfs_extlen_t, len) 405 ), 406 TP_fast_assign( 407 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 408 __entry->rgno = rtg_rgno(rtg); 409 __entry->used = rtg_rmap(rtg)->i_used_blocks; 410 __entry->rgbno = rgbno; 411 __entry->len = len; 412 ), 413 TP_printk("dev %d:%d rgno 0x%x used 0x%x rgbno 0x%x len 0x%x", 414 MAJOR(__entry->dev), MINOR(__entry->dev), 415 __entry->rgno, 416 __entry->used, 417 __entry->rgbno, 418 __entry->len) 419); 420 421DECLARE_EVENT_CLASS(xfs_zone_alloc_class, 422 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno, 423 xfs_extlen_t len), 424 TP_ARGS(oz, rgbno, len), 425 TP_STRUCT__entry( 426 __field(dev_t, dev) 427 __field(xfs_rgnumber_t, rgno) 428 __field(xfs_rgblock_t, used) 429 __field(xfs_rgblock_t, allocated) 430 __field(xfs_rgblock_t, written) 431 __field(xfs_rgblock_t, rgbno) 432 __field(xfs_extlen_t, len) 433 ), 434 TP_fast_assign( 435 __entry->dev = rtg_mount(oz->oz_rtg)->m_super->s_dev; 436 __entry->rgno = rtg_rgno(oz->oz_rtg); 437 __entry->used = rtg_rmap(oz->oz_rtg)->i_used_blocks; 438 __entry->allocated = oz->oz_allocated; 439 __entry->written = oz->oz_written; 440 __entry->rgbno = rgbno; 441 __entry->len = len; 442 ), 443 TP_printk("dev %d:%d rgno 0x%x used 0x%x alloced 0x%x written 0x%x rgbno 0x%x len 0x%x", 444 MAJOR(__entry->dev), MINOR(__entry->dev), 445 __entry->rgno, 446 __entry->used, 447 __entry->allocated, 448 __entry->written, 449 __entry->rgbno, 450 __entry->len) 451); 452 453#define DEFINE_ZONE_ALLOC_EVENT(name) \ 454DEFINE_EVENT(xfs_zone_alloc_class, name, \ 455 TP_PROTO(struct xfs_open_zone *oz, xfs_rgblock_t rgbno, \ 456 xfs_extlen_t len), \ 457 TP_ARGS(oz, rgbno, len)) 458DEFINE_ZONE_ALLOC_EVENT(xfs_zone_record_blocks); 459DEFINE_ZONE_ALLOC_EVENT(xfs_zone_skip_blocks); 460DEFINE_ZONE_ALLOC_EVENT(xfs_zone_alloc_blocks); 461 462TRACE_EVENT(xfs_zone_gc_select_victim, 463 TP_PROTO(struct xfs_rtgroup *rtg, unsigned int bucket), 464 TP_ARGS(rtg, bucket), 465 TP_STRUCT__entry( 466 __field(dev_t, dev) 467 __field(xfs_rgnumber_t, rgno) 468 __field(xfs_rgblock_t, used) 469 __field(unsigned int, bucket) 470 ), 471 TP_fast_assign( 472 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 473 __entry->rgno = rtg_rgno(rtg); 474 __entry->used = rtg_rmap(rtg)->i_used_blocks; 475 __entry->bucket = bucket; 476 ), 477 TP_printk("dev %d:%d rgno 0x%x used 0x%x bucket %u", 478 MAJOR(__entry->dev), MINOR(__entry->dev), 479 __entry->rgno, 480 __entry->used, 481 __entry->bucket) 482); 483 484TRACE_EVENT(xfs_zones_mount, 485 TP_PROTO(struct xfs_mount *mp), 486 TP_ARGS(mp), 487 TP_STRUCT__entry( 488 __field(dev_t, dev) 489 __field(xfs_rgnumber_t, rgcount) 490 __field(uint32_t, blocks) 491 __field(unsigned int, max_open_zones) 492 ), 493 TP_fast_assign( 494 __entry->dev = mp->m_super->s_dev; 495 __entry->rgcount = mp->m_sb.sb_rgcount; 496 __entry->blocks = mp->m_groups[XG_TYPE_RTG].blocks; 497 __entry->max_open_zones = mp->m_max_open_zones; 498 ), 499 TP_printk("dev %d:%d zoned %u blocks_per_zone %u, max_open %u", 500 MAJOR(__entry->dev), MINOR(__entry->dev), 501 __entry->rgcount, 502 __entry->blocks, 503 __entry->max_open_zones) 504); 505#endif /* CONFIG_XFS_RT */ 506 507TRACE_EVENT(xfs_inodegc_worker, 508 TP_PROTO(struct xfs_mount *mp, unsigned int shrinker_hits), 509 TP_ARGS(mp, shrinker_hits), 510 TP_STRUCT__entry( 511 __field(dev_t, dev) 512 __field(unsigned int, shrinker_hits) 513 ), 514 TP_fast_assign( 515 __entry->dev = mp->m_super->s_dev; 516 __entry->shrinker_hits = shrinker_hits; 517 ), 518 TP_printk("dev %d:%d shrinker_hits %u", 519 MAJOR(__entry->dev), MINOR(__entry->dev), 520 __entry->shrinker_hits) 521); 522 523DECLARE_EVENT_CLASS(xfs_fs_class, 524 TP_PROTO(struct xfs_mount *mp, void *caller_ip), 525 TP_ARGS(mp, caller_ip), 526 TP_STRUCT__entry( 527 __field(dev_t, dev) 528 __field(unsigned long long, mflags) 529 __field(unsigned long, opstate) 530 __field(unsigned long, sbflags) 531 __field(void *, caller_ip) 532 ), 533 TP_fast_assign( 534 if (mp) { 535 __entry->dev = mp->m_super->s_dev; 536 __entry->mflags = mp->m_features; 537 __entry->opstate = mp->m_opstate; 538 __entry->sbflags = mp->m_super->s_flags; 539 } 540 __entry->caller_ip = caller_ip; 541 ), 542 TP_printk("dev %d:%d m_features 0x%llx opstate (%s) s_flags 0x%lx caller %pS", 543 MAJOR(__entry->dev), MINOR(__entry->dev), 544 __entry->mflags, 545 __print_flags(__entry->opstate, "|", XFS_OPSTATE_STRINGS), 546 __entry->sbflags, 547 __entry->caller_ip) 548); 549 550#define DEFINE_FS_EVENT(name) \ 551DEFINE_EVENT(xfs_fs_class, name, \ 552 TP_PROTO(struct xfs_mount *mp, void *caller_ip), \ 553 TP_ARGS(mp, caller_ip)) 554DEFINE_FS_EVENT(xfs_inodegc_flush); 555DEFINE_FS_EVENT(xfs_inodegc_push); 556DEFINE_FS_EVENT(xfs_inodegc_start); 557DEFINE_FS_EVENT(xfs_inodegc_stop); 558DEFINE_FS_EVENT(xfs_inodegc_queue); 559DEFINE_FS_EVENT(xfs_inodegc_throttle); 560DEFINE_FS_EVENT(xfs_fs_sync_fs); 561DEFINE_FS_EVENT(xfs_blockgc_start); 562DEFINE_FS_EVENT(xfs_blockgc_stop); 563DEFINE_FS_EVENT(xfs_blockgc_worker); 564DEFINE_FS_EVENT(xfs_blockgc_flush_all); 565 566TRACE_EVENT(xfs_inodegc_shrinker_scan, 567 TP_PROTO(struct xfs_mount *mp, struct shrink_control *sc, 568 void *caller_ip), 569 TP_ARGS(mp, sc, caller_ip), 570 TP_STRUCT__entry( 571 __field(dev_t, dev) 572 __field(unsigned long, nr_to_scan) 573 __field(void *, caller_ip) 574 ), 575 TP_fast_assign( 576 __entry->dev = mp->m_super->s_dev; 577 __entry->nr_to_scan = sc->nr_to_scan; 578 __entry->caller_ip = caller_ip; 579 ), 580 TP_printk("dev %d:%d nr_to_scan %lu caller %pS", 581 MAJOR(__entry->dev), MINOR(__entry->dev), 582 __entry->nr_to_scan, 583 __entry->caller_ip) 584); 585 586DECLARE_EVENT_CLASS(xfs_ag_class, 587 TP_PROTO(const struct xfs_perag *pag), 588 TP_ARGS(pag), 589 TP_STRUCT__entry( 590 __field(dev_t, dev) 591 __field(xfs_agnumber_t, agno) 592 ), 593 TP_fast_assign( 594 __entry->dev = pag_mount(pag)->m_super->s_dev; 595 __entry->agno = pag_agno(pag); 596 ), 597 TP_printk("dev %d:%d agno 0x%x", 598 MAJOR(__entry->dev), MINOR(__entry->dev), 599 __entry->agno) 600); 601#define DEFINE_AG_EVENT(name) \ 602DEFINE_EVENT(xfs_ag_class, name, \ 603 TP_PROTO(const struct xfs_perag *pag), \ 604 TP_ARGS(pag)) 605 606DEFINE_AG_EVENT(xfs_read_agf); 607DEFINE_AG_EVENT(xfs_alloc_read_agf); 608DEFINE_AG_EVENT(xfs_read_agi); 609DEFINE_AG_EVENT(xfs_ialloc_read_agi); 610 611TRACE_EVENT(xfs_attr_list_node_descend, 612 TP_PROTO(struct xfs_attr_list_context *ctx, 613 struct xfs_da_node_entry *btree), 614 TP_ARGS(ctx, btree), 615 TP_STRUCT__entry( 616 __field(dev_t, dev) 617 __field(xfs_ino_t, ino) 618 __field(u32, hashval) 619 __field(u32, blkno) 620 __field(u32, offset) 621 __field(void *, buffer) 622 __field(int, bufsize) 623 __field(int, count) 624 __field(int, firstu) 625 __field(int, dupcnt) 626 __field(unsigned int, attr_filter) 627 __field(u32, bt_hashval) 628 __field(u32, bt_before) 629 ), 630 TP_fast_assign( 631 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; 632 __entry->ino = ctx->dp->i_ino; 633 __entry->hashval = ctx->cursor.hashval; 634 __entry->blkno = ctx->cursor.blkno; 635 __entry->offset = ctx->cursor.offset; 636 __entry->buffer = ctx->buffer; 637 __entry->bufsize = ctx->bufsize; 638 __entry->count = ctx->count; 639 __entry->firstu = ctx->firstu; 640 __entry->attr_filter = ctx->attr_filter; 641 __entry->bt_hashval = be32_to_cpu(btree->hashval); 642 __entry->bt_before = be32_to_cpu(btree->before); 643 ), 644 TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " 645 "buffer %p size %u count %u firstu %u filter %s " 646 "node hashval %u, node before %u", 647 MAJOR(__entry->dev), MINOR(__entry->dev), 648 __entry->ino, 649 __entry->hashval, 650 __entry->blkno, 651 __entry->offset, 652 __entry->dupcnt, 653 __entry->buffer, 654 __entry->bufsize, 655 __entry->count, 656 __entry->firstu, 657 __print_flags(__entry->attr_filter, "|", 658 XFS_ATTR_FILTER_FLAGS), 659 __entry->bt_hashval, 660 __entry->bt_before) 661); 662 663DECLARE_EVENT_CLASS(xfs_bmap_class, 664 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, 665 unsigned long caller_ip), 666 TP_ARGS(ip, cur, state, caller_ip), 667 TP_STRUCT__entry( 668 __field(dev_t, dev) 669 __field(xfs_ino_t, ino) 670 __field(void *, leaf) 671 __field(int, pos) 672 __field(xfs_fileoff_t, startoff) 673 __field(xfs_fsblock_t, startblock) 674 __field(xfs_filblks_t, blockcount) 675 __field(xfs_exntst_t, state) 676 __field(int, bmap_state) 677 __field(unsigned long, caller_ip) 678 ), 679 TP_fast_assign( 680 struct xfs_ifork *ifp; 681 struct xfs_bmbt_irec r; 682 683 ifp = xfs_iext_state_to_fork(ip, state); 684 xfs_iext_get_extent(ifp, cur, &r); 685 __entry->dev = VFS_I(ip)->i_sb->s_dev; 686 __entry->ino = ip->i_ino; 687 __entry->leaf = cur->leaf; 688 __entry->pos = cur->pos; 689 __entry->startoff = r.br_startoff; 690 __entry->startblock = r.br_startblock; 691 __entry->blockcount = r.br_blockcount; 692 __entry->state = r.br_state; 693 __entry->bmap_state = state; 694 __entry->caller_ip = caller_ip; 695 ), 696 TP_printk("dev %d:%d ino 0x%llx state %s cur %p/%d " 697 "fileoff 0x%llx startblock 0x%llx fsbcount 0x%llx flag %d caller %pS", 698 MAJOR(__entry->dev), MINOR(__entry->dev), 699 __entry->ino, 700 __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS), 701 __entry->leaf, 702 __entry->pos, 703 __entry->startoff, 704 (int64_t)__entry->startblock, 705 __entry->blockcount, 706 __entry->state, 707 (char *)__entry->caller_ip) 708) 709 710#define DEFINE_BMAP_EVENT(name) \ 711DEFINE_EVENT(xfs_bmap_class, name, \ 712 TP_PROTO(struct xfs_inode *ip, struct xfs_iext_cursor *cur, int state, \ 713 unsigned long caller_ip), \ 714 TP_ARGS(ip, cur, state, caller_ip)) 715DEFINE_BMAP_EVENT(xfs_iext_insert); 716DEFINE_BMAP_EVENT(xfs_iext_remove); 717DEFINE_BMAP_EVENT(xfs_bmap_pre_update); 718DEFINE_BMAP_EVENT(xfs_bmap_post_update); 719DEFINE_BMAP_EVENT(xfs_read_extent); 720DEFINE_BMAP_EVENT(xfs_write_extent); 721 722DECLARE_EVENT_CLASS(xfs_buf_class, 723 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), 724 TP_ARGS(bp, caller_ip), 725 TP_STRUCT__entry( 726 __field(dev_t, dev) 727 __field(xfs_daddr_t, bno) 728 __field(int, nblks) 729 __field(int, hold) 730 __field(int, pincount) 731 __field(unsigned, lockval) 732 __field(unsigned, flags) 733 __field(unsigned long, caller_ip) 734 __field(const void *, buf_ops) 735 ), 736 TP_fast_assign( 737 __entry->dev = bp->b_target->bt_dev; 738 __entry->bno = xfs_buf_daddr(bp); 739 __entry->nblks = bp->b_length; 740 __entry->hold = bp->b_hold; 741 __entry->pincount = atomic_read(&bp->b_pin_count); 742 __entry->lockval = bp->b_sema.count; 743 __entry->flags = bp->b_flags; 744 __entry->caller_ip = caller_ip; 745 __entry->buf_ops = bp->b_ops; 746 ), 747 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 748 "lock %d flags %s bufops %pS caller %pS", 749 MAJOR(__entry->dev), MINOR(__entry->dev), 750 (unsigned long long)__entry->bno, 751 __entry->nblks, 752 __entry->hold, 753 __entry->pincount, 754 __entry->lockval, 755 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 756 __entry->buf_ops, 757 (void *)__entry->caller_ip) 758) 759 760#define DEFINE_BUF_EVENT(name) \ 761DEFINE_EVENT(xfs_buf_class, name, \ 762 TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \ 763 TP_ARGS(bp, caller_ip)) 764DEFINE_BUF_EVENT(xfs_buf_init); 765DEFINE_BUF_EVENT(xfs_buf_free); 766DEFINE_BUF_EVENT(xfs_buf_hold); 767DEFINE_BUF_EVENT(xfs_buf_rele); 768DEFINE_BUF_EVENT(xfs_buf_iodone); 769DEFINE_BUF_EVENT(xfs_buf_submit); 770DEFINE_BUF_EVENT(xfs_buf_lock); 771DEFINE_BUF_EVENT(xfs_buf_lock_done); 772DEFINE_BUF_EVENT(xfs_buf_trylock_fail); 773DEFINE_BUF_EVENT(xfs_buf_trylock); 774DEFINE_BUF_EVENT(xfs_buf_unlock); 775DEFINE_BUF_EVENT(xfs_buf_iowait); 776DEFINE_BUF_EVENT(xfs_buf_iowait_done); 777DEFINE_BUF_EVENT(xfs_buf_delwri_queue); 778DEFINE_BUF_EVENT(xfs_buf_delwri_queued); 779DEFINE_BUF_EVENT(xfs_buf_delwri_split); 780DEFINE_BUF_EVENT(xfs_buf_get_uncached); 781DEFINE_BUF_EVENT(xfs_buf_item_relse); 782DEFINE_BUF_EVENT(xfs_buf_iodone_async); 783DEFINE_BUF_EVENT(xfs_buf_error_relse); 784DEFINE_BUF_EVENT(xfs_buf_drain_buftarg); 785DEFINE_BUF_EVENT(xfs_trans_read_buf_shut); 786DEFINE_BUF_EVENT(xfs_buf_backing_folio); 787DEFINE_BUF_EVENT(xfs_buf_backing_kmem); 788DEFINE_BUF_EVENT(xfs_buf_backing_vmalloc); 789DEFINE_BUF_EVENT(xfs_buf_backing_fallback); 790 791/* not really buffer traces, but the buf provides useful information */ 792DEFINE_BUF_EVENT(xfs_btree_corrupt); 793DEFINE_BUF_EVENT(xfs_reset_dqcounts); 794 795/* pass flags explicitly */ 796DECLARE_EVENT_CLASS(xfs_buf_flags_class, 797 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), 798 TP_ARGS(bp, flags, caller_ip), 799 TP_STRUCT__entry( 800 __field(dev_t, dev) 801 __field(xfs_daddr_t, bno) 802 __field(unsigned int, length) 803 __field(int, hold) 804 __field(int, pincount) 805 __field(unsigned, lockval) 806 __field(unsigned, flags) 807 __field(unsigned long, caller_ip) 808 ), 809 TP_fast_assign( 810 __entry->dev = bp->b_target->bt_dev; 811 __entry->bno = xfs_buf_daddr(bp); 812 __entry->length = bp->b_length; 813 __entry->flags = flags; 814 __entry->hold = bp->b_hold; 815 __entry->pincount = atomic_read(&bp->b_pin_count); 816 __entry->lockval = bp->b_sema.count; 817 __entry->caller_ip = caller_ip; 818 ), 819 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 820 "lock %d flags %s caller %pS", 821 MAJOR(__entry->dev), MINOR(__entry->dev), 822 (unsigned long long)__entry->bno, 823 __entry->length, 824 __entry->hold, 825 __entry->pincount, 826 __entry->lockval, 827 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 828 (void *)__entry->caller_ip) 829) 830 831#define DEFINE_BUF_FLAGS_EVENT(name) \ 832DEFINE_EVENT(xfs_buf_flags_class, name, \ 833 TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \ 834 TP_ARGS(bp, flags, caller_ip)) 835DEFINE_BUF_FLAGS_EVENT(xfs_buf_find); 836DEFINE_BUF_FLAGS_EVENT(xfs_buf_get); 837DEFINE_BUF_FLAGS_EVENT(xfs_buf_read); 838DEFINE_BUF_FLAGS_EVENT(xfs_buf_readahead); 839 840TRACE_EVENT(xfs_buf_ioerror, 841 TP_PROTO(struct xfs_buf *bp, int error, xfs_failaddr_t caller_ip), 842 TP_ARGS(bp, error, caller_ip), 843 TP_STRUCT__entry( 844 __field(dev_t, dev) 845 __field(xfs_daddr_t, bno) 846 __field(unsigned int, length) 847 __field(unsigned, flags) 848 __field(int, hold) 849 __field(int, pincount) 850 __field(unsigned, lockval) 851 __field(int, error) 852 __field(xfs_failaddr_t, caller_ip) 853 ), 854 TP_fast_assign( 855 __entry->dev = bp->b_target->bt_dev; 856 __entry->bno = xfs_buf_daddr(bp); 857 __entry->length = bp->b_length; 858 __entry->hold = bp->b_hold; 859 __entry->pincount = atomic_read(&bp->b_pin_count); 860 __entry->lockval = bp->b_sema.count; 861 __entry->error = error; 862 __entry->flags = bp->b_flags; 863 __entry->caller_ip = caller_ip; 864 ), 865 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 866 "lock %d error %d flags %s caller %pS", 867 MAJOR(__entry->dev), MINOR(__entry->dev), 868 (unsigned long long)__entry->bno, 869 __entry->length, 870 __entry->hold, 871 __entry->pincount, 872 __entry->lockval, 873 __entry->error, 874 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS), 875 (void *)__entry->caller_ip) 876); 877 878DECLARE_EVENT_CLASS(xfs_buf_item_class, 879 TP_PROTO(struct xfs_buf_log_item *bip), 880 TP_ARGS(bip), 881 TP_STRUCT__entry( 882 __field(dev_t, dev) 883 __field(xfs_daddr_t, buf_bno) 884 __field(unsigned int, buf_len) 885 __field(int, buf_hold) 886 __field(int, buf_pincount) 887 __field(int, buf_lockval) 888 __field(unsigned, buf_flags) 889 __field(unsigned, bli_recur) 890 __field(int, bli_refcount) 891 __field(unsigned, bli_flags) 892 __field(unsigned long, li_flags) 893 ), 894 TP_fast_assign( 895 __entry->dev = bip->bli_buf->b_target->bt_dev; 896 __entry->bli_flags = bip->bli_flags; 897 __entry->bli_recur = bip->bli_recur; 898 __entry->bli_refcount = atomic_read(&bip->bli_refcount); 899 __entry->buf_bno = xfs_buf_daddr(bip->bli_buf); 900 __entry->buf_len = bip->bli_buf->b_length; 901 __entry->buf_flags = bip->bli_buf->b_flags; 902 __entry->buf_hold = bip->bli_buf->b_hold; 903 __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count); 904 __entry->buf_lockval = bip->bli_buf->b_sema.count; 905 __entry->li_flags = bip->bli_item.li_flags; 906 ), 907 TP_printk("dev %d:%d daddr 0x%llx bbcount 0x%x hold %d pincount %d " 908 "lock %d flags %s recur %d refcount %d bliflags %s " 909 "liflags %s", 910 MAJOR(__entry->dev), MINOR(__entry->dev), 911 (unsigned long long)__entry->buf_bno, 912 __entry->buf_len, 913 __entry->buf_hold, 914 __entry->buf_pincount, 915 __entry->buf_lockval, 916 __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS), 917 __entry->bli_recur, 918 __entry->bli_refcount, 919 __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS), 920 __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS)) 921) 922 923#define DEFINE_BUF_ITEM_EVENT(name) \ 924DEFINE_EVENT(xfs_buf_item_class, name, \ 925 TP_PROTO(struct xfs_buf_log_item *bip), \ 926 TP_ARGS(bip)) 927DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size); 928DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_ordered); 929DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale); 930DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format); 931DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format_stale); 932DEFINE_BUF_ITEM_EVENT(xfs_buf_item_ordered); 933DEFINE_BUF_ITEM_EVENT(xfs_buf_item_pin); 934DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin); 935DEFINE_BUF_ITEM_EVENT(xfs_buf_item_unpin_stale); 936DEFINE_BUF_ITEM_EVENT(xfs_buf_item_release); 937DEFINE_BUF_ITEM_EVENT(xfs_buf_item_committed); 938DEFINE_BUF_ITEM_EVENT(xfs_buf_item_push); 939DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf); 940DEFINE_BUF_ITEM_EVENT(xfs_trans_get_buf_recur); 941DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb); 942DEFINE_BUF_ITEM_EVENT(xfs_trans_getsb_recur); 943DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf); 944DEFINE_BUF_ITEM_EVENT(xfs_trans_read_buf_recur); 945DEFINE_BUF_ITEM_EVENT(xfs_trans_log_buf); 946DEFINE_BUF_ITEM_EVENT(xfs_trans_brelse); 947DEFINE_BUF_ITEM_EVENT(xfs_trans_bdetach); 948DEFINE_BUF_ITEM_EVENT(xfs_trans_bjoin); 949DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold); 950DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release); 951DEFINE_BUF_ITEM_EVENT(xfs_trans_binval); 952 953DECLARE_EVENT_CLASS(xfs_filestream_class, 954 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), 955 TP_ARGS(pag, ino), 956 TP_STRUCT__entry( 957 __field(dev_t, dev) 958 __field(xfs_ino_t, ino) 959 __field(xfs_agnumber_t, agno) 960 __field(int, streams) 961 ), 962 TP_fast_assign( 963 __entry->dev = pag_mount(pag)->m_super->s_dev; 964 __entry->ino = ino; 965 __entry->agno = pag_agno(pag); 966 __entry->streams = atomic_read(&pag->pagf_fstrms); 967 ), 968 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d", 969 MAJOR(__entry->dev), MINOR(__entry->dev), 970 __entry->ino, 971 __entry->agno, 972 __entry->streams) 973) 974#define DEFINE_FILESTREAM_EVENT(name) \ 975DEFINE_EVENT(xfs_filestream_class, name, \ 976 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), \ 977 TP_ARGS(pag, ino)) 978DEFINE_FILESTREAM_EVENT(xfs_filestream_free); 979DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup); 980DEFINE_FILESTREAM_EVENT(xfs_filestream_scan); 981 982TRACE_EVENT(xfs_filestream_pick, 983 TP_PROTO(const struct xfs_perag *pag, xfs_ino_t ino), 984 TP_ARGS(pag, ino), 985 TP_STRUCT__entry( 986 __field(dev_t, dev) 987 __field(xfs_ino_t, ino) 988 __field(xfs_agnumber_t, agno) 989 __field(int, streams) 990 __field(xfs_extlen_t, free) 991 ), 992 TP_fast_assign( 993 __entry->dev = pag_mount(pag)->m_super->s_dev; 994 __entry->ino = ino; 995 __entry->agno = pag_agno(pag); 996 __entry->streams = atomic_read(&pag->pagf_fstrms); 997 __entry->free = pag->pagf_freeblks; 998 ), 999 TP_printk("dev %d:%d ino 0x%llx agno 0x%x streams %d free %d", 1000 MAJOR(__entry->dev), MINOR(__entry->dev), 1001 __entry->ino, 1002 __entry->agno, 1003 __entry->streams, 1004 __entry->free) 1005); 1006 1007DECLARE_EVENT_CLASS(xfs_lock_class, 1008 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, 1009 unsigned long caller_ip), 1010 TP_ARGS(ip, lock_flags, caller_ip), 1011 TP_STRUCT__entry( 1012 __field(dev_t, dev) 1013 __field(xfs_ino_t, ino) 1014 __field(int, lock_flags) 1015 __field(unsigned long, caller_ip) 1016 ), 1017 TP_fast_assign( 1018 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1019 __entry->ino = ip->i_ino; 1020 __entry->lock_flags = lock_flags; 1021 __entry->caller_ip = caller_ip; 1022 ), 1023 TP_printk("dev %d:%d ino 0x%llx flags %s caller %pS", 1024 MAJOR(__entry->dev), MINOR(__entry->dev), 1025 __entry->ino, 1026 __print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS), 1027 (void *)__entry->caller_ip) 1028) 1029 1030#define DEFINE_LOCK_EVENT(name) \ 1031DEFINE_EVENT(xfs_lock_class, name, \ 1032 TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \ 1033 unsigned long caller_ip), \ 1034 TP_ARGS(ip, lock_flags, caller_ip)) 1035DEFINE_LOCK_EVENT(xfs_ilock); 1036DEFINE_LOCK_EVENT(xfs_ilock_nowait); 1037DEFINE_LOCK_EVENT(xfs_ilock_demote); 1038DEFINE_LOCK_EVENT(xfs_iunlock); 1039 1040DECLARE_EVENT_CLASS(xfs_inode_class, 1041 TP_PROTO(struct xfs_inode *ip), 1042 TP_ARGS(ip), 1043 TP_STRUCT__entry( 1044 __field(dev_t, dev) 1045 __field(xfs_ino_t, ino) 1046 __field(unsigned long, iflags) 1047 ), 1048 TP_fast_assign( 1049 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1050 __entry->ino = ip->i_ino; 1051 __entry->iflags = ip->i_flags; 1052 ), 1053 TP_printk("dev %d:%d ino 0x%llx iflags 0x%lx", 1054 MAJOR(__entry->dev), MINOR(__entry->dev), 1055 __entry->ino, 1056 __entry->iflags) 1057) 1058 1059#define DEFINE_INODE_EVENT(name) \ 1060DEFINE_EVENT(xfs_inode_class, name, \ 1061 TP_PROTO(struct xfs_inode *ip), \ 1062 TP_ARGS(ip)) 1063DEFINE_INODE_EVENT(xfs_iget_skip); 1064DEFINE_INODE_EVENT(xfs_iget_recycle); 1065DEFINE_INODE_EVENT(xfs_iget_recycle_fail); 1066DEFINE_INODE_EVENT(xfs_iget_hit); 1067DEFINE_INODE_EVENT(xfs_iget_miss); 1068 1069DEFINE_INODE_EVENT(xfs_getattr); 1070DEFINE_INODE_EVENT(xfs_setattr); 1071DEFINE_INODE_EVENT(xfs_readlink); 1072DEFINE_INODE_EVENT(xfs_inactive_symlink); 1073DEFINE_INODE_EVENT(xfs_alloc_file_space); 1074DEFINE_INODE_EVENT(xfs_free_file_space); 1075DEFINE_INODE_EVENT(xfs_zero_file_space); 1076DEFINE_INODE_EVENT(xfs_collapse_file_space); 1077DEFINE_INODE_EVENT(xfs_insert_file_space); 1078DEFINE_INODE_EVENT(xfs_readdir); 1079#ifdef CONFIG_XFS_POSIX_ACL 1080DEFINE_INODE_EVENT(xfs_get_acl); 1081#endif 1082DEFINE_INODE_EVENT(xfs_vm_bmap); 1083DEFINE_INODE_EVENT(xfs_file_ioctl); 1084#ifdef CONFIG_COMPAT 1085DEFINE_INODE_EVENT(xfs_file_compat_ioctl); 1086#endif 1087DEFINE_INODE_EVENT(xfs_ioctl_setattr); 1088DEFINE_INODE_EVENT(xfs_dir_fsync); 1089DEFINE_INODE_EVENT(xfs_file_fsync); 1090DEFINE_INODE_EVENT(xfs_destroy_inode); 1091DEFINE_INODE_EVENT(xfs_update_time); 1092 1093DEFINE_INODE_EVENT(xfs_dquot_dqalloc); 1094DEFINE_INODE_EVENT(xfs_dquot_dqdetach); 1095 1096DEFINE_INODE_EVENT(xfs_inode_set_eofblocks_tag); 1097DEFINE_INODE_EVENT(xfs_inode_clear_eofblocks_tag); 1098DEFINE_INODE_EVENT(xfs_inode_free_eofblocks_invalid); 1099DEFINE_INODE_EVENT(xfs_inode_set_cowblocks_tag); 1100DEFINE_INODE_EVENT(xfs_inode_clear_cowblocks_tag); 1101DEFINE_INODE_EVENT(xfs_inode_free_cowblocks_invalid); 1102DEFINE_INODE_EVENT(xfs_inode_set_reclaimable); 1103DEFINE_INODE_EVENT(xfs_inode_reclaiming); 1104DEFINE_INODE_EVENT(xfs_inode_set_need_inactive); 1105DEFINE_INODE_EVENT(xfs_inode_inactivating); 1106 1107/* 1108 * ftrace's __print_symbolic requires that all enum values be wrapped in the 1109 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace 1110 * ring buffer. Somehow this was only worth mentioning in the ftrace sample 1111 * code. 1112 */ 1113TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_SHARED); 1114TRACE_DEFINE_ENUM(XFS_REFC_DOMAIN_COW); 1115 1116DECLARE_EVENT_CLASS(xfs_fault_class, 1117 TP_PROTO(struct xfs_inode *ip, unsigned int order), 1118 TP_ARGS(ip, order), 1119 TP_STRUCT__entry( 1120 __field(dev_t, dev) 1121 __field(xfs_ino_t, ino) 1122 __field(unsigned int, order) 1123 ), 1124 TP_fast_assign( 1125 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1126 __entry->ino = ip->i_ino; 1127 __entry->order = order; 1128 ), 1129 TP_printk("dev %d:%d ino 0x%llx order %u", 1130 MAJOR(__entry->dev), MINOR(__entry->dev), 1131 __entry->ino, 1132 __entry->order) 1133) 1134 1135#define DEFINE_FAULT_EVENT(name) \ 1136DEFINE_EVENT(xfs_fault_class, name, \ 1137 TP_PROTO(struct xfs_inode *ip, unsigned int order), \ 1138 TP_ARGS(ip, order)) 1139DEFINE_FAULT_EVENT(xfs_read_fault); 1140DEFINE_FAULT_EVENT(xfs_write_fault); 1141 1142DECLARE_EVENT_CLASS(xfs_iref_class, 1143 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), 1144 TP_ARGS(ip, caller_ip), 1145 TP_STRUCT__entry( 1146 __field(dev_t, dev) 1147 __field(xfs_ino_t, ino) 1148 __field(int, count) 1149 __field(int, pincount) 1150 __field(unsigned long, iflags) 1151 __field(unsigned long, caller_ip) 1152 ), 1153 TP_fast_assign( 1154 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1155 __entry->ino = ip->i_ino; 1156 __entry->count = icount_read(VFS_I(ip)); 1157 __entry->pincount = atomic_read(&ip->i_pincount); 1158 __entry->iflags = ip->i_flags; 1159 __entry->caller_ip = caller_ip; 1160 ), 1161 TP_printk("dev %d:%d ino 0x%llx count %d pincount %d iflags 0x%lx caller %pS", 1162 MAJOR(__entry->dev), MINOR(__entry->dev), 1163 __entry->ino, 1164 __entry->count, 1165 __entry->pincount, 1166 __entry->iflags, 1167 (char *)__entry->caller_ip) 1168) 1169 1170TRACE_EVENT(xfs_iomap_prealloc_size, 1171 TP_PROTO(struct xfs_inode *ip, xfs_fsblock_t blocks, int shift, 1172 unsigned int writeio_blocks), 1173 TP_ARGS(ip, blocks, shift, writeio_blocks), 1174 TP_STRUCT__entry( 1175 __field(dev_t, dev) 1176 __field(xfs_ino_t, ino) 1177 __field(xfs_fsblock_t, blocks) 1178 __field(int, shift) 1179 __field(unsigned int, writeio_blocks) 1180 ), 1181 TP_fast_assign( 1182 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1183 __entry->ino = ip->i_ino; 1184 __entry->blocks = blocks; 1185 __entry->shift = shift; 1186 __entry->writeio_blocks = writeio_blocks; 1187 ), 1188 TP_printk("dev %d:%d ino 0x%llx prealloc blocks %llu shift %d " 1189 "m_allocsize_blocks %u", 1190 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, 1191 __entry->blocks, __entry->shift, __entry->writeio_blocks) 1192) 1193 1194TRACE_EVENT(xfs_irec_merge_pre, 1195 TP_PROTO(const struct xfs_perag *pag, 1196 const struct xfs_inobt_rec_incore *rec, 1197 const struct xfs_inobt_rec_incore *nrec), 1198 TP_ARGS(pag, rec, nrec), 1199 TP_STRUCT__entry( 1200 __field(dev_t, dev) 1201 __field(xfs_agnumber_t, agno) 1202 __field(xfs_agino_t, agino) 1203 __field(uint16_t, holemask) 1204 __field(xfs_agino_t, nagino) 1205 __field(uint16_t, nholemask) 1206 ), 1207 TP_fast_assign( 1208 __entry->dev = pag_mount(pag)->m_super->s_dev; 1209 __entry->agno = pag_agno(pag); 1210 __entry->agino = rec->ir_startino; 1211 __entry->holemask = rec->ir_holemask; 1212 __entry->nagino = nrec->ir_startino; 1213 __entry->nholemask = nrec->ir_holemask; 1214 ), 1215 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x new_agino 0x%x new_holemask 0x%x", 1216 MAJOR(__entry->dev), MINOR(__entry->dev), 1217 __entry->agno, 1218 __entry->agino, 1219 __entry->holemask, 1220 __entry->nagino, 1221 __entry->nholemask) 1222) 1223 1224TRACE_EVENT(xfs_irec_merge_post, 1225 TP_PROTO(const struct xfs_perag *pag, 1226 const struct xfs_inobt_rec_incore *nrec), 1227 TP_ARGS(pag, nrec), 1228 TP_STRUCT__entry( 1229 __field(dev_t, dev) 1230 __field(xfs_agnumber_t, agno) 1231 __field(xfs_agino_t, agino) 1232 __field(uint16_t, holemask) 1233 ), 1234 TP_fast_assign( 1235 __entry->dev = pag_mount(pag)->m_super->s_dev; 1236 __entry->agno = pag_agno(pag); 1237 __entry->agino = nrec->ir_startino; 1238 __entry->holemask = nrec->ir_holemask; 1239 ), 1240 TP_printk("dev %d:%d agno 0x%x agino 0x%x holemask 0x%x", 1241 MAJOR(__entry->dev), 1242 MINOR(__entry->dev), 1243 __entry->agno, 1244 __entry->agino, 1245 __entry->holemask) 1246) 1247 1248#define DEFINE_IREF_EVENT(name) \ 1249DEFINE_EVENT(xfs_iref_class, name, \ 1250 TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \ 1251 TP_ARGS(ip, caller_ip)) 1252DEFINE_IREF_EVENT(xfs_irele); 1253DEFINE_IREF_EVENT(xfs_inode_pin); 1254DEFINE_IREF_EVENT(xfs_inode_unpin); 1255DEFINE_IREF_EVENT(xfs_inode_unpin_nowait); 1256DEFINE_IREF_EVENT(xfs_inode_push_pinned); 1257DEFINE_IREF_EVENT(xfs_inode_push_stale); 1258 1259DECLARE_EVENT_CLASS(xfs_namespace_class, 1260 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), 1261 TP_ARGS(dp, name), 1262 TP_STRUCT__entry( 1263 __field(dev_t, dev) 1264 __field(xfs_ino_t, dp_ino) 1265 __field(int, namelen) 1266 __dynamic_array(char, name, name->len) 1267 ), 1268 TP_fast_assign( 1269 __entry->dev = VFS_I(dp)->i_sb->s_dev; 1270 __entry->dp_ino = dp->i_ino; 1271 __entry->namelen = name->len; 1272 memcpy(__get_str(name), name->name, name->len); 1273 ), 1274 TP_printk("dev %d:%d dp ino 0x%llx name %.*s", 1275 MAJOR(__entry->dev), MINOR(__entry->dev), 1276 __entry->dp_ino, 1277 __entry->namelen, 1278 __get_str(name)) 1279) 1280 1281#define DEFINE_NAMESPACE_EVENT(name) \ 1282DEFINE_EVENT(xfs_namespace_class, name, \ 1283 TP_PROTO(struct xfs_inode *dp, const struct xfs_name *name), \ 1284 TP_ARGS(dp, name)) 1285DEFINE_NAMESPACE_EVENT(xfs_remove); 1286DEFINE_NAMESPACE_EVENT(xfs_link); 1287DEFINE_NAMESPACE_EVENT(xfs_lookup); 1288DEFINE_NAMESPACE_EVENT(xfs_create); 1289DEFINE_NAMESPACE_EVENT(xfs_symlink); 1290 1291TRACE_EVENT(xfs_rename, 1292 TP_PROTO(struct xfs_inode *src_dp, struct xfs_inode *target_dp, 1293 struct xfs_name *src_name, struct xfs_name *target_name), 1294 TP_ARGS(src_dp, target_dp, src_name, target_name), 1295 TP_STRUCT__entry( 1296 __field(dev_t, dev) 1297 __field(xfs_ino_t, src_dp_ino) 1298 __field(xfs_ino_t, target_dp_ino) 1299 __field(int, src_namelen) 1300 __field(int, target_namelen) 1301 __dynamic_array(char, src_name, src_name->len) 1302 __dynamic_array(char, target_name, target_name->len) 1303 ), 1304 TP_fast_assign( 1305 __entry->dev = VFS_I(src_dp)->i_sb->s_dev; 1306 __entry->src_dp_ino = src_dp->i_ino; 1307 __entry->target_dp_ino = target_dp->i_ino; 1308 __entry->src_namelen = src_name->len; 1309 __entry->target_namelen = target_name->len; 1310 memcpy(__get_str(src_name), src_name->name, src_name->len); 1311 memcpy(__get_str(target_name), target_name->name, 1312 target_name->len); 1313 ), 1314 TP_printk("dev %d:%d src dp ino 0x%llx target dp ino 0x%llx" 1315 " src name %.*s target name %.*s", 1316 MAJOR(__entry->dev), MINOR(__entry->dev), 1317 __entry->src_dp_ino, 1318 __entry->target_dp_ino, 1319 __entry->src_namelen, 1320 __get_str(src_name), 1321 __entry->target_namelen, 1322 __get_str(target_name)) 1323) 1324 1325DECLARE_EVENT_CLASS(xfs_dquot_class, 1326 TP_PROTO(struct xfs_dquot *dqp), 1327 TP_ARGS(dqp), 1328 TP_STRUCT__entry( 1329 __field(dev_t, dev) 1330 __field(u32, id) 1331 __field(xfs_dqtype_t, type) 1332 __field(unsigned, flags) 1333 __field(unsigned, nrefs) 1334 __field(unsigned long long, res_bcount) 1335 __field(unsigned long long, res_rtbcount) 1336 __field(unsigned long long, res_icount) 1337 1338 __field(unsigned long long, bcount) 1339 __field(unsigned long long, rtbcount) 1340 __field(unsigned long long, icount) 1341 1342 __field(unsigned long long, blk_hardlimit) 1343 __field(unsigned long long, blk_softlimit) 1344 __field(unsigned long long, rtb_hardlimit) 1345 __field(unsigned long long, rtb_softlimit) 1346 __field(unsigned long long, ino_hardlimit) 1347 __field(unsigned long long, ino_softlimit) 1348 ), 1349 TP_fast_assign( 1350 __entry->dev = dqp->q_mount->m_super->s_dev; 1351 __entry->id = dqp->q_id; 1352 __entry->type = dqp->q_type; 1353 __entry->flags = dqp->q_flags; 1354 __entry->nrefs = data_race(dqp->q_lockref.count); 1355 1356 __entry->res_bcount = dqp->q_blk.reserved; 1357 __entry->res_rtbcount = dqp->q_rtb.reserved; 1358 __entry->res_icount = dqp->q_ino.reserved; 1359 1360 __entry->bcount = dqp->q_blk.count; 1361 __entry->rtbcount = dqp->q_rtb.count; 1362 __entry->icount = dqp->q_ino.count; 1363 1364 __entry->blk_hardlimit = dqp->q_blk.hardlimit; 1365 __entry->blk_softlimit = dqp->q_blk.softlimit; 1366 __entry->rtb_hardlimit = dqp->q_rtb.hardlimit; 1367 __entry->rtb_softlimit = dqp->q_rtb.softlimit; 1368 __entry->ino_hardlimit = dqp->q_ino.hardlimit; 1369 __entry->ino_softlimit = dqp->q_ino.softlimit; 1370 ), 1371 TP_printk("dev %d:%d id 0x%x type %s flags %s nrefs %u " 1372 "res_bc 0x%llx res_rtbc 0x%llx res_ic 0x%llx " 1373 "bcnt 0x%llx bhardlimit 0x%llx bsoftlimit 0x%llx " 1374 "rtbcnt 0x%llx rtbhardlimit 0x%llx rtbsoftlimit 0x%llx " 1375 "icnt 0x%llx ihardlimit 0x%llx isoftlimit 0x%llx]", 1376 MAJOR(__entry->dev), MINOR(__entry->dev), 1377 __entry->id, 1378 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1379 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1380 __entry->nrefs, 1381 __entry->res_bcount, 1382 __entry->res_rtbcount, 1383 __entry->res_icount, 1384 __entry->bcount, 1385 __entry->blk_hardlimit, 1386 __entry->blk_softlimit, 1387 __entry->rtbcount, 1388 __entry->rtb_hardlimit, 1389 __entry->rtb_softlimit, 1390 __entry->icount, 1391 __entry->ino_hardlimit, 1392 __entry->ino_softlimit) 1393) 1394 1395#define DEFINE_DQUOT_EVENT(name) \ 1396DEFINE_EVENT(xfs_dquot_class, name, \ 1397 TP_PROTO(struct xfs_dquot *dqp), \ 1398 TP_ARGS(dqp)) 1399DEFINE_DQUOT_EVENT(xfs_dqadjust); 1400DEFINE_DQUOT_EVENT(xfs_dqreclaim_want); 1401DEFINE_DQUOT_EVENT(xfs_dqreclaim_busy); 1402DEFINE_DQUOT_EVENT(xfs_dqreclaim_done); 1403DEFINE_DQUOT_EVENT(xfs_dqattach_get); 1404DEFINE_DQUOT_EVENT(xfs_dqalloc); 1405DEFINE_DQUOT_EVENT(xfs_dqtobp_read); 1406DEFINE_DQUOT_EVENT(xfs_dqread); 1407DEFINE_DQUOT_EVENT(xfs_dqread_fail); 1408DEFINE_DQUOT_EVENT(xfs_dqget_hit); 1409DEFINE_DQUOT_EVENT(xfs_dqget_miss); 1410DEFINE_DQUOT_EVENT(xfs_dqget_freeing); 1411DEFINE_DQUOT_EVENT(xfs_dqget_dup); 1412DEFINE_DQUOT_EVENT(xfs_dqrele); 1413DEFINE_DQUOT_EVENT(xfs_dqrele_free); 1414DEFINE_DQUOT_EVENT(xfs_dqflush); 1415DEFINE_DQUOT_EVENT(xfs_dqflush_force); 1416DEFINE_DQUOT_EVENT(xfs_dqflush_done); 1417DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_before); 1418DEFINE_DQUOT_EVENT(xfs_trans_apply_dquot_deltas_after); 1419 1420TRACE_EVENT(xfs_trans_mod_dquot, 1421 TP_PROTO(struct xfs_trans *tp, struct xfs_dquot *dqp, 1422 unsigned int field, int64_t delta), 1423 TP_ARGS(tp, dqp, field, delta), 1424 TP_STRUCT__entry( 1425 __field(dev_t, dev) 1426 __field(xfs_dqtype_t, type) 1427 __field(unsigned int, flags) 1428 __field(unsigned int, dqid) 1429 __field(unsigned int, field) 1430 __field(int64_t, delta) 1431 ), 1432 TP_fast_assign( 1433 __entry->dev = tp->t_mountp->m_super->s_dev; 1434 __entry->type = dqp->q_type; 1435 __entry->flags = dqp->q_flags; 1436 __entry->dqid = dqp->q_id; 1437 __entry->field = field; 1438 __entry->delta = delta; 1439 ), 1440 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s field %s delta %lld", 1441 MAJOR(__entry->dev), MINOR(__entry->dev), 1442 __entry->dqid, 1443 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1444 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1445 __print_flags(__entry->field, "|", XFS_QMOPT_FLAGS), 1446 __entry->delta) 1447); 1448 1449DECLARE_EVENT_CLASS(xfs_dqtrx_class, 1450 TP_PROTO(struct xfs_dqtrx *qtrx), 1451 TP_ARGS(qtrx), 1452 TP_STRUCT__entry( 1453 __field(dev_t, dev) 1454 __field(xfs_dqtype_t, type) 1455 __field(unsigned int, flags) 1456 __field(u32, dqid) 1457 1458 __field(uint64_t, blk_res) 1459 __field(int64_t, bcount_delta) 1460 __field(int64_t, delbcnt_delta) 1461 1462 __field(uint64_t, rtblk_res) 1463 __field(uint64_t, rtblk_res_used) 1464 __field(int64_t, rtbcount_delta) 1465 __field(int64_t, delrtb_delta) 1466 1467 __field(uint64_t, ino_res) 1468 __field(uint64_t, ino_res_used) 1469 __field(int64_t, icount_delta) 1470 ), 1471 TP_fast_assign( 1472 __entry->dev = qtrx->qt_dquot->q_mount->m_super->s_dev; 1473 __entry->type = qtrx->qt_dquot->q_type; 1474 __entry->flags = qtrx->qt_dquot->q_flags; 1475 __entry->dqid = qtrx->qt_dquot->q_id; 1476 1477 __entry->blk_res = qtrx->qt_blk_res; 1478 __entry->bcount_delta = qtrx->qt_bcount_delta; 1479 __entry->delbcnt_delta = qtrx->qt_delbcnt_delta; 1480 1481 __entry->rtblk_res = qtrx->qt_rtblk_res; 1482 __entry->rtblk_res_used = qtrx->qt_rtblk_res_used; 1483 __entry->rtbcount_delta = qtrx->qt_rtbcount_delta; 1484 __entry->delrtb_delta = qtrx->qt_delrtb_delta; 1485 1486 __entry->ino_res = qtrx->qt_ino_res; 1487 __entry->ino_res_used = qtrx->qt_ino_res_used; 1488 __entry->icount_delta = qtrx->qt_icount_delta; 1489 ), 1490 TP_printk("dev %d:%d dquot id 0x%x type %s flags %s " 1491 "blk_res %llu bcount_delta %lld delbcnt_delta %lld " 1492 "rtblk_res %llu rtblk_res_used %llu rtbcount_delta %lld delrtb_delta %lld " 1493 "ino_res %llu ino_res_used %llu icount_delta %lld", 1494 MAJOR(__entry->dev), MINOR(__entry->dev), 1495 __entry->dqid, 1496 __print_flags(__entry->type, "|", XFS_DQTYPE_STRINGS), 1497 __print_flags(__entry->flags, "|", XFS_DQFLAG_STRINGS), 1498 1499 __entry->blk_res, 1500 __entry->bcount_delta, 1501 __entry->delbcnt_delta, 1502 1503 __entry->rtblk_res, 1504 __entry->rtblk_res_used, 1505 __entry->rtbcount_delta, 1506 __entry->delrtb_delta, 1507 1508 __entry->ino_res, 1509 __entry->ino_res_used, 1510 __entry->icount_delta) 1511) 1512 1513#define DEFINE_DQTRX_EVENT(name) \ 1514DEFINE_EVENT(xfs_dqtrx_class, name, \ 1515 TP_PROTO(struct xfs_dqtrx *qtrx), \ 1516 TP_ARGS(qtrx)) 1517DEFINE_DQTRX_EVENT(xfs_trans_apply_dquot_deltas); 1518DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_before); 1519DEFINE_DQTRX_EVENT(xfs_trans_mod_dquot_after); 1520 1521DECLARE_EVENT_CLASS(xfs_loggrant_class, 1522 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), 1523 TP_ARGS(log, tic), 1524 TP_STRUCT__entry( 1525 __field(dev_t, dev) 1526 __field(unsigned long, tic) 1527 __field(char, ocnt) 1528 __field(char, cnt) 1529 __field(int, curr_res) 1530 __field(int, unit_res) 1531 __field(unsigned int, flags) 1532 __field(int, reserveq) 1533 __field(int, writeq) 1534 __field(uint64_t, grant_reserve_bytes) 1535 __field(uint64_t, grant_write_bytes) 1536 __field(uint64_t, tail_space) 1537 __field(int, curr_cycle) 1538 __field(int, curr_block) 1539 __field(xfs_lsn_t, tail_lsn) 1540 ), 1541 TP_fast_assign( 1542 __entry->dev = log->l_mp->m_super->s_dev; 1543 __entry->tic = (unsigned long)tic; 1544 __entry->ocnt = tic->t_ocnt; 1545 __entry->cnt = tic->t_cnt; 1546 __entry->curr_res = tic->t_curr_res; 1547 __entry->unit_res = tic->t_unit_res; 1548 __entry->flags = tic->t_flags; 1549 __entry->reserveq = list_empty(&log->l_reserve_head.waiters); 1550 __entry->writeq = list_empty(&log->l_write_head.waiters); 1551 __entry->tail_space = READ_ONCE(log->l_tail_space); 1552 __entry->grant_reserve_bytes = __entry->tail_space + 1553 atomic64_read(&log->l_reserve_head.grant); 1554 __entry->grant_write_bytes = __entry->tail_space + 1555 atomic64_read(&log->l_write_head.grant); 1556 __entry->curr_cycle = log->l_curr_cycle; 1557 __entry->curr_block = log->l_curr_block; 1558 __entry->tail_lsn = atomic64_read(&log->l_tail_lsn); 1559 ), 1560 TP_printk("dev %d:%d tic 0x%lx t_ocnt %u t_cnt %u t_curr_res %u " 1561 "t_unit_res %u t_flags %s reserveq %s writeq %s " 1562 "tail space %llu grant_reserve_bytes %llu " 1563 "grant_write_bytes %llu curr_cycle %d curr_block %d " 1564 "tail_cycle %d tail_block %d", 1565 MAJOR(__entry->dev), MINOR(__entry->dev), 1566 __entry->tic, 1567 __entry->ocnt, 1568 __entry->cnt, 1569 __entry->curr_res, 1570 __entry->unit_res, 1571 __print_flags(__entry->flags, "|", XLOG_TIC_FLAGS), 1572 __entry->reserveq ? "empty" : "active", 1573 __entry->writeq ? "empty" : "active", 1574 __entry->tail_space, 1575 __entry->grant_reserve_bytes, 1576 __entry->grant_write_bytes, 1577 __entry->curr_cycle, 1578 __entry->curr_block, 1579 CYCLE_LSN(__entry->tail_lsn), 1580 BLOCK_LSN(__entry->tail_lsn) 1581 ) 1582) 1583 1584#define DEFINE_LOGGRANT_EVENT(name) \ 1585DEFINE_EVENT(xfs_loggrant_class, name, \ 1586 TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \ 1587 TP_ARGS(log, tic)) 1588DEFINE_LOGGRANT_EVENT(xfs_log_umount_write); 1589DEFINE_LOGGRANT_EVENT(xfs_log_grant_sleep); 1590DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake); 1591DEFINE_LOGGRANT_EVENT(xfs_log_grant_wake_up); 1592DEFINE_LOGGRANT_EVENT(xfs_log_reserve); 1593DEFINE_LOGGRANT_EVENT(xfs_log_reserve_exit); 1594DEFINE_LOGGRANT_EVENT(xfs_log_regrant); 1595DEFINE_LOGGRANT_EVENT(xfs_log_regrant_exit); 1596DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant); 1597DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_exit); 1598DEFINE_LOGGRANT_EVENT(xfs_log_ticket_regrant_sub); 1599DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant); 1600DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_sub); 1601DEFINE_LOGGRANT_EVENT(xfs_log_ticket_ungrant_exit); 1602DEFINE_LOGGRANT_EVENT(xfs_log_cil_wait); 1603 1604DECLARE_EVENT_CLASS(xfs_log_item_class, 1605 TP_PROTO(struct xfs_log_item *lip), 1606 TP_ARGS(lip), 1607 TP_STRUCT__entry( 1608 __field(dev_t, dev) 1609 __field(void *, lip) 1610 __field(uint, type) 1611 __field(unsigned long, flags) 1612 __field(xfs_lsn_t, lsn) 1613 ), 1614 TP_fast_assign( 1615 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1616 __entry->lip = lip; 1617 __entry->type = lip->li_type; 1618 __entry->flags = lip->li_flags; 1619 __entry->lsn = lip->li_lsn; 1620 ), 1621 TP_printk("dev %d:%d lip %p lsn %d/%d type %s flags %s", 1622 MAJOR(__entry->dev), MINOR(__entry->dev), 1623 __entry->lip, 1624 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn), 1625 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1626 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1627) 1628 1629TRACE_EVENT(xfs_log_force, 1630 TP_PROTO(struct xfs_mount *mp, xfs_lsn_t lsn, unsigned long caller_ip), 1631 TP_ARGS(mp, lsn, caller_ip), 1632 TP_STRUCT__entry( 1633 __field(dev_t, dev) 1634 __field(xfs_lsn_t, lsn) 1635 __field(unsigned long, caller_ip) 1636 ), 1637 TP_fast_assign( 1638 __entry->dev = mp->m_super->s_dev; 1639 __entry->lsn = lsn; 1640 __entry->caller_ip = caller_ip; 1641 ), 1642 TP_printk("dev %d:%d lsn 0x%llx caller %pS", 1643 MAJOR(__entry->dev), MINOR(__entry->dev), 1644 __entry->lsn, (void *)__entry->caller_ip) 1645) 1646 1647#define DEFINE_LOG_ITEM_EVENT(name) \ 1648DEFINE_EVENT(xfs_log_item_class, name, \ 1649 TP_PROTO(struct xfs_log_item *lip), \ 1650 TP_ARGS(lip)) 1651DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_mark); 1652DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_skip); 1653DEFINE_LOG_ITEM_EVENT(xfs_cil_whiteout_unpin); 1654DEFINE_LOG_ITEM_EVENT(xlog_ail_insert_abort); 1655DEFINE_LOG_ITEM_EVENT(xfs_trans_free_abort); 1656 1657DECLARE_EVENT_CLASS(xfs_ail_push_class, 1658 TP_PROTO(struct xfs_ail *ailp, uint type, unsigned long flags, xfs_lsn_t lsn), 1659 TP_ARGS(ailp, type, flags, lsn), 1660 TP_STRUCT__entry( 1661 __field(dev_t, dev) 1662 __field(uint, type) 1663 __field(unsigned long, flags) 1664 __field(xfs_lsn_t, lsn) 1665 ), 1666 TP_fast_assign( 1667 __entry->dev = ailp->ail_log->l_mp->m_super->s_dev; 1668 __entry->type = type; 1669 __entry->flags = flags; 1670 __entry->lsn = lsn; 1671 ), 1672 TP_printk("dev %d:%d lsn %d/%d type %s flags %s", 1673 MAJOR(__entry->dev), MINOR(__entry->dev), 1674 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn), 1675 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1676 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1677) 1678 1679#define DEFINE_AIL_PUSH_EVENT(name) \ 1680DEFINE_EVENT(xfs_ail_push_class, name, \ 1681 TP_PROTO(struct xfs_ail *ailp, uint type, unsigned long flags, xfs_lsn_t lsn), \ 1682 TP_ARGS(ailp, type, flags, lsn)) 1683DEFINE_AIL_PUSH_EVENT(xfs_ail_push); 1684DEFINE_AIL_PUSH_EVENT(xfs_ail_pinned); 1685DEFINE_AIL_PUSH_EVENT(xfs_ail_locked); 1686DEFINE_AIL_PUSH_EVENT(xfs_ail_flushing); 1687 1688DECLARE_EVENT_CLASS(xfs_ail_class, 1689 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), 1690 TP_ARGS(lip, old_lsn, new_lsn), 1691 TP_STRUCT__entry( 1692 __field(dev_t, dev) 1693 __field(void *, lip) 1694 __field(uint, type) 1695 __field(unsigned long, flags) 1696 __field(xfs_lsn_t, old_lsn) 1697 __field(xfs_lsn_t, new_lsn) 1698 ), 1699 TP_fast_assign( 1700 __entry->dev = lip->li_log->l_mp->m_super->s_dev; 1701 __entry->lip = lip; 1702 __entry->type = lip->li_type; 1703 __entry->flags = lip->li_flags; 1704 __entry->old_lsn = old_lsn; 1705 __entry->new_lsn = new_lsn; 1706 ), 1707 TP_printk("dev %d:%d lip %p old lsn %d/%d new lsn %d/%d type %s flags %s", 1708 MAJOR(__entry->dev), MINOR(__entry->dev), 1709 __entry->lip, 1710 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1711 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1712 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 1713 __print_flags(__entry->flags, "|", XFS_LI_FLAGS)) 1714) 1715 1716#define DEFINE_AIL_EVENT(name) \ 1717DEFINE_EVENT(xfs_ail_class, name, \ 1718 TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \ 1719 TP_ARGS(lip, old_lsn, new_lsn)) 1720DEFINE_AIL_EVENT(xfs_ail_insert); 1721DEFINE_AIL_EVENT(xfs_ail_move); 1722DEFINE_AIL_EVENT(xfs_ail_delete); 1723 1724TRACE_EVENT(xfs_log_assign_tail_lsn, 1725 TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn), 1726 TP_ARGS(log, new_lsn), 1727 TP_STRUCT__entry( 1728 __field(dev_t, dev) 1729 __field(xfs_lsn_t, new_lsn) 1730 __field(xfs_lsn_t, old_lsn) 1731 __field(xfs_lsn_t, head_lsn) 1732 ), 1733 TP_fast_assign( 1734 __entry->dev = log->l_mp->m_super->s_dev; 1735 __entry->new_lsn = new_lsn; 1736 __entry->old_lsn = atomic64_read(&log->l_tail_lsn); 1737 __entry->head_lsn = log->l_ailp->ail_head_lsn; 1738 ), 1739 TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, head lsn %d/%d", 1740 MAJOR(__entry->dev), MINOR(__entry->dev), 1741 CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn), 1742 CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn), 1743 CYCLE_LSN(__entry->head_lsn), BLOCK_LSN(__entry->head_lsn)) 1744) 1745 1746DECLARE_EVENT_CLASS(xfs_file_class, 1747 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), 1748 TP_ARGS(iocb, iter), 1749 TP_STRUCT__entry( 1750 __field(dev_t, dev) 1751 __field(xfs_ino_t, ino) 1752 __field(xfs_fsize_t, size) 1753 __field(loff_t, offset) 1754 __field(size_t, count) 1755 ), 1756 TP_fast_assign( 1757 __entry->dev = file_inode(iocb->ki_filp)->i_sb->s_dev; 1758 __entry->ino = XFS_I(file_inode(iocb->ki_filp))->i_ino; 1759 __entry->size = XFS_I(file_inode(iocb->ki_filp))->i_disk_size; 1760 __entry->offset = iocb->ki_pos; 1761 __entry->count = iov_iter_count(iter); 1762 ), 1763 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx", 1764 MAJOR(__entry->dev), MINOR(__entry->dev), 1765 __entry->ino, 1766 __entry->size, 1767 __entry->offset, 1768 __entry->count) 1769) 1770 1771#define DEFINE_RW_EVENT(name) \ 1772DEFINE_EVENT(xfs_file_class, name, \ 1773 TP_PROTO(struct kiocb *iocb, struct iov_iter *iter), \ 1774 TP_ARGS(iocb, iter)) 1775DEFINE_RW_EVENT(xfs_file_buffered_read); 1776DEFINE_RW_EVENT(xfs_file_direct_read); 1777DEFINE_RW_EVENT(xfs_file_dax_read); 1778DEFINE_RW_EVENT(xfs_file_buffered_write); 1779DEFINE_RW_EVENT(xfs_file_direct_write); 1780DEFINE_RW_EVENT(xfs_file_dax_write); 1781DEFINE_RW_EVENT(xfs_reflink_bounce_dio_write); 1782 1783TRACE_EVENT(xfs_iomap_atomic_write_cow, 1784 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), 1785 TP_ARGS(ip, offset, count), 1786 TP_STRUCT__entry( 1787 __field(dev_t, dev) 1788 __field(xfs_ino_t, ino) 1789 __field(xfs_off_t, offset) 1790 __field(ssize_t, count) 1791 ), 1792 TP_fast_assign( 1793 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1794 __entry->ino = ip->i_ino; 1795 __entry->offset = offset; 1796 __entry->count = count; 1797 ), 1798 TP_printk("dev %d:%d ino 0x%llx pos 0x%llx bytecount 0x%zx", 1799 MAJOR(__entry->dev), MINOR(__entry->dev), 1800 __entry->ino, 1801 __entry->offset, 1802 __entry->count) 1803) 1804 1805DECLARE_EVENT_CLASS(xfs_imap_class, 1806 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, 1807 int whichfork, struct xfs_bmbt_irec *irec), 1808 TP_ARGS(ip, offset, count, whichfork, irec), 1809 TP_STRUCT__entry( 1810 __field(dev_t, dev) 1811 __field(xfs_ino_t, ino) 1812 __field(loff_t, size) 1813 __field(loff_t, offset) 1814 __field(size_t, count) 1815 __field(int, whichfork) 1816 __field(xfs_fileoff_t, startoff) 1817 __field(xfs_fsblock_t, startblock) 1818 __field(xfs_filblks_t, blockcount) 1819 ), 1820 TP_fast_assign( 1821 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1822 __entry->ino = ip->i_ino; 1823 __entry->size = ip->i_disk_size; 1824 __entry->offset = offset; 1825 __entry->count = count; 1826 __entry->whichfork = whichfork; 1827 __entry->startoff = irec ? irec->br_startoff : 0; 1828 __entry->startblock = irec ? irec->br_startblock : 0; 1829 __entry->blockcount = irec ? irec->br_blockcount : 0; 1830 ), 1831 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx pos 0x%llx bytecount 0x%zx " 1832 "fork %s startoff 0x%llx startblock 0x%llx fsbcount 0x%llx", 1833 MAJOR(__entry->dev), MINOR(__entry->dev), 1834 __entry->ino, 1835 __entry->size, 1836 __entry->offset, 1837 __entry->count, 1838 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 1839 __entry->startoff, 1840 (int64_t)__entry->startblock, 1841 __entry->blockcount) 1842) 1843 1844#define DEFINE_IMAP_EVENT(name) \ 1845DEFINE_EVENT(xfs_imap_class, name, \ 1846 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, \ 1847 int whichfork, struct xfs_bmbt_irec *irec), \ 1848 TP_ARGS(ip, offset, count, whichfork, irec)) 1849DEFINE_IMAP_EVENT(xfs_map_blocks_found); 1850DEFINE_IMAP_EVENT(xfs_map_blocks_alloc); 1851DEFINE_IMAP_EVENT(xfs_iomap_alloc); 1852DEFINE_IMAP_EVENT(xfs_iomap_found); 1853 1854DECLARE_EVENT_CLASS(xfs_simple_io_class, 1855 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), 1856 TP_ARGS(ip, offset, count), 1857 TP_STRUCT__entry( 1858 __field(dev_t, dev) 1859 __field(xfs_ino_t, ino) 1860 __field(loff_t, isize) 1861 __field(loff_t, disize) 1862 __field(loff_t, offset) 1863 __field(size_t, count) 1864 ), 1865 TP_fast_assign( 1866 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1867 __entry->ino = ip->i_ino; 1868 __entry->isize = VFS_I(ip)->i_size; 1869 __entry->disize = ip->i_disk_size; 1870 __entry->offset = offset; 1871 __entry->count = count; 1872 ), 1873 TP_printk("dev %d:%d ino 0x%llx isize 0x%llx disize 0x%llx " 1874 "pos 0x%llx bytecount 0x%zx", 1875 MAJOR(__entry->dev), MINOR(__entry->dev), 1876 __entry->ino, 1877 __entry->isize, 1878 __entry->disize, 1879 __entry->offset, 1880 __entry->count) 1881); 1882 1883#define DEFINE_SIMPLE_IO_EVENT(name) \ 1884DEFINE_EVENT(xfs_simple_io_class, name, \ 1885 TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), \ 1886 TP_ARGS(ip, offset, count)) 1887DEFINE_SIMPLE_IO_EVENT(xfs_delalloc_enospc); 1888DEFINE_SIMPLE_IO_EVENT(xfs_unwritten_convert); 1889DEFINE_SIMPLE_IO_EVENT(xfs_setfilesize); 1890DEFINE_SIMPLE_IO_EVENT(xfs_zero_eof); 1891DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write); 1892DEFINE_SIMPLE_IO_EVENT(xfs_file_splice_read); 1893DEFINE_SIMPLE_IO_EVENT(xfs_zoned_map_blocks); 1894 1895DECLARE_EVENT_CLASS(xfs_itrunc_class, 1896 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), 1897 TP_ARGS(ip, new_size), 1898 TP_STRUCT__entry( 1899 __field(dev_t, dev) 1900 __field(xfs_ino_t, ino) 1901 __field(xfs_fsize_t, size) 1902 __field(xfs_fsize_t, new_size) 1903 ), 1904 TP_fast_assign( 1905 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1906 __entry->ino = ip->i_ino; 1907 __entry->size = ip->i_disk_size; 1908 __entry->new_size = new_size; 1909 ), 1910 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx new_size 0x%llx", 1911 MAJOR(__entry->dev), MINOR(__entry->dev), 1912 __entry->ino, 1913 __entry->size, 1914 __entry->new_size) 1915) 1916 1917#define DEFINE_ITRUNC_EVENT(name) \ 1918DEFINE_EVENT(xfs_itrunc_class, name, \ 1919 TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \ 1920 TP_ARGS(ip, new_size)) 1921DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_start); 1922DEFINE_ITRUNC_EVENT(xfs_itruncate_extents_end); 1923 1924TRACE_EVENT(xfs_bunmap, 1925 TP_PROTO(struct xfs_inode *ip, xfs_fileoff_t fileoff, xfs_filblks_t len, 1926 int flags, unsigned long caller_ip), 1927 TP_ARGS(ip, fileoff, len, flags, caller_ip), 1928 TP_STRUCT__entry( 1929 __field(dev_t, dev) 1930 __field(xfs_ino_t, ino) 1931 __field(xfs_fsize_t, size) 1932 __field(xfs_fileoff_t, fileoff) 1933 __field(xfs_filblks_t, len) 1934 __field(unsigned long, caller_ip) 1935 __field(int, flags) 1936 ), 1937 TP_fast_assign( 1938 __entry->dev = VFS_I(ip)->i_sb->s_dev; 1939 __entry->ino = ip->i_ino; 1940 __entry->size = ip->i_disk_size; 1941 __entry->fileoff = fileoff; 1942 __entry->len = len; 1943 __entry->caller_ip = caller_ip; 1944 __entry->flags = flags; 1945 ), 1946 TP_printk("dev %d:%d ino 0x%llx disize 0x%llx fileoff 0x%llx fsbcount 0x%llx " 1947 "flags %s caller %pS", 1948 MAJOR(__entry->dev), MINOR(__entry->dev), 1949 __entry->ino, 1950 __entry->size, 1951 __entry->fileoff, 1952 __entry->len, 1953 __print_flags(__entry->flags, "|", XFS_BMAPI_FLAGS), 1954 (void *)__entry->caller_ip) 1955 1956); 1957 1958DECLARE_EVENT_CLASS(xfs_extent_busy_class, 1959 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 1960 xfs_extlen_t len), 1961 TP_ARGS(xg, agbno, len), 1962 TP_STRUCT__entry( 1963 __field(dev_t, dev) 1964 __field(enum xfs_group_type, type) 1965 __field(xfs_agnumber_t, agno) 1966 __field(xfs_agblock_t, agbno) 1967 __field(xfs_extlen_t, len) 1968 ), 1969 TP_fast_assign( 1970 __entry->dev = xg->xg_mount->m_super->s_dev; 1971 __entry->type = xg->xg_type; 1972 __entry->agno = xg->xg_gno; 1973 __entry->agbno = agbno; 1974 __entry->len = len; 1975 ), 1976 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x", 1977 MAJOR(__entry->dev), MINOR(__entry->dev), 1978 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 1979 __entry->agno, 1980 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 1981 __entry->agbno, 1982 __entry->len) 1983); 1984#define DEFINE_BUSY_EVENT(name) \ 1985DEFINE_EVENT(xfs_extent_busy_class, name, \ 1986 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 1987 xfs_extlen_t len), \ 1988 TP_ARGS(xg, agbno, len)) 1989DEFINE_BUSY_EVENT(xfs_extent_busy); 1990DEFINE_BUSY_EVENT(xfs_extent_busy_force); 1991DEFINE_BUSY_EVENT(xfs_extent_busy_reuse); 1992DEFINE_BUSY_EVENT(xfs_extent_busy_clear); 1993 1994TRACE_EVENT(xfs_extent_busy_trim, 1995 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 1996 xfs_extlen_t len, xfs_agblock_t tbno, xfs_extlen_t tlen), 1997 TP_ARGS(xg, agbno, len, tbno, tlen), 1998 TP_STRUCT__entry( 1999 __field(dev_t, dev) 2000 __field(enum xfs_group_type, type) 2001 __field(xfs_agnumber_t, agno) 2002 __field(xfs_agblock_t, agbno) 2003 __field(xfs_extlen_t, len) 2004 __field(xfs_agblock_t, tbno) 2005 __field(xfs_extlen_t, tlen) 2006 ), 2007 TP_fast_assign( 2008 __entry->dev = xg->xg_mount->m_super->s_dev; 2009 __entry->type = xg->xg_type; 2010 __entry->agno = xg->xg_gno; 2011 __entry->agbno = agbno; 2012 __entry->len = len; 2013 __entry->tbno = tbno; 2014 __entry->tlen = tlen; 2015 ), 2016 TP_printk("dev %d:%d %sno 0x%x %sbno 0x%x fsbcount 0x%x found_agbno 0x%x found_fsbcount 0x%x", 2017 MAJOR(__entry->dev), MINOR(__entry->dev), 2018 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2019 __entry->agno, 2020 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2021 __entry->agbno, 2022 __entry->len, 2023 __entry->tbno, 2024 __entry->tlen) 2025); 2026 2027#ifdef CONFIG_XFS_RT 2028TRACE_EVENT(xfs_rtalloc_extent_busy, 2029 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t start, 2030 xfs_rtxlen_t minlen, xfs_rtxlen_t maxlen, 2031 xfs_rtxlen_t len, xfs_rtxlen_t prod, xfs_rtxnum_t rtx, 2032 unsigned busy_gen), 2033 TP_ARGS(rtg, start, minlen, maxlen, len, prod, rtx, busy_gen), 2034 TP_STRUCT__entry( 2035 __field(dev_t, dev) 2036 __field(xfs_rgnumber_t, rgno) 2037 __field(xfs_rtxnum_t, start) 2038 __field(xfs_rtxlen_t, minlen) 2039 __field(xfs_rtxlen_t, maxlen) 2040 __field(xfs_rtxlen_t, mod) 2041 __field(xfs_rtxlen_t, prod) 2042 __field(xfs_rtxlen_t, len) 2043 __field(xfs_rtxnum_t, rtx) 2044 __field(unsigned, busy_gen) 2045 ), 2046 TP_fast_assign( 2047 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 2048 __entry->rgno = rtg_rgno(rtg); 2049 __entry->start = start; 2050 __entry->minlen = minlen; 2051 __entry->maxlen = maxlen; 2052 __entry->prod = prod; 2053 __entry->len = len; 2054 __entry->rtx = rtx; 2055 __entry->busy_gen = busy_gen; 2056 ), 2057 TP_printk("dev %d:%d rgno 0x%x startrtx 0x%llx minlen %u maxlen %u " 2058 "prod %u len %u rtx 0%llx busy_gen 0x%x", 2059 MAJOR(__entry->dev), MINOR(__entry->dev), 2060 __entry->rgno, 2061 __entry->start, 2062 __entry->minlen, 2063 __entry->maxlen, 2064 __entry->prod, 2065 __entry->len, 2066 __entry->rtx, 2067 __entry->busy_gen) 2068) 2069 2070TRACE_EVENT(xfs_rtalloc_extent_busy_trim, 2071 TP_PROTO(struct xfs_rtgroup *rtg, xfs_rtxnum_t old_rtx, 2072 xfs_rtxlen_t old_len, xfs_rtxnum_t new_rtx, 2073 xfs_rtxlen_t new_len), 2074 TP_ARGS(rtg, old_rtx, old_len, new_rtx, new_len), 2075 TP_STRUCT__entry( 2076 __field(dev_t, dev) 2077 __field(xfs_rgnumber_t, rgno) 2078 __field(xfs_rtxnum_t, old_rtx) 2079 __field(xfs_rtxnum_t, new_rtx) 2080 __field(xfs_rtxlen_t, old_len) 2081 __field(xfs_rtxlen_t, new_len) 2082 ), 2083 TP_fast_assign( 2084 __entry->dev = rtg_mount(rtg)->m_super->s_dev; 2085 __entry->rgno = rtg_rgno(rtg); 2086 __entry->old_rtx = old_rtx; 2087 __entry->old_len = old_len; 2088 __entry->new_rtx = new_rtx; 2089 __entry->new_len = new_len; 2090 ), 2091 TP_printk("dev %d:%d rgno 0x%x rtx 0x%llx rtxcount 0x%x -> rtx 0x%llx rtxcount 0x%x", 2092 MAJOR(__entry->dev), MINOR(__entry->dev), 2093 __entry->rgno, 2094 __entry->old_rtx, 2095 __entry->old_len, 2096 __entry->new_rtx, 2097 __entry->new_len) 2098); 2099#endif /* CONFIG_XFS_RT */ 2100 2101DECLARE_EVENT_CLASS(xfs_agf_class, 2102 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, 2103 unsigned long caller_ip), 2104 TP_ARGS(mp, agf, flags, caller_ip), 2105 TP_STRUCT__entry( 2106 __field(dev_t, dev) 2107 __field(xfs_agnumber_t, agno) 2108 __field(int, flags) 2109 __field(__u32, length) 2110 __field(__u32, bno_root) 2111 __field(__u32, cnt_root) 2112 __field(__u32, bno_level) 2113 __field(__u32, cnt_level) 2114 __field(__u32, flfirst) 2115 __field(__u32, fllast) 2116 __field(__u32, flcount) 2117 __field(__u32, freeblks) 2118 __field(__u32, longest) 2119 __field(unsigned long, caller_ip) 2120 ), 2121 TP_fast_assign( 2122 __entry->dev = mp->m_super->s_dev; 2123 __entry->agno = be32_to_cpu(agf->agf_seqno), 2124 __entry->flags = flags; 2125 __entry->length = be32_to_cpu(agf->agf_length), 2126 __entry->bno_root = be32_to_cpu(agf->agf_bno_root), 2127 __entry->cnt_root = be32_to_cpu(agf->agf_cnt_root), 2128 __entry->bno_level = be32_to_cpu(agf->agf_bno_level), 2129 __entry->cnt_level = be32_to_cpu(agf->agf_cnt_level), 2130 __entry->flfirst = be32_to_cpu(agf->agf_flfirst), 2131 __entry->fllast = be32_to_cpu(agf->agf_fllast), 2132 __entry->flcount = be32_to_cpu(agf->agf_flcount), 2133 __entry->freeblks = be32_to_cpu(agf->agf_freeblks), 2134 __entry->longest = be32_to_cpu(agf->agf_longest); 2135 __entry->caller_ip = caller_ip; 2136 ), 2137 TP_printk("dev %d:%d agno 0x%x flags %s length %u roots b %u c %u " 2138 "levels b %u c %u flfirst %u fllast %u flcount %u " 2139 "freeblks %u longest %u caller %pS", 2140 MAJOR(__entry->dev), MINOR(__entry->dev), 2141 __entry->agno, 2142 __print_flags(__entry->flags, "|", XFS_AGF_FLAGS), 2143 __entry->length, 2144 __entry->bno_root, 2145 __entry->cnt_root, 2146 __entry->bno_level, 2147 __entry->cnt_level, 2148 __entry->flfirst, 2149 __entry->fllast, 2150 __entry->flcount, 2151 __entry->freeblks, 2152 __entry->longest, 2153 (void *)__entry->caller_ip) 2154); 2155#define DEFINE_AGF_EVENT(name) \ 2156DEFINE_EVENT(xfs_agf_class, name, \ 2157 TP_PROTO(struct xfs_mount *mp, struct xfs_agf *agf, int flags, \ 2158 unsigned long caller_ip), \ 2159 TP_ARGS(mp, agf, flags, caller_ip)) 2160DEFINE_AGF_EVENT(xfs_agf); 2161DEFINE_AGF_EVENT(xfs_agfl_reset); 2162 2163TRACE_EVENT(xfs_free_extent, 2164 TP_PROTO(const struct xfs_perag *pag, xfs_agblock_t agbno, 2165 xfs_extlen_t len, enum xfs_ag_resv_type resv, int haveleft, 2166 int haveright), 2167 TP_ARGS(pag, agbno, len, resv, haveleft, haveright), 2168 TP_STRUCT__entry( 2169 __field(dev_t, dev) 2170 __field(xfs_agnumber_t, agno) 2171 __field(xfs_agblock_t, agbno) 2172 __field(xfs_extlen_t, len) 2173 __field(int, resv) 2174 __field(int, haveleft) 2175 __field(int, haveright) 2176 ), 2177 TP_fast_assign( 2178 __entry->dev = pag_mount(pag)->m_super->s_dev; 2179 __entry->agno = pag_agno(pag); 2180 __entry->agbno = agbno; 2181 __entry->len = len; 2182 __entry->resv = resv; 2183 __entry->haveleft = haveleft; 2184 __entry->haveright = haveright; 2185 ), 2186 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x resv %d %s", 2187 MAJOR(__entry->dev), MINOR(__entry->dev), 2188 __entry->agno, 2189 __entry->agbno, 2190 __entry->len, 2191 __entry->resv, 2192 __entry->haveleft ? 2193 (__entry->haveright ? "both" : "left") : 2194 (__entry->haveright ? "right" : "none")) 2195 2196); 2197 2198DECLARE_EVENT_CLASS(xfs_alloc_class, 2199 TP_PROTO(struct xfs_alloc_arg *args), 2200 TP_ARGS(args), 2201 TP_STRUCT__entry( 2202 __field(dev_t, dev) 2203 __field(xfs_agnumber_t, agno) 2204 __field(xfs_agblock_t, agbno) 2205 __field(xfs_extlen_t, minlen) 2206 __field(xfs_extlen_t, maxlen) 2207 __field(xfs_extlen_t, mod) 2208 __field(xfs_extlen_t, prod) 2209 __field(xfs_extlen_t, minleft) 2210 __field(xfs_extlen_t, total) 2211 __field(xfs_extlen_t, alignment) 2212 __field(xfs_extlen_t, minalignslop) 2213 __field(xfs_extlen_t, len) 2214 __field(char, wasdel) 2215 __field(char, wasfromfl) 2216 __field(int, resv) 2217 __field(int, datatype) 2218 __field(xfs_agnumber_t, highest_agno) 2219 ), 2220 TP_fast_assign( 2221 __entry->dev = args->mp->m_super->s_dev; 2222 __entry->agno = args->agno; 2223 __entry->agbno = args->agbno; 2224 __entry->minlen = args->minlen; 2225 __entry->maxlen = args->maxlen; 2226 __entry->mod = args->mod; 2227 __entry->prod = args->prod; 2228 __entry->minleft = args->minleft; 2229 __entry->total = args->total; 2230 __entry->alignment = args->alignment; 2231 __entry->minalignslop = args->minalignslop; 2232 __entry->len = args->len; 2233 __entry->wasdel = args->wasdel; 2234 __entry->wasfromfl = args->wasfromfl; 2235 __entry->resv = args->resv; 2236 __entry->datatype = args->datatype; 2237 __entry->highest_agno = args->tp->t_highest_agno; 2238 ), 2239 TP_printk("dev %d:%d agno 0x%x agbno 0x%x minlen %u maxlen %u mod %u " 2240 "prod %u minleft %u total %u alignment %u minalignslop %u " 2241 "len %u wasdel %d wasfromfl %d resv %d " 2242 "datatype 0x%x highest_agno 0x%x", 2243 MAJOR(__entry->dev), MINOR(__entry->dev), 2244 __entry->agno, 2245 __entry->agbno, 2246 __entry->minlen, 2247 __entry->maxlen, 2248 __entry->mod, 2249 __entry->prod, 2250 __entry->minleft, 2251 __entry->total, 2252 __entry->alignment, 2253 __entry->minalignslop, 2254 __entry->len, 2255 __entry->wasdel, 2256 __entry->wasfromfl, 2257 __entry->resv, 2258 __entry->datatype, 2259 __entry->highest_agno) 2260) 2261 2262#define DEFINE_ALLOC_EVENT(name) \ 2263DEFINE_EVENT(xfs_alloc_class, name, \ 2264 TP_PROTO(struct xfs_alloc_arg *args), \ 2265 TP_ARGS(args)) 2266DEFINE_ALLOC_EVENT(xfs_alloc_exact_done); 2267DEFINE_ALLOC_EVENT(xfs_alloc_exact_notfound); 2268DEFINE_ALLOC_EVENT(xfs_alloc_exact_error); 2269DEFINE_ALLOC_EVENT(xfs_alloc_near_first); 2270DEFINE_ALLOC_EVENT(xfs_alloc_cur); 2271DEFINE_ALLOC_EVENT(xfs_alloc_cur_right); 2272DEFINE_ALLOC_EVENT(xfs_alloc_cur_left); 2273DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup); 2274DEFINE_ALLOC_EVENT(xfs_alloc_cur_lookup_done); 2275DEFINE_ALLOC_EVENT(xfs_alloc_near_noentry); 2276DEFINE_ALLOC_EVENT(xfs_alloc_near_busy); 2277DEFINE_ALLOC_EVENT(xfs_alloc_size_neither); 2278DEFINE_ALLOC_EVENT(xfs_alloc_size_noentry); 2279DEFINE_ALLOC_EVENT(xfs_alloc_size_nominleft); 2280DEFINE_ALLOC_EVENT(xfs_alloc_size_done); 2281DEFINE_ALLOC_EVENT(xfs_alloc_size_error); 2282DEFINE_ALLOC_EVENT(xfs_alloc_size_busy); 2283DEFINE_ALLOC_EVENT(xfs_alloc_small_freelist); 2284DEFINE_ALLOC_EVENT(xfs_alloc_small_notenough); 2285DEFINE_ALLOC_EVENT(xfs_alloc_small_done); 2286DEFINE_ALLOC_EVENT(xfs_alloc_small_error); 2287DEFINE_ALLOC_EVENT(xfs_alloc_vextent_badargs); 2288DEFINE_ALLOC_EVENT(xfs_alloc_vextent_skip_deadlock); 2289DEFINE_ALLOC_EVENT(xfs_alloc_vextent_nofix); 2290DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp); 2291DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed); 2292DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed); 2293 2294DEFINE_ALLOC_EVENT(xfs_alloc_vextent_this_ag); 2295DEFINE_ALLOC_EVENT(xfs_alloc_vextent_start_ag); 2296DEFINE_ALLOC_EVENT(xfs_alloc_vextent_first_ag); 2297DEFINE_ALLOC_EVENT(xfs_alloc_vextent_exact_bno); 2298DEFINE_ALLOC_EVENT(xfs_alloc_vextent_near_bno); 2299DEFINE_ALLOC_EVENT(xfs_alloc_vextent_finish); 2300 2301TRACE_EVENT(xfs_alloc_cur_check, 2302 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t bno, 2303 xfs_extlen_t len, xfs_extlen_t diff, bool new), 2304 TP_ARGS(cur, bno, len, diff, new), 2305 TP_STRUCT__entry( 2306 __field(dev_t, dev) 2307 __string(name, cur->bc_ops->name) 2308 __field(xfs_agblock_t, bno) 2309 __field(xfs_extlen_t, len) 2310 __field(xfs_extlen_t, diff) 2311 __field(bool, new) 2312 ), 2313 TP_fast_assign( 2314 __entry->dev = cur->bc_mp->m_super->s_dev; 2315 __assign_str(name); 2316 __entry->bno = bno; 2317 __entry->len = len; 2318 __entry->diff = diff; 2319 __entry->new = new; 2320 ), 2321 TP_printk("dev %d:%d %sbt agbno 0x%x fsbcount 0x%x diff 0x%x new %d", 2322 MAJOR(__entry->dev), MINOR(__entry->dev), 2323 __get_str(name), 2324 __entry->bno, __entry->len, __entry->diff, __entry->new) 2325) 2326 2327DECLARE_EVENT_CLASS(xfs_da_class, 2328 TP_PROTO(struct xfs_da_args *args), 2329 TP_ARGS(args), 2330 TP_STRUCT__entry( 2331 __field(dev_t, dev) 2332 __field(xfs_ino_t, ino) 2333 __dynamic_array(char, name, args->namelen) 2334 __field(int, namelen) 2335 __field(xfs_dahash_t, hashval) 2336 __field(xfs_ino_t, inumber) 2337 __field(uint32_t, op_flags) 2338 __field(xfs_ino_t, owner) 2339 ), 2340 TP_fast_assign( 2341 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2342 __entry->ino = args->dp->i_ino; 2343 if (args->namelen) 2344 memcpy(__get_str(name), args->name, args->namelen); 2345 __entry->namelen = args->namelen; 2346 __entry->hashval = args->hashval; 2347 __entry->inumber = args->inumber; 2348 __entry->op_flags = args->op_flags; 2349 __entry->owner = args->owner; 2350 ), 2351 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " 2352 "inumber 0x%llx op_flags %s owner 0x%llx", 2353 MAJOR(__entry->dev), MINOR(__entry->dev), 2354 __entry->ino, 2355 __entry->namelen, 2356 __entry->namelen ? __get_str(name) : NULL, 2357 __entry->namelen, 2358 __entry->hashval, 2359 __entry->inumber, 2360 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2361 __entry->owner) 2362) 2363 2364#define DEFINE_DIR2_EVENT(name) \ 2365DEFINE_EVENT(xfs_da_class, name, \ 2366 TP_PROTO(struct xfs_da_args *args), \ 2367 TP_ARGS(args)) 2368DEFINE_DIR2_EVENT(xfs_dir2_sf_addname); 2369DEFINE_DIR2_EVENT(xfs_dir2_sf_create); 2370DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup); 2371DEFINE_DIR2_EVENT(xfs_dir2_sf_replace); 2372DEFINE_DIR2_EVENT(xfs_dir2_sf_removename); 2373DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4); 2374DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8); 2375DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block); 2376DEFINE_DIR2_EVENT(xfs_dir2_block_addname); 2377DEFINE_DIR2_EVENT(xfs_dir2_block_lookup); 2378DEFINE_DIR2_EVENT(xfs_dir2_block_replace); 2379DEFINE_DIR2_EVENT(xfs_dir2_block_removename); 2380DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf); 2381DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf); 2382DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname); 2383DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup); 2384DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace); 2385DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename); 2386DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block); 2387DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node); 2388DEFINE_DIR2_EVENT(xfs_dir2_node_addname); 2389DEFINE_DIR2_EVENT(xfs_dir2_node_lookup); 2390DEFINE_DIR2_EVENT(xfs_dir2_node_replace); 2391DEFINE_DIR2_EVENT(xfs_dir2_node_removename); 2392DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf); 2393 2394DECLARE_EVENT_CLASS(xfs_attr_class, 2395 TP_PROTO(struct xfs_da_args *args), 2396 TP_ARGS(args), 2397 TP_STRUCT__entry( 2398 __field(dev_t, dev) 2399 __field(xfs_ino_t, ino) 2400 __dynamic_array(char, name, args->namelen) 2401 __field(int, namelen) 2402 __field(int, valuelen) 2403 __field(xfs_dahash_t, hashval) 2404 __field(unsigned int, attr_filter) 2405 __field(uint32_t, op_flags) 2406 ), 2407 TP_fast_assign( 2408 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2409 __entry->ino = args->dp->i_ino; 2410 if (args->namelen) 2411 memcpy(__get_str(name), args->name, args->namelen); 2412 __entry->namelen = args->namelen; 2413 __entry->valuelen = args->valuelen; 2414 __entry->hashval = args->hashval; 2415 __entry->attr_filter = args->attr_filter; 2416 __entry->op_flags = args->op_flags; 2417 ), 2418 TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d valuelen %d " 2419 "hashval 0x%x filter %s op_flags %s", 2420 MAJOR(__entry->dev), MINOR(__entry->dev), 2421 __entry->ino, 2422 __entry->namelen, 2423 __entry->namelen ? __get_str(name) : NULL, 2424 __entry->namelen, 2425 __entry->valuelen, 2426 __entry->hashval, 2427 __print_flags(__entry->attr_filter, "|", 2428 XFS_ATTR_FILTER_FLAGS), 2429 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) 2430) 2431 2432#define DEFINE_ATTR_EVENT(name) \ 2433DEFINE_EVENT(xfs_attr_class, name, \ 2434 TP_PROTO(struct xfs_da_args *args), \ 2435 TP_ARGS(args)) 2436DEFINE_ATTR_EVENT(xfs_attr_sf_add); 2437DEFINE_ATTR_EVENT(xfs_attr_sf_addname); 2438DEFINE_ATTR_EVENT(xfs_attr_sf_create); 2439DEFINE_ATTR_EVENT(xfs_attr_sf_lookup); 2440DEFINE_ATTR_EVENT(xfs_attr_sf_remove); 2441DEFINE_ATTR_EVENT(xfs_attr_sf_to_leaf); 2442 2443DEFINE_ATTR_EVENT(xfs_attr_leaf_add); 2444DEFINE_ATTR_EVENT(xfs_attr_leaf_add_old); 2445DEFINE_ATTR_EVENT(xfs_attr_leaf_add_new); 2446DEFINE_ATTR_EVENT(xfs_attr_leaf_add_work); 2447DEFINE_ATTR_EVENT(xfs_attr_leaf_create); 2448DEFINE_ATTR_EVENT(xfs_attr_leaf_compact); 2449DEFINE_ATTR_EVENT(xfs_attr_leaf_get); 2450DEFINE_ATTR_EVENT(xfs_attr_leaf_lookup); 2451DEFINE_ATTR_EVENT(xfs_attr_leaf_replace); 2452DEFINE_ATTR_EVENT(xfs_attr_leaf_remove); 2453DEFINE_ATTR_EVENT(xfs_attr_leaf_removename); 2454DEFINE_ATTR_EVENT(xfs_attr_leaf_split); 2455DEFINE_ATTR_EVENT(xfs_attr_leaf_split_before); 2456DEFINE_ATTR_EVENT(xfs_attr_leaf_split_after); 2457DEFINE_ATTR_EVENT(xfs_attr_leaf_clearflag); 2458DEFINE_ATTR_EVENT(xfs_attr_leaf_setflag); 2459DEFINE_ATTR_EVENT(xfs_attr_leaf_flipflags); 2460DEFINE_ATTR_EVENT(xfs_attr_leaf_to_sf); 2461DEFINE_ATTR_EVENT(xfs_attr_leaf_to_node); 2462DEFINE_ATTR_EVENT(xfs_attr_leaf_rebalance); 2463DEFINE_ATTR_EVENT(xfs_attr_leaf_unbalance); 2464DEFINE_ATTR_EVENT(xfs_attr_leaf_toosmall); 2465 2466DEFINE_ATTR_EVENT(xfs_attr_node_addname); 2467DEFINE_ATTR_EVENT(xfs_attr_node_get); 2468DEFINE_ATTR_EVENT(xfs_attr_node_replace); 2469 2470DEFINE_ATTR_EVENT(xfs_attr_rmtval_get); 2471 2472#define DEFINE_DA_EVENT(name) \ 2473DEFINE_EVENT(xfs_da_class, name, \ 2474 TP_PROTO(struct xfs_da_args *args), \ 2475 TP_ARGS(args)) 2476DEFINE_DA_EVENT(xfs_da_split); 2477DEFINE_DA_EVENT(xfs_da_join); 2478DEFINE_DA_EVENT(xfs_da_link_before); 2479DEFINE_DA_EVENT(xfs_da_link_after); 2480DEFINE_DA_EVENT(xfs_da_unlink_back); 2481DEFINE_DA_EVENT(xfs_da_unlink_forward); 2482DEFINE_DA_EVENT(xfs_da_root_split); 2483DEFINE_DA_EVENT(xfs_da_root_join); 2484DEFINE_DA_EVENT(xfs_da_node_add); 2485DEFINE_DA_EVENT(xfs_da_node_create); 2486DEFINE_DA_EVENT(xfs_da_node_split); 2487DEFINE_DA_EVENT(xfs_da_node_remove); 2488DEFINE_DA_EVENT(xfs_da_node_rebalance); 2489DEFINE_DA_EVENT(xfs_da_node_unbalance); 2490DEFINE_DA_EVENT(xfs_da_node_toosmall); 2491DEFINE_DA_EVENT(xfs_da_swap_lastblock); 2492DEFINE_DA_EVENT(xfs_da_grow_inode); 2493DEFINE_DA_EVENT(xfs_da_shrink_inode); 2494DEFINE_DA_EVENT(xfs_da_fixhashpath); 2495DEFINE_DA_EVENT(xfs_da_path_shift); 2496 2497DECLARE_EVENT_CLASS(xfs_dir2_space_class, 2498 TP_PROTO(struct xfs_da_args *args, int idx), 2499 TP_ARGS(args, idx), 2500 TP_STRUCT__entry( 2501 __field(dev_t, dev) 2502 __field(xfs_ino_t, ino) 2503 __field(uint32_t, op_flags) 2504 __field(int, idx) 2505 ), 2506 TP_fast_assign( 2507 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2508 __entry->ino = args->dp->i_ino; 2509 __entry->op_flags = args->op_flags; 2510 __entry->idx = idx; 2511 ), 2512 TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d", 2513 MAJOR(__entry->dev), MINOR(__entry->dev), 2514 __entry->ino, 2515 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2516 __entry->idx) 2517) 2518 2519#define DEFINE_DIR2_SPACE_EVENT(name) \ 2520DEFINE_EVENT(xfs_dir2_space_class, name, \ 2521 TP_PROTO(struct xfs_da_args *args, int idx), \ 2522 TP_ARGS(args, idx)) 2523DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add); 2524DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove); 2525DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode); 2526DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode); 2527 2528TRACE_EVENT(xfs_dir2_leafn_moveents, 2529 TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count), 2530 TP_ARGS(args, src_idx, dst_idx, count), 2531 TP_STRUCT__entry( 2532 __field(dev_t, dev) 2533 __field(xfs_ino_t, ino) 2534 __field(uint32_t, op_flags) 2535 __field(int, src_idx) 2536 __field(int, dst_idx) 2537 __field(int, count) 2538 ), 2539 TP_fast_assign( 2540 __entry->dev = VFS_I(args->dp)->i_sb->s_dev; 2541 __entry->ino = args->dp->i_ino; 2542 __entry->op_flags = args->op_flags; 2543 __entry->src_idx = src_idx; 2544 __entry->dst_idx = dst_idx; 2545 __entry->count = count; 2546 ), 2547 TP_printk("dev %d:%d ino 0x%llx op_flags %s " 2548 "src_idx %d dst_idx %d count %d", 2549 MAJOR(__entry->dev), MINOR(__entry->dev), 2550 __entry->ino, 2551 __print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), 2552 __entry->src_idx, 2553 __entry->dst_idx, 2554 __entry->count) 2555); 2556 2557#define XFS_SWAPEXT_INODES \ 2558 { 0, "target" }, \ 2559 { 1, "temp" } 2560 2561TRACE_DEFINE_ENUM(XFS_DINODE_FMT_DEV); 2562TRACE_DEFINE_ENUM(XFS_DINODE_FMT_LOCAL); 2563TRACE_DEFINE_ENUM(XFS_DINODE_FMT_EXTENTS); 2564TRACE_DEFINE_ENUM(XFS_DINODE_FMT_BTREE); 2565TRACE_DEFINE_ENUM(XFS_DINODE_FMT_UUID); 2566TRACE_DEFINE_ENUM(XFS_DINODE_FMT_META_BTREE); 2567 2568DECLARE_EVENT_CLASS(xfs_swap_extent_class, 2569 TP_PROTO(struct xfs_inode *ip, int which), 2570 TP_ARGS(ip, which), 2571 TP_STRUCT__entry( 2572 __field(dev_t, dev) 2573 __field(int, which) 2574 __field(xfs_ino_t, ino) 2575 __field(int, format) 2576 __field(xfs_extnum_t, nex) 2577 __field(int, broot_size) 2578 __field(int, fork_off) 2579 ), 2580 TP_fast_assign( 2581 __entry->dev = VFS_I(ip)->i_sb->s_dev; 2582 __entry->which = which; 2583 __entry->ino = ip->i_ino; 2584 __entry->format = ip->i_df.if_format; 2585 __entry->nex = ip->i_df.if_nextents; 2586 __entry->broot_size = ip->i_df.if_broot_bytes; 2587 __entry->fork_off = xfs_inode_fork_boff(ip); 2588 ), 2589 TP_printk("dev %d:%d ino 0x%llx (%s), %s format, num_extents %llu, " 2590 "broot size %d, forkoff 0x%x", 2591 MAJOR(__entry->dev), MINOR(__entry->dev), 2592 __entry->ino, 2593 __print_symbolic(__entry->which, XFS_SWAPEXT_INODES), 2594 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR), 2595 __entry->nex, 2596 __entry->broot_size, 2597 __entry->fork_off) 2598) 2599 2600#define DEFINE_SWAPEXT_EVENT(name) \ 2601DEFINE_EVENT(xfs_swap_extent_class, name, \ 2602 TP_PROTO(struct xfs_inode *ip, int which), \ 2603 TP_ARGS(ip, which)) 2604 2605DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before); 2606DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after); 2607 2608TRACE_EVENT(xfs_log_recover, 2609 TP_PROTO(struct xlog *log, xfs_daddr_t headblk, xfs_daddr_t tailblk), 2610 TP_ARGS(log, headblk, tailblk), 2611 TP_STRUCT__entry( 2612 __field(dev_t, dev) 2613 __field(xfs_daddr_t, headblk) 2614 __field(xfs_daddr_t, tailblk) 2615 ), 2616 TP_fast_assign( 2617 __entry->dev = log->l_mp->m_super->s_dev; 2618 __entry->headblk = headblk; 2619 __entry->tailblk = tailblk; 2620 ), 2621 TP_printk("dev %d:%d headblk 0x%llx tailblk 0x%llx", 2622 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->headblk, 2623 __entry->tailblk) 2624) 2625 2626TRACE_EVENT(xfs_log_recover_record, 2627 TP_PROTO(struct xlog *log, struct xlog_rec_header *rhead, int pass), 2628 TP_ARGS(log, rhead, pass), 2629 TP_STRUCT__entry( 2630 __field(dev_t, dev) 2631 __field(xfs_lsn_t, lsn) 2632 __field(int, len) 2633 __field(int, num_logops) 2634 __field(int, pass) 2635 ), 2636 TP_fast_assign( 2637 __entry->dev = log->l_mp->m_super->s_dev; 2638 __entry->lsn = be64_to_cpu(rhead->h_lsn); 2639 __entry->len = be32_to_cpu(rhead->h_len); 2640 __entry->num_logops = be32_to_cpu(rhead->h_num_logops); 2641 __entry->pass = pass; 2642 ), 2643 TP_printk("dev %d:%d lsn 0x%llx len 0x%x num_logops 0x%x pass %d", 2644 MAJOR(__entry->dev), MINOR(__entry->dev), 2645 __entry->lsn, __entry->len, __entry->num_logops, 2646 __entry->pass) 2647) 2648 2649DECLARE_EVENT_CLASS(xfs_log_recover_item_class, 2650 TP_PROTO(struct xlog *log, struct xlog_recover *trans, 2651 struct xlog_recover_item *item, int pass), 2652 TP_ARGS(log, trans, item, pass), 2653 TP_STRUCT__entry( 2654 __field(dev_t, dev) 2655 __field(unsigned long, item) 2656 __field(xlog_tid_t, tid) 2657 __field(xfs_lsn_t, lsn) 2658 __field(int, type) 2659 __field(int, pass) 2660 __field(int, count) 2661 __field(int, total) 2662 ), 2663 TP_fast_assign( 2664 __entry->dev = log->l_mp->m_super->s_dev; 2665 __entry->item = (unsigned long)item; 2666 __entry->tid = trans->r_log_tid; 2667 __entry->lsn = trans->r_lsn; 2668 __entry->type = ITEM_TYPE(item); 2669 __entry->pass = pass; 2670 __entry->count = item->ri_cnt; 2671 __entry->total = item->ri_total; 2672 ), 2673 TP_printk("dev %d:%d tid 0x%x lsn 0x%llx, pass %d, item %p, " 2674 "item type %s item region count/total %d/%d", 2675 MAJOR(__entry->dev), MINOR(__entry->dev), 2676 __entry->tid, 2677 __entry->lsn, 2678 __entry->pass, 2679 (void *)__entry->item, 2680 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC), 2681 __entry->count, 2682 __entry->total) 2683) 2684 2685#define DEFINE_LOG_RECOVER_ITEM(name) \ 2686DEFINE_EVENT(xfs_log_recover_item_class, name, \ 2687 TP_PROTO(struct xlog *log, struct xlog_recover *trans, \ 2688 struct xlog_recover_item *item, int pass), \ 2689 TP_ARGS(log, trans, item, pass)) 2690 2691DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add); 2692DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_add_cont); 2693DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_head); 2694DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail); 2695DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover); 2696 2697DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class, 2698 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), 2699 TP_ARGS(log, buf_f), 2700 TP_STRUCT__entry( 2701 __field(dev_t, dev) 2702 __field(int64_t, blkno) 2703 __field(unsigned short, len) 2704 __field(unsigned short, flags) 2705 __field(unsigned short, size) 2706 __field(unsigned int, map_size) 2707 ), 2708 TP_fast_assign( 2709 __entry->dev = log->l_mp->m_super->s_dev; 2710 __entry->blkno = buf_f->blf_blkno; 2711 __entry->len = buf_f->blf_len; 2712 __entry->flags = buf_f->blf_flags; 2713 __entry->size = buf_f->blf_size; 2714 __entry->map_size = buf_f->blf_map_size; 2715 ), 2716 TP_printk("dev %d:%d daddr 0x%llx, bbcount 0x%x, flags 0x%x, size %d, " 2717 "map_size %d", 2718 MAJOR(__entry->dev), MINOR(__entry->dev), 2719 __entry->blkno, 2720 __entry->len, 2721 __entry->flags, 2722 __entry->size, 2723 __entry->map_size) 2724) 2725 2726#define DEFINE_LOG_RECOVER_BUF_ITEM(name) \ 2727DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \ 2728 TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \ 2729 TP_ARGS(log, buf_f)) 2730 2731DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel); 2732DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel); 2733DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_add); 2734DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_cancel_ref_inc); 2735DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_recover); 2736DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_skip); 2737DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_inode_buf); 2738DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf); 2739DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf); 2740 2741DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class, 2742 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), 2743 TP_ARGS(log, in_f), 2744 TP_STRUCT__entry( 2745 __field(dev_t, dev) 2746 __field(xfs_ino_t, ino) 2747 __field(unsigned short, size) 2748 __field(int, fields) 2749 __field(unsigned short, asize) 2750 __field(unsigned short, dsize) 2751 __field(int64_t, blkno) 2752 __field(int, len) 2753 __field(int, boffset) 2754 ), 2755 TP_fast_assign( 2756 __entry->dev = log->l_mp->m_super->s_dev; 2757 __entry->ino = in_f->ilf_ino; 2758 __entry->size = in_f->ilf_size; 2759 __entry->fields = in_f->ilf_fields; 2760 __entry->asize = in_f->ilf_asize; 2761 __entry->dsize = in_f->ilf_dsize; 2762 __entry->blkno = in_f->ilf_blkno; 2763 __entry->len = in_f->ilf_len; 2764 __entry->boffset = in_f->ilf_boffset; 2765 ), 2766 TP_printk("dev %d:%d ino 0x%llx, size %u, fields 0x%x, asize %d, " 2767 "dsize %d, daddr 0x%llx, bbcount 0x%x, boffset %d", 2768 MAJOR(__entry->dev), MINOR(__entry->dev), 2769 __entry->ino, 2770 __entry->size, 2771 __entry->fields, 2772 __entry->asize, 2773 __entry->dsize, 2774 __entry->blkno, 2775 __entry->len, 2776 __entry->boffset) 2777) 2778#define DEFINE_LOG_RECOVER_INO_ITEM(name) \ 2779DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \ 2780 TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \ 2781 TP_ARGS(log, in_f)) 2782 2783DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover); 2784DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_cancel); 2785DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_skip); 2786 2787DECLARE_EVENT_CLASS(xfs_log_recover_icreate_item_class, 2788 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), 2789 TP_ARGS(log, in_f), 2790 TP_STRUCT__entry( 2791 __field(dev_t, dev) 2792 __field(xfs_agnumber_t, agno) 2793 __field(xfs_agblock_t, agbno) 2794 __field(unsigned int, count) 2795 __field(unsigned int, isize) 2796 __field(xfs_agblock_t, length) 2797 __field(unsigned int, gen) 2798 ), 2799 TP_fast_assign( 2800 __entry->dev = log->l_mp->m_super->s_dev; 2801 __entry->agno = be32_to_cpu(in_f->icl_ag); 2802 __entry->agbno = be32_to_cpu(in_f->icl_agbno); 2803 __entry->count = be32_to_cpu(in_f->icl_count); 2804 __entry->isize = be32_to_cpu(in_f->icl_isize); 2805 __entry->length = be32_to_cpu(in_f->icl_length); 2806 __entry->gen = be32_to_cpu(in_f->icl_gen); 2807 ), 2808 TP_printk("dev %d:%d agno 0x%x agbno 0x%x fsbcount 0x%x ireccount %u isize %u gen 0x%x", 2809 MAJOR(__entry->dev), MINOR(__entry->dev), 2810 __entry->agno, 2811 __entry->agbno, 2812 __entry->length, 2813 __entry->count, 2814 __entry->isize, 2815 __entry->gen) 2816) 2817#define DEFINE_LOG_RECOVER_ICREATE_ITEM(name) \ 2818DEFINE_EVENT(xfs_log_recover_icreate_item_class, name, \ 2819 TP_PROTO(struct xlog *log, struct xfs_icreate_log *in_f), \ 2820 TP_ARGS(log, in_f)) 2821 2822DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_cancel); 2823DEFINE_LOG_RECOVER_ICREATE_ITEM(xfs_log_recover_icreate_recover); 2824 2825DECLARE_EVENT_CLASS(xfs_discard_class, 2826 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, 2827 xfs_extlen_t len), 2828 TP_ARGS(xg, agbno, len), 2829 TP_STRUCT__entry( 2830 __field(dev_t, dev) 2831 __field(enum xfs_group_type, type) 2832 __field(xfs_agnumber_t, agno) 2833 __field(xfs_agblock_t, agbno) 2834 __field(xfs_extlen_t, len) 2835 ), 2836 TP_fast_assign( 2837 __entry->dev = xg->xg_mount->m_super->s_dev; 2838 __entry->type = xg->xg_type; 2839 __entry->agno = xg->xg_gno; 2840 __entry->agbno = agbno; 2841 __entry->len = len; 2842 ), 2843 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x", 2844 MAJOR(__entry->dev), MINOR(__entry->dev), 2845 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 2846 __entry->agno, 2847 __entry->agbno, 2848 __entry->len) 2849) 2850 2851#define DEFINE_DISCARD_EVENT(name) \ 2852DEFINE_EVENT(xfs_discard_class, name, \ 2853 TP_PROTO(const struct xfs_group *xg, xfs_agblock_t agbno, \ 2854 xfs_extlen_t len), \ 2855 TP_ARGS(xg, agbno, len)) 2856DEFINE_DISCARD_EVENT(xfs_discard_extent); 2857DEFINE_DISCARD_EVENT(xfs_discard_toosmall); 2858DEFINE_DISCARD_EVENT(xfs_discard_exclude); 2859DEFINE_DISCARD_EVENT(xfs_discard_busy); 2860 2861DECLARE_EVENT_CLASS(xfs_rtdiscard_class, 2862 TP_PROTO(struct xfs_mount *mp, 2863 xfs_rtblock_t rtbno, xfs_rtblock_t len), 2864 TP_ARGS(mp, rtbno, len), 2865 TP_STRUCT__entry( 2866 __field(dev_t, dev) 2867 __field(xfs_rtblock_t, rtbno) 2868 __field(xfs_rtblock_t, len) 2869 ), 2870 TP_fast_assign( 2871 __entry->dev = mp->m_rtdev_targp->bt_dev; 2872 __entry->rtbno = rtbno; 2873 __entry->len = len; 2874 ), 2875 TP_printk("dev %d:%d rtbno 0x%llx rtbcount 0x%llx", 2876 MAJOR(__entry->dev), MINOR(__entry->dev), 2877 __entry->rtbno, 2878 __entry->len) 2879) 2880 2881#define DEFINE_RTDISCARD_EVENT(name) \ 2882DEFINE_EVENT(xfs_rtdiscard_class, name, \ 2883 TP_PROTO(struct xfs_mount *mp, \ 2884 xfs_rtblock_t rtbno, xfs_rtblock_t len), \ 2885 TP_ARGS(mp, rtbno, len)) 2886DEFINE_RTDISCARD_EVENT(xfs_discard_rtextent); 2887DEFINE_RTDISCARD_EVENT(xfs_discard_rttoosmall); 2888 2889DECLARE_EVENT_CLASS(xfs_btree_cur_class, 2890 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), 2891 TP_ARGS(cur, level, bp), 2892 TP_STRUCT__entry( 2893 __field(dev_t, dev) 2894 __string(name, cur->bc_ops->name) 2895 __field(int, level) 2896 __field(int, nlevels) 2897 __field(int, ptr) 2898 __field(xfs_daddr_t, daddr) 2899 ), 2900 TP_fast_assign( 2901 __entry->dev = cur->bc_mp->m_super->s_dev; 2902 __assign_str(name); 2903 __entry->level = level; 2904 __entry->nlevels = cur->bc_nlevels; 2905 __entry->ptr = cur->bc_levels[level].ptr; 2906 __entry->daddr = bp ? xfs_buf_daddr(bp) : -1; 2907 ), 2908 TP_printk("dev %d:%d %sbt level %d/%d ptr %d daddr 0x%llx", 2909 MAJOR(__entry->dev), MINOR(__entry->dev), 2910 __get_str(name), 2911 __entry->level, 2912 __entry->nlevels, 2913 __entry->ptr, 2914 (unsigned long long)__entry->daddr) 2915) 2916 2917#define DEFINE_BTREE_CUR_EVENT(name) \ 2918DEFINE_EVENT(xfs_btree_cur_class, name, \ 2919 TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), \ 2920 TP_ARGS(cur, level, bp)) 2921DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys); 2922DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range); 2923 2924TRACE_EVENT(xfs_btree_alloc_block, 2925 TP_PROTO(struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr, int stat, 2926 int error), 2927 TP_ARGS(cur, ptr, stat, error), 2928 TP_STRUCT__entry( 2929 __field(dev_t, dev) 2930 __field(xfs_agnumber_t, agno) 2931 __field(xfs_ino_t, ino) 2932 __string(name, cur->bc_ops->name) 2933 __field(int, error) 2934 __field(xfs_agblock_t, agbno) 2935 ), 2936 TP_fast_assign( 2937 __entry->dev = cur->bc_mp->m_super->s_dev; 2938 switch (cur->bc_ops->type) { 2939 case XFS_BTREE_TYPE_INODE: 2940 __entry->agno = 0; 2941 __entry->ino = cur->bc_ino.ip->i_ino; 2942 break; 2943 case XFS_BTREE_TYPE_AG: 2944 __entry->agno = cur->bc_group->xg_gno; 2945 __entry->ino = 0; 2946 break; 2947 case XFS_BTREE_TYPE_MEM: 2948 __entry->agno = 0; 2949 __entry->ino = 0; 2950 break; 2951 } 2952 __assign_str(name); 2953 __entry->error = error; 2954 if (!error && stat) { 2955 if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN) { 2956 xfs_fsblock_t fsb = be64_to_cpu(ptr->l); 2957 2958 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, 2959 fsb); 2960 __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, 2961 fsb); 2962 } else { 2963 __entry->agbno = be32_to_cpu(ptr->s); 2964 } 2965 } else { 2966 __entry->agbno = NULLAGBLOCK; 2967 } 2968 ), 2969 TP_printk("dev %d:%d %sbt agno 0x%x ino 0x%llx agbno 0x%x error %d", 2970 MAJOR(__entry->dev), MINOR(__entry->dev), 2971 __get_str(name), 2972 __entry->agno, 2973 __entry->ino, 2974 __entry->agbno, 2975 __entry->error) 2976); 2977 2978TRACE_EVENT(xfs_btree_free_block, 2979 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_buf *bp), 2980 TP_ARGS(cur, bp), 2981 TP_STRUCT__entry( 2982 __field(dev_t, dev) 2983 __field(xfs_agnumber_t, agno) 2984 __field(xfs_ino_t, ino) 2985 __string(name, cur->bc_ops->name) 2986 __field(xfs_agblock_t, agbno) 2987 ), 2988 TP_fast_assign( 2989 __entry->dev = cur->bc_mp->m_super->s_dev; 2990 __entry->agno = xfs_daddr_to_agno(cur->bc_mp, 2991 xfs_buf_daddr(bp)); 2992 if (cur->bc_ops->type == XFS_BTREE_TYPE_INODE) 2993 __entry->ino = cur->bc_ino.ip->i_ino; 2994 else 2995 __entry->ino = 0; 2996 __assign_str(name); 2997 __entry->agbno = xfs_daddr_to_agbno(cur->bc_mp, 2998 xfs_buf_daddr(bp)); 2999 ), 3000 TP_printk("dev %d:%d %sbt agno 0x%x ino 0x%llx agbno 0x%x", 3001 MAJOR(__entry->dev), MINOR(__entry->dev), 3002 __get_str(name), 3003 __entry->agno, 3004 __entry->ino, 3005 __entry->agbno) 3006); 3007 3008/* deferred ops */ 3009struct xfs_defer_pending; 3010 3011DECLARE_EVENT_CLASS(xfs_defer_class, 3012 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 3013 TP_ARGS(tp, caller_ip), 3014 TP_STRUCT__entry( 3015 __field(dev_t, dev) 3016 __field(struct xfs_trans *, tp) 3017 __field(char, committed) 3018 __field(unsigned long, caller_ip) 3019 ), 3020 TP_fast_assign( 3021 __entry->dev = tp->t_mountp->m_super->s_dev; 3022 __entry->tp = tp; 3023 __entry->caller_ip = caller_ip; 3024 ), 3025 TP_printk("dev %d:%d tp %p caller %pS", 3026 MAJOR(__entry->dev), MINOR(__entry->dev), 3027 __entry->tp, 3028 (char *)__entry->caller_ip) 3029) 3030#define DEFINE_DEFER_EVENT(name) \ 3031DEFINE_EVENT(xfs_defer_class, name, \ 3032 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 3033 TP_ARGS(tp, caller_ip)) 3034 3035DECLARE_EVENT_CLASS(xfs_defer_error_class, 3036 TP_PROTO(struct xfs_trans *tp, int error), 3037 TP_ARGS(tp, error), 3038 TP_STRUCT__entry( 3039 __field(dev_t, dev) 3040 __field(struct xfs_trans *, tp) 3041 __field(char, committed) 3042 __field(int, error) 3043 ), 3044 TP_fast_assign( 3045 __entry->dev = tp->t_mountp->m_super->s_dev; 3046 __entry->tp = tp; 3047 __entry->error = error; 3048 ), 3049 TP_printk("dev %d:%d tp %p err %d", 3050 MAJOR(__entry->dev), MINOR(__entry->dev), 3051 __entry->tp, 3052 __entry->error) 3053) 3054#define DEFINE_DEFER_ERROR_EVENT(name) \ 3055DEFINE_EVENT(xfs_defer_error_class, name, \ 3056 TP_PROTO(struct xfs_trans *tp, int error), \ 3057 TP_ARGS(tp, error)) 3058 3059DECLARE_EVENT_CLASS(xfs_defer_pending_class, 3060 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), 3061 TP_ARGS(mp, dfp), 3062 TP_STRUCT__entry( 3063 __field(dev_t, dev) 3064 __string(name, dfp->dfp_ops->name) 3065 __field(void *, intent) 3066 __field(unsigned int, flags) 3067 __field(char, committed) 3068 __field(int, nr) 3069 ), 3070 TP_fast_assign( 3071 __entry->dev = mp ? mp->m_super->s_dev : 0; 3072 __assign_str(name); 3073 __entry->intent = dfp->dfp_intent; 3074 __entry->flags = dfp->dfp_flags; 3075 __entry->committed = dfp->dfp_done != NULL; 3076 __entry->nr = dfp->dfp_count; 3077 ), 3078 TP_printk("dev %d:%d optype %s intent %p flags %s committed %d nr %d", 3079 MAJOR(__entry->dev), MINOR(__entry->dev), 3080 __get_str(name), 3081 __entry->intent, 3082 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 3083 __entry->committed, 3084 __entry->nr) 3085) 3086#define DEFINE_DEFER_PENDING_EVENT(name) \ 3087DEFINE_EVENT(xfs_defer_pending_class, name, \ 3088 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \ 3089 TP_ARGS(mp, dfp)) 3090 3091DEFINE_DEFER_EVENT(xfs_defer_cancel); 3092DEFINE_DEFER_EVENT(xfs_defer_trans_roll); 3093DEFINE_DEFER_EVENT(xfs_defer_trans_abort); 3094DEFINE_DEFER_EVENT(xfs_defer_finish); 3095DEFINE_DEFER_EVENT(xfs_defer_finish_done); 3096 3097DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error); 3098DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error); 3099 3100DEFINE_DEFER_PENDING_EVENT(xfs_defer_create_intent); 3101DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list); 3102DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish); 3103DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort); 3104DEFINE_DEFER_PENDING_EVENT(xfs_defer_relog_intent); 3105DEFINE_DEFER_PENDING_EVENT(xfs_defer_isolate_paused); 3106DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_pause); 3107DEFINE_DEFER_PENDING_EVENT(xfs_defer_item_unpause); 3108 3109DECLARE_EVENT_CLASS(xfs_free_extent_deferred_class, 3110 TP_PROTO(struct xfs_mount *mp, struct xfs_extent_free_item *free), 3111 TP_ARGS(mp, free), 3112 TP_STRUCT__entry( 3113 __field(dev_t, dev) 3114 __field(enum xfs_group_type, type) 3115 __field(xfs_agnumber_t, agno) 3116 __field(xfs_agblock_t, agbno) 3117 __field(xfs_extlen_t, len) 3118 __field(unsigned int, flags) 3119 ), 3120 TP_fast_assign( 3121 __entry->dev = mp->m_super->s_dev; 3122 __entry->type = free->xefi_group->xg_type; 3123 __entry->agno = free->xefi_group->xg_gno; 3124 __entry->agbno = xfs_fsb_to_gbno(mp, free->xefi_startblock, 3125 free->xefi_group->xg_type); 3126 __entry->len = free->xefi_blockcount; 3127 __entry->flags = free->xefi_flags; 3128 ), 3129 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x flags 0x%x", 3130 MAJOR(__entry->dev), MINOR(__entry->dev), 3131 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3132 __entry->agno, 3133 __entry->agbno, 3134 __entry->len, 3135 __entry->flags) 3136); 3137#define DEFINE_FREE_EXTENT_DEFERRED_EVENT(name) \ 3138DEFINE_EVENT(xfs_free_extent_deferred_class, name, \ 3139 TP_PROTO(struct xfs_mount *mp, struct xfs_extent_free_item *free), \ 3140 TP_ARGS(mp, free)) 3141DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_agfl_free_deferred); 3142DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_extent_free_defer); 3143DEFINE_FREE_EXTENT_DEFERRED_EVENT(xfs_extent_free_deferred); 3144 3145DECLARE_EVENT_CLASS(xfs_defer_pending_item_class, 3146 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, 3147 void *item), 3148 TP_ARGS(mp, dfp, item), 3149 TP_STRUCT__entry( 3150 __field(dev_t, dev) 3151 __string(name, dfp->dfp_ops->name) 3152 __field(void *, intent) 3153 __field(void *, item) 3154 __field(char, committed) 3155 __field(unsigned int, flags) 3156 __field(int, nr) 3157 ), 3158 TP_fast_assign( 3159 __entry->dev = mp ? mp->m_super->s_dev : 0; 3160 __assign_str(name); 3161 __entry->intent = dfp->dfp_intent; 3162 __entry->item = item; 3163 __entry->committed = dfp->dfp_done != NULL; 3164 __entry->flags = dfp->dfp_flags; 3165 __entry->nr = dfp->dfp_count; 3166 ), 3167 TP_printk("dev %d:%d optype %s intent %p item %p flags %s committed %d nr %d", 3168 MAJOR(__entry->dev), MINOR(__entry->dev), 3169 __get_str(name), 3170 __entry->intent, 3171 __entry->item, 3172 __print_flags(__entry->flags, "|", XFS_DEFER_PENDING_STRINGS), 3173 __entry->committed, 3174 __entry->nr) 3175) 3176#define DEFINE_DEFER_PENDING_ITEM_EVENT(name) \ 3177DEFINE_EVENT(xfs_defer_pending_item_class, name, \ 3178 TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp, \ 3179 void *item), \ 3180 TP_ARGS(mp, dfp, item)) 3181 3182DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_add_item); 3183DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_cancel_item); 3184DEFINE_DEFER_PENDING_ITEM_EVENT(xfs_defer_finish_item); 3185 3186/* rmap tracepoints */ 3187DECLARE_EVENT_CLASS(xfs_rmap_class, 3188 TP_PROTO(struct xfs_btree_cur *cur, 3189 xfs_agblock_t gbno, xfs_extlen_t len, bool unwritten, 3190 const struct xfs_owner_info *oinfo), 3191 TP_ARGS(cur, gbno, len, unwritten, oinfo), 3192 TP_STRUCT__entry( 3193 __field(dev_t, dev) 3194 __field(enum xfs_group_type, type) 3195 __field(xfs_agnumber_t, agno) 3196 __field(xfs_agblock_t, gbno) 3197 __field(xfs_extlen_t, len) 3198 __field(uint64_t, owner) 3199 __field(uint64_t, offset) 3200 __field(unsigned long, flags) 3201 ), 3202 TP_fast_assign( 3203 __entry->dev = cur->bc_mp->m_super->s_dev; 3204 __entry->type = cur->bc_group->xg_type; 3205 __entry->agno = cur->bc_group->xg_gno; 3206 __entry->gbno = gbno; 3207 __entry->len = len; 3208 __entry->owner = oinfo->oi_owner; 3209 __entry->offset = oinfo->oi_offset; 3210 __entry->flags = oinfo->oi_flags; 3211 if (unwritten) 3212 __entry->flags |= XFS_RMAP_UNWRITTEN; 3213 ), 3214 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%lx", 3215 MAJOR(__entry->dev), MINOR(__entry->dev), 3216 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3217 __entry->agno, 3218 __entry->gbno, 3219 __entry->len, 3220 __entry->owner, 3221 __entry->offset, 3222 __entry->flags) 3223); 3224#define DEFINE_RMAP_EVENT(name) \ 3225DEFINE_EVENT(xfs_rmap_class, name, \ 3226 TP_PROTO(struct xfs_btree_cur *cur, \ 3227 xfs_agblock_t gbno, xfs_extlen_t len, bool unwritten, \ 3228 const struct xfs_owner_info *oinfo), \ 3229 TP_ARGS(cur, gbno, len, unwritten, oinfo)) 3230 3231/* btree cursor error/%ip tracepoint class */ 3232DECLARE_EVENT_CLASS(xfs_btree_error_class, 3233 TP_PROTO(struct xfs_btree_cur *cur, int error, 3234 unsigned long caller_ip), 3235 TP_ARGS(cur, error, caller_ip), 3236 TP_STRUCT__entry( 3237 __field(dev_t, dev) 3238 __field(xfs_agnumber_t, agno) 3239 __field(xfs_ino_t, ino) 3240 __field(int, error) 3241 __field(unsigned long, caller_ip) 3242 ), 3243 TP_fast_assign( 3244 __entry->dev = cur->bc_mp->m_super->s_dev; 3245 switch (cur->bc_ops->type) { 3246 case XFS_BTREE_TYPE_INODE: 3247 __entry->agno = 0; 3248 __entry->ino = cur->bc_ino.ip->i_ino; 3249 break; 3250 case XFS_BTREE_TYPE_AG: 3251 __entry->agno = cur->bc_group->xg_gno; 3252 __entry->ino = 0; 3253 break; 3254 case XFS_BTREE_TYPE_MEM: 3255 __entry->agno = 0; 3256 __entry->ino = 0; 3257 break; 3258 } 3259 __entry->error = error; 3260 __entry->caller_ip = caller_ip; 3261 ), 3262 TP_printk("dev %d:%d agno 0x%x ino 0x%llx error %d caller %pS", 3263 MAJOR(__entry->dev), MINOR(__entry->dev), 3264 __entry->agno, 3265 __entry->ino, 3266 __entry->error, 3267 (char *)__entry->caller_ip) 3268); 3269 3270#define DEFINE_BTREE_ERROR_EVENT(name) \ 3271DEFINE_EVENT(xfs_btree_error_class, name, \ 3272 TP_PROTO(struct xfs_btree_cur *cur, int error, \ 3273 unsigned long caller_ip), \ 3274 TP_ARGS(cur, error, caller_ip)) 3275 3276DEFINE_RMAP_EVENT(xfs_rmap_unmap); 3277DEFINE_RMAP_EVENT(xfs_rmap_unmap_done); 3278DEFINE_BTREE_ERROR_EVENT(xfs_rmap_unmap_error); 3279DEFINE_RMAP_EVENT(xfs_rmap_map); 3280DEFINE_RMAP_EVENT(xfs_rmap_map_done); 3281DEFINE_BTREE_ERROR_EVENT(xfs_rmap_map_error); 3282DEFINE_RMAP_EVENT(xfs_rmap_convert); 3283DEFINE_RMAP_EVENT(xfs_rmap_convert_done); 3284DEFINE_BTREE_ERROR_EVENT(xfs_rmap_convert_error); 3285 3286TRACE_EVENT(xfs_rmap_convert_state, 3287 TP_PROTO(struct xfs_btree_cur *cur, int state, 3288 unsigned long caller_ip), 3289 TP_ARGS(cur, state, caller_ip), 3290 TP_STRUCT__entry( 3291 __field(dev_t, dev) 3292 __field(enum xfs_group_type, type) 3293 __field(xfs_agnumber_t, agno) 3294 __field(int, state) 3295 __field(unsigned long, caller_ip) 3296 ), 3297 TP_fast_assign( 3298 __entry->dev = cur->bc_mp->m_super->s_dev; 3299 __entry->type = cur->bc_group->xg_type; 3300 __entry->agno = cur->bc_group->xg_gno; 3301 __entry->state = state; 3302 __entry->caller_ip = caller_ip; 3303 ), 3304 TP_printk("dev %d:%d %sno 0x%x state %d caller %pS", 3305 MAJOR(__entry->dev), MINOR(__entry->dev), 3306 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3307 __entry->agno, 3308 __entry->state, 3309 (char *)__entry->caller_ip) 3310); 3311 3312DECLARE_EVENT_CLASS(xfs_rmapbt_class, 3313 TP_PROTO(struct xfs_btree_cur *cur, 3314 xfs_agblock_t gbno, xfs_extlen_t len, 3315 uint64_t owner, uint64_t offset, unsigned int flags), 3316 TP_ARGS(cur, gbno, len, owner, offset, flags), 3317 TP_STRUCT__entry( 3318 __field(dev_t, dev) 3319 __field(enum xfs_group_type, type) 3320 __field(xfs_agnumber_t, agno) 3321 __field(xfs_agblock_t, gbno) 3322 __field(xfs_extlen_t, len) 3323 __field(uint64_t, owner) 3324 __field(uint64_t, offset) 3325 __field(unsigned int, flags) 3326 ), 3327 TP_fast_assign( 3328 __entry->dev = cur->bc_mp->m_super->s_dev; 3329 __entry->type = cur->bc_group->xg_type; 3330 __entry->agno = cur->bc_group->xg_gno; 3331 __entry->gbno = gbno; 3332 __entry->len = len; 3333 __entry->owner = owner; 3334 __entry->offset = offset; 3335 __entry->flags = flags; 3336 ), 3337 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 3338 MAJOR(__entry->dev), MINOR(__entry->dev), 3339 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3340 __entry->agno, 3341 __entry->gbno, 3342 __entry->len, 3343 __entry->owner, 3344 __entry->offset, 3345 __entry->flags) 3346); 3347#define DEFINE_RMAPBT_EVENT(name) \ 3348DEFINE_EVENT(xfs_rmapbt_class, name, \ 3349 TP_PROTO(struct xfs_btree_cur *cur, \ 3350 xfs_agblock_t gbno, xfs_extlen_t len, \ 3351 uint64_t owner, uint64_t offset, unsigned int flags), \ 3352 TP_ARGS(cur, gbno, len, owner, offset, flags)) 3353 3354TRACE_DEFINE_ENUM(XFS_RMAP_MAP); 3355TRACE_DEFINE_ENUM(XFS_RMAP_MAP_SHARED); 3356TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP); 3357TRACE_DEFINE_ENUM(XFS_RMAP_UNMAP_SHARED); 3358TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT); 3359TRACE_DEFINE_ENUM(XFS_RMAP_CONVERT_SHARED); 3360TRACE_DEFINE_ENUM(XFS_RMAP_ALLOC); 3361TRACE_DEFINE_ENUM(XFS_RMAP_FREE); 3362 3363DECLARE_EVENT_CLASS(xfs_rmap_deferred_class, 3364 TP_PROTO(struct xfs_mount *mp, struct xfs_rmap_intent *ri), 3365 TP_ARGS(mp, ri), 3366 TP_STRUCT__entry( 3367 __field(dev_t, dev) 3368 __field(unsigned long long, owner) 3369 __field(enum xfs_group_type, type) 3370 __field(xfs_agnumber_t, agno) 3371 __field(xfs_agblock_t, gbno) 3372 __field(int, whichfork) 3373 __field(xfs_fileoff_t, l_loff) 3374 __field(xfs_filblks_t, l_len) 3375 __field(xfs_exntst_t, l_state) 3376 __field(int, op) 3377 ), 3378 TP_fast_assign( 3379 __entry->dev = mp->m_super->s_dev; 3380 __entry->type = ri->ri_group->xg_type; 3381 __entry->agno = ri->ri_group->xg_gno; 3382 __entry->gbno = xfs_fsb_to_gbno(mp, 3383 ri->ri_bmap.br_startblock, 3384 ri->ri_group->xg_type); 3385 __entry->owner = ri->ri_owner; 3386 __entry->whichfork = ri->ri_whichfork; 3387 __entry->l_loff = ri->ri_bmap.br_startoff; 3388 __entry->l_len = ri->ri_bmap.br_blockcount; 3389 __entry->l_state = ri->ri_bmap.br_state; 3390 __entry->op = ri->ri_type; 3391 ), 3392 TP_printk("dev %d:%d op %s %sno 0x%x gbno 0x%x owner 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", 3393 MAJOR(__entry->dev), MINOR(__entry->dev), 3394 __print_symbolic(__entry->op, XFS_RMAP_INTENT_STRINGS), 3395 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3396 __entry->agno, 3397 __entry->gbno, 3398 __entry->owner, 3399 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 3400 __entry->l_loff, 3401 __entry->l_len, 3402 __entry->l_state) 3403); 3404#define DEFINE_RMAP_DEFERRED_EVENT(name) \ 3405DEFINE_EVENT(xfs_rmap_deferred_class, name, \ 3406 TP_PROTO(struct xfs_mount *mp, struct xfs_rmap_intent *ri), \ 3407 TP_ARGS(mp, ri)) 3408DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer); 3409DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred); 3410 3411DEFINE_RMAPBT_EVENT(xfs_rmap_update); 3412DEFINE_RMAPBT_EVENT(xfs_rmap_insert); 3413DEFINE_RMAPBT_EVENT(xfs_rmap_delete); 3414DEFINE_BTREE_ERROR_EVENT(xfs_rmap_insert_error); 3415DEFINE_BTREE_ERROR_EVENT(xfs_rmap_delete_error); 3416DEFINE_BTREE_ERROR_EVENT(xfs_rmap_update_error); 3417 3418DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_candidate); 3419DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_query); 3420DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_candidate); 3421DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range); 3422DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_result); 3423DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result); 3424DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_result); 3425 3426/* deferred bmbt updates */ 3427TRACE_DEFINE_ENUM(XFS_BMAP_MAP); 3428TRACE_DEFINE_ENUM(XFS_BMAP_UNMAP); 3429 3430DECLARE_EVENT_CLASS(xfs_bmap_deferred_class, 3431 TP_PROTO(struct xfs_bmap_intent *bi), 3432 TP_ARGS(bi), 3433 TP_STRUCT__entry( 3434 __field(dev_t, dev) 3435 __field(enum xfs_group_type, type) 3436 __field(xfs_agnumber_t, agno) 3437 __field(xfs_ino_t, ino) 3438 __field(unsigned long long, gbno) 3439 __field(int, whichfork) 3440 __field(xfs_fileoff_t, l_loff) 3441 __field(xfs_filblks_t, l_len) 3442 __field(xfs_exntst_t, l_state) 3443 __field(int, op) 3444 ), 3445 TP_fast_assign( 3446 struct xfs_inode *ip = bi->bi_owner; 3447 struct xfs_mount *mp = ip->i_mount; 3448 3449 __entry->dev = mp->m_super->s_dev; 3450 __entry->type = bi->bi_group->xg_type; 3451 __entry->agno = bi->bi_group->xg_gno; 3452 if (bi->bi_group->xg_type == XG_TYPE_RTG && 3453 !xfs_has_rtgroups(mp)) { 3454 /* 3455 * Legacy rt filesystems do not have allocation groups 3456 * ondisk. We emulate this incore with one gigantic 3457 * rtgroup whose size can exceed a 32-bit block number. 3458 * For this tracepoint, we report group 0 and a 64-bit 3459 * group block number. 3460 */ 3461 __entry->gbno = bi->bi_bmap.br_startblock; 3462 } else { 3463 __entry->gbno = xfs_fsb_to_gbno(mp, 3464 bi->bi_bmap.br_startblock, 3465 bi->bi_group->xg_type); 3466 } 3467 __entry->ino = ip->i_ino; 3468 __entry->whichfork = bi->bi_whichfork; 3469 __entry->l_loff = bi->bi_bmap.br_startoff; 3470 __entry->l_len = bi->bi_bmap.br_blockcount; 3471 __entry->l_state = bi->bi_bmap.br_state; 3472 __entry->op = bi->bi_type; 3473 ), 3474 TP_printk("dev %d:%d op %s ino 0x%llx %sno 0x%x gbno 0x%llx %s fileoff 0x%llx fsbcount 0x%llx state %d", 3475 MAJOR(__entry->dev), MINOR(__entry->dev), 3476 __print_symbolic(__entry->op, XFS_BMAP_INTENT_STRINGS), 3477 __entry->ino, 3478 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3479 __entry->agno, 3480 __entry->gbno, 3481 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 3482 __entry->l_loff, 3483 __entry->l_len, 3484 __entry->l_state) 3485); 3486#define DEFINE_BMAP_DEFERRED_EVENT(name) \ 3487DEFINE_EVENT(xfs_bmap_deferred_class, name, \ 3488 TP_PROTO(struct xfs_bmap_intent *bi), \ 3489 TP_ARGS(bi)) 3490DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_defer); 3491DEFINE_BMAP_DEFERRED_EVENT(xfs_bmap_deferred); 3492 3493/* per-AG reservation */ 3494DECLARE_EVENT_CLASS(xfs_ag_resv_class, 3495 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type resv, 3496 xfs_extlen_t len), 3497 TP_ARGS(pag, resv, len), 3498 TP_STRUCT__entry( 3499 __field(dev_t, dev) 3500 __field(xfs_agnumber_t, agno) 3501 __field(int, resv) 3502 __field(xfs_extlen_t, freeblks) 3503 __field(xfs_extlen_t, flcount) 3504 __field(xfs_extlen_t, reserved) 3505 __field(xfs_extlen_t, asked) 3506 __field(xfs_extlen_t, len) 3507 ), 3508 TP_fast_assign( 3509 struct xfs_ag_resv *r = xfs_perag_resv(pag, resv); 3510 3511 __entry->dev = pag_mount(pag)->m_super->s_dev; 3512 __entry->agno = pag_agno(pag); 3513 __entry->resv = resv; 3514 __entry->freeblks = pag->pagf_freeblks; 3515 __entry->flcount = pag->pagf_flcount; 3516 __entry->reserved = r ? r->ar_reserved : 0; 3517 __entry->asked = r ? r->ar_asked : 0; 3518 __entry->len = len; 3519 ), 3520 TP_printk("dev %d:%d agno 0x%x resv %d freeblks %u flcount %u " 3521 "resv %u ask %u len %u", 3522 MAJOR(__entry->dev), MINOR(__entry->dev), 3523 __entry->agno, 3524 __entry->resv, 3525 __entry->freeblks, 3526 __entry->flcount, 3527 __entry->reserved, 3528 __entry->asked, 3529 __entry->len) 3530) 3531#define DEFINE_AG_RESV_EVENT(name) \ 3532DEFINE_EVENT(xfs_ag_resv_class, name, \ 3533 TP_PROTO(struct xfs_perag *pag, enum xfs_ag_resv_type type, \ 3534 xfs_extlen_t len), \ 3535 TP_ARGS(pag, type, len)) 3536 3537/* per-AG reservation tracepoints */ 3538DEFINE_AG_RESV_EVENT(xfs_ag_resv_init); 3539DEFINE_AG_RESV_EVENT(xfs_ag_resv_free); 3540DEFINE_AG_RESV_EVENT(xfs_ag_resv_alloc_extent); 3541DEFINE_AG_RESV_EVENT(xfs_ag_resv_free_extent); 3542DEFINE_AG_RESV_EVENT(xfs_ag_resv_critical); 3543DEFINE_AG_RESV_EVENT(xfs_ag_resv_needed); 3544 3545TRACE_EVENT(xfs_ag_resv_init_error, 3546 TP_PROTO(const struct xfs_perag *pag, int error, 3547 unsigned long caller_ip), 3548 TP_ARGS(pag, error, caller_ip), 3549 TP_STRUCT__entry( 3550 __field(dev_t, dev) 3551 __field(xfs_agnumber_t, agno) 3552 __field(int, error) 3553 __field(unsigned long, caller_ip) 3554 ), 3555 TP_fast_assign( 3556 __entry->dev = pag_mount(pag)->m_super->s_dev; 3557 __entry->agno = pag_agno(pag); 3558 __entry->error = error; 3559 __entry->caller_ip = caller_ip; 3560 ), 3561 TP_printk("dev %d:%d agno 0x%x error %d caller %pS", 3562 MAJOR(__entry->dev), MINOR(__entry->dev), 3563 __entry->agno, 3564 __entry->error, 3565 (char *)__entry->caller_ip) 3566); 3567 3568/* refcount tracepoint classes */ 3569 3570DECLARE_EVENT_CLASS(xfs_refcount_class, 3571 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, 3572 xfs_extlen_t len), 3573 TP_ARGS(cur, gbno, len), 3574 TP_STRUCT__entry( 3575 __field(dev_t, dev) 3576 __field(enum xfs_group_type, type) 3577 __field(xfs_agnumber_t, agno) 3578 __field(xfs_agblock_t, gbno) 3579 __field(xfs_extlen_t, len) 3580 ), 3581 TP_fast_assign( 3582 __entry->dev = cur->bc_mp->m_super->s_dev; 3583 __entry->type = cur->bc_group->xg_type; 3584 __entry->agno = cur->bc_group->xg_gno; 3585 __entry->gbno = gbno; 3586 __entry->len = len; 3587 ), 3588 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x fsbcount 0x%x", 3589 MAJOR(__entry->dev), MINOR(__entry->dev), 3590 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3591 __entry->agno, 3592 __entry->gbno, 3593 __entry->len) 3594); 3595#define DEFINE_REFCOUNT_EVENT(name) \ 3596DEFINE_EVENT(xfs_refcount_class, name, \ 3597 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, \ 3598 xfs_extlen_t len), \ 3599 TP_ARGS(cur, gbno, len)) 3600 3601TRACE_DEFINE_ENUM(XFS_LOOKUP_EQi); 3602TRACE_DEFINE_ENUM(XFS_LOOKUP_LEi); 3603TRACE_DEFINE_ENUM(XFS_LOOKUP_GEi); 3604TRACE_EVENT(xfs_refcount_lookup, 3605 TP_PROTO(struct xfs_btree_cur *cur, xfs_agblock_t gbno, 3606 xfs_lookup_t dir), 3607 TP_ARGS(cur, gbno, dir), 3608 TP_STRUCT__entry( 3609 __field(dev_t, dev) 3610 __field(enum xfs_group_type, type) 3611 __field(xfs_agnumber_t, agno) 3612 __field(xfs_agblock_t, gbno) 3613 __field(xfs_lookup_t, dir) 3614 ), 3615 TP_fast_assign( 3616 __entry->dev = cur->bc_mp->m_super->s_dev; 3617 __entry->type = cur->bc_group->xg_type; 3618 __entry->agno = cur->bc_group->xg_gno; 3619 __entry->gbno = gbno; 3620 __entry->dir = dir; 3621 ), 3622 TP_printk("dev %d:%d %sno 0x%x gbno 0x%x cmp %s(%d)", 3623 MAJOR(__entry->dev), MINOR(__entry->dev), 3624 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3625 __entry->agno, 3626 __entry->gbno, 3627 __print_symbolic(__entry->dir, XFS_AG_BTREE_CMP_FORMAT_STR), 3628 __entry->dir) 3629) 3630 3631/* single-rcext tracepoint class */ 3632DECLARE_EVENT_CLASS(xfs_refcount_extent_class, 3633 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec), 3634 TP_ARGS(cur, irec), 3635 TP_STRUCT__entry( 3636 __field(dev_t, dev) 3637 __field(enum xfs_group_type, type) 3638 __field(xfs_agnumber_t, agno) 3639 __field(enum xfs_refc_domain, domain) 3640 __field(xfs_agblock_t, startblock) 3641 __field(xfs_extlen_t, blockcount) 3642 __field(xfs_nlink_t, refcount) 3643 ), 3644 TP_fast_assign( 3645 __entry->dev = cur->bc_mp->m_super->s_dev; 3646 __entry->type = cur->bc_group->xg_type; 3647 __entry->agno = cur->bc_group->xg_gno; 3648 __entry->domain = irec->rc_domain; 3649 __entry->startblock = irec->rc_startblock; 3650 __entry->blockcount = irec->rc_blockcount; 3651 __entry->refcount = irec->rc_refcount; 3652 ), 3653 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3654 MAJOR(__entry->dev), MINOR(__entry->dev), 3655 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3656 __entry->agno, 3657 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3658 __entry->startblock, 3659 __entry->blockcount, 3660 __entry->refcount) 3661) 3662 3663#define DEFINE_REFCOUNT_EXTENT_EVENT(name) \ 3664DEFINE_EVENT(xfs_refcount_extent_class, name, \ 3665 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec), \ 3666 TP_ARGS(cur, irec)) 3667 3668/* single-rcext and an agbno tracepoint class */ 3669DECLARE_EVENT_CLASS(xfs_refcount_extent_at_class, 3670 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec, 3671 xfs_agblock_t gbno), 3672 TP_ARGS(cur, irec, gbno), 3673 TP_STRUCT__entry( 3674 __field(dev_t, dev) 3675 __field(enum xfs_group_type, type) 3676 __field(xfs_agnumber_t, agno) 3677 __field(enum xfs_refc_domain, domain) 3678 __field(xfs_agblock_t, startblock) 3679 __field(xfs_extlen_t, blockcount) 3680 __field(xfs_nlink_t, refcount) 3681 __field(xfs_agblock_t, gbno) 3682 ), 3683 TP_fast_assign( 3684 __entry->dev = cur->bc_mp->m_super->s_dev; 3685 __entry->type = cur->bc_group->xg_type; 3686 __entry->agno = cur->bc_group->xg_gno; 3687 __entry->domain = irec->rc_domain; 3688 __entry->startblock = irec->rc_startblock; 3689 __entry->blockcount = irec->rc_blockcount; 3690 __entry->refcount = irec->rc_refcount; 3691 __entry->gbno = gbno; 3692 ), 3693 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u @ gbno 0x%x", 3694 MAJOR(__entry->dev), MINOR(__entry->dev), 3695 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3696 __entry->agno, 3697 __print_symbolic(__entry->domain, XFS_REFC_DOMAIN_STRINGS), 3698 __entry->startblock, 3699 __entry->blockcount, 3700 __entry->refcount, 3701 __entry->gbno) 3702) 3703 3704#define DEFINE_REFCOUNT_EXTENT_AT_EVENT(name) \ 3705DEFINE_EVENT(xfs_refcount_extent_at_class, name, \ 3706 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *irec, \ 3707 xfs_agblock_t gbno), \ 3708 TP_ARGS(cur, irec, gbno)) 3709 3710/* double-rcext tracepoint class */ 3711DECLARE_EVENT_CLASS(xfs_refcount_double_extent_class, 3712 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3713 struct xfs_refcount_irec *i2), 3714 TP_ARGS(cur, i1, i2), 3715 TP_STRUCT__entry( 3716 __field(dev_t, dev) 3717 __field(enum xfs_group_type, type) 3718 __field(xfs_agnumber_t, agno) 3719 __field(enum xfs_refc_domain, i1_domain) 3720 __field(xfs_agblock_t, i1_startblock) 3721 __field(xfs_extlen_t, i1_blockcount) 3722 __field(xfs_nlink_t, i1_refcount) 3723 __field(enum xfs_refc_domain, i2_domain) 3724 __field(xfs_agblock_t, i2_startblock) 3725 __field(xfs_extlen_t, i2_blockcount) 3726 __field(xfs_nlink_t, i2_refcount) 3727 ), 3728 TP_fast_assign( 3729 __entry->dev = cur->bc_mp->m_super->s_dev; 3730 __entry->type = cur->bc_group->xg_type; 3731 __entry->agno = cur->bc_group->xg_gno; 3732 __entry->i1_domain = i1->rc_domain; 3733 __entry->i1_startblock = i1->rc_startblock; 3734 __entry->i1_blockcount = i1->rc_blockcount; 3735 __entry->i1_refcount = i1->rc_refcount; 3736 __entry->i2_domain = i2->rc_domain; 3737 __entry->i2_startblock = i2->rc_startblock; 3738 __entry->i2_blockcount = i2->rc_blockcount; 3739 __entry->i2_refcount = i2->rc_refcount; 3740 ), 3741 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3742 "dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3743 MAJOR(__entry->dev), MINOR(__entry->dev), 3744 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3745 __entry->agno, 3746 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3747 __entry->i1_startblock, 3748 __entry->i1_blockcount, 3749 __entry->i1_refcount, 3750 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3751 __entry->i2_startblock, 3752 __entry->i2_blockcount, 3753 __entry->i2_refcount) 3754) 3755 3756#define DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(name) \ 3757DEFINE_EVENT(xfs_refcount_double_extent_class, name, \ 3758 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3759 struct xfs_refcount_irec *i2), \ 3760 TP_ARGS(cur, i1, i2)) 3761 3762/* double-rcext and an agbno tracepoint class */ 3763DECLARE_EVENT_CLASS(xfs_refcount_double_extent_at_class, 3764 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3765 struct xfs_refcount_irec *i2, xfs_agblock_t gbno), 3766 TP_ARGS(cur, i1, i2, gbno), 3767 TP_STRUCT__entry( 3768 __field(dev_t, dev) 3769 __field(enum xfs_group_type, type) 3770 __field(xfs_agnumber_t, agno) 3771 __field(enum xfs_refc_domain, i1_domain) 3772 __field(xfs_agblock_t, i1_startblock) 3773 __field(xfs_extlen_t, i1_blockcount) 3774 __field(xfs_nlink_t, i1_refcount) 3775 __field(enum xfs_refc_domain, i2_domain) 3776 __field(xfs_agblock_t, i2_startblock) 3777 __field(xfs_extlen_t, i2_blockcount) 3778 __field(xfs_nlink_t, i2_refcount) 3779 __field(xfs_agblock_t, gbno) 3780 ), 3781 TP_fast_assign( 3782 __entry->dev = cur->bc_mp->m_super->s_dev; 3783 __entry->type = cur->bc_group->xg_type; 3784 __entry->agno = cur->bc_group->xg_gno; 3785 __entry->i1_domain = i1->rc_domain; 3786 __entry->i1_startblock = i1->rc_startblock; 3787 __entry->i1_blockcount = i1->rc_blockcount; 3788 __entry->i1_refcount = i1->rc_refcount; 3789 __entry->i2_domain = i2->rc_domain; 3790 __entry->i2_startblock = i2->rc_startblock; 3791 __entry->i2_blockcount = i2->rc_blockcount; 3792 __entry->i2_refcount = i2->rc_refcount; 3793 __entry->gbno = gbno; 3794 ), 3795 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3796 "dom %s gbno 0x%x fsbcount 0x%x refcount %u @ gbno 0x%x", 3797 MAJOR(__entry->dev), MINOR(__entry->dev), 3798 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3799 __entry->agno, 3800 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3801 __entry->i1_startblock, 3802 __entry->i1_blockcount, 3803 __entry->i1_refcount, 3804 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3805 __entry->i2_startblock, 3806 __entry->i2_blockcount, 3807 __entry->i2_refcount, 3808 __entry->gbno) 3809) 3810 3811#define DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(name) \ 3812DEFINE_EVENT(xfs_refcount_double_extent_at_class, name, \ 3813 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3814 struct xfs_refcount_irec *i2, xfs_agblock_t gbno), \ 3815 TP_ARGS(cur, i1, i2, gbno)) 3816 3817/* triple-rcext tracepoint class */ 3818DECLARE_EVENT_CLASS(xfs_refcount_triple_extent_class, 3819 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, 3820 struct xfs_refcount_irec *i2, struct xfs_refcount_irec *i3), 3821 TP_ARGS(cur, i1, i2, i3), 3822 TP_STRUCT__entry( 3823 __field(dev_t, dev) 3824 __field(enum xfs_group_type, type) 3825 __field(xfs_agnumber_t, agno) 3826 __field(enum xfs_refc_domain, i1_domain) 3827 __field(xfs_agblock_t, i1_startblock) 3828 __field(xfs_extlen_t, i1_blockcount) 3829 __field(xfs_nlink_t, i1_refcount) 3830 __field(enum xfs_refc_domain, i2_domain) 3831 __field(xfs_agblock_t, i2_startblock) 3832 __field(xfs_extlen_t, i2_blockcount) 3833 __field(xfs_nlink_t, i2_refcount) 3834 __field(enum xfs_refc_domain, i3_domain) 3835 __field(xfs_agblock_t, i3_startblock) 3836 __field(xfs_extlen_t, i3_blockcount) 3837 __field(xfs_nlink_t, i3_refcount) 3838 ), 3839 TP_fast_assign( 3840 __entry->dev = cur->bc_mp->m_super->s_dev; 3841 __entry->type = cur->bc_group->xg_type; 3842 __entry->agno = cur->bc_group->xg_gno; 3843 __entry->i1_domain = i1->rc_domain; 3844 __entry->i1_startblock = i1->rc_startblock; 3845 __entry->i1_blockcount = i1->rc_blockcount; 3846 __entry->i1_refcount = i1->rc_refcount; 3847 __entry->i2_domain = i2->rc_domain; 3848 __entry->i2_startblock = i2->rc_startblock; 3849 __entry->i2_blockcount = i2->rc_blockcount; 3850 __entry->i2_refcount = i2->rc_refcount; 3851 __entry->i3_domain = i3->rc_domain; 3852 __entry->i3_startblock = i3->rc_startblock; 3853 __entry->i3_blockcount = i3->rc_blockcount; 3854 __entry->i3_refcount = i3->rc_refcount; 3855 ), 3856 TP_printk("dev %d:%d %sno 0x%x dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3857 "dom %s gbno 0x%x fsbcount 0x%x refcount %u -- " 3858 "dom %s gbno 0x%x fsbcount 0x%x refcount %u", 3859 MAJOR(__entry->dev), MINOR(__entry->dev), 3860 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3861 __entry->agno, 3862 __print_symbolic(__entry->i1_domain, XFS_REFC_DOMAIN_STRINGS), 3863 __entry->i1_startblock, 3864 __entry->i1_blockcount, 3865 __entry->i1_refcount, 3866 __print_symbolic(__entry->i2_domain, XFS_REFC_DOMAIN_STRINGS), 3867 __entry->i2_startblock, 3868 __entry->i2_blockcount, 3869 __entry->i2_refcount, 3870 __print_symbolic(__entry->i3_domain, XFS_REFC_DOMAIN_STRINGS), 3871 __entry->i3_startblock, 3872 __entry->i3_blockcount, 3873 __entry->i3_refcount) 3874); 3875 3876#define DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(name) \ 3877DEFINE_EVENT(xfs_refcount_triple_extent_class, name, \ 3878 TP_PROTO(struct xfs_btree_cur *cur, struct xfs_refcount_irec *i1, \ 3879 struct xfs_refcount_irec *i2, struct xfs_refcount_irec *i3), \ 3880 TP_ARGS(cur, i1, i2, i3)) 3881 3882/* refcount btree tracepoints */ 3883DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_get); 3884DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_update); 3885DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_insert); 3886DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_delete); 3887DEFINE_BTREE_ERROR_EVENT(xfs_refcount_insert_error); 3888DEFINE_BTREE_ERROR_EVENT(xfs_refcount_delete_error); 3889DEFINE_BTREE_ERROR_EVENT(xfs_refcount_update_error); 3890 3891/* refcount adjustment tracepoints */ 3892DEFINE_REFCOUNT_EVENT(xfs_refcount_increase); 3893DEFINE_REFCOUNT_EVENT(xfs_refcount_decrease); 3894DEFINE_REFCOUNT_EVENT(xfs_refcount_cow_increase); 3895DEFINE_REFCOUNT_EVENT(xfs_refcount_cow_decrease); 3896DEFINE_REFCOUNT_TRIPLE_EXTENT_EVENT(xfs_refcount_merge_center_extents); 3897DEFINE_REFCOUNT_EXTENT_EVENT(xfs_refcount_modify_extent); 3898DEFINE_REFCOUNT_EXTENT_AT_EVENT(xfs_refcount_split_extent); 3899DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_left_extent); 3900DEFINE_REFCOUNT_DOUBLE_EXTENT_EVENT(xfs_refcount_merge_right_extent); 3901DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_left_extent); 3902DEFINE_REFCOUNT_DOUBLE_EXTENT_AT_EVENT(xfs_refcount_find_right_extent); 3903DEFINE_BTREE_ERROR_EVENT(xfs_refcount_adjust_error); 3904DEFINE_BTREE_ERROR_EVENT(xfs_refcount_adjust_cow_error); 3905DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_center_extents_error); 3906DEFINE_BTREE_ERROR_EVENT(xfs_refcount_modify_extent_error); 3907DEFINE_BTREE_ERROR_EVENT(xfs_refcount_split_extent_error); 3908DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_left_extent_error); 3909DEFINE_BTREE_ERROR_EVENT(xfs_refcount_merge_right_extent_error); 3910DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_left_extent_error); 3911DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_right_extent_error); 3912 3913/* reflink helpers */ 3914DEFINE_REFCOUNT_EVENT(xfs_refcount_find_shared); 3915DEFINE_REFCOUNT_EVENT(xfs_refcount_find_shared_result); 3916DEFINE_BTREE_ERROR_EVENT(xfs_refcount_find_shared_error); 3917 3918TRACE_DEFINE_ENUM(XFS_REFCOUNT_INCREASE); 3919TRACE_DEFINE_ENUM(XFS_REFCOUNT_DECREASE); 3920TRACE_DEFINE_ENUM(XFS_REFCOUNT_ALLOC_COW); 3921TRACE_DEFINE_ENUM(XFS_REFCOUNT_FREE_COW); 3922 3923DECLARE_EVENT_CLASS(xfs_refcount_deferred_class, 3924 TP_PROTO(struct xfs_mount *mp, struct xfs_refcount_intent *refc), 3925 TP_ARGS(mp, refc), 3926 TP_STRUCT__entry( 3927 __field(dev_t, dev) 3928 __field(enum xfs_group_type, type) 3929 __field(xfs_agnumber_t, agno) 3930 __field(int, op) 3931 __field(xfs_agblock_t, gbno) 3932 __field(xfs_extlen_t, len) 3933 ), 3934 TP_fast_assign( 3935 __entry->dev = mp->m_super->s_dev; 3936 __entry->type = refc->ri_group->xg_type; 3937 __entry->agno = refc->ri_group->xg_gno; 3938 __entry->op = refc->ri_type; 3939 __entry->gbno = xfs_fsb_to_gbno(mp, refc->ri_startblock, 3940 refc->ri_group->xg_type); 3941 __entry->len = refc->ri_blockcount; 3942 ), 3943 TP_printk("dev %d:%d op %s %sno 0x%x gbno 0x%x fsbcount 0x%x", 3944 MAJOR(__entry->dev), MINOR(__entry->dev), 3945 __print_symbolic(__entry->op, XFS_REFCOUNT_INTENT_STRINGS), 3946 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 3947 __entry->agno, 3948 __entry->gbno, 3949 __entry->len) 3950); 3951#define DEFINE_REFCOUNT_DEFERRED_EVENT(name) \ 3952DEFINE_EVENT(xfs_refcount_deferred_class, name, \ 3953 TP_PROTO(struct xfs_mount *mp, struct xfs_refcount_intent *refc), \ 3954 TP_ARGS(mp, refc)) 3955DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_defer); 3956DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_deferred); 3957DEFINE_REFCOUNT_DEFERRED_EVENT(xfs_refcount_finish_one_leftover); 3958 3959/* simple inode-based error/%ip tracepoint class */ 3960DECLARE_EVENT_CLASS(xfs_inode_error_class, 3961 TP_PROTO(struct xfs_inode *ip, int error, unsigned long caller_ip), 3962 TP_ARGS(ip, error, caller_ip), 3963 TP_STRUCT__entry( 3964 __field(dev_t, dev) 3965 __field(xfs_ino_t, ino) 3966 __field(int, error) 3967 __field(unsigned long, caller_ip) 3968 ), 3969 TP_fast_assign( 3970 __entry->dev = VFS_I(ip)->i_sb->s_dev; 3971 __entry->ino = ip->i_ino; 3972 __entry->error = error; 3973 __entry->caller_ip = caller_ip; 3974 ), 3975 TP_printk("dev %d:%d ino 0x%llx error %d caller %pS", 3976 MAJOR(__entry->dev), MINOR(__entry->dev), 3977 __entry->ino, 3978 __entry->error, 3979 (char *)__entry->caller_ip) 3980); 3981 3982#define DEFINE_INODE_ERROR_EVENT(name) \ 3983DEFINE_EVENT(xfs_inode_error_class, name, \ 3984 TP_PROTO(struct xfs_inode *ip, int error, \ 3985 unsigned long caller_ip), \ 3986 TP_ARGS(ip, error, caller_ip)) 3987 3988/* reflink tracepoint classes */ 3989 3990/* two-file io tracepoint class */ 3991DECLARE_EVENT_CLASS(xfs_double_io_class, 3992 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, 3993 struct xfs_inode *dest, xfs_off_t doffset), 3994 TP_ARGS(src, soffset, len, dest, doffset), 3995 TP_STRUCT__entry( 3996 __field(dev_t, dev) 3997 __field(xfs_ino_t, src_ino) 3998 __field(loff_t, src_isize) 3999 __field(loff_t, src_disize) 4000 __field(loff_t, src_offset) 4001 __field(long long, len) 4002 __field(xfs_ino_t, dest_ino) 4003 __field(loff_t, dest_isize) 4004 __field(loff_t, dest_disize) 4005 __field(loff_t, dest_offset) 4006 ), 4007 TP_fast_assign( 4008 __entry->dev = VFS_I(src)->i_sb->s_dev; 4009 __entry->src_ino = src->i_ino; 4010 __entry->src_isize = VFS_I(src)->i_size; 4011 __entry->src_disize = src->i_disk_size; 4012 __entry->src_offset = soffset; 4013 __entry->len = len; 4014 __entry->dest_ino = dest->i_ino; 4015 __entry->dest_isize = VFS_I(dest)->i_size; 4016 __entry->dest_disize = dest->i_disk_size; 4017 __entry->dest_offset = doffset; 4018 ), 4019 TP_printk("dev %d:%d bytecount 0x%llx " 4020 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx -> " 4021 "ino 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx", 4022 MAJOR(__entry->dev), MINOR(__entry->dev), 4023 __entry->len, 4024 __entry->src_ino, 4025 __entry->src_isize, 4026 __entry->src_disize, 4027 __entry->src_offset, 4028 __entry->dest_ino, 4029 __entry->dest_isize, 4030 __entry->dest_disize, 4031 __entry->dest_offset) 4032) 4033 4034#define DEFINE_DOUBLE_IO_EVENT(name) \ 4035DEFINE_EVENT(xfs_double_io_class, name, \ 4036 TP_PROTO(struct xfs_inode *src, xfs_off_t soffset, xfs_off_t len, \ 4037 struct xfs_inode *dest, xfs_off_t doffset), \ 4038 TP_ARGS(src, soffset, len, dest, doffset)) 4039 4040/* inode/irec events */ 4041DECLARE_EVENT_CLASS(xfs_inode_irec_class, 4042 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), 4043 TP_ARGS(ip, irec), 4044 TP_STRUCT__entry( 4045 __field(dev_t, dev) 4046 __field(xfs_ino_t, ino) 4047 __field(xfs_fileoff_t, lblk) 4048 __field(xfs_extlen_t, len) 4049 __field(xfs_fsblock_t, pblk) 4050 __field(int, state) 4051 ), 4052 TP_fast_assign( 4053 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4054 __entry->ino = ip->i_ino; 4055 __entry->lblk = irec->br_startoff; 4056 __entry->len = irec->br_blockcount; 4057 __entry->pblk = irec->br_startblock; 4058 __entry->state = irec->br_state; 4059 ), 4060 TP_printk("dev %d:%d ino 0x%llx fileoff 0x%llx fsbcount 0x%x startblock 0x%llx st %d", 4061 MAJOR(__entry->dev), MINOR(__entry->dev), 4062 __entry->ino, 4063 __entry->lblk, 4064 __entry->len, 4065 __entry->pblk, 4066 __entry->state) 4067); 4068#define DEFINE_INODE_IREC_EVENT(name) \ 4069DEFINE_EVENT(xfs_inode_irec_class, name, \ 4070 TP_PROTO(struct xfs_inode *ip, struct xfs_bmbt_irec *irec), \ 4071 TP_ARGS(ip, irec)) 4072 4073/* inode iomap invalidation events */ 4074DECLARE_EVENT_CLASS(xfs_wb_invalid_class, 4075 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), 4076 TP_ARGS(ip, iomap, wpcseq, whichfork), 4077 TP_STRUCT__entry( 4078 __field(dev_t, dev) 4079 __field(xfs_ino_t, ino) 4080 __field(u64, addr) 4081 __field(loff_t, pos) 4082 __field(u64, len) 4083 __field(u16, type) 4084 __field(u16, flags) 4085 __field(u32, wpcseq) 4086 __field(u32, forkseq) 4087 ), 4088 TP_fast_assign( 4089 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4090 __entry->ino = ip->i_ino; 4091 __entry->addr = iomap->addr; 4092 __entry->pos = iomap->offset; 4093 __entry->len = iomap->length; 4094 __entry->type = iomap->type; 4095 __entry->flags = iomap->flags; 4096 __entry->wpcseq = wpcseq; 4097 __entry->forkseq = READ_ONCE(xfs_ifork_ptr(ip, whichfork)->if_seq); 4098 ), 4099 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", 4100 MAJOR(__entry->dev), MINOR(__entry->dev), 4101 __entry->ino, 4102 __entry->pos, 4103 __entry->addr, 4104 __entry->len, 4105 __entry->type, 4106 __entry->flags, 4107 __entry->wpcseq, 4108 __entry->forkseq) 4109); 4110#define DEFINE_WB_INVALID_EVENT(name) \ 4111DEFINE_EVENT(xfs_wb_invalid_class, name, \ 4112 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap, unsigned int wpcseq, int whichfork), \ 4113 TP_ARGS(ip, iomap, wpcseq, whichfork)) 4114DEFINE_WB_INVALID_EVENT(xfs_wb_cow_iomap_invalid); 4115DEFINE_WB_INVALID_EVENT(xfs_wb_data_iomap_invalid); 4116 4117DECLARE_EVENT_CLASS(xfs_iomap_invalid_class, 4118 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), 4119 TP_ARGS(ip, iomap), 4120 TP_STRUCT__entry( 4121 __field(dev_t, dev) 4122 __field(xfs_ino_t, ino) 4123 __field(u64, addr) 4124 __field(loff_t, pos) 4125 __field(u64, len) 4126 __field(u64, validity_cookie) 4127 __field(u64, inodeseq) 4128 __field(u16, type) 4129 __field(u16, flags) 4130 ), 4131 TP_fast_assign( 4132 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4133 __entry->ino = ip->i_ino; 4134 __entry->addr = iomap->addr; 4135 __entry->pos = iomap->offset; 4136 __entry->len = iomap->length; 4137 __entry->validity_cookie = iomap->validity_cookie; 4138 __entry->type = iomap->type; 4139 __entry->flags = iomap->flags; 4140 __entry->inodeseq = xfs_iomap_inode_sequence(ip, iomap->flags); 4141 ), 4142 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", 4143 MAJOR(__entry->dev), MINOR(__entry->dev), 4144 __entry->ino, 4145 __entry->pos, 4146 __entry->addr, 4147 __entry->len, 4148 __entry->type, 4149 __entry->flags, 4150 __entry->validity_cookie, 4151 __entry->inodeseq) 4152); 4153#define DEFINE_IOMAP_INVALID_EVENT(name) \ 4154DEFINE_EVENT(xfs_iomap_invalid_class, name, \ 4155 TP_PROTO(struct xfs_inode *ip, const struct iomap *iomap), \ 4156 TP_ARGS(ip, iomap)) 4157DEFINE_IOMAP_INVALID_EVENT(xfs_iomap_invalid); 4158 4159/* refcount/reflink tracepoint definitions */ 4160 4161/* reflink tracepoints */ 4162DEFINE_INODE_EVENT(xfs_reflink_set_inode_flag); 4163DEFINE_INODE_EVENT(xfs_reflink_unset_inode_flag); 4164DEFINE_ITRUNC_EVENT(xfs_reflink_update_inode_size); 4165TRACE_EVENT(xfs_reflink_remap_blocks, 4166 TP_PROTO(struct xfs_inode *src, xfs_fileoff_t soffset, 4167 xfs_filblks_t len, struct xfs_inode *dest, 4168 xfs_fileoff_t doffset), 4169 TP_ARGS(src, soffset, len, dest, doffset), 4170 TP_STRUCT__entry( 4171 __field(dev_t, dev) 4172 __field(xfs_ino_t, src_ino) 4173 __field(xfs_fileoff_t, src_lblk) 4174 __field(xfs_filblks_t, len) 4175 __field(xfs_ino_t, dest_ino) 4176 __field(xfs_fileoff_t, dest_lblk) 4177 ), 4178 TP_fast_assign( 4179 __entry->dev = VFS_I(src)->i_sb->s_dev; 4180 __entry->src_ino = src->i_ino; 4181 __entry->src_lblk = soffset; 4182 __entry->len = len; 4183 __entry->dest_ino = dest->i_ino; 4184 __entry->dest_lblk = doffset; 4185 ), 4186 TP_printk("dev %d:%d fsbcount 0x%llx " 4187 "ino 0x%llx fileoff 0x%llx -> ino 0x%llx fileoff 0x%llx", 4188 MAJOR(__entry->dev), MINOR(__entry->dev), 4189 __entry->len, 4190 __entry->src_ino, 4191 __entry->src_lblk, 4192 __entry->dest_ino, 4193 __entry->dest_lblk) 4194); 4195DEFINE_DOUBLE_IO_EVENT(xfs_reflink_remap_range); 4196DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_range_error); 4197DEFINE_INODE_ERROR_EVENT(xfs_reflink_set_inode_flag_error); 4198DEFINE_INODE_ERROR_EVENT(xfs_reflink_update_inode_size_error); 4199DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_blocks_error); 4200DEFINE_INODE_ERROR_EVENT(xfs_reflink_remap_extent_error); 4201DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_src); 4202DEFINE_INODE_IREC_EVENT(xfs_reflink_remap_extent_dest); 4203 4204/* unshare tracepoints */ 4205DEFINE_SIMPLE_IO_EVENT(xfs_reflink_unshare); 4206DEFINE_INODE_ERROR_EVENT(xfs_reflink_unshare_error); 4207 4208/* copy on write */ 4209DEFINE_INODE_IREC_EVENT(xfs_reflink_trim_around_shared); 4210DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_found); 4211DEFINE_INODE_IREC_EVENT(xfs_reflink_convert_cow); 4212 4213DEFINE_SIMPLE_IO_EVENT(xfs_reflink_cancel_cow_range); 4214DEFINE_SIMPLE_IO_EVENT(xfs_reflink_end_cow); 4215DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_from); 4216DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_to); 4217DEFINE_INODE_IREC_EVENT(xfs_reflink_cow_remap_skip); 4218 4219DEFINE_INODE_ERROR_EVENT(xfs_reflink_cancel_cow_range_error); 4220DEFINE_INODE_ERROR_EVENT(xfs_reflink_end_cow_error); 4221 4222 4223DEFINE_INODE_IREC_EVENT(xfs_reflink_cancel_cow); 4224 4225/* rmap swapext tracepoints */ 4226DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap); 4227DEFINE_INODE_IREC_EVENT(xfs_swap_extent_rmap_remap_piece); 4228DEFINE_INODE_ERROR_EVENT(xfs_swap_extent_rmap_error); 4229 4230/* fsmap traces */ 4231TRACE_EVENT(xfs_fsmap_mapping, 4232 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, 4233 const struct xfs_fsmap_irec *frec), 4234 TP_ARGS(mp, keydev, agno, frec), 4235 TP_STRUCT__entry( 4236 __field(dev_t, dev) 4237 __field(dev_t, keydev) 4238 __field(xfs_agnumber_t, agno) 4239 __field(xfs_agblock_t, agbno) 4240 __field(xfs_daddr_t, start_daddr) 4241 __field(xfs_daddr_t, len_daddr) 4242 __field(uint64_t, owner) 4243 __field(uint64_t, offset) 4244 __field(unsigned int, flags) 4245 ), 4246 TP_fast_assign( 4247 __entry->dev = mp->m_super->s_dev; 4248 __entry->keydev = new_decode_dev(keydev); 4249 __entry->agno = agno; 4250 __entry->agbno = frec->rec_key; 4251 __entry->start_daddr = frec->start_daddr; 4252 __entry->len_daddr = frec->len_daddr; 4253 __entry->owner = frec->owner; 4254 __entry->offset = frec->offset; 4255 __entry->flags = frec->rm_flags; 4256 ), 4257 TP_printk("dev %d:%d keydev %d:%d agno 0x%x gbno 0x%x start_daddr 0x%llx len_daddr 0x%llx owner 0x%llx fileoff 0x%llx flags 0x%x", 4258 MAJOR(__entry->dev), MINOR(__entry->dev), 4259 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4260 __entry->agno, 4261 __entry->agbno, 4262 __entry->start_daddr, 4263 __entry->len_daddr, 4264 __entry->owner, 4265 __entry->offset, 4266 __entry->flags) 4267); 4268 4269DECLARE_EVENT_CLASS(xfs_fsmap_group_key_class, 4270 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, 4271 const struct xfs_rmap_irec *rmap), 4272 TP_ARGS(mp, keydev, agno, rmap), 4273 TP_STRUCT__entry( 4274 __field(dev_t, dev) 4275 __field(dev_t, keydev) 4276 __field(xfs_agnumber_t, agno) 4277 __field(xfs_agblock_t, agbno) 4278 __field(uint64_t, owner) 4279 __field(uint64_t, offset) 4280 __field(unsigned int, flags) 4281 ), 4282 TP_fast_assign( 4283 __entry->dev = mp->m_super->s_dev; 4284 __entry->keydev = new_decode_dev(keydev); 4285 __entry->agno = agno; 4286 __entry->agbno = rmap->rm_startblock; 4287 __entry->owner = rmap->rm_owner; 4288 __entry->offset = rmap->rm_offset; 4289 __entry->flags = rmap->rm_flags; 4290 ), 4291 TP_printk("dev %d:%d keydev %d:%d agno 0x%x startblock 0x%x owner 0x%llx fileoff 0x%llx flags 0x%x", 4292 MAJOR(__entry->dev), MINOR(__entry->dev), 4293 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4294 __entry->agno, 4295 __entry->agbno, 4296 __entry->owner, 4297 __entry->offset, 4298 __entry->flags) 4299) 4300#define DEFINE_FSMAP_GROUP_KEY_EVENT(name) \ 4301DEFINE_EVENT(xfs_fsmap_group_key_class, name, \ 4302 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_agnumber_t agno, \ 4303 const struct xfs_rmap_irec *rmap), \ 4304 TP_ARGS(mp, keydev, agno, rmap)) 4305DEFINE_FSMAP_GROUP_KEY_EVENT(xfs_fsmap_low_group_key); 4306DEFINE_FSMAP_GROUP_KEY_EVENT(xfs_fsmap_high_group_key); 4307 4308DECLARE_EVENT_CLASS(xfs_fsmap_linear_key_class, 4309 TP_PROTO(struct xfs_mount *mp, u32 keydev, xfs_fsblock_t bno), 4310 TP_ARGS(mp, keydev, bno), 4311 TP_STRUCT__entry( 4312 __field(dev_t, dev) 4313 __field(dev_t, keydev) 4314 __field(xfs_fsblock_t, bno) 4315 ), 4316 TP_fast_assign( 4317 __entry->dev = mp->m_super->s_dev; 4318 __entry->keydev = new_decode_dev(keydev); 4319 __entry->bno = bno; 4320 ), 4321 TP_printk("dev %d:%d keydev %d:%d bno 0x%llx", 4322 MAJOR(__entry->dev), MINOR(__entry->dev), 4323 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4324 __entry->bno) 4325) 4326#define DEFINE_FSMAP_LINEAR_KEY_EVENT(name) \ 4327DEFINE_EVENT(xfs_fsmap_linear_key_class, name, \ 4328 TP_PROTO(struct xfs_mount *mp, u32 keydev, uint64_t bno), \ 4329 TP_ARGS(mp, keydev, bno)) 4330DEFINE_FSMAP_LINEAR_KEY_EVENT(xfs_fsmap_low_linear_key); 4331DEFINE_FSMAP_LINEAR_KEY_EVENT(xfs_fsmap_high_linear_key); 4332 4333DECLARE_EVENT_CLASS(xfs_getfsmap_class, 4334 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), 4335 TP_ARGS(mp, fsmap), 4336 TP_STRUCT__entry( 4337 __field(dev_t, dev) 4338 __field(dev_t, keydev) 4339 __field(xfs_daddr_t, block) 4340 __field(xfs_daddr_t, len) 4341 __field(uint64_t, owner) 4342 __field(uint64_t, offset) 4343 __field(uint64_t, flags) 4344 ), 4345 TP_fast_assign( 4346 __entry->dev = mp->m_super->s_dev; 4347 __entry->keydev = new_decode_dev(fsmap->fmr_device); 4348 __entry->block = fsmap->fmr_physical; 4349 __entry->len = fsmap->fmr_length; 4350 __entry->owner = fsmap->fmr_owner; 4351 __entry->offset = fsmap->fmr_offset; 4352 __entry->flags = fsmap->fmr_flags; 4353 ), 4354 TP_printk("dev %d:%d keydev %d:%d daddr 0x%llx bbcount 0x%llx owner 0x%llx fileoff_daddr 0x%llx flags 0x%llx", 4355 MAJOR(__entry->dev), MINOR(__entry->dev), 4356 MAJOR(__entry->keydev), MINOR(__entry->keydev), 4357 __entry->block, 4358 __entry->len, 4359 __entry->owner, 4360 __entry->offset, 4361 __entry->flags) 4362) 4363#define DEFINE_GETFSMAP_EVENT(name) \ 4364DEFINE_EVENT(xfs_getfsmap_class, name, \ 4365 TP_PROTO(struct xfs_mount *mp, struct xfs_fsmap *fsmap), \ 4366 TP_ARGS(mp, fsmap)) 4367DEFINE_GETFSMAP_EVENT(xfs_getfsmap_low_key); 4368DEFINE_GETFSMAP_EVENT(xfs_getfsmap_high_key); 4369DEFINE_GETFSMAP_EVENT(xfs_getfsmap_mapping); 4370 4371DECLARE_EVENT_CLASS(xfs_trans_resv_class, 4372 TP_PROTO(struct xfs_mount *mp, unsigned int type, 4373 struct xfs_trans_res *res), 4374 TP_ARGS(mp, type, res), 4375 TP_STRUCT__entry( 4376 __field(dev_t, dev) 4377 __field(int, type) 4378 __field(uint, logres) 4379 __field(int, logcount) 4380 __field(int, logflags) 4381 ), 4382 TP_fast_assign( 4383 __entry->dev = mp->m_super->s_dev; 4384 __entry->type = type; 4385 __entry->logres = res->tr_logres; 4386 __entry->logcount = res->tr_logcount; 4387 __entry->logflags = res->tr_logflags; 4388 ), 4389 TP_printk("dev %d:%d type %d logres %u logcount %d flags 0x%x", 4390 MAJOR(__entry->dev), MINOR(__entry->dev), 4391 __entry->type, 4392 __entry->logres, 4393 __entry->logcount, 4394 __entry->logflags) 4395) 4396 4397#define DEFINE_TRANS_RESV_EVENT(name) \ 4398DEFINE_EVENT(xfs_trans_resv_class, name, \ 4399 TP_PROTO(struct xfs_mount *mp, unsigned int type, \ 4400 struct xfs_trans_res *res), \ 4401 TP_ARGS(mp, type, res)) 4402DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc); 4403DEFINE_TRANS_RESV_EVENT(xfs_trans_resv_calc_minlogsize); 4404 4405TRACE_EVENT(xfs_log_get_max_trans_res, 4406 TP_PROTO(struct xfs_mount *mp, const struct xfs_trans_res *res), 4407 TP_ARGS(mp, res), 4408 TP_STRUCT__entry( 4409 __field(dev_t, dev) 4410 __field(uint, logres) 4411 __field(int, logcount) 4412 ), 4413 TP_fast_assign( 4414 __entry->dev = mp->m_super->s_dev; 4415 __entry->logres = res->tr_logres; 4416 __entry->logcount = res->tr_logcount; 4417 ), 4418 TP_printk("dev %d:%d logres %u logcount %d", 4419 MAJOR(__entry->dev), MINOR(__entry->dev), 4420 __entry->logres, 4421 __entry->logcount) 4422); 4423 4424DECLARE_EVENT_CLASS(xfs_trans_class, 4425 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), 4426 TP_ARGS(tp, caller_ip), 4427 TP_STRUCT__entry( 4428 __field(dev_t, dev) 4429 __field(uint32_t, tid) 4430 __field(uint32_t, flags) 4431 __field(unsigned long, caller_ip) 4432 ), 4433 TP_fast_assign( 4434 __entry->dev = tp->t_mountp->m_super->s_dev; 4435 __entry->tid = 0; 4436 if (tp->t_ticket) 4437 __entry->tid = tp->t_ticket->t_tid; 4438 __entry->flags = tp->t_flags; 4439 __entry->caller_ip = caller_ip; 4440 ), 4441 TP_printk("dev %d:%d trans %x flags 0x%x caller %pS", 4442 MAJOR(__entry->dev), MINOR(__entry->dev), 4443 __entry->tid, 4444 __entry->flags, 4445 (char *)__entry->caller_ip) 4446) 4447 4448#define DEFINE_TRANS_EVENT(name) \ 4449DEFINE_EVENT(xfs_trans_class, name, \ 4450 TP_PROTO(struct xfs_trans *tp, unsigned long caller_ip), \ 4451 TP_ARGS(tp, caller_ip)) 4452DEFINE_TRANS_EVENT(xfs_trans_alloc); 4453DEFINE_TRANS_EVENT(xfs_trans_cancel); 4454DEFINE_TRANS_EVENT(xfs_trans_commit); 4455DEFINE_TRANS_EVENT(xfs_trans_dup); 4456DEFINE_TRANS_EVENT(xfs_trans_free); 4457DEFINE_TRANS_EVENT(xfs_trans_roll); 4458DEFINE_TRANS_EVENT(xfs_trans_add_item); 4459DEFINE_TRANS_EVENT(xfs_trans_commit_items); 4460DEFINE_TRANS_EVENT(xfs_trans_free_items); 4461 4462TRACE_EVENT(xfs_iunlink_update_bucket, 4463 TP_PROTO(const struct xfs_perag *pag, unsigned int bucket, 4464 xfs_agino_t old_ptr, xfs_agino_t new_ptr), 4465 TP_ARGS(pag, bucket, old_ptr, new_ptr), 4466 TP_STRUCT__entry( 4467 __field(dev_t, dev) 4468 __field(xfs_agnumber_t, agno) 4469 __field(unsigned int, bucket) 4470 __field(xfs_agino_t, old_ptr) 4471 __field(xfs_agino_t, new_ptr) 4472 ), 4473 TP_fast_assign( 4474 __entry->dev = pag_mount(pag)->m_super->s_dev; 4475 __entry->agno = pag_agno(pag); 4476 __entry->bucket = bucket; 4477 __entry->old_ptr = old_ptr; 4478 __entry->new_ptr = new_ptr; 4479 ), 4480 TP_printk("dev %d:%d agno 0x%x bucket %u old 0x%x new 0x%x", 4481 MAJOR(__entry->dev), MINOR(__entry->dev), 4482 __entry->agno, 4483 __entry->bucket, 4484 __entry->old_ptr, 4485 __entry->new_ptr) 4486); 4487 4488TRACE_EVENT(xfs_iunlink_update_dinode, 4489 TP_PROTO(const struct xfs_iunlink_item *iup, xfs_agino_t old_ptr), 4490 TP_ARGS(iup, old_ptr), 4491 TP_STRUCT__entry( 4492 __field(dev_t, dev) 4493 __field(xfs_agnumber_t, agno) 4494 __field(xfs_agino_t, agino) 4495 __field(xfs_agino_t, old_ptr) 4496 __field(xfs_agino_t, new_ptr) 4497 ), 4498 TP_fast_assign( 4499 __entry->dev = pag_mount(iup->pag)->m_super->s_dev; 4500 __entry->agno = pag_agno(iup->pag); 4501 __entry->agino = 4502 XFS_INO_TO_AGINO(iup->ip->i_mount, iup->ip->i_ino); 4503 __entry->old_ptr = old_ptr; 4504 __entry->new_ptr = iup->next_agino; 4505 ), 4506 TP_printk("dev %d:%d agno 0x%x agino 0x%x old 0x%x new 0x%x", 4507 MAJOR(__entry->dev), MINOR(__entry->dev), 4508 __entry->agno, 4509 __entry->agino, 4510 __entry->old_ptr, 4511 __entry->new_ptr) 4512); 4513 4514TRACE_EVENT(xfs_iunlink_reload_next, 4515 TP_PROTO(struct xfs_inode *ip), 4516 TP_ARGS(ip), 4517 TP_STRUCT__entry( 4518 __field(dev_t, dev) 4519 __field(xfs_agnumber_t, agno) 4520 __field(xfs_agino_t, agino) 4521 __field(xfs_agino_t, prev_agino) 4522 __field(xfs_agino_t, next_agino) 4523 ), 4524 TP_fast_assign( 4525 __entry->dev = ip->i_mount->m_super->s_dev; 4526 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4527 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4528 __entry->prev_agino = ip->i_prev_unlinked; 4529 __entry->next_agino = ip->i_next_unlinked; 4530 ), 4531 TP_printk("dev %d:%d agno 0x%x agino 0x%x prev_unlinked 0x%x next_unlinked 0x%x", 4532 MAJOR(__entry->dev), MINOR(__entry->dev), 4533 __entry->agno, 4534 __entry->agino, 4535 __entry->prev_agino, 4536 __entry->next_agino) 4537); 4538 4539TRACE_EVENT(xfs_inode_reload_unlinked_bucket, 4540 TP_PROTO(struct xfs_inode *ip), 4541 TP_ARGS(ip), 4542 TP_STRUCT__entry( 4543 __field(dev_t, dev) 4544 __field(xfs_agnumber_t, agno) 4545 __field(xfs_agino_t, agino) 4546 ), 4547 TP_fast_assign( 4548 __entry->dev = ip->i_mount->m_super->s_dev; 4549 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4550 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4551 ), 4552 TP_printk("dev %d:%d agno 0x%x agino 0x%x bucket %u", 4553 MAJOR(__entry->dev), MINOR(__entry->dev), 4554 __entry->agno, 4555 __entry->agino, 4556 __entry->agino % XFS_AGI_UNLINKED_BUCKETS) 4557); 4558 4559DECLARE_EVENT_CLASS(xfs_ag_inode_class, 4560 TP_PROTO(struct xfs_inode *ip), 4561 TP_ARGS(ip), 4562 TP_STRUCT__entry( 4563 __field(dev_t, dev) 4564 __field(xfs_agnumber_t, agno) 4565 __field(xfs_agino_t, agino) 4566 ), 4567 TP_fast_assign( 4568 __entry->dev = VFS_I(ip)->i_sb->s_dev; 4569 __entry->agno = XFS_INO_TO_AGNO(ip->i_mount, ip->i_ino); 4570 __entry->agino = XFS_INO_TO_AGINO(ip->i_mount, ip->i_ino); 4571 ), 4572 TP_printk("dev %d:%d agno 0x%x agino 0x%x", 4573 MAJOR(__entry->dev), MINOR(__entry->dev), 4574 __entry->agno, __entry->agino) 4575) 4576 4577#define DEFINE_AGINODE_EVENT(name) \ 4578DEFINE_EVENT(xfs_ag_inode_class, name, \ 4579 TP_PROTO(struct xfs_inode *ip), \ 4580 TP_ARGS(ip)) 4581DEFINE_AGINODE_EVENT(xfs_iunlink); 4582DEFINE_AGINODE_EVENT(xfs_iunlink_remove); 4583 4584DECLARE_EVENT_CLASS(xfs_fs_corrupt_class, 4585 TP_PROTO(struct xfs_mount *mp, unsigned int flags), 4586 TP_ARGS(mp, flags), 4587 TP_STRUCT__entry( 4588 __field(dev_t, dev) 4589 __field(unsigned int, flags) 4590 ), 4591 TP_fast_assign( 4592 __entry->dev = mp->m_super->s_dev; 4593 __entry->flags = flags; 4594 ), 4595 TP_printk("dev %d:%d flags 0x%x", 4596 MAJOR(__entry->dev), MINOR(__entry->dev), 4597 __entry->flags) 4598); 4599#define DEFINE_FS_CORRUPT_EVENT(name) \ 4600DEFINE_EVENT(xfs_fs_corrupt_class, name, \ 4601 TP_PROTO(struct xfs_mount *mp, unsigned int flags), \ 4602 TP_ARGS(mp, flags)) 4603DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_sick); 4604DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_corrupt); 4605DEFINE_FS_CORRUPT_EVENT(xfs_fs_mark_healthy); 4606DEFINE_FS_CORRUPT_EVENT(xfs_fs_unfixed_corruption); 4607 4608DECLARE_EVENT_CLASS(xfs_group_corrupt_class, 4609 TP_PROTO(const struct xfs_group *xg, unsigned int flags), 4610 TP_ARGS(xg, flags), 4611 TP_STRUCT__entry( 4612 __field(dev_t, dev) 4613 __field(enum xfs_group_type, type) 4614 __field(uint32_t, index) 4615 __field(unsigned int, flags) 4616 ), 4617 TP_fast_assign( 4618 __entry->dev = xg->xg_mount->m_super->s_dev; 4619 __entry->type = xg->xg_type; 4620 __entry->index = xg->xg_gno; 4621 __entry->flags = flags; 4622 ), 4623 TP_printk("dev %d:%d %sno 0x%x flags 0x%x", 4624 MAJOR(__entry->dev), MINOR(__entry->dev), 4625 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 4626 __entry->index, __entry->flags) 4627); 4628#define DEFINE_GROUP_CORRUPT_EVENT(name) \ 4629DEFINE_EVENT(xfs_group_corrupt_class, name, \ 4630 TP_PROTO(const struct xfs_group *xg, unsigned int flags), \ 4631 TP_ARGS(xg, flags)) 4632DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_sick); 4633DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_corrupt); 4634DEFINE_GROUP_CORRUPT_EVENT(xfs_group_mark_healthy); 4635DEFINE_GROUP_CORRUPT_EVENT(xfs_group_unfixed_corruption); 4636 4637DECLARE_EVENT_CLASS(xfs_inode_corrupt_class, 4638 TP_PROTO(struct xfs_inode *ip, unsigned int flags), 4639 TP_ARGS(ip, flags), 4640 TP_STRUCT__entry( 4641 __field(dev_t, dev) 4642 __field(xfs_ino_t, ino) 4643 __field(unsigned int, flags) 4644 ), 4645 TP_fast_assign( 4646 __entry->dev = ip->i_mount->m_super->s_dev; 4647 __entry->ino = ip->i_ino; 4648 __entry->flags = flags; 4649 ), 4650 TP_printk("dev %d:%d ino 0x%llx flags 0x%x", 4651 MAJOR(__entry->dev), MINOR(__entry->dev), 4652 __entry->ino, __entry->flags) 4653); 4654#define DEFINE_INODE_CORRUPT_EVENT(name) \ 4655DEFINE_EVENT(xfs_inode_corrupt_class, name, \ 4656 TP_PROTO(struct xfs_inode *ip, unsigned int flags), \ 4657 TP_ARGS(ip, flags)) 4658DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_sick); 4659DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_corrupt); 4660DEFINE_INODE_CORRUPT_EVENT(xfs_inode_mark_healthy); 4661DEFINE_INODE_CORRUPT_EVENT(xfs_inode_unfixed_corruption); 4662 4663TRACE_EVENT(xfs_iwalk_ag_rec, 4664 TP_PROTO(const struct xfs_perag *pag, \ 4665 struct xfs_inobt_rec_incore *irec), 4666 TP_ARGS(pag, irec), 4667 TP_STRUCT__entry( 4668 __field(dev_t, dev) 4669 __field(xfs_agnumber_t, agno) 4670 __field(xfs_agino_t, startino) 4671 __field(uint64_t, freemask) 4672 ), 4673 TP_fast_assign( 4674 __entry->dev = pag_mount(pag)->m_super->s_dev; 4675 __entry->agno = pag_agno(pag); 4676 __entry->startino = irec->ir_startino; 4677 __entry->freemask = irec->ir_free; 4678 ), 4679 TP_printk("dev %d:%d agno 0x%x startino 0x%x freemask 0x%llx", 4680 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->agno, 4681 __entry->startino, __entry->freemask) 4682) 4683 4684TRACE_EVENT(xfs_pwork_init, 4685 TP_PROTO(struct xfs_mount *mp, unsigned int nr_threads, pid_t pid), 4686 TP_ARGS(mp, nr_threads, pid), 4687 TP_STRUCT__entry( 4688 __field(dev_t, dev) 4689 __field(unsigned int, nr_threads) 4690 __field(pid_t, pid) 4691 ), 4692 TP_fast_assign( 4693 __entry->dev = mp->m_super->s_dev; 4694 __entry->nr_threads = nr_threads; 4695 __entry->pid = pid; 4696 ), 4697 TP_printk("dev %d:%d nr_threads %u pid %u", 4698 MAJOR(__entry->dev), MINOR(__entry->dev), 4699 __entry->nr_threads, __entry->pid) 4700) 4701 4702TRACE_EVENT(xfs_check_new_dalign, 4703 TP_PROTO(struct xfs_mount *mp, int new_dalign, xfs_ino_t calc_rootino), 4704 TP_ARGS(mp, new_dalign, calc_rootino), 4705 TP_STRUCT__entry( 4706 __field(dev_t, dev) 4707 __field(int, new_dalign) 4708 __field(xfs_ino_t, sb_rootino) 4709 __field(xfs_ino_t, calc_rootino) 4710 ), 4711 TP_fast_assign( 4712 __entry->dev = mp->m_super->s_dev; 4713 __entry->new_dalign = new_dalign; 4714 __entry->sb_rootino = mp->m_sb.sb_rootino; 4715 __entry->calc_rootino = calc_rootino; 4716 ), 4717 TP_printk("dev %d:%d new_dalign %d sb_rootino 0x%llx calc_rootino 0x%llx", 4718 MAJOR(__entry->dev), MINOR(__entry->dev), 4719 __entry->new_dalign, __entry->sb_rootino, 4720 __entry->calc_rootino) 4721) 4722 4723TRACE_EVENT(xfs_btree_commit_afakeroot, 4724 TP_PROTO(struct xfs_btree_cur *cur), 4725 TP_ARGS(cur), 4726 TP_STRUCT__entry( 4727 __field(dev_t, dev) 4728 __string(name, cur->bc_ops->name) 4729 __field(xfs_agnumber_t, agno) 4730 __field(xfs_agblock_t, agbno) 4731 __field(unsigned int, levels) 4732 __field(unsigned int, blocks) 4733 ), 4734 TP_fast_assign( 4735 __entry->dev = cur->bc_mp->m_super->s_dev; 4736 __assign_str(name); 4737 __entry->agno = cur->bc_group->xg_gno; 4738 __entry->agbno = cur->bc_ag.afake->af_root; 4739 __entry->levels = cur->bc_ag.afake->af_levels; 4740 __entry->blocks = cur->bc_ag.afake->af_blocks; 4741 ), 4742 TP_printk("dev %d:%d %sbt agno 0x%x levels %u blocks %u root %u", 4743 MAJOR(__entry->dev), MINOR(__entry->dev), 4744 __get_str(name), 4745 __entry->agno, 4746 __entry->levels, 4747 __entry->blocks, 4748 __entry->agbno) 4749) 4750 4751TRACE_EVENT(xfs_btree_commit_ifakeroot, 4752 TP_PROTO(struct xfs_btree_cur *cur), 4753 TP_ARGS(cur), 4754 TP_STRUCT__entry( 4755 __field(dev_t, dev) 4756 __string(name, cur->bc_ops->name) 4757 __field(xfs_agnumber_t, agno) 4758 __field(xfs_agino_t, agino) 4759 __field(unsigned int, levels) 4760 __field(unsigned int, blocks) 4761 __field(int, whichfork) 4762 ), 4763 TP_fast_assign( 4764 __entry->dev = cur->bc_mp->m_super->s_dev; 4765 __assign_str(name); 4766 __entry->agno = XFS_INO_TO_AGNO(cur->bc_mp, 4767 cur->bc_ino.ip->i_ino); 4768 __entry->agino = XFS_INO_TO_AGINO(cur->bc_mp, 4769 cur->bc_ino.ip->i_ino); 4770 __entry->levels = cur->bc_ino.ifake->if_levels; 4771 __entry->blocks = cur->bc_ino.ifake->if_blocks; 4772 __entry->whichfork = cur->bc_ino.whichfork; 4773 ), 4774 TP_printk("dev %d:%d %sbt agno 0x%x agino 0x%x whichfork %s levels %u blocks %u", 4775 MAJOR(__entry->dev), MINOR(__entry->dev), 4776 __get_str(name), 4777 __entry->agno, 4778 __entry->agino, 4779 __print_symbolic(__entry->whichfork, XFS_WHICHFORK_STRINGS), 4780 __entry->levels, 4781 __entry->blocks) 4782) 4783 4784TRACE_EVENT(xfs_btree_bload_level_geometry, 4785 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4786 uint64_t nr_this_level, unsigned int nr_per_block, 4787 unsigned int desired_npb, uint64_t blocks, 4788 uint64_t blocks_with_extra), 4789 TP_ARGS(cur, level, nr_this_level, nr_per_block, desired_npb, blocks, 4790 blocks_with_extra), 4791 TP_STRUCT__entry( 4792 __field(dev_t, dev) 4793 __string(name, cur->bc_ops->name) 4794 __field(unsigned int, level) 4795 __field(unsigned int, nlevels) 4796 __field(uint64_t, nr_this_level) 4797 __field(unsigned int, nr_per_block) 4798 __field(unsigned int, desired_npb) 4799 __field(unsigned long long, blocks) 4800 __field(unsigned long long, blocks_with_extra) 4801 ), 4802 TP_fast_assign( 4803 __entry->dev = cur->bc_mp->m_super->s_dev; 4804 __assign_str(name); 4805 __entry->level = level; 4806 __entry->nlevels = cur->bc_nlevels; 4807 __entry->nr_this_level = nr_this_level; 4808 __entry->nr_per_block = nr_per_block; 4809 __entry->desired_npb = desired_npb; 4810 __entry->blocks = blocks; 4811 __entry->blocks_with_extra = blocks_with_extra; 4812 ), 4813 TP_printk("dev %d:%d %sbt level %u/%u nr_this_level %llu nr_per_block %u desired_npb %u blocks %llu blocks_with_extra %llu", 4814 MAJOR(__entry->dev), MINOR(__entry->dev), 4815 __get_str(name), 4816 __entry->level, 4817 __entry->nlevels, 4818 __entry->nr_this_level, 4819 __entry->nr_per_block, 4820 __entry->desired_npb, 4821 __entry->blocks, 4822 __entry->blocks_with_extra) 4823) 4824 4825TRACE_EVENT(xfs_btree_bload_block, 4826 TP_PROTO(struct xfs_btree_cur *cur, unsigned int level, 4827 uint64_t block_idx, uint64_t nr_blocks, 4828 union xfs_btree_ptr *ptr, unsigned int nr_records), 4829 TP_ARGS(cur, level, block_idx, nr_blocks, ptr, nr_records), 4830 TP_STRUCT__entry( 4831 __field(dev_t, dev) 4832 __string(name, cur->bc_ops->name) 4833 __field(unsigned int, level) 4834 __field(unsigned long long, block_idx) 4835 __field(unsigned long long, nr_blocks) 4836 __field(xfs_agnumber_t, agno) 4837 __field(xfs_agblock_t, agbno) 4838 __field(unsigned int, nr_records) 4839 ), 4840 TP_fast_assign( 4841 __entry->dev = cur->bc_mp->m_super->s_dev; 4842 __assign_str(name); 4843 __entry->level = level; 4844 __entry->block_idx = block_idx; 4845 __entry->nr_blocks = nr_blocks; 4846 if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN) { 4847 xfs_fsblock_t fsb = be64_to_cpu(ptr->l); 4848 4849 __entry->agno = XFS_FSB_TO_AGNO(cur->bc_mp, fsb); 4850 __entry->agbno = XFS_FSB_TO_AGBNO(cur->bc_mp, fsb); 4851 } else { 4852 __entry->agno = cur->bc_group->xg_gno; 4853 __entry->agbno = be32_to_cpu(ptr->s); 4854 } 4855 __entry->nr_records = nr_records; 4856 ), 4857 TP_printk("dev %d:%d %sbt level %u block %llu/%llu agno 0x%x agbno 0x%x recs %u", 4858 MAJOR(__entry->dev), MINOR(__entry->dev), 4859 __get_str(name), 4860 __entry->level, 4861 __entry->block_idx, 4862 __entry->nr_blocks, 4863 __entry->agno, 4864 __entry->agbno, 4865 __entry->nr_records) 4866) 4867 4868DECLARE_EVENT_CLASS(xfs_timestamp_range_class, 4869 TP_PROTO(struct xfs_mount *mp, time64_t min, time64_t max), 4870 TP_ARGS(mp, min, max), 4871 TP_STRUCT__entry( 4872 __field(dev_t, dev) 4873 __field(long long, min) 4874 __field(long long, max) 4875 ), 4876 TP_fast_assign( 4877 __entry->dev = mp->m_super->s_dev; 4878 __entry->min = min; 4879 __entry->max = max; 4880 ), 4881 TP_printk("dev %d:%d min %lld max %lld", 4882 MAJOR(__entry->dev), MINOR(__entry->dev), 4883 __entry->min, 4884 __entry->max) 4885) 4886 4887#define DEFINE_TIMESTAMP_RANGE_EVENT(name) \ 4888DEFINE_EVENT(xfs_timestamp_range_class, name, \ 4889 TP_PROTO(struct xfs_mount *mp, long long min, long long max), \ 4890 TP_ARGS(mp, min, max)) 4891DEFINE_TIMESTAMP_RANGE_EVENT(xfs_inode_timestamp_range); 4892DEFINE_TIMESTAMP_RANGE_EVENT(xfs_quota_expiry_range); 4893 4894DECLARE_EVENT_CLASS(xfs_icwalk_class, 4895 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, 4896 unsigned long caller_ip), 4897 TP_ARGS(mp, icw, caller_ip), 4898 TP_STRUCT__entry( 4899 __field(dev_t, dev) 4900 __field(__u32, flags) 4901 __field(uint32_t, uid) 4902 __field(uint32_t, gid) 4903 __field(prid_t, prid) 4904 __field(__u64, min_file_size) 4905 __field(long, scan_limit) 4906 __field(unsigned long, caller_ip) 4907 ), 4908 TP_fast_assign( 4909 __entry->dev = mp->m_super->s_dev; 4910 __entry->flags = icw ? icw->icw_flags : 0; 4911 __entry->uid = icw ? from_kuid(mp->m_super->s_user_ns, 4912 icw->icw_uid) : 0; 4913 __entry->gid = icw ? from_kgid(mp->m_super->s_user_ns, 4914 icw->icw_gid) : 0; 4915 __entry->prid = icw ? icw->icw_prid : 0; 4916 __entry->min_file_size = icw ? icw->icw_min_file_size : 0; 4917 __entry->scan_limit = icw ? icw->icw_scan_limit : 0; 4918 __entry->caller_ip = caller_ip; 4919 ), 4920 TP_printk("dev %d:%d flags 0x%x uid %u gid %u prid %u minsize %llu scan_limit %ld caller %pS", 4921 MAJOR(__entry->dev), MINOR(__entry->dev), 4922 __entry->flags, 4923 __entry->uid, 4924 __entry->gid, 4925 __entry->prid, 4926 __entry->min_file_size, 4927 __entry->scan_limit, 4928 (char *)__entry->caller_ip) 4929); 4930#define DEFINE_ICWALK_EVENT(name) \ 4931DEFINE_EVENT(xfs_icwalk_class, name, \ 4932 TP_PROTO(struct xfs_mount *mp, struct xfs_icwalk *icw, \ 4933 unsigned long caller_ip), \ 4934 TP_ARGS(mp, icw, caller_ip)) 4935DEFINE_ICWALK_EVENT(xfs_ioc_free_eofblocks); 4936DEFINE_ICWALK_EVENT(xfs_blockgc_free_space); 4937 4938TRACE_DEFINE_ENUM(XLOG_STATE_ACTIVE); 4939TRACE_DEFINE_ENUM(XLOG_STATE_WANT_SYNC); 4940TRACE_DEFINE_ENUM(XLOG_STATE_SYNCING); 4941TRACE_DEFINE_ENUM(XLOG_STATE_DONE_SYNC); 4942TRACE_DEFINE_ENUM(XLOG_STATE_CALLBACK); 4943TRACE_DEFINE_ENUM(XLOG_STATE_DIRTY); 4944 4945DECLARE_EVENT_CLASS(xlog_iclog_class, 4946 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), 4947 TP_ARGS(iclog, caller_ip), 4948 TP_STRUCT__entry( 4949 __field(dev_t, dev) 4950 __field(uint32_t, state) 4951 __field(int32_t, refcount) 4952 __field(uint32_t, offset) 4953 __field(uint32_t, flags) 4954 __field(unsigned long long, lsn) 4955 __field(unsigned long, caller_ip) 4956 ), 4957 TP_fast_assign( 4958 __entry->dev = iclog->ic_log->l_mp->m_super->s_dev; 4959 __entry->state = iclog->ic_state; 4960 __entry->refcount = atomic_read(&iclog->ic_refcnt); 4961 __entry->offset = iclog->ic_offset; 4962 __entry->flags = iclog->ic_flags; 4963 __entry->lsn = be64_to_cpu(iclog->ic_header->h_lsn); 4964 __entry->caller_ip = caller_ip; 4965 ), 4966 TP_printk("dev %d:%d state %s refcnt %d offset %u lsn 0x%llx flags %s caller %pS", 4967 MAJOR(__entry->dev), MINOR(__entry->dev), 4968 __print_symbolic(__entry->state, XLOG_STATE_STRINGS), 4969 __entry->refcount, 4970 __entry->offset, 4971 __entry->lsn, 4972 __print_flags(__entry->flags, "|", XLOG_ICL_STRINGS), 4973 (char *)__entry->caller_ip) 4974 4975); 4976 4977#define DEFINE_ICLOG_EVENT(name) \ 4978DEFINE_EVENT(xlog_iclog_class, name, \ 4979 TP_PROTO(struct xlog_in_core *iclog, unsigned long caller_ip), \ 4980 TP_ARGS(iclog, caller_ip)) 4981 4982DEFINE_ICLOG_EVENT(xlog_iclog_activate); 4983DEFINE_ICLOG_EVENT(xlog_iclog_clean); 4984DEFINE_ICLOG_EVENT(xlog_iclog_callback); 4985DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_start); 4986DEFINE_ICLOG_EVENT(xlog_iclog_callbacks_done); 4987DEFINE_ICLOG_EVENT(xlog_iclog_force); 4988DEFINE_ICLOG_EVENT(xlog_iclog_force_lsn); 4989DEFINE_ICLOG_EVENT(xlog_iclog_get_space); 4990DEFINE_ICLOG_EVENT(xlog_iclog_release); 4991DEFINE_ICLOG_EVENT(xlog_iclog_switch); 4992DEFINE_ICLOG_EVENT(xlog_iclog_sync); 4993DEFINE_ICLOG_EVENT(xlog_iclog_syncing); 4994DEFINE_ICLOG_EVENT(xlog_iclog_sync_done); 4995DEFINE_ICLOG_EVENT(xlog_iclog_wait_on); 4996DEFINE_ICLOG_EVENT(xlog_iclog_write); 4997 4998TRACE_DEFINE_ENUM(XFS_DAS_UNINIT); 4999TRACE_DEFINE_ENUM(XFS_DAS_SF_ADD); 5000TRACE_DEFINE_ENUM(XFS_DAS_SF_REMOVE); 5001TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ADD); 5002TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE); 5003TRACE_DEFINE_ENUM(XFS_DAS_NODE_ADD); 5004TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE); 5005TRACE_DEFINE_ENUM(XFS_DAS_LEAF_SET_RMT); 5006TRACE_DEFINE_ENUM(XFS_DAS_LEAF_ALLOC_RMT); 5007TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REPLACE); 5008TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_OLD); 5009TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_RMT); 5010TRACE_DEFINE_ENUM(XFS_DAS_LEAF_REMOVE_ATTR); 5011TRACE_DEFINE_ENUM(XFS_DAS_NODE_SET_RMT); 5012TRACE_DEFINE_ENUM(XFS_DAS_NODE_ALLOC_RMT); 5013TRACE_DEFINE_ENUM(XFS_DAS_NODE_REPLACE); 5014TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_OLD); 5015TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_RMT); 5016TRACE_DEFINE_ENUM(XFS_DAS_NODE_REMOVE_ATTR); 5017TRACE_DEFINE_ENUM(XFS_DAS_DONE); 5018 5019DECLARE_EVENT_CLASS(xfs_das_state_class, 5020 TP_PROTO(int das, struct xfs_inode *ip), 5021 TP_ARGS(das, ip), 5022 TP_STRUCT__entry( 5023 __field(int, das) 5024 __field(xfs_ino_t, ino) 5025 ), 5026 TP_fast_assign( 5027 __entry->das = das; 5028 __entry->ino = ip->i_ino; 5029 ), 5030 TP_printk("state change %s ino 0x%llx", 5031 __print_symbolic(__entry->das, XFS_DAS_STRINGS), 5032 __entry->ino) 5033) 5034 5035#define DEFINE_DAS_STATE_EVENT(name) \ 5036DEFINE_EVENT(xfs_das_state_class, name, \ 5037 TP_PROTO(int das, struct xfs_inode *ip), \ 5038 TP_ARGS(das, ip)) 5039DEFINE_DAS_STATE_EVENT(xfs_attr_sf_addname_return); 5040DEFINE_DAS_STATE_EVENT(xfs_attr_set_iter_return); 5041DEFINE_DAS_STATE_EVENT(xfs_attr_leaf_addname_return); 5042DEFINE_DAS_STATE_EVENT(xfs_attr_node_addname_return); 5043DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_alloc); 5044DEFINE_DAS_STATE_EVENT(xfs_attr_rmtval_remove_return); 5045DEFINE_DAS_STATE_EVENT(xfs_attr_defer_add); 5046 5047 5048TRACE_EVENT(xfs_force_shutdown, 5049 TP_PROTO(struct xfs_mount *mp, int ptag, int flags, const char *fname, 5050 int line_num), 5051 TP_ARGS(mp, ptag, flags, fname, line_num), 5052 TP_STRUCT__entry( 5053 __field(dev_t, dev) 5054 __field(int, ptag) 5055 __field(int, flags) 5056 __string(fname, fname) 5057 __field(int, line_num) 5058 ), 5059 TP_fast_assign( 5060 __entry->dev = mp->m_super->s_dev; 5061 __entry->ptag = ptag; 5062 __entry->flags = flags; 5063 __assign_str(fname); 5064 __entry->line_num = line_num; 5065 ), 5066 TP_printk("dev %d:%d tag %s flags %s file %s line_num %d", 5067 MAJOR(__entry->dev), MINOR(__entry->dev), 5068 __print_flags(__entry->ptag, "|", XFS_PTAG_STRINGS), 5069 __print_flags(__entry->flags, "|", XFS_SHUTDOWN_STRINGS), 5070 __get_str(fname), 5071 __entry->line_num) 5072); 5073 5074#ifdef CONFIG_XFS_DRAIN_INTENTS 5075DECLARE_EVENT_CLASS(xfs_group_intents_class, 5076 TP_PROTO(const struct xfs_group *xg, void *caller_ip), 5077 TP_ARGS(xg, caller_ip), 5078 TP_STRUCT__entry( 5079 __field(dev_t, dev) 5080 __field(enum xfs_group_type, type) 5081 __field(uint32_t, index) 5082 __field(long, nr_intents) 5083 __field(void *, caller_ip) 5084 ), 5085 TP_fast_assign( 5086 __entry->dev = xg->xg_mount->m_super->s_dev; 5087 __entry->type = xg->xg_type; 5088 __entry->index = xg->xg_gno; 5089 __entry->nr_intents = 5090 atomic_read(&xg->xg_intents_drain.dr_count); 5091 __entry->caller_ip = caller_ip; 5092 ), 5093 TP_printk("dev %d:%d %sno 0x%x intents %ld caller %pS", 5094 MAJOR(__entry->dev), MINOR(__entry->dev), 5095 __print_symbolic(__entry->type, XG_TYPE_STRINGS), 5096 __entry->index, 5097 __entry->nr_intents, 5098 __entry->caller_ip) 5099); 5100 5101#define DEFINE_GROUP_INTENTS_EVENT(name) \ 5102DEFINE_EVENT(xfs_group_intents_class, name, \ 5103 TP_PROTO(const struct xfs_group *xg, void *caller_ip), \ 5104 TP_ARGS(xg, caller_ip)) 5105DEFINE_GROUP_INTENTS_EVENT(xfs_group_intent_hold); 5106DEFINE_GROUP_INTENTS_EVENT(xfs_group_intent_rele); 5107DEFINE_GROUP_INTENTS_EVENT(xfs_group_wait_intents); 5108 5109#endif /* CONFIG_XFS_DRAIN_INTENTS */ 5110 5111#ifdef CONFIG_XFS_MEMORY_BUFS 5112TRACE_EVENT(xmbuf_create, 5113 TP_PROTO(struct xfs_buftarg *btp), 5114 TP_ARGS(btp), 5115 TP_STRUCT__entry( 5116 __field(dev_t, dev) 5117 __field(unsigned long, ino) 5118 ), 5119 TP_fast_assign( 5120 struct file *file = btp->bt_file; 5121 5122 __entry->dev = btp->bt_mount->m_super->s_dev; 5123 __entry->ino = file_inode(file)->i_ino; 5124 ), 5125 TP_printk("dev %d:%d xmino 0x%lx", 5126 MAJOR(__entry->dev), MINOR(__entry->dev), 5127 __entry->ino) 5128); 5129 5130TRACE_EVENT(xmbuf_free, 5131 TP_PROTO(struct xfs_buftarg *btp), 5132 TP_ARGS(btp), 5133 TP_STRUCT__entry( 5134 __field(dev_t, dev) 5135 __field(unsigned long, ino) 5136 __field(unsigned long long, bytes) 5137 __field(loff_t, size) 5138 ), 5139 TP_fast_assign( 5140 struct file *file = btp->bt_file; 5141 struct inode *inode = file_inode(file); 5142 5143 __entry->dev = btp->bt_mount->m_super->s_dev; 5144 __entry->size = i_size_read(inode); 5145 __entry->bytes = (inode->i_blocks << SECTOR_SHIFT) + inode->i_bytes; 5146 __entry->ino = inode->i_ino; 5147 ), 5148 TP_printk("dev %d:%d xmino 0x%lx mem_bytes 0x%llx isize 0x%llx", 5149 MAJOR(__entry->dev), MINOR(__entry->dev), 5150 __entry->ino, 5151 __entry->bytes, 5152 __entry->size) 5153); 5154#endif /* CONFIG_XFS_MEMORY_BUFS */ 5155 5156#ifdef CONFIG_XFS_BTREE_IN_MEM 5157TRACE_EVENT(xfbtree_init, 5158 TP_PROTO(struct xfs_mount *mp, struct xfbtree *xfbt, 5159 const struct xfs_btree_ops *ops), 5160 TP_ARGS(mp, xfbt, ops), 5161 TP_STRUCT__entry( 5162 __field(const void *, btree_ops) 5163 __field(unsigned long, xfino) 5164 __field(unsigned int, leaf_mxr) 5165 __field(unsigned int, leaf_mnr) 5166 __field(unsigned int, node_mxr) 5167 __field(unsigned int, node_mnr) 5168 __field(unsigned long long, owner) 5169 ), 5170 TP_fast_assign( 5171 __entry->btree_ops = ops; 5172 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5173 __entry->leaf_mxr = xfbt->maxrecs[0]; 5174 __entry->node_mxr = xfbt->maxrecs[1]; 5175 __entry->leaf_mnr = xfbt->minrecs[0]; 5176 __entry->node_mnr = xfbt->minrecs[1]; 5177 __entry->owner = xfbt->owner; 5178 ), 5179 TP_printk("xfino 0x%lx btree_ops %pS owner 0x%llx leaf_mxr %u leaf_mnr %u node_mxr %u node_mnr %u", 5180 __entry->xfino, 5181 __entry->btree_ops, 5182 __entry->owner, 5183 __entry->leaf_mxr, 5184 __entry->leaf_mnr, 5185 __entry->node_mxr, 5186 __entry->node_mnr) 5187); 5188 5189DECLARE_EVENT_CLASS(xfbtree_buf_class, 5190 TP_PROTO(struct xfbtree *xfbt, struct xfs_buf *bp), 5191 TP_ARGS(xfbt, bp), 5192 TP_STRUCT__entry( 5193 __field(unsigned long, xfino) 5194 __field(xfs_daddr_t, bno) 5195 __field(int, nblks) 5196 __field(int, hold) 5197 __field(int, pincount) 5198 __field(unsigned int, lockval) 5199 __field(unsigned int, flags) 5200 ), 5201 TP_fast_assign( 5202 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5203 __entry->bno = xfs_buf_daddr(bp); 5204 __entry->nblks = bp->b_length; 5205 __entry->hold = bp->b_hold; 5206 __entry->pincount = atomic_read(&bp->b_pin_count); 5207 __entry->lockval = bp->b_sema.count; 5208 __entry->flags = bp->b_flags; 5209 ), 5210 TP_printk("xfino 0x%lx daddr 0x%llx bbcount 0x%x hold %d pincount %d lock %d flags %s", 5211 __entry->xfino, 5212 (unsigned long long)__entry->bno, 5213 __entry->nblks, 5214 __entry->hold, 5215 __entry->pincount, 5216 __entry->lockval, 5217 __print_flags(__entry->flags, "|", XFS_BUF_FLAGS)) 5218) 5219 5220#define DEFINE_XFBTREE_BUF_EVENT(name) \ 5221DEFINE_EVENT(xfbtree_buf_class, name, \ 5222 TP_PROTO(struct xfbtree *xfbt, struct xfs_buf *bp), \ 5223 TP_ARGS(xfbt, bp)) 5224DEFINE_XFBTREE_BUF_EVENT(xfbtree_create_root_buf); 5225DEFINE_XFBTREE_BUF_EVENT(xfbtree_trans_commit_buf); 5226DEFINE_XFBTREE_BUF_EVENT(xfbtree_trans_cancel_buf); 5227 5228DECLARE_EVENT_CLASS(xfbtree_freesp_class, 5229 TP_PROTO(struct xfbtree *xfbt, struct xfs_btree_cur *cur, 5230 xfs_fileoff_t fileoff), 5231 TP_ARGS(xfbt, cur, fileoff), 5232 TP_STRUCT__entry( 5233 __field(unsigned long, xfino) 5234 __string(btname, cur->bc_ops->name) 5235 __field(int, nlevels) 5236 __field(xfs_fileoff_t, fileoff) 5237 ), 5238 TP_fast_assign( 5239 __entry->xfino = file_inode(xfbt->target->bt_file)->i_ino; 5240 __assign_str(btname); 5241 __entry->nlevels = cur->bc_nlevels; 5242 __entry->fileoff = fileoff; 5243 ), 5244 TP_printk("xfino 0x%lx %sbt nlevels %d fileoff 0x%llx", 5245 __entry->xfino, 5246 __get_str(btname), 5247 __entry->nlevels, 5248 (unsigned long long)__entry->fileoff) 5249) 5250 5251#define DEFINE_XFBTREE_FREESP_EVENT(name) \ 5252DEFINE_EVENT(xfbtree_freesp_class, name, \ 5253 TP_PROTO(struct xfbtree *xfbt, struct xfs_btree_cur *cur, \ 5254 xfs_fileoff_t fileoff), \ 5255 TP_ARGS(xfbt, cur, fileoff)) 5256DEFINE_XFBTREE_FREESP_EVENT(xfbtree_alloc_block); 5257DEFINE_XFBTREE_FREESP_EVENT(xfbtree_free_block); 5258#endif /* CONFIG_XFS_BTREE_IN_MEM */ 5259 5260/* exchmaps tracepoints */ 5261#define XFS_EXCHMAPS_STRINGS \ 5262 { XFS_EXCHMAPS_ATTR_FORK, "ATTRFORK" }, \ 5263 { XFS_EXCHMAPS_SET_SIZES, "SETSIZES" }, \ 5264 { XFS_EXCHMAPS_INO1_WRITTEN, "INO1_WRITTEN" }, \ 5265 { XFS_EXCHMAPS_CLEAR_INO1_REFLINK, "CLEAR_INO1_REFLINK" }, \ 5266 { XFS_EXCHMAPS_CLEAR_INO2_REFLINK, "CLEAR_INO2_REFLINK" }, \ 5267 { __XFS_EXCHMAPS_INO2_SHORTFORM, "INO2_SF" } 5268 5269DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping1_skip); 5270DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping1); 5271DEFINE_INODE_IREC_EVENT(xfs_exchmaps_mapping2); 5272DEFINE_ITRUNC_EVENT(xfs_exchmaps_update_inode_size); 5273 5274#define XFS_EXCHRANGE_INODES \ 5275 { 1, "file1" }, \ 5276 { 2, "file2" } 5277 5278DECLARE_EVENT_CLASS(xfs_exchrange_inode_class, 5279 TP_PROTO(struct xfs_inode *ip, int whichfile), 5280 TP_ARGS(ip, whichfile), 5281 TP_STRUCT__entry( 5282 __field(dev_t, dev) 5283 __field(int, whichfile) 5284 __field(xfs_ino_t, ino) 5285 __field(int, format) 5286 __field(xfs_extnum_t, nex) 5287 __field(int, broot_size) 5288 __field(int, fork_off) 5289 ), 5290 TP_fast_assign( 5291 __entry->dev = VFS_I(ip)->i_sb->s_dev; 5292 __entry->whichfile = whichfile; 5293 __entry->ino = ip->i_ino; 5294 __entry->format = ip->i_df.if_format; 5295 __entry->nex = ip->i_df.if_nextents; 5296 __entry->fork_off = xfs_inode_fork_boff(ip); 5297 ), 5298 TP_printk("dev %d:%d ino 0x%llx whichfile %s format %s num_extents %llu forkoff 0x%x", 5299 MAJOR(__entry->dev), MINOR(__entry->dev), 5300 __entry->ino, 5301 __print_symbolic(__entry->whichfile, XFS_EXCHRANGE_INODES), 5302 __print_symbolic(__entry->format, XFS_INODE_FORMAT_STR), 5303 __entry->nex, 5304 __entry->fork_off) 5305) 5306 5307#define DEFINE_EXCHRANGE_INODE_EVENT(name) \ 5308DEFINE_EVENT(xfs_exchrange_inode_class, name, \ 5309 TP_PROTO(struct xfs_inode *ip, int whichfile), \ 5310 TP_ARGS(ip, whichfile)) 5311 5312DEFINE_EXCHRANGE_INODE_EVENT(xfs_exchrange_before); 5313DEFINE_EXCHRANGE_INODE_EVENT(xfs_exchrange_after); 5314DEFINE_INODE_ERROR_EVENT(xfs_exchrange_error); 5315 5316#define XFS_EXCHANGE_RANGE_FLAGS_STRS \ 5317 { XFS_EXCHANGE_RANGE_TO_EOF, "TO_EOF" }, \ 5318 { XFS_EXCHANGE_RANGE_DSYNC , "DSYNC" }, \ 5319 { XFS_EXCHANGE_RANGE_DRY_RUN, "DRY_RUN" }, \ 5320 { XFS_EXCHANGE_RANGE_FILE1_WRITTEN, "F1_WRITTEN" }, \ 5321 { __XFS_EXCHANGE_RANGE_UPD_CMTIME1, "CMTIME1" }, \ 5322 { __XFS_EXCHANGE_RANGE_UPD_CMTIME2, "CMTIME2" }, \ 5323 { __XFS_EXCHANGE_RANGE_CHECK_FRESH2, "FRESH2" } 5324 5325/* file exchange-range tracepoint class */ 5326DECLARE_EVENT_CLASS(xfs_exchrange_class, 5327 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip1, 5328 struct xfs_inode *ip2), 5329 TP_ARGS(fxr, ip1, ip2), 5330 TP_STRUCT__entry( 5331 __field(dev_t, dev) 5332 __field(xfs_ino_t, ip1_ino) 5333 __field(loff_t, ip1_isize) 5334 __field(loff_t, ip1_disize) 5335 __field(xfs_ino_t, ip2_ino) 5336 __field(loff_t, ip2_isize) 5337 __field(loff_t, ip2_disize) 5338 5339 __field(loff_t, file1_offset) 5340 __field(loff_t, file2_offset) 5341 __field(unsigned long long, length) 5342 __field(unsigned long long, flags) 5343 ), 5344 TP_fast_assign( 5345 __entry->dev = VFS_I(ip1)->i_sb->s_dev; 5346 __entry->ip1_ino = ip1->i_ino; 5347 __entry->ip1_isize = VFS_I(ip1)->i_size; 5348 __entry->ip1_disize = ip1->i_disk_size; 5349 __entry->ip2_ino = ip2->i_ino; 5350 __entry->ip2_isize = VFS_I(ip2)->i_size; 5351 __entry->ip2_disize = ip2->i_disk_size; 5352 5353 __entry->file1_offset = fxr->file1_offset; 5354 __entry->file2_offset = fxr->file2_offset; 5355 __entry->length = fxr->length; 5356 __entry->flags = fxr->flags; 5357 ), 5358 TP_printk("dev %d:%d flags %s bytecount 0x%llx " 5359 "ino1 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx -> " 5360 "ino2 0x%llx isize 0x%llx disize 0x%llx pos 0x%llx", 5361 MAJOR(__entry->dev), MINOR(__entry->dev), 5362 __print_flags_u64(__entry->flags, "|", XFS_EXCHANGE_RANGE_FLAGS_STRS), 5363 __entry->length, 5364 __entry->ip1_ino, 5365 __entry->ip1_isize, 5366 __entry->ip1_disize, 5367 __entry->file1_offset, 5368 __entry->ip2_ino, 5369 __entry->ip2_isize, 5370 __entry->ip2_disize, 5371 __entry->file2_offset) 5372) 5373 5374#define DEFINE_EXCHRANGE_EVENT(name) \ 5375DEFINE_EVENT(xfs_exchrange_class, name, \ 5376 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip1, \ 5377 struct xfs_inode *ip2), \ 5378 TP_ARGS(fxr, ip1, ip2)) 5379DEFINE_EXCHRANGE_EVENT(xfs_exchrange_prep); 5380DEFINE_EXCHRANGE_EVENT(xfs_exchrange_flush); 5381DEFINE_EXCHRANGE_EVENT(xfs_exchrange_mappings); 5382 5383TRACE_EVENT(xfs_exchrange_freshness, 5384 TP_PROTO(const struct xfs_exchrange *fxr, struct xfs_inode *ip2), 5385 TP_ARGS(fxr, ip2), 5386 TP_STRUCT__entry( 5387 __field(dev_t, dev) 5388 __field(xfs_ino_t, ip2_ino) 5389 __field(long long, ip2_mtime) 5390 __field(long long, ip2_ctime) 5391 __field(int, ip2_mtime_nsec) 5392 __field(int, ip2_ctime_nsec) 5393 5394 __field(xfs_ino_t, file2_ino) 5395 __field(long long, file2_mtime) 5396 __field(long long, file2_ctime) 5397 __field(int, file2_mtime_nsec) 5398 __field(int, file2_ctime_nsec) 5399 ), 5400 TP_fast_assign( 5401 struct timespec64 ts64; 5402 struct inode *inode2 = VFS_I(ip2); 5403 5404 __entry->dev = inode2->i_sb->s_dev; 5405 __entry->ip2_ino = ip2->i_ino; 5406 5407 ts64 = inode_get_ctime(inode2); 5408 __entry->ip2_ctime = ts64.tv_sec; 5409 __entry->ip2_ctime_nsec = ts64.tv_nsec; 5410 5411 ts64 = inode_get_mtime(inode2); 5412 __entry->ip2_mtime = ts64.tv_sec; 5413 __entry->ip2_mtime_nsec = ts64.tv_nsec; 5414 5415 __entry->file2_ino = fxr->file2_ino; 5416 __entry->file2_mtime = fxr->file2_mtime.tv_sec; 5417 __entry->file2_ctime = fxr->file2_ctime.tv_sec; 5418 __entry->file2_mtime_nsec = fxr->file2_mtime.tv_nsec; 5419 __entry->file2_ctime_nsec = fxr->file2_ctime.tv_nsec; 5420 ), 5421 TP_printk("dev %d:%d " 5422 "ino 0x%llx mtime %lld:%d ctime %lld:%d -> " 5423 "file 0x%llx mtime %lld:%d ctime %lld:%d", 5424 MAJOR(__entry->dev), MINOR(__entry->dev), 5425 __entry->ip2_ino, 5426 __entry->ip2_mtime, 5427 __entry->ip2_mtime_nsec, 5428 __entry->ip2_ctime, 5429 __entry->ip2_ctime_nsec, 5430 __entry->file2_ino, 5431 __entry->file2_mtime, 5432 __entry->file2_mtime_nsec, 5433 __entry->file2_ctime, 5434 __entry->file2_ctime_nsec) 5435); 5436 5437TRACE_EVENT(xfs_exchmaps_overhead, 5438 TP_PROTO(struct xfs_mount *mp, unsigned long long bmbt_blocks, 5439 unsigned long long rmapbt_blocks), 5440 TP_ARGS(mp, bmbt_blocks, rmapbt_blocks), 5441 TP_STRUCT__entry( 5442 __field(dev_t, dev) 5443 __field(unsigned long long, bmbt_blocks) 5444 __field(unsigned long long, rmapbt_blocks) 5445 ), 5446 TP_fast_assign( 5447 __entry->dev = mp->m_super->s_dev; 5448 __entry->bmbt_blocks = bmbt_blocks; 5449 __entry->rmapbt_blocks = rmapbt_blocks; 5450 ), 5451 TP_printk("dev %d:%d bmbt_blocks 0x%llx rmapbt_blocks 0x%llx", 5452 MAJOR(__entry->dev), MINOR(__entry->dev), 5453 __entry->bmbt_blocks, 5454 __entry->rmapbt_blocks) 5455); 5456 5457DECLARE_EVENT_CLASS(xfs_exchmaps_estimate_class, 5458 TP_PROTO(const struct xfs_exchmaps_req *req), 5459 TP_ARGS(req), 5460 TP_STRUCT__entry( 5461 __field(dev_t, dev) 5462 __field(xfs_ino_t, ino1) 5463 __field(xfs_ino_t, ino2) 5464 __field(xfs_fileoff_t, startoff1) 5465 __field(xfs_fileoff_t, startoff2) 5466 __field(xfs_filblks_t, blockcount) 5467 __field(uint64_t, flags) 5468 __field(xfs_filblks_t, ip1_bcount) 5469 __field(xfs_filblks_t, ip2_bcount) 5470 __field(xfs_filblks_t, ip1_rtbcount) 5471 __field(xfs_filblks_t, ip2_rtbcount) 5472 __field(unsigned long long, resblks) 5473 __field(unsigned long long, nr_exchanges) 5474 ), 5475 TP_fast_assign( 5476 __entry->dev = req->ip1->i_mount->m_super->s_dev; 5477 __entry->ino1 = req->ip1->i_ino; 5478 __entry->ino2 = req->ip2->i_ino; 5479 __entry->startoff1 = req->startoff1; 5480 __entry->startoff2 = req->startoff2; 5481 __entry->blockcount = req->blockcount; 5482 __entry->flags = req->flags; 5483 __entry->ip1_bcount = req->ip1_bcount; 5484 __entry->ip2_bcount = req->ip2_bcount; 5485 __entry->ip1_rtbcount = req->ip1_rtbcount; 5486 __entry->ip2_rtbcount = req->ip2_rtbcount; 5487 __entry->resblks = req->resblks; 5488 __entry->nr_exchanges = req->nr_exchanges; 5489 ), 5490 TP_printk("dev %d:%d ino1 0x%llx fileoff1 0x%llx ino2 0x%llx fileoff2 0x%llx fsbcount 0x%llx flags (%s) bcount1 0x%llx rtbcount1 0x%llx bcount2 0x%llx rtbcount2 0x%llx resblks 0x%llx nr_exchanges %llu", 5491 MAJOR(__entry->dev), MINOR(__entry->dev), 5492 __entry->ino1, __entry->startoff1, 5493 __entry->ino2, __entry->startoff2, 5494 __entry->blockcount, 5495 __print_flags_u64(__entry->flags, "|", XFS_EXCHMAPS_STRINGS), 5496 __entry->ip1_bcount, 5497 __entry->ip1_rtbcount, 5498 __entry->ip2_bcount, 5499 __entry->ip2_rtbcount, 5500 __entry->resblks, 5501 __entry->nr_exchanges) 5502); 5503 5504#define DEFINE_EXCHMAPS_ESTIMATE_EVENT(name) \ 5505DEFINE_EVENT(xfs_exchmaps_estimate_class, name, \ 5506 TP_PROTO(const struct xfs_exchmaps_req *req), \ 5507 TP_ARGS(req)) 5508DEFINE_EXCHMAPS_ESTIMATE_EVENT(xfs_exchmaps_initial_estimate); 5509DEFINE_EXCHMAPS_ESTIMATE_EVENT(xfs_exchmaps_final_estimate); 5510 5511DECLARE_EVENT_CLASS(xfs_exchmaps_intent_class, 5512 TP_PROTO(struct xfs_mount *mp, const struct xfs_exchmaps_intent *xmi), 5513 TP_ARGS(mp, xmi), 5514 TP_STRUCT__entry( 5515 __field(dev_t, dev) 5516 __field(xfs_ino_t, ino1) 5517 __field(xfs_ino_t, ino2) 5518 __field(uint64_t, flags) 5519 __field(xfs_fileoff_t, startoff1) 5520 __field(xfs_fileoff_t, startoff2) 5521 __field(xfs_filblks_t, blockcount) 5522 __field(xfs_fsize_t, isize1) 5523 __field(xfs_fsize_t, isize2) 5524 __field(xfs_fsize_t, new_isize1) 5525 __field(xfs_fsize_t, new_isize2) 5526 ), 5527 TP_fast_assign( 5528 __entry->dev = mp->m_super->s_dev; 5529 __entry->ino1 = xmi->xmi_ip1->i_ino; 5530 __entry->ino2 = xmi->xmi_ip2->i_ino; 5531 __entry->flags = xmi->xmi_flags; 5532 __entry->startoff1 = xmi->xmi_startoff1; 5533 __entry->startoff2 = xmi->xmi_startoff2; 5534 __entry->blockcount = xmi->xmi_blockcount; 5535 __entry->isize1 = xmi->xmi_ip1->i_disk_size; 5536 __entry->isize2 = xmi->xmi_ip2->i_disk_size; 5537 __entry->new_isize1 = xmi->xmi_isize1; 5538 __entry->new_isize2 = xmi->xmi_isize2; 5539 ), 5540 TP_printk("dev %d:%d ino1 0x%llx fileoff1 0x%llx ino2 0x%llx fileoff2 0x%llx fsbcount 0x%llx flags (%s) isize1 0x%llx newisize1 0x%llx isize2 0x%llx newisize2 0x%llx", 5541 MAJOR(__entry->dev), MINOR(__entry->dev), 5542 __entry->ino1, __entry->startoff1, 5543 __entry->ino2, __entry->startoff2, 5544 __entry->blockcount, 5545 __print_flags_u64(__entry->flags, "|", XFS_EXCHMAPS_STRINGS), 5546 __entry->isize1, __entry->new_isize1, 5547 __entry->isize2, __entry->new_isize2) 5548); 5549 5550#define DEFINE_EXCHMAPS_INTENT_EVENT(name) \ 5551DEFINE_EVENT(xfs_exchmaps_intent_class, name, \ 5552 TP_PROTO(struct xfs_mount *mp, const struct xfs_exchmaps_intent *xmi), \ 5553 TP_ARGS(mp, xmi)) 5554DEFINE_EXCHMAPS_INTENT_EVENT(xfs_exchmaps_defer); 5555DEFINE_EXCHMAPS_INTENT_EVENT(xfs_exchmaps_recover); 5556 5557TRACE_EVENT(xfs_exchmaps_delta_nextents_step, 5558 TP_PROTO(struct xfs_mount *mp, 5559 const struct xfs_bmbt_irec *left, 5560 const struct xfs_bmbt_irec *curr, 5561 const struct xfs_bmbt_irec *new, 5562 const struct xfs_bmbt_irec *right, 5563 int delta, unsigned int state), 5564 TP_ARGS(mp, left, curr, new, right, delta, state), 5565 TP_STRUCT__entry( 5566 __field(dev_t, dev) 5567 __field(xfs_fileoff_t, loff) 5568 __field(xfs_fsblock_t, lstart) 5569 __field(xfs_filblks_t, lcount) 5570 __field(xfs_fileoff_t, coff) 5571 __field(xfs_fsblock_t, cstart) 5572 __field(xfs_filblks_t, ccount) 5573 __field(xfs_fileoff_t, noff) 5574 __field(xfs_fsblock_t, nstart) 5575 __field(xfs_filblks_t, ncount) 5576 __field(xfs_fileoff_t, roff) 5577 __field(xfs_fsblock_t, rstart) 5578 __field(xfs_filblks_t, rcount) 5579 __field(int, delta) 5580 __field(unsigned int, state) 5581 ), 5582 TP_fast_assign( 5583 __entry->dev = mp->m_super->s_dev; 5584 __entry->loff = left->br_startoff; 5585 __entry->lstart = left->br_startblock; 5586 __entry->lcount = left->br_blockcount; 5587 __entry->coff = curr->br_startoff; 5588 __entry->cstart = curr->br_startblock; 5589 __entry->ccount = curr->br_blockcount; 5590 __entry->noff = new->br_startoff; 5591 __entry->nstart = new->br_startblock; 5592 __entry->ncount = new->br_blockcount; 5593 __entry->roff = right->br_startoff; 5594 __entry->rstart = right->br_startblock; 5595 __entry->rcount = right->br_blockcount; 5596 __entry->delta = delta; 5597 __entry->state = state; 5598 ), 5599 TP_printk("dev %d:%d left 0x%llx:0x%llx:0x%llx; curr 0x%llx:0x%llx:0x%llx <- new 0x%llx:0x%llx:0x%llx; right 0x%llx:0x%llx:0x%llx delta %d state 0x%x", 5600 MAJOR(__entry->dev), MINOR(__entry->dev), 5601 __entry->loff, __entry->lstart, __entry->lcount, 5602 __entry->coff, __entry->cstart, __entry->ccount, 5603 __entry->noff, __entry->nstart, __entry->ncount, 5604 __entry->roff, __entry->rstart, __entry->rcount, 5605 __entry->delta, __entry->state) 5606); 5607 5608TRACE_EVENT(xfs_exchmaps_delta_nextents, 5609 TP_PROTO(const struct xfs_exchmaps_req *req, int64_t d_nexts1, 5610 int64_t d_nexts2), 5611 TP_ARGS(req, d_nexts1, d_nexts2), 5612 TP_STRUCT__entry( 5613 __field(dev_t, dev) 5614 __field(xfs_ino_t, ino1) 5615 __field(xfs_ino_t, ino2) 5616 __field(xfs_extnum_t, nexts1) 5617 __field(xfs_extnum_t, nexts2) 5618 __field(int64_t, d_nexts1) 5619 __field(int64_t, d_nexts2) 5620 ), 5621 TP_fast_assign( 5622 int whichfork = xfs_exchmaps_reqfork(req); 5623 5624 __entry->dev = req->ip1->i_mount->m_super->s_dev; 5625 __entry->ino1 = req->ip1->i_ino; 5626 __entry->ino2 = req->ip2->i_ino; 5627 __entry->nexts1 = xfs_ifork_ptr(req->ip1, whichfork)->if_nextents; 5628 __entry->nexts2 = xfs_ifork_ptr(req->ip2, whichfork)->if_nextents; 5629 __entry->d_nexts1 = d_nexts1; 5630 __entry->d_nexts2 = d_nexts2; 5631 ), 5632 TP_printk("dev %d:%d ino1 0x%llx nexts %llu ino2 0x%llx nexts %llu delta1 %lld delta2 %lld", 5633 MAJOR(__entry->dev), MINOR(__entry->dev), 5634 __entry->ino1, __entry->nexts1, 5635 __entry->ino2, __entry->nexts2, 5636 __entry->d_nexts1, __entry->d_nexts2) 5637); 5638 5639DECLARE_EVENT_CLASS(xfs_getparents_rec_class, 5640 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, 5641 const struct xfs_attr_list_context *context, 5642 const struct xfs_getparents_rec *pptr), 5643 TP_ARGS(ip, ppi, context, pptr), 5644 TP_STRUCT__entry( 5645 __field(dev_t, dev) 5646 __field(xfs_ino_t, ino) 5647 __field(unsigned int, firstu) 5648 __field(unsigned short, reclen) 5649 __field(unsigned int, bufsize) 5650 __field(xfs_ino_t, parent_ino) 5651 __field(unsigned int, parent_gen) 5652 __string(name, pptr->gpr_name) 5653 ), 5654 TP_fast_assign( 5655 __entry->dev = ip->i_mount->m_super->s_dev; 5656 __entry->ino = ip->i_ino; 5657 __entry->firstu = context->firstu; 5658 __entry->reclen = pptr->gpr_reclen; 5659 __entry->bufsize = ppi->gp_bufsize; 5660 __entry->parent_ino = pptr->gpr_parent.ha_fid.fid_ino; 5661 __entry->parent_gen = pptr->gpr_parent.ha_fid.fid_gen; 5662 __assign_str(name); 5663 ), 5664 TP_printk("dev %d:%d ino 0x%llx firstu %u reclen %u bufsize %u parent_ino 0x%llx parent_gen 0x%x name '%s'", 5665 MAJOR(__entry->dev), MINOR(__entry->dev), 5666 __entry->ino, 5667 __entry->firstu, 5668 __entry->reclen, 5669 __entry->bufsize, 5670 __entry->parent_ino, 5671 __entry->parent_gen, 5672 __get_str(name)) 5673) 5674#define DEFINE_XFS_GETPARENTS_REC_EVENT(name) \ 5675DEFINE_EVENT(xfs_getparents_rec_class, name, \ 5676 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, \ 5677 const struct xfs_attr_list_context *context, \ 5678 const struct xfs_getparents_rec *pptr), \ 5679 TP_ARGS(ip, ppi, context, pptr)) 5680DEFINE_XFS_GETPARENTS_REC_EVENT(xfs_getparents_put_listent); 5681DEFINE_XFS_GETPARENTS_REC_EVENT(xfs_getparents_expand_lastrec); 5682 5683DECLARE_EVENT_CLASS(xfs_getparents_class, 5684 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, 5685 const struct xfs_attrlist_cursor_kern *cur), 5686 TP_ARGS(ip, ppi, cur), 5687 TP_STRUCT__entry( 5688 __field(dev_t, dev) 5689 __field(xfs_ino_t, ino) 5690 __field(unsigned short, iflags) 5691 __field(unsigned short, oflags) 5692 __field(unsigned int, bufsize) 5693 __field(unsigned int, hashval) 5694 __field(unsigned int, blkno) 5695 __field(unsigned int, offset) 5696 __field(int, initted) 5697 ), 5698 TP_fast_assign( 5699 __entry->dev = ip->i_mount->m_super->s_dev; 5700 __entry->ino = ip->i_ino; 5701 __entry->iflags = ppi->gp_iflags; 5702 __entry->oflags = ppi->gp_oflags; 5703 __entry->bufsize = ppi->gp_bufsize; 5704 __entry->hashval = cur->hashval; 5705 __entry->blkno = cur->blkno; 5706 __entry->offset = cur->offset; 5707 __entry->initted = cur->initted; 5708 ), 5709 TP_printk("dev %d:%d ino 0x%llx iflags 0x%x oflags 0x%x bufsize %u cur_init? %d hashval 0x%x blkno %u offset %u", 5710 MAJOR(__entry->dev), MINOR(__entry->dev), 5711 __entry->ino, 5712 __entry->iflags, 5713 __entry->oflags, 5714 __entry->bufsize, 5715 __entry->initted, 5716 __entry->hashval, 5717 __entry->blkno, 5718 __entry->offset) 5719) 5720#define DEFINE_XFS_GETPARENTS_EVENT(name) \ 5721DEFINE_EVENT(xfs_getparents_class, name, \ 5722 TP_PROTO(struct xfs_inode *ip, const struct xfs_getparents *ppi, \ 5723 const struct xfs_attrlist_cursor_kern *cur), \ 5724 TP_ARGS(ip, ppi, cur)) 5725DEFINE_XFS_GETPARENTS_EVENT(xfs_getparents_begin); 5726DEFINE_XFS_GETPARENTS_EVENT(xfs_getparents_end); 5727 5728DECLARE_EVENT_CLASS(xfs_metadir_update_class, 5729 TP_PROTO(const struct xfs_metadir_update *upd), 5730 TP_ARGS(upd), 5731 TP_STRUCT__entry( 5732 __field(dev_t, dev) 5733 __field(xfs_ino_t, dp_ino) 5734 __field(xfs_ino_t, ino) 5735 __string(fname, upd->path) 5736 ), 5737 TP_fast_assign( 5738 __entry->dev = upd->dp->i_mount->m_super->s_dev; 5739 __entry->dp_ino = upd->dp->i_ino; 5740 __entry->ino = upd->ip ? upd->ip->i_ino : NULLFSINO; 5741 __assign_str(fname); 5742 ), 5743 TP_printk("dev %d:%d dp 0x%llx fname '%s' ino 0x%llx", 5744 MAJOR(__entry->dev), MINOR(__entry->dev), 5745 __entry->dp_ino, 5746 __get_str(fname), 5747 __entry->ino) 5748) 5749 5750#define DEFINE_METADIR_UPDATE_EVENT(name) \ 5751DEFINE_EVENT(xfs_metadir_update_class, name, \ 5752 TP_PROTO(const struct xfs_metadir_update *upd), \ 5753 TP_ARGS(upd)) 5754DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_start_create); 5755DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_start_link); 5756DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_commit); 5757DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_cancel); 5758DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_try_create); 5759DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_create); 5760DEFINE_METADIR_UPDATE_EVENT(xfs_metadir_link); 5761 5762DECLARE_EVENT_CLASS(xfs_metadir_update_error_class, 5763 TP_PROTO(const struct xfs_metadir_update *upd, int error), 5764 TP_ARGS(upd, error), 5765 TP_STRUCT__entry( 5766 __field(dev_t, dev) 5767 __field(xfs_ino_t, dp_ino) 5768 __field(xfs_ino_t, ino) 5769 __field(int, error) 5770 __string(fname, upd->path) 5771 ), 5772 TP_fast_assign( 5773 __entry->dev = upd->dp->i_mount->m_super->s_dev; 5774 __entry->dp_ino = upd->dp->i_ino; 5775 __entry->ino = upd->ip ? upd->ip->i_ino : NULLFSINO; 5776 __entry->error = error; 5777 __assign_str(fname); 5778 ), 5779 TP_printk("dev %d:%d dp 0x%llx fname '%s' ino 0x%llx error %d", 5780 MAJOR(__entry->dev), MINOR(__entry->dev), 5781 __entry->dp_ino, 5782 __get_str(fname), 5783 __entry->ino, 5784 __entry->error) 5785) 5786 5787#define DEFINE_METADIR_UPDATE_ERROR_EVENT(name) \ 5788DEFINE_EVENT(xfs_metadir_update_error_class, name, \ 5789 TP_PROTO(const struct xfs_metadir_update *upd, int error), \ 5790 TP_ARGS(upd, error)) 5791DEFINE_METADIR_UPDATE_ERROR_EVENT(xfs_metadir_teardown); 5792 5793DECLARE_EVENT_CLASS(xfs_metadir_class, 5794 TP_PROTO(struct xfs_inode *dp, struct xfs_name *name, 5795 xfs_ino_t ino), 5796 TP_ARGS(dp, name, ino), 5797 TP_STRUCT__entry( 5798 __field(dev_t, dev) 5799 __field(xfs_ino_t, dp_ino) 5800 __field(xfs_ino_t, ino) 5801 __field(int, ftype) 5802 __field(int, namelen) 5803 __dynamic_array(char, name, name->len) 5804 ), 5805 TP_fast_assign( 5806 __entry->dev = VFS_I(dp)->i_sb->s_dev; 5807 __entry->dp_ino = dp->i_ino; 5808 __entry->ino = ino, 5809 __entry->ftype = name->type; 5810 __entry->namelen = name->len; 5811 memcpy(__get_str(name), name->name, name->len); 5812 ), 5813 TP_printk("dev %d:%d dir 0x%llx type %s name '%.*s' ino 0x%llx", 5814 MAJOR(__entry->dev), MINOR(__entry->dev), 5815 __entry->dp_ino, 5816 __print_symbolic(__entry->ftype, XFS_DIR3_FTYPE_STR), 5817 __entry->namelen, 5818 __get_str(name), 5819 __entry->ino) 5820) 5821 5822#define DEFINE_METADIR_EVENT(name) \ 5823DEFINE_EVENT(xfs_metadir_class, name, \ 5824 TP_PROTO(struct xfs_inode *dp, struct xfs_name *name, \ 5825 xfs_ino_t ino), \ 5826 TP_ARGS(dp, name, ino)) 5827DEFINE_METADIR_EVENT(xfs_metadir_lookup); 5828 5829/* metadata inode space reservations */ 5830 5831DECLARE_EVENT_CLASS(xfs_metafile_resv_class, 5832 TP_PROTO(struct xfs_mount *mp, xfs_filblks_t len), 5833 TP_ARGS(mp, len), 5834 TP_STRUCT__entry( 5835 __field(dev_t, dev) 5836 __field(unsigned long long, freeblks) 5837 __field(unsigned long long, reserved) 5838 __field(unsigned long long, asked) 5839 __field(unsigned long long, used) 5840 __field(unsigned long long, len) 5841 ), 5842 TP_fast_assign( 5843 __entry->dev = mp->m_super->s_dev; 5844 __entry->freeblks = xfs_sum_freecounter_raw(mp, XC_FREE_BLOCKS); 5845 __entry->reserved = mp->m_metafile_resv_avail; 5846 __entry->asked = mp->m_metafile_resv_target; 5847 __entry->used = mp->m_metafile_resv_used; 5848 __entry->len = len; 5849 ), 5850 TP_printk("dev %d:%d freeblks %llu resv %llu ask %llu used %llu len %llu", 5851 MAJOR(__entry->dev), MINOR(__entry->dev), 5852 __entry->freeblks, 5853 __entry->reserved, 5854 __entry->asked, 5855 __entry->used, 5856 __entry->len) 5857) 5858#define DEFINE_METAFILE_RESV_EVENT(name) \ 5859DEFINE_EVENT(xfs_metafile_resv_class, name, \ 5860 TP_PROTO(struct xfs_mount *mp, xfs_filblks_t len), \ 5861 TP_ARGS(mp, len)) 5862DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_init); 5863DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_free); 5864DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_alloc_space); 5865DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_free_space); 5866DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_critical); 5867DEFINE_METAFILE_RESV_EVENT(xfs_metafile_resv_init_error); 5868 5869#ifdef CONFIG_XFS_RT 5870TRACE_EVENT(xfs_growfs_check_rtgeom, 5871 TP_PROTO(const struct xfs_mount *mp, unsigned int min_logfsbs), 5872 TP_ARGS(mp, min_logfsbs), 5873 TP_STRUCT__entry( 5874 __field(dev_t, dev) 5875 __field(unsigned int, logblocks) 5876 __field(unsigned int, min_logfsbs) 5877 ), 5878 TP_fast_assign( 5879 __entry->dev = mp->m_super->s_dev; 5880 __entry->logblocks = mp->m_sb.sb_logblocks; 5881 __entry->min_logfsbs = min_logfsbs; 5882 ), 5883 TP_printk("dev %d:%d logblocks %u min_logfsbs %u", 5884 MAJOR(__entry->dev), MINOR(__entry->dev), 5885 __entry->logblocks, 5886 __entry->min_logfsbs) 5887); 5888#endif /* CONFIG_XFS_RT */ 5889 5890TRACE_DEFINE_ENUM(XC_FREE_BLOCKS); 5891TRACE_DEFINE_ENUM(XC_FREE_RTEXTENTS); 5892TRACE_DEFINE_ENUM(XC_FREE_RTAVAILABLE); 5893 5894DECLARE_EVENT_CLASS(xfs_freeblocks_resv_class, 5895 TP_PROTO(struct xfs_mount *mp, enum xfs_free_counter ctr, 5896 uint64_t delta, unsigned long caller_ip), 5897 TP_ARGS(mp, ctr, delta, caller_ip), 5898 TP_STRUCT__entry( 5899 __field(dev_t, dev) 5900 __field(enum xfs_free_counter, ctr) 5901 __field(uint64_t, delta) 5902 __field(uint64_t, avail) 5903 __field(uint64_t, total) 5904 __field(unsigned long, caller_ip) 5905 ), 5906 TP_fast_assign( 5907 __entry->dev = mp->m_super->s_dev; 5908 __entry->ctr = ctr; 5909 __entry->delta = delta; 5910 __entry->avail = mp->m_free[ctr].res_avail; 5911 __entry->total = mp->m_free[ctr].res_total; 5912 __entry->caller_ip = caller_ip; 5913 ), 5914 TP_printk("dev %d:%d ctr %s delta %llu avail %llu total %llu caller %pS", 5915 MAJOR(__entry->dev), MINOR(__entry->dev), 5916 __print_symbolic(__entry->ctr, XFS_FREECOUNTER_STR), 5917 __entry->delta, 5918 __entry->avail, 5919 __entry->total, 5920 (char *)__entry->caller_ip) 5921) 5922#define DEFINE_FREEBLOCKS_RESV_EVENT(name) \ 5923DEFINE_EVENT(xfs_freeblocks_resv_class, name, \ 5924 TP_PROTO(struct xfs_mount *mp, enum xfs_free_counter ctr, \ 5925 uint64_t delta, unsigned long caller_ip), \ 5926 TP_ARGS(mp, ctr, delta, caller_ip)) 5927DEFINE_FREEBLOCKS_RESV_EVENT(xfs_freecounter_reserved); 5928DEFINE_FREEBLOCKS_RESV_EVENT(xfs_freecounter_enospc); 5929 5930#endif /* _TRACE_XFS_H */ 5931 5932#undef TRACE_INCLUDE_PATH 5933#define TRACE_INCLUDE_PATH . 5934#define TRACE_INCLUDE_FILE xfs_trace 5935#include <trace/define_trace.h>
~/
Read-only file preview.