1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #undef TRACE_SYSTEM 3 #define TRACE_SYSTEM btrfs 4 5 #if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ) 6 #define _TRACE_BTRFS_H 7 8 #include <linux/writeback.h> 9 #include <linux/tracepoint.h> 10 #include <trace/events/mmflags.h> 11 12 struct btrfs_root; 13 struct btrfs_fs_info; 14 struct btrfs_inode; 15 struct extent_map; 16 struct btrfs_file_extent_item; 17 struct btrfs_ordered_extent; 18 struct btrfs_delayed_ref_node; 19 struct btrfs_delayed_ref_head; 20 struct btrfs_block_group; 21 struct btrfs_free_cluster; 22 struct btrfs_chunk_map; 23 struct extent_buffer; 24 struct btrfs_work; 25 struct btrfs_workqueue; 26 struct btrfs_qgroup_extent_record; 27 struct btrfs_qgroup; 28 struct extent_io_tree; 29 struct prelim_ref; 30 struct btrfs_space_info; 31 struct btrfs_raid_bio; 32 struct raid56_bio_trace_info; 33 struct find_free_extent_ctl; 34 struct btrfs_trans_handle; 35 struct btrfs_transaction; 36 struct btrfs_log_ctx; 37 38 #define show_inode_type(mode) \ 39 __print_symbolic((mode) & S_IFMT, \ 40 { S_IFDIR, "DIR" }, \ 41 { S_IFREG, "REG" }, \ 42 { S_IFLNK, "LNK" }, \ 43 { S_IFIFO, "FIFO" }, \ 44 { S_IFCHR, "CHR" }, \ 45 { S_IFBLK, "BLK" }, \ 46 { S_IFSOCK, "SOCK" }) 47 48 #define show_ref_type(type) \ 49 __print_symbolic(type, \ 50 { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \ 51 { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \ 52 { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \ 53 { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" }) 54 55 #define __show_root_type(obj) \ 56 __print_symbolic_u64(obj, \ 57 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \ 58 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \ 59 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \ 60 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \ 61 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \ 62 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \ 63 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \ 64 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \ 65 { BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, \ 66 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \ 67 { BTRFS_UUID_TREE_OBJECTID, "UUID_TREE" }, \ 68 { BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" }, \ 69 { BTRFS_BLOCK_GROUP_TREE_OBJECTID, "BLOCK_GROUP_TREE" },\ 70 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" }) 71 72 #define show_root_type(obj) \ 73 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \ 74 (obj >= BTRFS_ROOT_TREE_OBJECTID && \ 75 obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-" 76 77 #define FLUSH_ACTIONS \ 78 EM( BTRFS_RESERVE_NO_FLUSH, "BTRFS_RESERVE_NO_FLUSH") \ 79 EM( BTRFS_RESERVE_FLUSH_LIMIT, "BTRFS_RESERVE_FLUSH_LIMIT") \ 80 EM( BTRFS_RESERVE_FLUSH_ALL, "BTRFS_RESERVE_FLUSH_ALL") \ 81 EMe(BTRFS_RESERVE_FLUSH_ALL_STEAL, "BTRFS_RESERVE_FLUSH_ALL_STEAL") 82 83 #define FI_TYPES \ 84 EM( BTRFS_FILE_EXTENT_INLINE, "INLINE") \ 85 EM( BTRFS_FILE_EXTENT_REG, "REG") \ 86 EMe(BTRFS_FILE_EXTENT_PREALLOC, "PREALLOC") 87 88 #define QGROUP_RSV_TYPES \ 89 EM( BTRFS_QGROUP_RSV_DATA, "DATA") \ 90 EM( BTRFS_QGROUP_RSV_META_PERTRANS, "META_PERTRANS") \ 91 EMe(BTRFS_QGROUP_RSV_META_PREALLOC, "META_PREALLOC") 92 93 #define IO_TREE_OWNER \ 94 EM( IO_TREE_FS_PINNED_EXTENTS, "PINNED_EXTENTS") \ 95 EM( IO_TREE_FS_EXCLUDED_EXTENTS, "EXCLUDED_EXTENTS") \ 96 EM( IO_TREE_BTREE_INODE_IO, "BTREE_INODE_IO") \ 97 EM( IO_TREE_INODE_IO, "INODE_IO") \ 98 EM( IO_TREE_RELOC_BLOCKS, "RELOC_BLOCKS") \ 99 EM( IO_TREE_TRANS_DIRTY_PAGES, "TRANS_DIRTY_PAGES") \ 100 EM( IO_TREE_ROOT_DIRTY_LOG_PAGES, "ROOT_DIRTY_LOG_PAGES") \ 101 EM( IO_TREE_INODE_FILE_EXTENT, "INODE_FILE_EXTENT") \ 102 EM( IO_TREE_LOG_CSUM_RANGE, "LOG_CSUM_RANGE") \ 103 EMe(IO_TREE_SELFTEST, "SELFTEST") 104 105 #define FLUSH_STATES \ 106 EM( FLUSH_DELAYED_ITEMS_NR, "FLUSH_DELAYED_ITEMS_NR") \ 107 EM( FLUSH_DELAYED_ITEMS, "FLUSH_DELAYED_ITEMS") \ 108 EM( FLUSH_DELALLOC, "FLUSH_DELALLOC") \ 109 EM( FLUSH_DELALLOC_WAIT, "FLUSH_DELALLOC_WAIT") \ 110 EM( FLUSH_DELALLOC_FULL, "FLUSH_DELALLOC_FULL") \ 111 EM( FLUSH_DELAYED_REFS_NR, "FLUSH_DELAYED_REFS_NR") \ 112 EM( FLUSH_DELAYED_REFS, "FLUSH_DELAYED_REFS") \ 113 EM( ALLOC_CHUNK, "ALLOC_CHUNK") \ 114 EM( ALLOC_CHUNK_FORCE, "ALLOC_CHUNK_FORCE") \ 115 EM( RUN_DELAYED_IPUTS, "RUN_DELAYED_IPUTS") \ 116 EM( COMMIT_TRANS, "COMMIT_TRANS") \ 117 EM( RECLAIM_ZONES, "RECLAIM_ZONES") \ 118 EMe(RESET_ZONES, "RESET_ZONES") 119 120 #define TRANSACTION_STATES \ 121 EM( TRANS_STATE_RUNNING, "TRANS_STATE_RUNNING") \ 122 EM( TRANS_STATE_COMMIT_PREP, "TRANS_STATE_COMMIT_PREP") \ 123 EM( TRANS_STATE_COMMIT_START, "TRANS_STATE_COMMIT_START") \ 124 EM( TRANS_STATE_COMMIT_DOING, "TRANS_STATE_COMMIT_DOING") \ 125 EM( TRANS_STATE_UNBLOCKED, "TRANS_STATE_UNBLOCKED") \ 126 EM( TRANS_STATE_SUPER_COMMITTED, "TRANS_STATE_SUPER_COMMITTED") \ 127 EMe(TRANS_STATE_COMPLETED, "TRANS_STATE_COMPLETED") 128 129 #define LOG_MODES \ 130 EM( LOG_INODE_ALL, "LOG_INODE_ALL") \ 131 EMe(LOG_INODE_EXISTS, "LOG_INODE_EXISTS") 132 /* 133 * First define the enums in the above macros to be exported to userspace via 134 * TRACE_DEFINE_ENUM(). 135 */ 136 137 #undef EM 138 #undef EMe 139 #define EM(a, b) TRACE_DEFINE_ENUM(a); 140 #define EMe(a, b) TRACE_DEFINE_ENUM(a); 141 142 FLUSH_ACTIONS 143 FI_TYPES 144 QGROUP_RSV_TYPES 145 IO_TREE_OWNER 146 FLUSH_STATES 147 TRANSACTION_STATES 148 LOG_MODES 149 150 /* 151 * Now redefine the EM and EMe macros to map the enums to the strings that will 152 * be printed in the output 153 */ 154 155 #undef EM 156 #undef EMe 157 #define EM(a, b) {a, b}, 158 #define EMe(a, b) {a, b} 159 160 161 #define BTRFS_GROUP_FLAGS \ 162 { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \ 163 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \ 164 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \ 165 { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \ 166 { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \ 167 { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \ 168 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \ 169 { BTRFS_BLOCK_GROUP_RAID5, "RAID5"}, \ 170 { BTRFS_BLOCK_GROUP_RAID6, "RAID6"} 171 172 #define EXTENT_FLAGS \ 173 { EXTENT_DIRTY, "DIRTY"}, \ 174 { EXTENT_LOCKED, "LOCKED"}, \ 175 { EXTENT_DIRTY_LOG1, "DIRTY_LOG1"}, \ 176 { EXTENT_DIRTY_LOG2, "DIRTY_LOG2"}, \ 177 { EXTENT_DELALLOC, "DELALLOC"}, \ 178 { EXTENT_DEFRAG, "DEFRAG"}, \ 179 { EXTENT_BOUNDARY, "BOUNDARY"}, \ 180 { EXTENT_NODATASUM, "NODATASUM"}, \ 181 { EXTENT_CLEAR_META_RESV, "CLEAR_META_RESV"}, \ 182 { EXTENT_NEED_WAIT, "NEED_WAIT"}, \ 183 { EXTENT_NORESERVE, "NORESERVE"}, \ 184 { EXTENT_QGROUP_RESERVED, "QGROUP_RESERVED"}, \ 185 { EXTENT_CLEAR_DATA_RESV, "CLEAR_DATA_RESV"}, \ 186 { EXTENT_DELALLOC_NEW, "DELALLOC_NEW"} 187 188 #define BTRFS_FSID_SIZE 16 189 #define TP_STRUCT__entry_fsid __array(u8, fsid, BTRFS_FSID_SIZE) 190 191 #define TP_fast_assign_fsid(fs_info) \ 192 ({ \ 193 if (fs_info) \ 194 memcpy(__entry->fsid, fs_info->fs_devices->fsid, \ 195 BTRFS_FSID_SIZE); \ 196 else \ 197 memset(__entry->fsid, 0, BTRFS_FSID_SIZE); \ 198 }) 199 200 #define TP_STRUCT__entry_btrfs(args...) \ 201 TP_STRUCT__entry( \ 202 TP_STRUCT__entry_fsid \ 203 args) 204 #define TP_fast_assign_btrfs(fs_info, args...) \ 205 TP_fast_assign( \ 206 TP_fast_assign_fsid(fs_info); \ 207 args) 208 #define TP_printk_btrfs(fmt, args...) \ 209 TP_printk("%pU: " fmt, __entry->fsid, args) 210 211 TRACE_EVENT(btrfs_transaction_start, 212 213 TP_PROTO(const struct btrfs_transaction *trans), 214 215 TP_ARGS(trans), 216 217 TP_STRUCT__entry_btrfs( 218 __field( u64, generation ) 219 ), 220 221 TP_fast_assign_btrfs(trans->fs_info, 222 __entry->generation = trans->transid; 223 ), 224 225 TP_printk_btrfs("gen=%llu", __entry->generation) 226 ); 227 228 TRACE_EVENT(btrfs_transaction_commit, 229 230 TP_PROTO(const struct btrfs_trans_handle *trans), 231 232 TP_ARGS(trans), 233 234 TP_STRUCT__entry_btrfs( 235 __field( u64, generation ) 236 __field( bool, in_fsync ) 237 __field( int, state ) 238 ), 239 240 TP_fast_assign_btrfs(trans->fs_info, 241 __entry->generation = trans->transid; 242 __entry->in_fsync = trans->in_fsync; 243 __entry->state = trans->transaction->state; 244 ), 245 246 TP_printk_btrfs("gen=%llu in_fsync=%d state=%d(%s)", __entry->generation, 247 __entry->in_fsync, __entry->state, 248 __print_symbolic(__entry->state, TRANSACTION_STATES)) 249 ); 250 251 TRACE_EVENT(btrfs_transaction_abort, 252 253 TP_PROTO(const struct btrfs_trans_handle *trans), 254 255 TP_ARGS(trans), 256 257 TP_STRUCT__entry_btrfs( 258 __field( u64, generation ) 259 __field( bool, in_fsync ) 260 __field( int, error ) 261 ), 262 263 TP_fast_assign_btrfs(trans->fs_info, 264 __entry->generation = trans->transid; 265 __entry->in_fsync = trans->in_fsync; 266 __entry->error = trans->aborted; 267 ), 268 269 TP_printk_btrfs("gen=%llu in_fsync=%d error=%d", __entry->generation, 270 __entry->in_fsync, __entry->error) 271 ); 272 273 DECLARE_EVENT_CLASS(btrfs__inode, 274 275 TP_PROTO(const struct inode *inode), 276 277 TP_ARGS(inode), 278 279 TP_STRUCT__entry_btrfs( 280 __field( u64, ino ) 281 __field( u64, blocks ) 282 __field( u64, disk_i_size ) 283 __field( u64, generation ) 284 __field( u64, last_trans ) 285 __field( u64, logged_trans ) 286 __field( u64, root_objectid ) 287 ), 288 289 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb), 290 __entry->ino = btrfs_ino(BTRFS_I(inode)); 291 __entry->blocks = inode->i_blocks; 292 __entry->disk_i_size = BTRFS_I(inode)->disk_i_size; 293 __entry->generation = BTRFS_I(inode)->generation; 294 __entry->last_trans = BTRFS_I(inode)->last_trans; 295 __entry->logged_trans = BTRFS_I(inode)->logged_trans; 296 __entry->root_objectid = BTRFS_I(inode)->root ? 297 btrfs_root_id(BTRFS_I(inode)->root) : 0; 298 ), 299 300 TP_printk_btrfs("root=%llu(%s) gen=%llu ino=%llu blocks=%llu " 301 "disk_i_size=%llu last_trans=%llu logged_trans=%llu", 302 show_root_type(__entry->root_objectid), 303 __entry->generation, 304 __entry->ino, 305 __entry->blocks, 306 __entry->disk_i_size, 307 __entry->last_trans, 308 __entry->logged_trans) 309 ); 310 311 DEFINE_EVENT(btrfs__inode, btrfs_inode_new, 312 313 TP_PROTO(const struct inode *inode), 314 315 TP_ARGS(inode) 316 ); 317 318 DEFINE_EVENT(btrfs__inode, btrfs_inode_request, 319 320 TP_PROTO(const struct inode *inode), 321 322 TP_ARGS(inode) 323 ); 324 325 DEFINE_EVENT(btrfs__inode, btrfs_inode_evict, 326 327 TP_PROTO(const struct inode *inode), 328 329 TP_ARGS(inode) 330 ); 331 332 #define __show_map_type(type) \ 333 __print_symbolic_u64(type, \ 334 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \ 335 { EXTENT_MAP_HOLE, "HOLE" }, \ 336 { EXTENT_MAP_INLINE, "INLINE" }) 337 338 #define show_map_type(type) \ 339 type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type) 340 341 #define show_map_flags(flag) \ 342 __print_flags(flag, "|", \ 343 { EXTENT_FLAG_PINNED, "PINNED" },\ 344 { EXTENT_FLAG_COMPRESS_ZLIB, "COMPRESS_ZLIB" },\ 345 { EXTENT_FLAG_COMPRESS_LZO, "COMPRESS_LZO" },\ 346 { EXTENT_FLAG_COMPRESS_ZSTD, "COMPRESS_ZSTD" },\ 347 { EXTENT_FLAG_PREALLOC, "PREALLOC" },\ 348 { EXTENT_FLAG_LOGGING, "LOGGING" }) 349 350 TRACE_EVENT_CONDITION(btrfs_get_extent, 351 352 TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode, 353 const struct extent_map *map), 354 355 TP_ARGS(root, inode, map), 356 357 TP_CONDITION(map), 358 359 TP_STRUCT__entry_btrfs( 360 __field( u64, root_objectid ) 361 __field( u64, ino ) 362 __field( u64, start ) 363 __field( u64, len ) 364 __field( u32, flags ) 365 __field( int, refs ) 366 ), 367 368 TP_fast_assign_btrfs(root->fs_info, 369 __entry->root_objectid = btrfs_root_id(root); 370 __entry->ino = btrfs_ino(inode); 371 __entry->start = map->start; 372 __entry->len = map->len; 373 __entry->flags = map->flags; 374 __entry->refs = refcount_read(&map->refs); 375 ), 376 377 TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu flags=%s refs=%u", 378 show_root_type(__entry->root_objectid), 379 __entry->ino, 380 __entry->start, 381 __entry->len, 382 show_map_flags(__entry->flags), 383 __entry->refs) 384 ); 385 386 TRACE_EVENT(btrfs_handle_em_exist, 387 388 TP_PROTO(const struct btrfs_fs_info *fs_info, 389 const struct extent_map *existing, const struct extent_map *map, 390 u64 start, u64 len), 391 392 TP_ARGS(fs_info, existing, map, start, len), 393 394 TP_STRUCT__entry_btrfs( 395 __field( u64, e_start ) 396 __field( u64, e_len ) 397 __field( u64, map_start ) 398 __field( u64, map_len ) 399 __field( u64, start ) 400 __field( u64, len ) 401 ), 402 403 TP_fast_assign_btrfs(fs_info, 404 __entry->e_start = existing->start; 405 __entry->e_len = existing->len; 406 __entry->map_start = map->start; 407 __entry->map_len = map->len; 408 __entry->start = start; 409 __entry->len = len; 410 ), 411 412 TP_printk_btrfs("start=%llu len=%llu " 413 "existing(start=%llu len=%llu) " 414 "em(start=%llu len=%llu)", 415 __entry->start, 416 __entry->len, 417 __entry->e_start, 418 __entry->e_len, 419 __entry->map_start, 420 __entry->map_len) 421 ); 422 423 /* file extent item */ 424 DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular, 425 426 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 427 const struct btrfs_file_extent_item *fi, u64 start), 428 429 TP_ARGS(bi, l, fi, start), 430 431 TP_STRUCT__entry_btrfs( 432 __field( u64, root_obj ) 433 __field( u64, ino ) 434 __field( loff_t, isize ) 435 __field( u64, disk_isize ) 436 __field( u64, num_bytes ) 437 __field( u64, ram_bytes ) 438 __field( u64, disk_bytenr ) 439 __field( u64, disk_num_bytes ) 440 __field( u64, extent_offset ) 441 __field( u8, extent_type ) 442 __field( u8, compression ) 443 __field( u64, extent_start ) 444 __field( u64, extent_end ) 445 ), 446 447 TP_fast_assign_btrfs(bi->root->fs_info, 448 __entry->root_obj = btrfs_root_id(bi->root); 449 __entry->ino = btrfs_ino(bi); 450 __entry->isize = bi->vfs_inode.i_size; 451 __entry->disk_isize = bi->disk_i_size; 452 __entry->num_bytes = btrfs_file_extent_num_bytes(l, fi); 453 __entry->ram_bytes = btrfs_file_extent_ram_bytes(l, fi); 454 __entry->disk_bytenr = btrfs_file_extent_disk_bytenr(l, fi); 455 __entry->disk_num_bytes = btrfs_file_extent_disk_num_bytes(l, fi); 456 __entry->extent_offset = btrfs_file_extent_offset(l, fi); 457 __entry->extent_type = btrfs_file_extent_type(l, fi); 458 __entry->compression = btrfs_file_extent_compression(l, fi); 459 __entry->extent_start = start; 460 __entry->extent_end = (start + __entry->num_bytes); 461 ), 462 463 TP_printk_btrfs( 464 "root=%llu(%s) inode=%llu size=%llu disk_isize=%llu " 465 "file extent range=[%llu %llu] " 466 "(num_bytes=%llu ram_bytes=%llu disk_bytenr=%llu " 467 "disk_num_bytes=%llu extent_offset=%llu type=%s " 468 "compression=%u", 469 show_root_type(__entry->root_obj), __entry->ino, 470 __entry->isize, 471 __entry->disk_isize, __entry->extent_start, 472 __entry->extent_end, __entry->num_bytes, __entry->ram_bytes, 473 __entry->disk_bytenr, __entry->disk_num_bytes, 474 __entry->extent_offset, __print_symbolic(__entry->extent_type, FI_TYPES), 475 __entry->compression) 476 ); 477 478 DECLARE_EVENT_CLASS( 479 btrfs__file_extent_item_inline, 480 481 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 482 const struct btrfs_file_extent_item *fi, int slot, u64 start), 483 484 TP_ARGS(bi, l, fi, slot, start), 485 486 TP_STRUCT__entry_btrfs( 487 __field( u64, root_obj ) 488 __field( u64, ino ) 489 __field( loff_t, isize ) 490 __field( u64, disk_isize ) 491 __field( u8, extent_type ) 492 __field( u8, compression ) 493 __field( u64, extent_start ) 494 __field( u64, extent_end ) 495 ), 496 497 TP_fast_assign_btrfs( 498 bi->root->fs_info, 499 __entry->root_obj = btrfs_root_id(bi->root); 500 __entry->ino = btrfs_ino(bi); 501 __entry->isize = bi->vfs_inode.i_size; 502 __entry->disk_isize = bi->disk_i_size; 503 __entry->extent_type = btrfs_file_extent_type(l, fi); 504 __entry->compression = btrfs_file_extent_compression(l, fi); 505 __entry->extent_start = start; 506 __entry->extent_end = (start + btrfs_file_extent_ram_bytes(l, fi)); 507 ), 508 509 TP_printk_btrfs( 510 "root=%llu(%s) inode=%llu size=%llu disk_isize=%llu " 511 "file extent range=[%llu %llu] " 512 "extent_type=%s compression=%u", 513 show_root_type(__entry->root_obj), __entry->ino, __entry->isize, 514 __entry->disk_isize, __entry->extent_start, 515 __entry->extent_end, __print_symbolic(__entry->extent_type, FI_TYPES), 516 __entry->compression) 517 ); 518 519 DEFINE_EVENT( 520 btrfs__file_extent_item_regular, btrfs_get_extent_show_fi_regular, 521 522 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 523 const struct btrfs_file_extent_item *fi, u64 start), 524 525 TP_ARGS(bi, l, fi, start) 526 ); 527 528 DEFINE_EVENT( 529 btrfs__file_extent_item_regular, btrfs_truncate_show_fi_regular, 530 531 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 532 const struct btrfs_file_extent_item *fi, u64 start), 533 534 TP_ARGS(bi, l, fi, start) 535 ); 536 537 DEFINE_EVENT( 538 btrfs__file_extent_item_inline, btrfs_get_extent_show_fi_inline, 539 540 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 541 const struct btrfs_file_extent_item *fi, int slot, u64 start), 542 543 TP_ARGS(bi, l, fi, slot, start) 544 ); 545 546 DEFINE_EVENT( 547 btrfs__file_extent_item_inline, btrfs_truncate_show_fi_inline, 548 549 TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l, 550 const struct btrfs_file_extent_item *fi, int slot, u64 start), 551 552 TP_ARGS(bi, l, fi, slot, start) 553 ); 554 555 #define show_ordered_flags(flags) \ 556 __print_flags(flags, "|", \ 557 { (1 << BTRFS_ORDERED_REGULAR), "REGULAR" }, \ 558 { (1 << BTRFS_ORDERED_NOCOW), "NOCOW" }, \ 559 { (1 << BTRFS_ORDERED_PREALLOC), "PREALLOC" }, \ 560 { (1 << BTRFS_ORDERED_COMPRESSED), "COMPRESSED" }, \ 561 { (1 << BTRFS_ORDERED_DIRECT), "DIRECT" }, \ 562 { (1 << BTRFS_ORDERED_IO_DONE), "IO_DONE" }, \ 563 { (1 << BTRFS_ORDERED_COMPLETE), "COMPLETE" }, \ 564 { (1 << BTRFS_ORDERED_IOERR), "IOERR" }, \ 565 { (1 << BTRFS_ORDERED_TRUNCATED), "TRUNCATED" }) 566 567 568 DECLARE_EVENT_CLASS(btrfs__ordered_extent, 569 570 TP_PROTO(const struct btrfs_inode *inode, 571 const struct btrfs_ordered_extent *ordered), 572 573 TP_ARGS(inode, ordered), 574 575 TP_STRUCT__entry_btrfs( 576 __field( u64, ino ) 577 __field( u64, file_offset ) 578 __field( u64, start ) 579 __field( u64, len ) 580 __field( u64, disk_len ) 581 __field( u64, bytes_left ) 582 __field( unsigned long, flags ) 583 __field( int, compress_type ) 584 __field( int, refs ) 585 __field( u64, root_objectid ) 586 __field( u64, truncated_len ) 587 ), 588 589 TP_fast_assign_btrfs(inode->root->fs_info, 590 __entry->ino = btrfs_ino(inode); 591 __entry->file_offset = ordered->file_offset; 592 __entry->start = ordered->disk_bytenr; 593 __entry->len = ordered->num_bytes; 594 __entry->disk_len = ordered->disk_num_bytes; 595 __entry->bytes_left = ordered->bytes_left; 596 __entry->flags = ordered->flags; 597 __entry->compress_type = ordered->compress_type; 598 __entry->refs = refcount_read(&ordered->refs); 599 __entry->root_objectid = btrfs_root_id(inode->root); 600 __entry->truncated_len = ordered->truncated_len; 601 ), 602 603 TP_printk_btrfs("root=%llu(%s) ino=%llu file_offset=%llu " 604 "start=%llu len=%llu disk_len=%llu " 605 "truncated_len=%llu " 606 "bytes_left=%llu flags=%s compress_type=%d " 607 "refs=%d", 608 show_root_type(__entry->root_objectid), 609 __entry->ino, 610 __entry->file_offset, 611 __entry->start, 612 __entry->len, 613 __entry->disk_len, 614 __entry->truncated_len, 615 __entry->bytes_left, 616 show_ordered_flags(__entry->flags), 617 __entry->compress_type, __entry->refs) 618 ); 619 620 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add, 621 622 TP_PROTO(const struct btrfs_inode *inode, 623 const struct btrfs_ordered_extent *ordered), 624 625 TP_ARGS(inode, ordered) 626 ); 627 628 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove, 629 630 TP_PROTO(const struct btrfs_inode *inode, 631 const struct btrfs_ordered_extent *ordered), 632 633 TP_ARGS(inode, ordered) 634 ); 635 636 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start, 637 638 TP_PROTO(const struct btrfs_inode *inode, 639 const struct btrfs_ordered_extent *ordered), 640 641 TP_ARGS(inode, ordered) 642 ); 643 644 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put, 645 646 TP_PROTO(const struct btrfs_inode *inode, 647 const struct btrfs_ordered_extent *ordered), 648 649 TP_ARGS(inode, ordered) 650 ); 651 652 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup, 653 654 TP_PROTO(const struct btrfs_inode *inode, 655 const struct btrfs_ordered_extent *ordered), 656 657 TP_ARGS(inode, ordered) 658 ); 659 660 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_range, 661 662 TP_PROTO(const struct btrfs_inode *inode, 663 const struct btrfs_ordered_extent *ordered), 664 665 TP_ARGS(inode, ordered) 666 ); 667 668 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_first_range, 669 670 TP_PROTO(const struct btrfs_inode *inode, 671 const struct btrfs_ordered_extent *ordered), 672 673 TP_ARGS(inode, ordered) 674 ); 675 676 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_for_logging, 677 678 TP_PROTO(const struct btrfs_inode *inode, 679 const struct btrfs_ordered_extent *ordered), 680 681 TP_ARGS(inode, ordered) 682 ); 683 684 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_first, 685 686 TP_PROTO(const struct btrfs_inode *inode, 687 const struct btrfs_ordered_extent *ordered), 688 689 TP_ARGS(inode, ordered) 690 ); 691 692 /* 693 * The writepage fixup worker deferred a block because this still-running 694 * ordered extent covers it. 695 */ 696 DEFINE_EVENT(btrfs__ordered_extent, btrfs_writepage_fixup_defer, 697 698 TP_PROTO(const struct btrfs_inode *inode, 699 const struct btrfs_ordered_extent *ordered), 700 701 TP_ARGS(inode, ordered) 702 ); 703 704 /* The writepage fixup worker reserved space for a block and set delalloc. */ 705 TRACE_EVENT(btrfs_writepage_fixup_reserve, 706 707 TP_PROTO(const struct btrfs_inode *inode, u64 start, u32 len), 708 709 TP_ARGS(inode, start, len), 710 711 TP_STRUCT__entry_btrfs( 712 __field( u64, ino ) 713 __field( u64, start ) 714 __field( u32, len ) 715 ), 716 717 TP_fast_assign_btrfs(inode->root->fs_info, 718 __entry->ino = btrfs_ino(inode); 719 __entry->start = start; 720 __entry->len = len; 721 ), 722 723 TP_printk_btrfs("ino=%llu start=%llu len=%u", 724 __entry->ino, __entry->start, __entry->len) 725 ); 726 727 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_split, 728 729 TP_PROTO(const struct btrfs_inode *inode, 730 const struct btrfs_ordered_extent *ordered), 731 732 TP_ARGS(inode, ordered) 733 ); 734 735 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_dec_test_pending, 736 737 TP_PROTO(const struct btrfs_inode *inode, 738 const struct btrfs_ordered_extent *ordered), 739 740 TP_ARGS(inode, ordered) 741 ); 742 743 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_mark_finished, 744 745 TP_PROTO(const struct btrfs_inode *inode, 746 const struct btrfs_ordered_extent *ordered), 747 748 TP_ARGS(inode, ordered) 749 ); 750 751 TRACE_EVENT(btrfs_finish_ordered_extent, 752 753 TP_PROTO(const struct btrfs_inode *inode, u64 start, u64 len, 754 bool uptodate), 755 756 TP_ARGS(inode, start, len, uptodate), 757 758 TP_STRUCT__entry_btrfs( 759 __field( u64, ino ) 760 __field( u64, start ) 761 __field( u64, len ) 762 __field( bool, uptodate ) 763 __field( u64, root_objectid ) 764 ), 765 766 TP_fast_assign_btrfs(inode->root->fs_info, 767 __entry->ino = btrfs_ino(inode); 768 __entry->start = start; 769 __entry->len = len; 770 __entry->uptodate = uptodate; 771 __entry->root_objectid = btrfs_root_id(inode->root); 772 ), 773 774 TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu uptodate=%d", 775 show_root_type(__entry->root_objectid), 776 __entry->ino, __entry->start, 777 __entry->len, __entry->uptodate) 778 ); 779 780 DECLARE_EVENT_CLASS(btrfs__writepage, 781 782 TP_PROTO(const struct folio *folio, const struct inode *inode, 783 const struct writeback_control *wbc), 784 785 TP_ARGS(folio, inode, wbc), 786 787 TP_STRUCT__entry_btrfs( 788 __field( u64, ino ) 789 __field( pgoff_t, index ) 790 __field( long, nr_to_write ) 791 __field( long, pages_skipped ) 792 __field( loff_t, range_start ) 793 __field( loff_t, range_end ) 794 __field( char, for_kupdate ) 795 __field( char, range_cyclic ) 796 __field( unsigned long, writeback_index ) 797 __field( u64, root_objectid ) 798 ), 799 800 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb), 801 __entry->ino = btrfs_ino(BTRFS_I(inode)); 802 __entry->index = folio->index; 803 __entry->nr_to_write = wbc->nr_to_write; 804 __entry->pages_skipped = wbc->pages_skipped; 805 __entry->range_start = wbc->range_start; 806 __entry->range_end = wbc->range_end; 807 __entry->for_kupdate = wbc->for_kupdate; 808 __entry->range_cyclic = wbc->range_cyclic; 809 __entry->writeback_index = inode->i_mapping->writeback_index; 810 __entry->root_objectid = btrfs_root_id(BTRFS_I(inode)->root); 811 ), 812 813 TP_printk_btrfs("root=%llu(%s) ino=%llu page_index=%lu " 814 "nr_to_write=%ld pages_skipped=%ld range_start=%llu " 815 "range_end=%llu for_kupdate=%d " 816 "range_cyclic=%d writeback_index=%lu", 817 show_root_type(__entry->root_objectid), 818 __entry->ino, __entry->index, 819 __entry->nr_to_write, __entry->pages_skipped, 820 __entry->range_start, __entry->range_end, 821 __entry->for_kupdate, __entry->range_cyclic, 822 __entry->writeback_index) 823 ); 824 825 DEFINE_EVENT(btrfs__writepage, extent_writepage, 826 827 TP_PROTO(const struct folio *folio, const struct inode *inode, 828 const struct writeback_control *wbc), 829 830 TP_ARGS(folio, inode, wbc) 831 ); 832 833 TRACE_EVENT(btrfs_writepage_end_io_hook, 834 835 TP_PROTO(const struct btrfs_inode *inode, u64 start, u64 end, 836 int uptodate), 837 838 TP_ARGS(inode, start, end, uptodate), 839 840 TP_STRUCT__entry_btrfs( 841 __field( u64, ino ) 842 __field( u64, start ) 843 __field( u64, end ) 844 __field( int, uptodate ) 845 __field( u64, root_objectid ) 846 ), 847 848 TP_fast_assign_btrfs(inode->root->fs_info, 849 __entry->ino = btrfs_ino(inode); 850 __entry->start = start; 851 __entry->end = end; 852 __entry->uptodate = uptodate; 853 __entry->root_objectid = btrfs_root_id(inode->root); 854 ), 855 856 TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu end=%llu uptodate=%d", 857 show_root_type(__entry->root_objectid), 858 __entry->ino, __entry->start, 859 __entry->end, __entry->uptodate) 860 ); 861 862 TRACE_EVENT(btrfs_sync_file_enter, 863 864 TP_PROTO(const struct file *file, int datasync), 865 866 TP_ARGS(file, datasync), 867 868 TP_STRUCT__entry_btrfs( 869 __field( u64, ino ) 870 __field( umode_t, mode ) 871 __field( u64, parent ) 872 __field( int, datasync ) 873 __field( u64, root_objectid ) 874 ), 875 876 TP_fast_assign( 877 struct dentry *dentry = file_dentry(file); 878 struct inode *inode = file_inode(file); 879 struct inode *parent_inode = d_inode(dentry->d_parent); 880 881 TP_fast_assign_fsid(btrfs_sb(inode->i_sb)); 882 __entry->ino = btrfs_ino(BTRFS_I(inode)); 883 __entry->parent = btrfs_ino(BTRFS_I(parent_inode)); 884 __entry->datasync = datasync; 885 __entry->root_objectid = btrfs_root_id(BTRFS_I(inode)->root); 886 __entry->mode = inode->i_mode; 887 ), 888 889 TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s parent=%llu datasync=%d", 890 show_root_type(__entry->root_objectid), __entry->ino, 891 show_inode_type(__entry->mode), __entry->parent, 892 __entry->datasync) 893 ); 894 895 TRACE_EVENT(btrfs_sync_file_exit, 896 897 TP_PROTO(const struct file *file, int ret), 898 899 TP_ARGS(file, ret), 900 901 TP_STRUCT__entry_btrfs( 902 __field( u64, ino ) 903 __field( int, ret ) 904 __field( u64, root_objectid ) 905 ), 906 907 TP_fast_assign( 908 struct btrfs_inode *inode = BTRFS_I(file_inode(file)); 909 910 TP_fast_assign_fsid(inode->root->fs_info); 911 __entry->root_objectid = btrfs_root_id(inode->root); 912 __entry->ino = btrfs_ino(inode); 913 __entry->ret = ret; 914 ), 915 916 TP_printk_btrfs("root=%llu(%s) ino=%llu ret=%d", 917 show_root_type(__entry->root_objectid), 918 __entry->ino, __entry->ret) 919 ); 920 921 TRACE_EVENT(btrfs_log_inode_parent_enter, 922 923 TP_PROTO(const struct btrfs_trans_handle *trans, struct btrfs_inode *inode), 924 925 TP_ARGS(trans, inode), 926 927 TP_STRUCT__entry_btrfs( 928 __field( u64, root_objectid ) 929 __field( u64, ino ) 930 __field( umode_t, mode ) 931 __field( u64, transid ) 932 __field( u64, generation ) 933 __field( u64, logged_trans ) 934 __field( u64, last_unlink_trans ) 935 __field( int, last_sub_trans ) 936 __field( int, inode_last_log_commit ) 937 __field( int, root_last_log_commit ) 938 ), 939 940 TP_fast_assign( 941 struct btrfs_root *root = inode->root; 942 943 TP_fast_assign_fsid(root->fs_info); 944 __entry->root_objectid = btrfs_root_id(root); 945 __entry->ino = btrfs_ino(inode); 946 __entry->mode = inode->vfs_inode.i_mode; 947 __entry->transid = trans->transid; 948 __entry->generation = inode->generation; 949 spin_lock(&inode->lock); 950 __entry->logged_trans = inode->logged_trans; 951 __entry->last_unlink_trans = inode->last_unlink_trans; 952 __entry->last_sub_trans = inode->last_sub_trans; 953 __entry->inode_last_log_commit = inode->last_log_commit; 954 spin_unlock(&inode->lock); 955 __entry->root_last_log_commit = btrfs_get_root_last_log_commit(root); 956 ), 957 958 TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s transid=%llu gen=%llu" 959 " logged_trans=%llu last_unlink_trans=%llu last_sub_trans=%d" 960 " inode_last_log_commit=%d root_last_log_commit=%d", 961 show_root_type(__entry->root_objectid), __entry->ino, 962 show_inode_type(__entry->mode), __entry->transid, 963 __entry->generation, __entry->logged_trans, 964 __entry->last_unlink_trans, __entry->last_sub_trans, 965 __entry->inode_last_log_commit, __entry->root_last_log_commit) 966 ); 967 968 TRACE_EVENT(btrfs_log_inode_parent_exit, 969 970 TP_PROTO(const struct btrfs_trans_handle *trans, 971 const struct btrfs_inode *inode, 972 int ret), 973 974 TP_ARGS(trans, inode, ret), 975 976 TP_STRUCT__entry_btrfs( 977 __field( u64, root_objectid ) 978 __field( u64, ino ) 979 __field( u64, transid ) 980 __field( int, ret ) 981 ), 982 983 TP_fast_assign( 984 TP_fast_assign_fsid(inode->root->fs_info); 985 __entry->root_objectid = btrfs_root_id(inode->root); 986 __entry->ino = btrfs_ino(inode); 987 __entry->transid = trans->transid; 988 __entry->ret = ret; 989 ), 990 991 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d", 992 show_root_type(__entry->root_objectid), __entry->ino, 993 __entry->transid, __entry->ret) 994 ); 995 996 TRACE_EVENT(btrfs_log_inode_enter, 997 998 TP_PROTO(const struct btrfs_trans_handle *trans, struct btrfs_inode *inode, 999 const struct btrfs_log_ctx *ctx, int log_mode), 1000 1001 TP_ARGS(trans, inode, ctx, log_mode), 1002 1003 TP_STRUCT__entry_btrfs( 1004 __field( u64, root_objectid ) 1005 __field( u64, ino ) 1006 __field( umode_t, mode ) 1007 __field( u64, transid ) 1008 __field( u64, generation ) 1009 __field( u64, logged_trans ) 1010 __field( u64, last_unlink_trans ) 1011 __field( u64, last_reflink_trans ) 1012 __field( int, last_sub_trans ) 1013 __field( int, last_log_commit ) 1014 __field( bool, logging_new_name ) 1015 __field( bool, logging_new_delayed_dentries ) 1016 __field( bool, is_conflict_inode ) 1017 __field( bool, full_sync ) 1018 __field( bool, copy_everything ) 1019 __field( bool, no_xattrs ) 1020 __field( int, log_mode ) 1021 ), 1022 1023 TP_fast_assign( 1024 TP_fast_assign_fsid(inode->root->fs_info); 1025 __entry->root_objectid = btrfs_root_id(inode->root); 1026 __entry->ino = btrfs_ino(inode); 1027 __entry->mode = inode->vfs_inode.i_mode; 1028 __entry->transid = trans->transid; 1029 __entry->generation = inode->generation; 1030 spin_lock(&inode->lock); 1031 __entry->logged_trans = inode->logged_trans; 1032 __entry->last_unlink_trans = inode->last_unlink_trans; 1033 __entry->last_reflink_trans = inode->last_reflink_trans; 1034 __entry->last_sub_trans = inode->last_sub_trans; 1035 __entry->last_log_commit = inode->last_log_commit; 1036 spin_unlock(&inode->lock); 1037 __entry->logging_new_name = ctx->logging_new_name; 1038 __entry->logging_new_delayed_dentries = ctx->logging_new_delayed_dentries; 1039 __entry->is_conflict_inode = ctx->logging_conflict_inodes; 1040 __entry->full_sync = 1041 test_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags); 1042 __entry->copy_everything = 1043 test_bit(BTRFS_INODE_COPY_EVERYTHING, &inode->runtime_flags); 1044 __entry->no_xattrs = 1045 test_bit(BTRFS_INODE_NO_XATTRS, &inode->runtime_flags); 1046 __entry->log_mode = log_mode; 1047 ), 1048 1049 TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s transid=%llu gen=%llu" 1050 " logged_trans=%llu last_unlink_trans=%llu" 1051 " last_reflink_trans=%llu last_sub_trans=%d last_log_commit=%d" 1052 " logging_new_name=%d logging_new_delayed_dentries=%d" 1053 " is_conflict_inode=%d full_sync=%d copy_everything=%d" 1054 " no_xattrs=%d log_mode=%d(%s)", 1055 show_root_type(__entry->root_objectid), __entry->ino, 1056 show_inode_type(__entry->mode), __entry->transid, 1057 __entry->generation, __entry->logged_trans, 1058 __entry->last_unlink_trans, __entry->last_reflink_trans, 1059 __entry->last_sub_trans, __entry->last_log_commit, 1060 __entry->logging_new_name, __entry->logging_new_delayed_dentries, 1061 __entry->is_conflict_inode, __entry->log_mode, 1062 __entry->full_sync, __entry->copy_everything, __entry->no_xattrs, 1063 __print_symbolic(__entry->log_mode, LOG_MODES)) 1064 ); 1065 1066 TRACE_EVENT(btrfs_log_inode_exit, 1067 1068 TP_PROTO(const struct btrfs_trans_handle *trans, struct btrfs_inode *inode, 1069 int ret), 1070 1071 TP_ARGS(trans, inode, ret), 1072 1073 TP_STRUCT__entry_btrfs( 1074 __field( u64, root_objectid ) 1075 __field( u64, ino ) 1076 __field( u64, transid ) 1077 __field( u64, logged_trans ) 1078 __field( u64, last_reflink_trans ) 1079 __field( int, last_sub_trans ) 1080 __field( int, last_log_commit ) 1081 __field( int, ret ) 1082 ), 1083 1084 TP_fast_assign( 1085 TP_fast_assign_fsid(inode->root->fs_info); 1086 __entry->root_objectid = btrfs_root_id(inode->root); 1087 __entry->ino = btrfs_ino(inode); 1088 __entry->transid = trans->transid; 1089 spin_lock(&inode->lock); 1090 __entry->logged_trans = inode->logged_trans; 1091 __entry->last_reflink_trans = inode->last_reflink_trans; 1092 __entry->last_sub_trans = inode->last_sub_trans; 1093 __entry->last_log_commit = inode->last_log_commit; 1094 spin_unlock(&inode->lock); 1095 __entry->ret = ret; 1096 ), 1097 1098 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu logged_trans=%llu" 1099 " last_reflink_trans=%llu last_sub_trans=%d" 1100 " last_log_commit=%d ret=%d", 1101 show_root_type(__entry->root_objectid), __entry->ino, 1102 __entry->transid, __entry->logged_trans, 1103 __entry->last_reflink_trans, __entry->last_sub_trans, 1104 __entry->last_log_commit, __entry->ret) 1105 ); 1106 1107 TRACE_EVENT(btrfs_log_all_parents_enter, 1108 1109 TP_PROTO(const struct btrfs_trans_handle *trans, 1110 const struct btrfs_inode *inode), 1111 1112 TP_ARGS(trans, inode), 1113 1114 TP_STRUCT__entry_btrfs( 1115 __field( u64, root_objectid ) 1116 __field( u64, ino ) 1117 __field( u64, transid ) 1118 ), 1119 1120 TP_fast_assign( 1121 TP_fast_assign_fsid(inode->root->fs_info); 1122 __entry->root_objectid = btrfs_root_id(inode->root); 1123 __entry->ino = btrfs_ino(inode); 1124 __entry->transid = trans->transid; 1125 ), 1126 1127 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu", 1128 show_root_type(__entry->root_objectid), __entry->ino, 1129 __entry->transid) 1130 ); 1131 1132 TRACE_EVENT(btrfs_log_all_parents_exit, 1133 1134 TP_PROTO(const struct btrfs_trans_handle *trans, 1135 const struct btrfs_inode *inode, 1136 int ret), 1137 1138 TP_ARGS(trans, inode, ret), 1139 1140 TP_STRUCT__entry_btrfs( 1141 __field( u64, root_objectid ) 1142 __field( u64, ino ) 1143 __field( u64, transid ) 1144 __field( int, ret ) 1145 ), 1146 1147 TP_fast_assign( 1148 TP_fast_assign_fsid(inode->root->fs_info); 1149 __entry->root_objectid = btrfs_root_id(inode->root); 1150 __entry->ino = btrfs_ino(inode); 1151 __entry->transid = trans->transid; 1152 __entry->ret = ret; 1153 ), 1154 1155 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d", 1156 show_root_type(__entry->root_objectid), __entry->ino, 1157 __entry->transid, __entry->ret) 1158 ); 1159 1160 TRACE_EVENT(btrfs_log_all_new_ancestors_enter, 1161 1162 TP_PROTO(const struct btrfs_trans_handle *trans, 1163 const struct btrfs_inode *inode), 1164 1165 TP_ARGS(trans, inode), 1166 1167 TP_STRUCT__entry_btrfs( 1168 __field( u64, root_objectid ) 1169 __field( u64, ino ) 1170 __field( u64, transid ) 1171 __field( unsigned int, nlink ) 1172 ), 1173 1174 TP_fast_assign( 1175 TP_fast_assign_fsid(inode->root->fs_info); 1176 __entry->root_objectid = btrfs_root_id(inode->root); 1177 __entry->ino = btrfs_ino(inode); 1178 __entry->transid = trans->transid; 1179 __entry->nlink = inode->vfs_inode.i_nlink; 1180 ), 1181 1182 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu nlink=%u", 1183 show_root_type(__entry->root_objectid), __entry->ino, 1184 __entry->transid, __entry->nlink) 1185 ); 1186 1187 TRACE_EVENT(btrfs_log_all_new_ancestors_exit, 1188 1189 TP_PROTO(const struct btrfs_trans_handle *trans, 1190 const struct btrfs_inode *inode, 1191 int ret), 1192 1193 TP_ARGS(trans, inode, ret), 1194 1195 TP_STRUCT__entry_btrfs( 1196 __field( u64, root_objectid ) 1197 __field( u64, ino ) 1198 __field( u64, transid ) 1199 __field( int, ret ) 1200 ), 1201 1202 TP_fast_assign( 1203 TP_fast_assign_fsid(inode->root->fs_info); 1204 __entry->root_objectid = btrfs_root_id(inode->root); 1205 __entry->ino = btrfs_ino(inode); 1206 __entry->transid = trans->transid; 1207 __entry->ret = ret; 1208 ), 1209 1210 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d", 1211 show_root_type(__entry->root_objectid), __entry->ino, 1212 __entry->transid, __entry->ret) 1213 ); 1214 1215 TRACE_EVENT(btrfs_log_new_dir_dentries_enter, 1216 1217 TP_PROTO(const struct btrfs_trans_handle *trans, 1218 const struct btrfs_inode *inode), 1219 1220 TP_ARGS(trans, inode), 1221 1222 TP_STRUCT__entry_btrfs( 1223 __field( u64, root_objectid ) 1224 __field( u64, ino ) 1225 __field( u64, transid ) 1226 ), 1227 1228 TP_fast_assign( 1229 TP_fast_assign_fsid(inode->root->fs_info); 1230 __entry->root_objectid = btrfs_root_id(inode->root); 1231 __entry->ino = btrfs_ino(inode); 1232 __entry->transid = trans->transid; 1233 ), 1234 1235 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu", 1236 show_root_type(__entry->root_objectid), __entry->ino, 1237 __entry->transid) 1238 ); 1239 1240 TRACE_EVENT(btrfs_log_new_dir_dentries_exit, 1241 1242 TP_PROTO(const struct btrfs_trans_handle *trans, 1243 const struct btrfs_inode *inode, 1244 int ret), 1245 1246 TP_ARGS(trans, inode, ret), 1247 1248 TP_STRUCT__entry_btrfs( 1249 __field( u64, root_objectid ) 1250 __field( u64, ino ) 1251 __field( u64, transid ) 1252 __field( int, ret ) 1253 ), 1254 1255 TP_fast_assign( 1256 TP_fast_assign_fsid(inode->root->fs_info); 1257 __entry->root_objectid = btrfs_root_id(inode->root); 1258 __entry->ino = btrfs_ino(inode); 1259 __entry->transid = trans->transid; 1260 __entry->ret = ret; 1261 ), 1262 1263 TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d", 1264 show_root_type(__entry->root_objectid), __entry->ino, 1265 __entry->transid, __entry->ret) 1266 ); 1267 1268 TRACE_EVENT(btrfs_add_conflicting_inode_enter, 1269 1270 TP_PROTO(const struct btrfs_trans_handle *trans, 1271 const struct btrfs_log_ctx *ctx, 1272 u64 ino, u64 parent), 1273 1274 TP_ARGS(trans, ctx, ino, parent), 1275 1276 TP_STRUCT__entry_btrfs( 1277 __field( u64, root_objectid ) 1278 __field( u64, transid ) 1279 __field( u64, ctx_ino ) 1280 __field( u64, conflict_ino ) 1281 __field( u64, conflict_ino_parent ) 1282 ), 1283 1284 TP_fast_assign( 1285 TP_fast_assign_fsid(trans->fs_info); 1286 __entry->root_objectid = btrfs_root_id(ctx->inode->root); 1287 __entry->transid = trans->transid; 1288 __entry->ctx_ino = btrfs_ino(ctx->inode); 1289 __entry->conflict_ino = ino; 1290 __entry->conflict_ino_parent = parent; 1291 ), 1292 1293 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu conflict_ino=%llu" 1294 " conflict_ino_parent=%llu", 1295 show_root_type(__entry->root_objectid), __entry->transid, 1296 __entry->ctx_ino, __entry->conflict_ino, 1297 __entry->conflict_ino_parent) 1298 ); 1299 1300 TRACE_EVENT(btrfs_add_conflicting_inode_exit, 1301 1302 TP_PROTO(const struct btrfs_trans_handle *trans, 1303 const struct btrfs_log_ctx *ctx, 1304 u64 ino, u64 parent, int ret), 1305 1306 TP_ARGS(trans, ctx, ino, parent, ret), 1307 1308 TP_STRUCT__entry_btrfs( 1309 __field( u64, root_objectid ) 1310 __field( u64, transid ) 1311 __field( u64, ctx_ino ) 1312 __field( u64, conflict_ino ) 1313 __field( u64, conflict_ino_parent ) 1314 __field( int, ret ) 1315 ), 1316 1317 TP_fast_assign( 1318 TP_fast_assign_fsid(trans->fs_info); 1319 __entry->root_objectid = btrfs_root_id(ctx->inode->root); 1320 __entry->transid = trans->transid; 1321 __entry->ctx_ino = btrfs_ino(ctx->inode); 1322 __entry->conflict_ino = ino; 1323 __entry->conflict_ino_parent = parent; 1324 __entry->ret = ret; 1325 ), 1326 1327 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu conflict_ino=%llu" 1328 " conflict_ino_parent=%llu ret=%d", 1329 show_root_type(__entry->root_objectid), __entry->transid, 1330 __entry->ctx_ino, __entry->conflict_ino, 1331 __entry->conflict_ino_parent, __entry->ret) 1332 ); 1333 1334 TRACE_EVENT(btrfs_log_conflicting_inodes_enter, 1335 1336 TP_PROTO(const struct btrfs_trans_handle *trans, 1337 const struct btrfs_log_ctx *ctx), 1338 1339 TP_ARGS(trans, ctx), 1340 1341 TP_STRUCT__entry_btrfs( 1342 __field( u64, root_objectid ) 1343 __field( u64, transid ) 1344 __field( u64, ctx_ino ) 1345 ), 1346 1347 TP_fast_assign( 1348 TP_fast_assign_fsid(trans->fs_info); 1349 __entry->root_objectid = btrfs_root_id(ctx->inode->root); 1350 __entry->transid = trans->transid; 1351 __entry->ctx_ino = btrfs_ino(ctx->inode); 1352 ), 1353 1354 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu", 1355 show_root_type(__entry->root_objectid), __entry->transid, 1356 __entry->ctx_ino) 1357 ); 1358 1359 TRACE_EVENT(btrfs_log_conflicting_inodes_exit, 1360 1361 TP_PROTO(const struct btrfs_trans_handle *trans, 1362 const struct btrfs_log_ctx *ctx, 1363 int ret), 1364 1365 TP_ARGS(trans, ctx, ret), 1366 1367 TP_STRUCT__entry_btrfs( 1368 __field( u64, root_objectid ) 1369 __field( u64, transid ) 1370 __field( u64, ctx_ino ) 1371 __field( int, ret ) 1372 ), 1373 1374 TP_fast_assign( 1375 TP_fast_assign_fsid(trans->fs_info); 1376 __entry->root_objectid = btrfs_root_id(ctx->inode->root); 1377 __entry->transid = trans->transid; 1378 __entry->ctx_ino = btrfs_ino(ctx->inode); 1379 __entry->ret = ret; 1380 ), 1381 1382 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu ret=%d", 1383 show_root_type(__entry->root_objectid), __entry->transid, 1384 __entry->ctx_ino, __entry->ret) 1385 ); 1386 1387 TRACE_EVENT(btrfs_log_new_delayed_dentries_enter, 1388 1389 TP_PROTO(const struct btrfs_trans_handle *trans, 1390 const struct btrfs_inode *inode), 1391 1392 TP_ARGS(trans, inode), 1393 1394 TP_STRUCT__entry_btrfs( 1395 __field( u64, root_objectid ) 1396 __field( u64, transid ) 1397 __field( u64, ino ) 1398 ), 1399 1400 TP_fast_assign( 1401 TP_fast_assign_fsid(trans->fs_info); 1402 __entry->root_objectid = btrfs_root_id(inode->root); 1403 __entry->transid = trans->transid; 1404 __entry->ino = btrfs_ino(inode); 1405 ), 1406 1407 TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu", 1408 show_root_type(__entry->root_objectid), __entry->transid, 1409 __entry->ino) 1410 ); 1411 1412 TRACE_EVENT(btrfs_log_new_delayed_dentries_exit, 1413 1414 TP_PROTO(const struct btrfs_trans_handle *trans, 1415 const struct btrfs_inode *inode, 1416 int ret), 1417 1418 TP_ARGS(trans, inode, ret), 1419 1420 TP_STRUCT__entry_btrfs( 1421 __field( u64, root_objectid ) 1422 __field( u64, transid ) 1423 __field( u64, ino ) 1424 __field( int, ret ) 1425 ), 1426 1427 TP_fast_assign( 1428 TP_fast_assign_fsid(trans->fs_info); 1429 __entry->root_objectid = btrfs_root_id(inode->root); 1430 __entry->transid = trans->transid; 1431 __entry->ino = btrfs_ino(inode); 1432 __entry->ret = ret; 1433 ), 1434 1435 TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu ret=%d", 1436 show_root_type(__entry->root_objectid), __entry->transid, 1437 __entry->ino, __entry->ret) 1438 ); 1439 1440 TRACE_EVENT(btrfs_record_unlink_dir, 1441 1442 TP_PROTO(const struct btrfs_trans_handle *trans, 1443 const struct btrfs_inode *dir, 1444 const struct btrfs_inode *inode, 1445 bool for_rename), 1446 1447 TP_ARGS(trans, dir, inode, for_rename), 1448 1449 TP_STRUCT__entry_btrfs( 1450 __field( u64, root_objectid ) 1451 __field( u64, transid ) 1452 __field( u64, ino ) 1453 __field( u64, dir ) 1454 __field( bool, for_rename ) 1455 ), 1456 1457 TP_fast_assign( 1458 TP_fast_assign_fsid(trans->fs_info); 1459 __entry->root_objectid = btrfs_root_id(inode->root); 1460 __entry->transid = trans->transid; 1461 __entry->ino = btrfs_ino(inode); 1462 __entry->dir = btrfs_ino(dir); 1463 __entry->for_rename = for_rename; 1464 ), 1465 1466 TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu dir=%llu for_rename=%d", 1467 show_root_type(__entry->root_objectid), __entry->transid, 1468 __entry->ino, __entry->dir, __entry->for_rename) 1469 ); 1470 1471 TRACE_EVENT(btrfs_record_snapshot_destroy, 1472 1473 TP_PROTO(const struct btrfs_trans_handle *trans, 1474 const struct btrfs_inode *dir), 1475 1476 TP_ARGS(trans, dir), 1477 1478 TP_STRUCT__entry_btrfs( 1479 __field( u64, root_objectid ) 1480 __field( u64, transid ) 1481 __field( u64, dir ) 1482 ), 1483 1484 TP_fast_assign( 1485 TP_fast_assign_fsid(trans->fs_info); 1486 __entry->root_objectid = btrfs_root_id(dir->root); 1487 __entry->transid = trans->transid; 1488 __entry->dir = btrfs_ino(dir); 1489 ), 1490 1491 TP_printk_btrfs("root=%llu(%s) transid=%llu dir=%llu", 1492 show_root_type(__entry->root_objectid), __entry->transid, 1493 __entry->dir) 1494 ); 1495 1496 TRACE_EVENT(btrfs_record_new_subvolume, 1497 1498 TP_PROTO(const struct btrfs_trans_handle *trans, 1499 const struct btrfs_inode *dir), 1500 1501 TP_ARGS(trans, dir), 1502 1503 TP_STRUCT__entry_btrfs( 1504 __field( u64, root_objectid ) 1505 __field( u64, transid ) 1506 __field( u64, dir ) 1507 ), 1508 1509 TP_fast_assign( 1510 TP_fast_assign_fsid(trans->fs_info); 1511 __entry->root_objectid = btrfs_root_id(dir->root); 1512 __entry->transid = trans->transid; 1513 __entry->dir = btrfs_ino(dir); 1514 ), 1515 1516 TP_printk_btrfs("root=%llu(%s) transid=%llu dir=%llu", 1517 show_root_type(__entry->root_objectid), __entry->transid, 1518 __entry->dir) 1519 ); 1520 1521 TRACE_EVENT(btrfs_log_new_name_enter, 1522 1523 TP_PROTO(const struct btrfs_trans_handle *trans, 1524 const struct btrfs_inode *inode, 1525 const struct btrfs_inode *old_dir, 1526 u64 old_dir_index), 1527 1528 TP_ARGS(trans, inode, old_dir, old_dir_index), 1529 1530 TP_STRUCT__entry_btrfs( 1531 __field( u64, root_objectid ) 1532 __field( u64, transid ) 1533 __field( u64, ino ) 1534 __field( umode_t, mode ) 1535 __field( u64, old_dir_ino ) 1536 __field( u64, old_dir_index ) 1537 ), 1538 1539 TP_fast_assign( 1540 TP_fast_assign_fsid(trans->fs_info); 1541 __entry->root_objectid = btrfs_root_id(inode->root); 1542 __entry->transid = trans->transid; 1543 __entry->ino = btrfs_ino(inode); 1544 __entry->mode = inode->vfs_inode.i_mode; 1545 __entry->old_dir_ino = old_dir ? btrfs_ino(old_dir) : 0; 1546 __entry->old_dir_index = old_dir_index; 1547 ), 1548 1549 TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu type=%s" 1550 " old_dir=%llu old_dir_index=%llu", 1551 show_root_type(__entry->root_objectid), __entry->transid, 1552 __entry->ino, show_inode_type(__entry->mode), 1553 __entry->old_dir_ino, __entry->old_dir_index) 1554 ); 1555 1556 TRACE_EVENT(btrfs_log_new_name_exit, 1557 1558 TP_PROTO(const struct btrfs_trans_handle *trans, 1559 const struct btrfs_inode *inode, 1560 const struct btrfs_inode *old_dir, 1561 int ret), 1562 1563 TP_ARGS(trans, inode, old_dir, ret), 1564 1565 TP_STRUCT__entry_btrfs( 1566 __field( u64, root_objectid ) 1567 __field( u64, transid ) 1568 __field( u64, ino ) 1569 __field( u64, old_dir_ino ) 1570 __field( int, ret ) 1571 ), 1572 1573 TP_fast_assign( 1574 TP_fast_assign_fsid(trans->fs_info); 1575 __entry->root_objectid = btrfs_root_id(inode->root); 1576 __entry->transid = trans->transid; 1577 __entry->ino = btrfs_ino(inode); 1578 __entry->old_dir_ino = old_dir ? btrfs_ino(old_dir) : 0; 1579 __entry->ret = ret; 1580 ), 1581 1582 TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu old_dir=%llu ret=%d", 1583 show_root_type(__entry->root_objectid), __entry->transid, 1584 __entry->ino, __entry->old_dir_ino, __entry->ret) 1585 ); 1586 1587 /* Ideally call this while under root->log_mutex (but not always possible). */ 1588 TRACE_EVENT(btrfs_sync_log_enter, 1589 1590 TP_PROTO(const struct btrfs_trans_handle *trans, 1591 const struct btrfs_root *root, 1592 const struct btrfs_log_ctx *ctx), 1593 1594 TP_ARGS(trans, root, ctx), 1595 1596 TP_STRUCT__entry_btrfs( 1597 __field( u64, root_objectid ) 1598 __field( u64, transid ) 1599 __field( int, ctx_log_transid ) 1600 __field( int, root_log_transid ) 1601 __field( int, log_transid_committed ) 1602 __field( bool, log_committing ) 1603 __field( bool, log_committing_prev ) 1604 __field( int, log_writers ) 1605 ), 1606 1607 TP_fast_assign( 1608 TP_fast_assign_fsid(trans->fs_info); 1609 __entry->root_objectid = btrfs_root_id(root); 1610 __entry->transid = trans->transid; 1611 __entry->ctx_log_transid = ctx->log_transid; 1612 __entry->root_log_transid = btrfs_get_root_log_transid(root); 1613 __entry->log_transid_committed = 1614 data_race(root->log_transid_committed); 1615 __entry->log_committing = 1616 atomic_read(&root->log_commit[ctx->log_transid % 2]); 1617 __entry->log_committing_prev = 1618 atomic_read(&root->log_commit[(ctx->log_transid + 1) % 2]); 1619 __entry->log_writers = atomic_read(&root->log_writers); 1620 ), 1621 1622 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_log_transid=%d" 1623 " root_log_transid=%d log_transid_committed=%d" 1624 " log_committing=%d log_committing_prev=%d log_writers=%d", 1625 show_root_type(__entry->root_objectid), __entry->transid, 1626 __entry->ctx_log_transid, __entry->root_log_transid, 1627 __entry->log_transid_committed, __entry->log_committing, 1628 __entry->log_committing_prev, __entry->log_writers) 1629 ); 1630 1631 /* 1632 * Ideally call this while under root->log_mutex and in the same critical 1633 * section that calls the btrfs_sync_log_enter() trace event (though it's not 1634 * always possible). 1635 */ 1636 TRACE_EVENT(btrfs_sync_log_exit, 1637 1638 TP_PROTO(const struct btrfs_trans_handle *trans, 1639 const struct btrfs_root *root, 1640 const struct btrfs_log_ctx *ctx, 1641 int ret), 1642 1643 TP_ARGS(trans, root, ctx, ret), 1644 1645 TP_STRUCT__entry_btrfs( 1646 __field( u64, root_objectid ) 1647 __field( u64, transid ) 1648 __field( int, ctx_log_transid ) 1649 __field( int, root_log_transid ) 1650 __field( int, log_transid_committed ) 1651 __field( int, ret ) 1652 ), 1653 1654 TP_fast_assign( 1655 TP_fast_assign_fsid(trans->fs_info); 1656 __entry->root_objectid = btrfs_root_id(root); 1657 __entry->transid = trans->transid; 1658 __entry->ctx_log_transid = ctx->log_transid; 1659 __entry->root_log_transid = btrfs_get_root_log_transid(root); 1660 __entry->log_transid_committed = 1661 data_race(root->log_transid_committed); 1662 __entry->ret = ret; 1663 ), 1664 1665 TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_log_transid=%d" 1666 " root_log_transid=%d log_transid_committed=%d ret=%d", 1667 show_root_type(__entry->root_objectid), __entry->transid, 1668 __entry->ctx_log_transid, __entry->root_log_transid, 1669 __entry->log_transid_committed, __entry->ret) 1670 ); 1671 1672 TRACE_EVENT(btrfs_sync_fs, 1673 1674 TP_PROTO(const struct btrfs_fs_info *fs_info, int wait), 1675 1676 TP_ARGS(fs_info, wait), 1677 1678 TP_STRUCT__entry_btrfs( 1679 __field( int, wait ) 1680 ), 1681 1682 TP_fast_assign_btrfs(fs_info, 1683 __entry->wait = wait; 1684 ), 1685 1686 TP_printk_btrfs("wait=%d", __entry->wait) 1687 ); 1688 1689 TRACE_EVENT(btrfs_add_block_group, 1690 1691 TP_PROTO(const struct btrfs_fs_info *fs_info, 1692 const struct btrfs_block_group *block_group, int create), 1693 1694 TP_ARGS(fs_info, block_group, create), 1695 1696 TP_STRUCT__entry_btrfs( 1697 __field( u64, offset ) 1698 __field( u64, size ) 1699 __field( u64, flags ) 1700 __field( u64, bytes_used ) 1701 __field( u64, bytes_super ) 1702 __field( int, create ) 1703 ), 1704 1705 TP_fast_assign_btrfs(fs_info, 1706 __entry->offset = block_group->start; 1707 __entry->size = block_group->length; 1708 __entry->flags = block_group->flags; 1709 __entry->bytes_used = block_group->used; 1710 __entry->bytes_super = block_group->bytes_super; 1711 __entry->create = create; 1712 ), 1713 1714 TP_printk_btrfs("block_group offset=%llu size=%llu " 1715 "flags=%llu(%s) bytes_used=%llu bytes_super=%llu " 1716 "create=%d", 1717 __entry->offset, 1718 __entry->size, 1719 __entry->flags, 1720 __print_flags((unsigned long)__entry->flags, "|", 1721 BTRFS_GROUP_FLAGS), 1722 __entry->bytes_used, 1723 __entry->bytes_super, __entry->create) 1724 ); 1725 1726 #define show_ref_action(action) \ 1727 __print_symbolic(action, \ 1728 { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \ 1729 { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \ 1730 { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \ 1731 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" }) 1732 1733 1734 DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref, 1735 1736 TP_PROTO(const struct btrfs_fs_info *fs_info, 1737 const struct btrfs_delayed_ref_node *ref), 1738 1739 TP_ARGS(fs_info, ref), 1740 1741 TP_STRUCT__entry_btrfs( 1742 __field( u64, bytenr ) 1743 __field( u64, num_bytes ) 1744 __field( int, action ) 1745 __field( u64, parent ) 1746 __field( u64, ref_root ) 1747 __field( int, level ) 1748 __field( int, type ) 1749 __field( u64, seq ) 1750 ), 1751 1752 TP_fast_assign_btrfs(fs_info, 1753 __entry->bytenr = ref->bytenr; 1754 __entry->num_bytes = ref->num_bytes; 1755 __entry->action = ref->action; 1756 __entry->parent = ref->parent; 1757 __entry->ref_root = ref->ref_root; 1758 __entry->level = ref->tree_ref.level; 1759 __entry->type = ref->type; 1760 __entry->seq = ref->seq; 1761 ), 1762 1763 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s " 1764 "parent=%llu(%s) ref_root=%llu(%s) level=%d " 1765 "type=%s seq=%llu", 1766 __entry->bytenr, 1767 __entry->num_bytes, 1768 show_ref_action(__entry->action), 1769 show_root_type(__entry->parent), 1770 show_root_type(__entry->ref_root), 1771 __entry->level, show_ref_type(__entry->type), 1772 __entry->seq) 1773 ); 1774 1775 DEFINE_EVENT(btrfs_delayed_tree_ref, add_delayed_tree_ref, 1776 1777 TP_PROTO(const struct btrfs_fs_info *fs_info, 1778 const struct btrfs_delayed_ref_node *ref), 1779 1780 TP_ARGS(fs_info, ref) 1781 ); 1782 1783 DEFINE_EVENT(btrfs_delayed_tree_ref, run_delayed_tree_ref, 1784 1785 TP_PROTO(const struct btrfs_fs_info *fs_info, 1786 const struct btrfs_delayed_ref_node *ref), 1787 1788 TP_ARGS(fs_info, ref) 1789 ); 1790 1791 DECLARE_EVENT_CLASS(btrfs_delayed_data_ref, 1792 1793 TP_PROTO(const struct btrfs_fs_info *fs_info, 1794 const struct btrfs_delayed_ref_node *ref), 1795 1796 TP_ARGS(fs_info, ref), 1797 1798 TP_STRUCT__entry_btrfs( 1799 __field( u64, bytenr ) 1800 __field( u64, num_bytes ) 1801 __field( int, action ) 1802 __field( u64, parent ) 1803 __field( u64, ref_root ) 1804 __field( u64, owner ) 1805 __field( u64, offset ) 1806 __field( int, type ) 1807 __field( u64, seq ) 1808 ), 1809 1810 TP_fast_assign_btrfs(fs_info, 1811 __entry->bytenr = ref->bytenr; 1812 __entry->num_bytes = ref->num_bytes; 1813 __entry->action = ref->action; 1814 __entry->parent = ref->parent; 1815 __entry->ref_root = ref->ref_root; 1816 __entry->owner = ref->data_ref.objectid; 1817 __entry->offset = ref->data_ref.offset; 1818 __entry->type = ref->type; 1819 __entry->seq = ref->seq; 1820 ), 1821 1822 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s " 1823 "parent=%llu(%s) ref_root=%llu(%s) owner=%llu " 1824 "offset=%llu type=%s seq=%llu", 1825 __entry->bytenr, 1826 __entry->num_bytes, 1827 show_ref_action(__entry->action), 1828 show_root_type(__entry->parent), 1829 show_root_type(__entry->ref_root), 1830 __entry->owner, 1831 __entry->offset, 1832 show_ref_type(__entry->type), 1833 __entry->seq) 1834 ); 1835 1836 DEFINE_EVENT(btrfs_delayed_data_ref, add_delayed_data_ref, 1837 1838 TP_PROTO(const struct btrfs_fs_info *fs_info, 1839 const struct btrfs_delayed_ref_node *ref), 1840 1841 TP_ARGS(fs_info, ref) 1842 ); 1843 1844 DEFINE_EVENT(btrfs_delayed_data_ref, run_delayed_data_ref, 1845 1846 TP_PROTO(const struct btrfs_fs_info *fs_info, 1847 const struct btrfs_delayed_ref_node *ref), 1848 1849 TP_ARGS(fs_info, ref) 1850 ); 1851 1852 DECLARE_EVENT_CLASS(btrfs_delayed_ref_head, 1853 1854 TP_PROTO(const struct btrfs_fs_info *fs_info, 1855 const struct btrfs_delayed_ref_head *head_ref, 1856 int action), 1857 1858 TP_ARGS(fs_info, head_ref, action), 1859 1860 TP_STRUCT__entry_btrfs( 1861 __field( u64, bytenr ) 1862 __field( u64, num_bytes ) 1863 __field( int, action ) 1864 __field( int, is_data ) 1865 ), 1866 1867 TP_fast_assign_btrfs(fs_info, 1868 __entry->bytenr = head_ref->bytenr; 1869 __entry->num_bytes = head_ref->num_bytes; 1870 __entry->action = action; 1871 __entry->is_data = head_ref->is_data; 1872 ), 1873 1874 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s is_data=%d", 1875 __entry->bytenr, 1876 __entry->num_bytes, 1877 show_ref_action(__entry->action), 1878 __entry->is_data) 1879 ); 1880 1881 DEFINE_EVENT(btrfs_delayed_ref_head, add_delayed_ref_head, 1882 1883 TP_PROTO(const struct btrfs_fs_info *fs_info, 1884 const struct btrfs_delayed_ref_head *head_ref, 1885 int action), 1886 1887 TP_ARGS(fs_info, head_ref, action) 1888 ); 1889 1890 DEFINE_EVENT(btrfs_delayed_ref_head, run_delayed_ref_head, 1891 1892 TP_PROTO(const struct btrfs_fs_info *fs_info, 1893 const struct btrfs_delayed_ref_head *head_ref, 1894 int action), 1895 1896 TP_ARGS(fs_info, head_ref, action) 1897 ); 1898 1899 #define show_chunk_type(type) \ 1900 __print_flags(type, "|", \ 1901 { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \ 1902 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \ 1903 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \ 1904 { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \ 1905 { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \ 1906 { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \ 1907 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \ 1908 { BTRFS_BLOCK_GROUP_RAID5, "RAID5" }, \ 1909 { BTRFS_BLOCK_GROUP_RAID6, "RAID6" }) 1910 1911 DECLARE_EVENT_CLASS(btrfs__chunk, 1912 1913 TP_PROTO(const struct btrfs_fs_info *fs_info, 1914 const struct btrfs_chunk_map *map, u64 offset, u64 size), 1915 1916 TP_ARGS(fs_info, map, offset, size), 1917 1918 TP_STRUCT__entry_btrfs( 1919 __field( int, num_stripes ) 1920 __field( u64, type ) 1921 __field( int, sub_stripes ) 1922 __field( u64, offset ) 1923 __field( u64, size ) 1924 __field( u64, root_objectid ) 1925 ), 1926 1927 TP_fast_assign_btrfs(fs_info, 1928 __entry->num_stripes = map->num_stripes; 1929 __entry->type = map->type; 1930 __entry->sub_stripes = map->sub_stripes; 1931 __entry->offset = offset; 1932 __entry->size = size; 1933 __entry->root_objectid = btrfs_root_id(fs_info->chunk_root); 1934 ), 1935 1936 TP_printk_btrfs("root=%llu(%s) offset=%llu size=%llu " 1937 "num_stripes=%d sub_stripes=%d type=%s", 1938 show_root_type(__entry->root_objectid), 1939 __entry->offset, 1940 __entry->size, 1941 __entry->num_stripes, __entry->sub_stripes, 1942 show_chunk_type(__entry->type)) 1943 ); 1944 1945 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc, 1946 1947 TP_PROTO(const struct btrfs_fs_info *fs_info, 1948 const struct btrfs_chunk_map *map, u64 offset, u64 size), 1949 1950 TP_ARGS(fs_info, map, offset, size) 1951 ); 1952 1953 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free, 1954 1955 TP_PROTO(const struct btrfs_fs_info *fs_info, 1956 const struct btrfs_chunk_map *map, u64 offset, u64 size), 1957 1958 TP_ARGS(fs_info, map, offset, size) 1959 ); 1960 1961 TRACE_EVENT(btrfs_cow_block, 1962 1963 TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf, 1964 const struct extent_buffer *cow), 1965 1966 TP_ARGS(root, buf, cow), 1967 1968 TP_STRUCT__entry_btrfs( 1969 __field( u64, root_objectid ) 1970 __field( u64, buf_start ) 1971 __field( int, refs ) 1972 __field( u64, cow_start ) 1973 __field( int, buf_level ) 1974 __field( int, cow_level ) 1975 ), 1976 1977 TP_fast_assign_btrfs(root->fs_info, 1978 __entry->root_objectid = btrfs_root_id(root); 1979 __entry->buf_start = buf->start; 1980 __entry->refs = refcount_read(&buf->refs); 1981 __entry->cow_start = cow->start; 1982 __entry->buf_level = btrfs_header_level(buf); 1983 __entry->cow_level = btrfs_header_level(cow); 1984 ), 1985 1986 TP_printk_btrfs("root=%llu(%s) refs=%d orig_buf=%llu " 1987 "(orig_level=%d) cow_buf=%llu (cow_level=%d)", 1988 show_root_type(__entry->root_objectid), 1989 __entry->refs, 1990 __entry->buf_start, 1991 __entry->buf_level, 1992 __entry->cow_start, 1993 __entry->cow_level) 1994 ); 1995 1996 TRACE_EVENT(btrfs_search_slot_restart, 1997 1998 TP_PROTO(const struct btrfs_root *root, int level, 1999 const char *reason), 2000 2001 TP_ARGS(root, level, reason), 2002 2003 TP_STRUCT__entry_btrfs( 2004 __field( u64, root_objectid ) 2005 __field( int, level ) 2006 __string( reason, reason ) 2007 ), 2008 2009 TP_fast_assign_btrfs(root->fs_info, 2010 __entry->root_objectid = btrfs_root_id(root); 2011 __entry->level = level; 2012 __assign_str(reason); 2013 ), 2014 2015 TP_printk_btrfs("root=%llu(%s) level=%d reason=%s", 2016 show_root_type(__entry->root_objectid), 2017 __entry->level, __get_str(reason)) 2018 ); 2019 2020 TRACE_EVENT(btrfs_space_reservation, 2021 2022 TP_PROTO(const struct btrfs_fs_info *fs_info, const char *type, u64 val, 2023 u64 bytes, int reserve), 2024 2025 TP_ARGS(fs_info, type, val, bytes, reserve), 2026 2027 TP_STRUCT__entry_btrfs( 2028 __string( type, type ) 2029 __field( u64, val ) 2030 __field( u64, bytes ) 2031 __field( int, reserve ) 2032 ), 2033 2034 TP_fast_assign_btrfs(fs_info, 2035 __assign_str(type); 2036 __entry->val = val; 2037 __entry->bytes = bytes; 2038 __entry->reserve = reserve; 2039 ), 2040 2041 TP_printk_btrfs("%s: %llu %s %llu", __get_str(type), __entry->val, 2042 __entry->reserve ? "reserve" : "release", 2043 __entry->bytes) 2044 ); 2045 2046 TRACE_EVENT(btrfs_trigger_flush, 2047 2048 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes, 2049 int flush, const char *reason), 2050 2051 TP_ARGS(fs_info, flags, bytes, flush, reason), 2052 2053 TP_STRUCT__entry_btrfs( 2054 __field( u64, flags ) 2055 __field( u64, bytes ) 2056 __field( int, flush ) 2057 __string( reason, reason ) 2058 ), 2059 2060 TP_fast_assign_btrfs(fs_info, 2061 __entry->flags = flags; 2062 __entry->bytes = bytes; 2063 __entry->flush = flush; 2064 __assign_str(reason); 2065 ), 2066 2067 TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu", 2068 __get_str(reason), __entry->flush, 2069 __print_symbolic(__entry->flush, FLUSH_ACTIONS), 2070 __entry->flags, 2071 __print_flags((unsigned long)__entry->flags, "|", 2072 BTRFS_GROUP_FLAGS), 2073 __entry->bytes) 2074 ); 2075 2076 2077 TRACE_EVENT(btrfs_flush_space, 2078 2079 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes, 2080 int state, int ret, bool for_preempt), 2081 2082 TP_ARGS(fs_info, flags, num_bytes, state, ret, for_preempt), 2083 2084 TP_STRUCT__entry_btrfs( 2085 __field( u64, flags ) 2086 __field( u64, num_bytes ) 2087 __field( int, state ) 2088 __field( int, ret ) 2089 __field( bool, for_preempt ) 2090 ), 2091 2092 TP_fast_assign_btrfs(fs_info, 2093 __entry->flags = flags; 2094 __entry->num_bytes = num_bytes; 2095 __entry->state = state; 2096 __entry->ret = ret; 2097 __entry->for_preempt = for_preempt; 2098 ), 2099 2100 TP_printk_btrfs("state=%d(%s) flags=%llu(%s) num_bytes=%llu ret=%d for_preempt=%d", 2101 __entry->state, 2102 __print_symbolic(__entry->state, FLUSH_STATES), 2103 __entry->flags, 2104 __print_flags((unsigned long)__entry->flags, "|", 2105 BTRFS_GROUP_FLAGS), 2106 __entry->num_bytes, __entry->ret, __entry->for_preempt) 2107 ); 2108 2109 DECLARE_EVENT_CLASS(btrfs__reserved_extent, 2110 2111 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), 2112 2113 TP_ARGS(fs_info, start, len), 2114 2115 TP_STRUCT__entry_btrfs( 2116 __field( u64, start ) 2117 __field( u64, len ) 2118 ), 2119 2120 TP_fast_assign_btrfs(fs_info, 2121 __entry->start = start; 2122 __entry->len = len; 2123 ), 2124 2125 TP_printk_btrfs("root=%llu(%s) start=%llu len=%llu", 2126 show_root_type(BTRFS_EXTENT_TREE_OBJECTID), 2127 __entry->start, 2128 __entry->len) 2129 ); 2130 2131 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc, 2132 2133 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), 2134 2135 TP_ARGS(fs_info, start, len) 2136 ); 2137 2138 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free, 2139 2140 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len), 2141 2142 TP_ARGS(fs_info, start, len) 2143 ); 2144 2145 TRACE_EVENT(btrfs_find_free_extent, 2146 2147 TP_PROTO(const struct btrfs_root *root, 2148 const struct find_free_extent_ctl *ffe_ctl), 2149 2150 TP_ARGS(root, ffe_ctl), 2151 2152 TP_STRUCT__entry_btrfs( 2153 __field( u64, root_objectid ) 2154 __field( u64, num_bytes ) 2155 __field( u64, empty_size ) 2156 __field( u64, flags ) 2157 ), 2158 2159 TP_fast_assign_btrfs(root->fs_info, 2160 __entry->root_objectid = btrfs_root_id(root); 2161 __entry->num_bytes = ffe_ctl->num_bytes; 2162 __entry->empty_size = ffe_ctl->empty_size; 2163 __entry->flags = ffe_ctl->flags; 2164 ), 2165 2166 TP_printk_btrfs("root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s)", 2167 show_root_type(__entry->root_objectid), 2168 __entry->num_bytes, __entry->empty_size, __entry->flags, 2169 __print_flags((unsigned long)__entry->flags, "|", 2170 BTRFS_GROUP_FLAGS)) 2171 ); 2172 2173 TRACE_EVENT(btrfs_find_free_extent_search_loop, 2174 2175 TP_PROTO(const struct btrfs_root *root, 2176 const struct find_free_extent_ctl *ffe_ctl), 2177 2178 TP_ARGS(root, ffe_ctl), 2179 2180 TP_STRUCT__entry_btrfs( 2181 __field( u64, root_objectid ) 2182 __field( u64, num_bytes ) 2183 __field( u64, empty_size ) 2184 __field( u64, flags ) 2185 __field( u64, loop ) 2186 ), 2187 2188 TP_fast_assign_btrfs(root->fs_info, 2189 __entry->root_objectid = btrfs_root_id(root); 2190 __entry->num_bytes = ffe_ctl->num_bytes; 2191 __entry->empty_size = ffe_ctl->empty_size; 2192 __entry->flags = ffe_ctl->flags; 2193 __entry->loop = ffe_ctl->loop; 2194 ), 2195 2196 TP_printk_btrfs("root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s) loop=%llu", 2197 show_root_type(__entry->root_objectid), 2198 __entry->num_bytes, __entry->empty_size, __entry->flags, 2199 __print_flags((unsigned long)__entry->flags, "|", BTRFS_GROUP_FLAGS), 2200 __entry->loop) 2201 ); 2202 2203 TRACE_EVENT(btrfs_find_free_extent_have_block_group, 2204 2205 TP_PROTO(const struct btrfs_root *root, 2206 const struct find_free_extent_ctl *ffe_ctl, 2207 const struct btrfs_block_group *block_group), 2208 2209 TP_ARGS(root, ffe_ctl, block_group), 2210 2211 TP_STRUCT__entry_btrfs( 2212 __field( u64, root_objectid ) 2213 __field( u64, num_bytes ) 2214 __field( u64, empty_size ) 2215 __field( u64, flags ) 2216 __field( u64, loop ) 2217 __field( bool, hinted ) 2218 __field( u64, bg_start ) 2219 __field( u64, bg_flags ) 2220 ), 2221 2222 TP_fast_assign_btrfs(root->fs_info, 2223 __entry->root_objectid = btrfs_root_id(root); 2224 __entry->num_bytes = ffe_ctl->num_bytes; 2225 __entry->empty_size = ffe_ctl->empty_size; 2226 __entry->flags = ffe_ctl->flags; 2227 __entry->loop = ffe_ctl->loop; 2228 __entry->hinted = ffe_ctl->hinted; 2229 __entry->bg_start = block_group->start; 2230 __entry->bg_flags = block_group->flags; 2231 ), 2232 2233 TP_printk_btrfs( 2234 "root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s) loop=%llu hinted=%d block_group=%llu bg_flags=%llu(%s)", 2235 show_root_type(__entry->root_objectid), 2236 __entry->num_bytes, __entry->empty_size, __entry->flags, 2237 __print_flags((unsigned long)__entry->flags, "|", BTRFS_GROUP_FLAGS), 2238 __entry->loop, __entry->hinted, 2239 __entry->bg_start, __entry->bg_flags, 2240 __print_flags((unsigned long)__entry->bg_flags, "|", 2241 BTRFS_GROUP_FLAGS)) 2242 ); 2243 2244 DECLARE_EVENT_CLASS(btrfs__reserve_extent, 2245 2246 TP_PROTO(const struct btrfs_block_group *block_group, 2247 const struct find_free_extent_ctl *ffe_ctl), 2248 2249 TP_ARGS(block_group, ffe_ctl), 2250 2251 TP_STRUCT__entry_btrfs( 2252 __field( u64, bg_objectid ) 2253 __field( u64, flags ) 2254 __field( int, bg_size_class ) 2255 __field( u64, start ) 2256 __field( u64, len ) 2257 __field( u64, loop ) 2258 __field( bool, hinted ) 2259 __field( int, size_class ) 2260 ), 2261 2262 TP_fast_assign_btrfs(block_group->fs_info, 2263 __entry->bg_objectid = block_group->start; 2264 __entry->flags = block_group->flags; 2265 __entry->bg_size_class = block_group->size_class; 2266 __entry->start = ffe_ctl->search_start; 2267 __entry->len = ffe_ctl->num_bytes; 2268 __entry->loop = ffe_ctl->loop; 2269 __entry->hinted = ffe_ctl->hinted; 2270 __entry->size_class = ffe_ctl->size_class; 2271 ), 2272 2273 TP_printk_btrfs( 2274 "root=%llu(%s) block_group=%llu flags=%llu(%s) bg_size_class=%d start=%llu len=%llu loop=%llu hinted=%d size_class=%d", 2275 show_root_type(BTRFS_EXTENT_TREE_OBJECTID), 2276 __entry->bg_objectid, 2277 __entry->flags, __print_flags((unsigned long)__entry->flags, 2278 "|", BTRFS_GROUP_FLAGS), 2279 __entry->bg_size_class, __entry->start, __entry->len, 2280 __entry->loop, __entry->hinted, __entry->size_class) 2281 ); 2282 2283 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent, 2284 2285 TP_PROTO(const struct btrfs_block_group *block_group, 2286 const struct find_free_extent_ctl *ffe_ctl), 2287 2288 TP_ARGS(block_group, ffe_ctl) 2289 ); 2290 2291 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster, 2292 2293 TP_PROTO(const struct btrfs_block_group *block_group, 2294 const struct find_free_extent_ctl *ffe_ctl), 2295 2296 TP_ARGS(block_group, ffe_ctl) 2297 ); 2298 2299 TRACE_EVENT(btrfs_find_cluster, 2300 2301 TP_PROTO(const struct btrfs_block_group *block_group, u64 start, 2302 u64 bytes, u64 empty_size, u64 min_bytes), 2303 2304 TP_ARGS(block_group, start, bytes, empty_size, min_bytes), 2305 2306 TP_STRUCT__entry_btrfs( 2307 __field( u64, bg_objectid ) 2308 __field( u64, flags ) 2309 __field( u64, start ) 2310 __field( u64, bytes ) 2311 __field( u64, empty_size ) 2312 __field( u64, min_bytes ) 2313 ), 2314 2315 TP_fast_assign_btrfs(block_group->fs_info, 2316 __entry->bg_objectid = block_group->start; 2317 __entry->flags = block_group->flags; 2318 __entry->start = start; 2319 __entry->bytes = bytes; 2320 __entry->empty_size = empty_size; 2321 __entry->min_bytes = min_bytes; 2322 ), 2323 2324 TP_printk_btrfs("block_group=%llu flags=%llu(%s) start=%llu len=%llu " 2325 "empty_size=%llu min_bytes=%llu", __entry->bg_objectid, 2326 __entry->flags, 2327 __print_flags((unsigned long)__entry->flags, "|", 2328 BTRFS_GROUP_FLAGS), __entry->start, 2329 __entry->bytes, __entry->empty_size, __entry->min_bytes) 2330 ); 2331 2332 TRACE_EVENT(btrfs_failed_cluster_setup, 2333 2334 TP_PROTO(const struct btrfs_block_group *block_group), 2335 2336 TP_ARGS(block_group), 2337 2338 TP_STRUCT__entry_btrfs( 2339 __field( u64, bg_objectid ) 2340 ), 2341 2342 TP_fast_assign_btrfs(block_group->fs_info, 2343 __entry->bg_objectid = block_group->start; 2344 ), 2345 2346 TP_printk_btrfs("block_group=%llu", __entry->bg_objectid) 2347 ); 2348 2349 TRACE_EVENT(btrfs_setup_cluster, 2350 2351 TP_PROTO(const struct btrfs_block_group *block_group, 2352 const struct btrfs_free_cluster *cluster, 2353 u64 size, int bitmap), 2354 2355 TP_ARGS(block_group, cluster, size, bitmap), 2356 2357 TP_STRUCT__entry_btrfs( 2358 __field( u64, bg_objectid ) 2359 __field( u64, flags ) 2360 __field( u64, start ) 2361 __field( u64, max_size ) 2362 __field( u64, size ) 2363 __field( int, bitmap ) 2364 ), 2365 2366 TP_fast_assign_btrfs(block_group->fs_info, 2367 __entry->bg_objectid = block_group->start; 2368 __entry->flags = block_group->flags; 2369 __entry->start = cluster->window_start; 2370 __entry->max_size = cluster->max_size; 2371 __entry->size = size; 2372 __entry->bitmap = bitmap; 2373 ), 2374 2375 TP_printk_btrfs("block_group=%llu flags=%llu(%s) window_start=%llu " 2376 "size=%llu max_size=%llu bitmap=%d", 2377 __entry->bg_objectid, 2378 __entry->flags, 2379 __print_flags((unsigned long)__entry->flags, "|", 2380 BTRFS_GROUP_FLAGS), __entry->start, 2381 __entry->size, __entry->max_size, __entry->bitmap) 2382 ); 2383 2384 struct extent_state; 2385 TRACE_EVENT(btrfs_alloc_extent_state, 2386 2387 TP_PROTO(const struct extent_state *state, 2388 gfp_t mask, unsigned long IP), 2389 2390 TP_ARGS(state, mask, IP), 2391 2392 TP_STRUCT__entry( 2393 __field(const struct extent_state *, state) 2394 __field(unsigned long, mask) 2395 __field(const void*, ip) 2396 ), 2397 2398 TP_fast_assign( 2399 __entry->state = state, 2400 __entry->mask = (__force unsigned long)mask, 2401 __entry->ip = (const void *)IP 2402 ), 2403 2404 TP_printk("state=%p mask=%s caller=%pS", __entry->state, 2405 show_gfp_flags(__entry->mask), __entry->ip) 2406 ); 2407 2408 TRACE_EVENT(btrfs_free_extent_state, 2409 2410 TP_PROTO(const struct extent_state *state, unsigned long IP), 2411 2412 TP_ARGS(state, IP), 2413 2414 TP_STRUCT__entry( 2415 __field(const struct extent_state *, state) 2416 __field(const void*, ip) 2417 ), 2418 2419 TP_fast_assign( 2420 __entry->state = state, 2421 __entry->ip = (const void *)IP 2422 ), 2423 2424 TP_printk("state=%p caller=%pS", __entry->state, __entry->ip) 2425 ); 2426 2427 DECLARE_EVENT_CLASS(btrfs__work, 2428 2429 TP_PROTO(const struct btrfs_work *work), 2430 2431 TP_ARGS(work), 2432 2433 TP_STRUCT__entry_btrfs( 2434 __field( const void *, work ) 2435 __field( const void *, wq ) 2436 __field( const void *, func ) 2437 __field( const void *, ordered_func ) 2438 __field( const void *, normal_work ) 2439 ), 2440 2441 TP_fast_assign_btrfs(btrfs_work_owner(work), 2442 __entry->work = work; 2443 __entry->wq = work->wq; 2444 __entry->func = work->func; 2445 __entry->ordered_func = work->ordered_func; 2446 __entry->normal_work = &work->normal_work; 2447 ), 2448 2449 TP_printk_btrfs("work=%p (normal_work=%p) wq=%p func=%ps ordered_func=%p", 2450 __entry->work, __entry->normal_work, __entry->wq, 2451 __entry->func, __entry->ordered_func) 2452 ); 2453 2454 /* 2455 * For situations when the work is freed, we pass fs_info and a tag that matches 2456 * the address of the work structure so it can be paired with the scheduling 2457 * event. DO NOT add anything here that dereferences wtag. 2458 */ 2459 DECLARE_EVENT_CLASS(btrfs__work__done, 2460 2461 TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag), 2462 2463 TP_ARGS(fs_info, wtag), 2464 2465 TP_STRUCT__entry_btrfs( 2466 __field( const void *, wtag ) 2467 ), 2468 2469 TP_fast_assign_btrfs(fs_info, 2470 __entry->wtag = wtag; 2471 ), 2472 2473 TP_printk_btrfs("work->%p", __entry->wtag) 2474 ); 2475 2476 DEFINE_EVENT(btrfs__work, btrfs_work_queued, 2477 2478 TP_PROTO(const struct btrfs_work *work), 2479 2480 TP_ARGS(work) 2481 ); 2482 2483 DEFINE_EVENT(btrfs__work, btrfs_work_sched, 2484 2485 TP_PROTO(const struct btrfs_work *work), 2486 2487 TP_ARGS(work) 2488 ); 2489 2490 DEFINE_EVENT(btrfs__work__done, btrfs_all_work_done, 2491 2492 TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag), 2493 2494 TP_ARGS(fs_info, wtag) 2495 ); 2496 2497 DEFINE_EVENT(btrfs__work, btrfs_ordered_sched, 2498 2499 TP_PROTO(const struct btrfs_work *work), 2500 2501 TP_ARGS(work) 2502 ); 2503 2504 DECLARE_EVENT_CLASS(btrfs_workqueue, 2505 2506 TP_PROTO(const struct btrfs_workqueue *wq, const char *name), 2507 2508 TP_ARGS(wq, name), 2509 2510 TP_STRUCT__entry_btrfs( 2511 __field( const void *, wq ) 2512 __string( name, name ) 2513 ), 2514 2515 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq), 2516 __entry->wq = wq; 2517 __assign_str(name); 2518 ), 2519 2520 TP_printk_btrfs("name=%s wq=%p", __get_str(name), 2521 __entry->wq) 2522 ); 2523 2524 DEFINE_EVENT(btrfs_workqueue, btrfs_workqueue_alloc, 2525 2526 TP_PROTO(const struct btrfs_workqueue *wq, const char *name), 2527 2528 TP_ARGS(wq, name) 2529 ); 2530 2531 DECLARE_EVENT_CLASS(btrfs_workqueue_done, 2532 2533 TP_PROTO(const struct btrfs_workqueue *wq), 2534 2535 TP_ARGS(wq), 2536 2537 TP_STRUCT__entry_btrfs( 2538 __field( const void *, wq ) 2539 ), 2540 2541 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq), 2542 __entry->wq = wq; 2543 ), 2544 2545 TP_printk_btrfs("wq=%p", __entry->wq) 2546 ); 2547 2548 DEFINE_EVENT(btrfs_workqueue_done, btrfs_workqueue_destroy, 2549 2550 TP_PROTO(const struct btrfs_workqueue *wq), 2551 2552 TP_ARGS(wq) 2553 ); 2554 2555 #define BTRFS_QGROUP_OPERATIONS \ 2556 { QGROUP_RESERVE, "reserve" }, \ 2557 { QGROUP_RELEASE, "release" }, \ 2558 { QGROUP_FREE, "free" } 2559 2560 DECLARE_EVENT_CLASS(btrfs__qgroup_rsv_data, 2561 2562 TP_PROTO(const struct inode *inode, u64 start, u64 len, 2563 u64 reserved, int op), 2564 2565 TP_ARGS(inode, start, len, reserved, op), 2566 2567 TP_STRUCT__entry_btrfs( 2568 __field( u64, rootid ) 2569 __field( u64, ino ) 2570 __field( u64, start ) 2571 __field( u64, len ) 2572 __field( u64, reserved ) 2573 __field( int, op ) 2574 ), 2575 2576 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb), 2577 __entry->rootid = btrfs_root_id(BTRFS_I(inode)->root); 2578 __entry->ino = btrfs_ino(BTRFS_I(inode)); 2579 __entry->start = start; 2580 __entry->len = len; 2581 __entry->reserved = reserved; 2582 __entry->op = op; 2583 ), 2584 2585 TP_printk_btrfs("root=%llu ino=%llu start=%llu len=%llu reserved=%llu op=%s", 2586 __entry->rootid, __entry->ino, __entry->start, __entry->len, 2587 __entry->reserved, 2588 __print_flags((unsigned long)__entry->op, "", 2589 BTRFS_QGROUP_OPERATIONS) 2590 ) 2591 ); 2592 2593 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_reserve_data, 2594 2595 TP_PROTO(const struct inode *inode, u64 start, u64 len, 2596 u64 reserved, int op), 2597 2598 TP_ARGS(inode, start, len, reserved, op) 2599 ); 2600 2601 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_release_data, 2602 2603 TP_PROTO(const struct inode *inode, u64 start, u64 len, 2604 u64 reserved, int op), 2605 2606 TP_ARGS(inode, start, len, reserved, op) 2607 ); 2608 2609 DECLARE_EVENT_CLASS(btrfs_qgroup_extent, 2610 TP_PROTO(const struct btrfs_fs_info *fs_info, 2611 const struct btrfs_qgroup_extent_record *rec, 2612 u64 bytenr), 2613 2614 TP_ARGS(fs_info, rec, bytenr), 2615 2616 TP_STRUCT__entry_btrfs( 2617 __field( u64, bytenr ) 2618 __field( u64, num_bytes ) 2619 ), 2620 2621 TP_fast_assign_btrfs(fs_info, 2622 __entry->bytenr = bytenr; 2623 __entry->num_bytes = rec->num_bytes; 2624 ), 2625 2626 TP_printk_btrfs("bytenr=%llu num_bytes=%llu", 2627 __entry->bytenr, __entry->num_bytes) 2628 ); 2629 2630 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_account_extents, 2631 2632 TP_PROTO(const struct btrfs_fs_info *fs_info, 2633 const struct btrfs_qgroup_extent_record *rec, 2634 u64 bytenr), 2635 2636 TP_ARGS(fs_info, rec, bytenr) 2637 ); 2638 2639 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_trace_extent, 2640 2641 TP_PROTO(const struct btrfs_fs_info *fs_info, 2642 const struct btrfs_qgroup_extent_record *rec, 2643 u64 bytenr), 2644 2645 TP_ARGS(fs_info, rec, bytenr) 2646 ); 2647 2648 TRACE_EVENT(btrfs_qgroup_num_dirty_extents, 2649 2650 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid, 2651 u64 num_dirty_extents), 2652 2653 TP_ARGS(fs_info, transid, num_dirty_extents), 2654 2655 TP_STRUCT__entry_btrfs( 2656 __field( u64, transid ) 2657 __field( u64, num_dirty_extents ) 2658 ), 2659 2660 TP_fast_assign_btrfs(fs_info, 2661 __entry->transid = transid; 2662 __entry->num_dirty_extents = num_dirty_extents; 2663 ), 2664 2665 TP_printk_btrfs("transid=%llu num_dirty_extents=%llu", 2666 __entry->transid, __entry->num_dirty_extents) 2667 ); 2668 2669 TRACE_EVENT(btrfs_qgroup_account_extent, 2670 2671 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid, u64 bytenr, 2672 u64 num_bytes, u64 nr_old_roots, u64 nr_new_roots), 2673 2674 TP_ARGS(fs_info, transid, bytenr, num_bytes, nr_old_roots, 2675 nr_new_roots), 2676 2677 TP_STRUCT__entry_btrfs( 2678 __field( u64, transid ) 2679 __field( u64, bytenr ) 2680 __field( u64, num_bytes ) 2681 __field( u64, nr_old_roots ) 2682 __field( u64, nr_new_roots ) 2683 ), 2684 2685 TP_fast_assign_btrfs(fs_info, 2686 __entry->transid = transid; 2687 __entry->bytenr = bytenr; 2688 __entry->num_bytes = num_bytes; 2689 __entry->nr_old_roots = nr_old_roots; 2690 __entry->nr_new_roots = nr_new_roots; 2691 ), 2692 2693 TP_printk_btrfs( 2694 "transid=%llu bytenr=%llu num_bytes=%llu nr_old_roots=%llu nr_new_roots=%llu", 2695 __entry->transid, 2696 __entry->bytenr, 2697 __entry->num_bytes, 2698 __entry->nr_old_roots, 2699 __entry->nr_new_roots) 2700 ); 2701 2702 TRACE_EVENT(btrfs_qgroup_update_counters, 2703 2704 TP_PROTO(const struct btrfs_fs_info *fs_info, 2705 const struct btrfs_qgroup *qgroup, 2706 u64 cur_old_count, u64 cur_new_count), 2707 2708 TP_ARGS(fs_info, qgroup, cur_old_count, cur_new_count), 2709 2710 TP_STRUCT__entry_btrfs( 2711 __field( u64, qgid ) 2712 __field( u64, old_rfer ) 2713 __field( u64, old_excl ) 2714 __field( u64, cur_old_count ) 2715 __field( u64, cur_new_count ) 2716 ), 2717 2718 TP_fast_assign_btrfs(fs_info, 2719 __entry->qgid = qgroup->qgroupid; 2720 __entry->old_rfer = qgroup->rfer; 2721 __entry->old_excl = qgroup->excl; 2722 __entry->cur_old_count = cur_old_count; 2723 __entry->cur_new_count = cur_new_count; 2724 ), 2725 2726 TP_printk_btrfs("qgid=%llu old_rfer=%llu old_excl=%llu cur_old_count=%llu cur_new_count=%llu", 2727 __entry->qgid, __entry->old_rfer, __entry->old_excl, 2728 __entry->cur_old_count, __entry->cur_new_count) 2729 ); 2730 2731 TRACE_EVENT(btrfs_qgroup_update_reserve, 2732 2733 TP_PROTO(const struct btrfs_fs_info *fs_info, const struct btrfs_qgroup *qgroup, 2734 s64 diff, int type), 2735 2736 TP_ARGS(fs_info, qgroup, diff, type), 2737 2738 TP_STRUCT__entry_btrfs( 2739 __field( u64, qgid ) 2740 __field( u64, cur_reserved ) 2741 __field( s64, diff ) 2742 __field( int, type ) 2743 ), 2744 2745 TP_fast_assign_btrfs(fs_info, 2746 __entry->qgid = qgroup->qgroupid; 2747 __entry->cur_reserved = qgroup->rsv.values[type]; 2748 __entry->diff = diff; 2749 __entry->type = type; 2750 ), 2751 2752 TP_printk_btrfs("qgid=%llu type=%s cur_reserved=%llu diff=%lld", 2753 __entry->qgid, __print_symbolic(__entry->type, QGROUP_RSV_TYPES), 2754 __entry->cur_reserved, __entry->diff) 2755 ); 2756 2757 TRACE_EVENT(btrfs_qgroup_meta_reserve, 2758 2759 TP_PROTO(const struct btrfs_root *root, s64 diff, int type), 2760 2761 TP_ARGS(root, diff, type), 2762 2763 TP_STRUCT__entry_btrfs( 2764 __field( u64, refroot ) 2765 __field( s64, diff ) 2766 __field( int, type ) 2767 ), 2768 2769 TP_fast_assign_btrfs(root->fs_info, 2770 __entry->refroot = btrfs_root_id(root); 2771 __entry->diff = diff; 2772 __entry->type = type; 2773 ), 2774 2775 TP_printk_btrfs("refroot=%llu(%s) type=%s diff=%lld", 2776 show_root_type(__entry->refroot), 2777 __print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff) 2778 ); 2779 2780 TRACE_EVENT(btrfs_qgroup_meta_convert, 2781 2782 TP_PROTO(const struct btrfs_root *root, s64 diff), 2783 2784 TP_ARGS(root, diff), 2785 2786 TP_STRUCT__entry_btrfs( 2787 __field( u64, refroot ) 2788 __field( s64, diff ) 2789 ), 2790 2791 TP_fast_assign_btrfs(root->fs_info, 2792 __entry->refroot = btrfs_root_id(root); 2793 __entry->diff = diff; 2794 ), 2795 2796 TP_printk_btrfs("refroot=%llu(%s) type=%s->%s diff=%lld", 2797 show_root_type(__entry->refroot), 2798 __print_symbolic(BTRFS_QGROUP_RSV_META_PREALLOC, QGROUP_RSV_TYPES), 2799 __print_symbolic(BTRFS_QGROUP_RSV_META_PERTRANS, QGROUP_RSV_TYPES), 2800 __entry->diff) 2801 ); 2802 2803 TRACE_EVENT(btrfs_qgroup_meta_free_all_pertrans, 2804 2805 TP_PROTO(struct btrfs_root *root), 2806 2807 TP_ARGS(root), 2808 2809 TP_STRUCT__entry_btrfs( 2810 __field( u64, refroot ) 2811 __field( s64, diff ) 2812 __field( int, type ) 2813 ), 2814 2815 TP_fast_assign_btrfs(root->fs_info, 2816 __entry->refroot = btrfs_root_id(root); 2817 spin_lock(&root->qgroup_meta_rsv_lock); 2818 __entry->diff = -(s64)root->qgroup_meta_rsv_pertrans; 2819 spin_unlock(&root->qgroup_meta_rsv_lock); 2820 __entry->type = BTRFS_QGROUP_RSV_META_PERTRANS; 2821 ), 2822 2823 TP_printk_btrfs("refroot=%llu(%s) type=%s diff=%lld", 2824 show_root_type(__entry->refroot), 2825 __print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff) 2826 ); 2827 2828 DECLARE_EVENT_CLASS(btrfs__prelim_ref, 2829 TP_PROTO(const struct btrfs_fs_info *fs_info, 2830 const struct prelim_ref *oldref, 2831 const struct prelim_ref *newref, u64 tree_size), 2832 TP_ARGS(fs_info, oldref, newref, tree_size), 2833 2834 TP_STRUCT__entry_btrfs( 2835 __field( u64, root_id ) 2836 __field( u64, objectid ) 2837 __field( u8, type ) 2838 __field( u64, offset ) 2839 __field( int, level ) 2840 __field( int, old_count ) 2841 __field( u64, parent ) 2842 __field( u64, bytenr ) 2843 __field( int, mod_count ) 2844 __field( u64, tree_size ) 2845 ), 2846 2847 TP_fast_assign_btrfs(fs_info, 2848 __entry->root_id = oldref->root_id; 2849 __entry->objectid = oldref->key_for_search.objectid; 2850 __entry->type = oldref->key_for_search.type; 2851 __entry->offset = oldref->key_for_search.offset; 2852 __entry->level = oldref->level; 2853 __entry->old_count = oldref->count; 2854 __entry->parent = oldref->parent; 2855 __entry->bytenr = oldref->wanted_disk_byte; 2856 __entry->mod_count = newref ? newref->count : 0; 2857 __entry->tree_size = tree_size; 2858 ), 2859 2860 TP_printk_btrfs("root_id=%llu key=[%llu,%u,%llu] level=%d count=[%d+%d=%d] parent=%llu wanted_disk_byte=%llu nodes=%llu", 2861 __entry->root_id, 2862 __entry->objectid, __entry->type, 2863 __entry->offset, __entry->level, 2864 __entry->old_count, __entry->mod_count, 2865 __entry->old_count + __entry->mod_count, 2866 __entry->parent, 2867 __entry->bytenr, 2868 __entry->tree_size) 2869 ); 2870 2871 DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_merge, 2872 TP_PROTO(const struct btrfs_fs_info *fs_info, 2873 const struct prelim_ref *oldref, 2874 const struct prelim_ref *newref, u64 tree_size), 2875 TP_ARGS(fs_info, oldref, newref, tree_size) 2876 ); 2877 2878 DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_insert, 2879 TP_PROTO(const struct btrfs_fs_info *fs_info, 2880 const struct prelim_ref *oldref, 2881 const struct prelim_ref *newref, u64 tree_size), 2882 TP_ARGS(fs_info, oldref, newref, tree_size) 2883 ); 2884 2885 TRACE_EVENT(btrfs_inode_mod_outstanding_extents, 2886 TP_PROTO(const struct btrfs_root *root, u64 ino, int mod, unsigned outstanding), 2887 2888 TP_ARGS(root, ino, mod, outstanding), 2889 2890 TP_STRUCT__entry_btrfs( 2891 __field( u64, root_objectid ) 2892 __field( u64, ino ) 2893 __field( int, mod ) 2894 __field( unsigned, outstanding ) 2895 ), 2896 2897 TP_fast_assign_btrfs(root->fs_info, 2898 __entry->root_objectid = btrfs_root_id(root); 2899 __entry->ino = ino; 2900 __entry->mod = mod; 2901 __entry->outstanding = outstanding; 2902 ), 2903 2904 TP_printk_btrfs("root=%llu(%s) ino=%llu mod=%d outstanding=%u", 2905 show_root_type(__entry->root_objectid), 2906 __entry->ino, __entry->mod, __entry->outstanding) 2907 ); 2908 2909 DECLARE_EVENT_CLASS(btrfs__block_group, 2910 TP_PROTO(const struct btrfs_block_group *bg_cache), 2911 2912 TP_ARGS(bg_cache), 2913 2914 TP_STRUCT__entry_btrfs( 2915 __field( u64, bytenr ) 2916 __field( u64, len ) 2917 __field( u64, used ) 2918 __field( u64, flags ) 2919 ), 2920 2921 TP_fast_assign_btrfs(bg_cache->fs_info, 2922 __entry->bytenr = bg_cache->start, 2923 __entry->len = bg_cache->length, 2924 __entry->used = bg_cache->used; 2925 __entry->flags = bg_cache->flags; 2926 ), 2927 2928 TP_printk_btrfs("bg bytenr=%llu len=%llu used=%llu flags=%llu(%s)", 2929 __entry->bytenr, __entry->len, __entry->used, __entry->flags, 2930 __print_flags(__entry->flags, "|", BTRFS_GROUP_FLAGS)) 2931 ); 2932 2933 DEFINE_EVENT(btrfs__block_group, btrfs_remove_block_group, 2934 TP_PROTO(const struct btrfs_block_group *bg_cache), 2935 2936 TP_ARGS(bg_cache) 2937 ); 2938 2939 DEFINE_EVENT(btrfs__block_group, btrfs_add_unused_block_group, 2940 TP_PROTO(const struct btrfs_block_group *bg_cache), 2941 2942 TP_ARGS(bg_cache) 2943 ); 2944 2945 DEFINE_EVENT(btrfs__block_group, btrfs_add_reclaim_block_group, 2946 TP_PROTO(const struct btrfs_block_group *bg_cache), 2947 2948 TP_ARGS(bg_cache) 2949 ); 2950 2951 DEFINE_EVENT(btrfs__block_group, btrfs_reclaim_block_group, 2952 TP_PROTO(const struct btrfs_block_group *bg_cache), 2953 2954 TP_ARGS(bg_cache) 2955 ); 2956 2957 DEFINE_EVENT(btrfs__block_group, btrfs_skip_unused_block_group, 2958 TP_PROTO(const struct btrfs_block_group *bg_cache), 2959 2960 TP_ARGS(bg_cache) 2961 ); 2962 2963 TRACE_EVENT(btrfs_set_extent_bit, 2964 TP_PROTO(const struct extent_io_tree *tree, 2965 u64 start, u64 len, unsigned set_bits), 2966 2967 TP_ARGS(tree, start, len, set_bits), 2968 2969 TP_STRUCT__entry_btrfs( 2970 __field( unsigned, owner ) 2971 __field( u64, ino ) 2972 __field( u64, rootid ) 2973 __field( u64, start ) 2974 __field( u64, len ) 2975 __field( unsigned, set_bits) 2976 ), 2977 2978 TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree), 2979 const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); 2980 2981 __entry->owner = tree->owner; 2982 __entry->ino = inode ? btrfs_ino(inode) : 0; 2983 __entry->rootid = inode ? btrfs_root_id(inode->root) : 0; 2984 __entry->start = start; 2985 __entry->len = len; 2986 __entry->set_bits = set_bits; 2987 ), 2988 2989 TP_printk_btrfs( 2990 "io_tree=%s ino=%llu root=%llu start=%llu len=%llu set_bits=%s", 2991 __print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino, 2992 __entry->rootid, __entry->start, __entry->len, 2993 __print_flags(__entry->set_bits, "|", EXTENT_FLAGS)) 2994 ); 2995 2996 TRACE_EVENT(btrfs_clear_extent_bit, 2997 TP_PROTO(const struct extent_io_tree *tree, 2998 u64 start, u64 len, unsigned clear_bits), 2999 3000 TP_ARGS(tree, start, len, clear_bits), 3001 3002 TP_STRUCT__entry_btrfs( 3003 __field( unsigned, owner ) 3004 __field( u64, ino ) 3005 __field( u64, rootid ) 3006 __field( u64, start ) 3007 __field( u64, len ) 3008 __field( unsigned, clear_bits) 3009 ), 3010 3011 TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree), 3012 const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); 3013 3014 __entry->owner = tree->owner; 3015 __entry->ino = inode ? btrfs_ino(inode) : 0; 3016 __entry->rootid = inode ? btrfs_root_id(inode->root) : 0; 3017 __entry->start = start; 3018 __entry->len = len; 3019 __entry->clear_bits = clear_bits; 3020 ), 3021 3022 TP_printk_btrfs( 3023 "io_tree=%s ino=%llu root=%llu start=%llu len=%llu clear_bits=%s", 3024 __print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino, 3025 __entry->rootid, __entry->start, __entry->len, 3026 __print_flags(__entry->clear_bits, "|", EXTENT_FLAGS)) 3027 ); 3028 3029 TRACE_EVENT(btrfs_convert_extent_bit, 3030 TP_PROTO(const struct extent_io_tree *tree, 3031 u64 start, u64 len, unsigned set_bits, unsigned clear_bits), 3032 3033 TP_ARGS(tree, start, len, set_bits, clear_bits), 3034 3035 TP_STRUCT__entry_btrfs( 3036 __field( unsigned, owner ) 3037 __field( u64, ino ) 3038 __field( u64, rootid ) 3039 __field( u64, start ) 3040 __field( u64, len ) 3041 __field( unsigned, set_bits) 3042 __field( unsigned, clear_bits) 3043 ), 3044 3045 TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree), 3046 const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); 3047 3048 __entry->owner = tree->owner; 3049 __entry->ino = inode ? btrfs_ino(inode) : 0; 3050 __entry->rootid = inode ? btrfs_root_id(inode->root) : 0; 3051 __entry->start = start; 3052 __entry->len = len; 3053 __entry->set_bits = set_bits; 3054 __entry->clear_bits = clear_bits; 3055 ), 3056 3057 TP_printk_btrfs( 3058 "io_tree=%s ino=%llu root=%llu start=%llu len=%llu set_bits=%s clear_bits=%s", 3059 __print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino, 3060 __entry->rootid, __entry->start, __entry->len, 3061 __print_flags(__entry->set_bits , "|", EXTENT_FLAGS), 3062 __print_flags(__entry->clear_bits, "|", EXTENT_FLAGS)) 3063 ); 3064 3065 DECLARE_EVENT_CLASS(btrfs_dump_space_info, 3066 TP_PROTO(struct btrfs_fs_info *fs_info, 3067 const struct btrfs_space_info *sinfo), 3068 3069 TP_ARGS(fs_info, sinfo), 3070 3071 TP_STRUCT__entry_btrfs( 3072 __field( u64, flags ) 3073 __field( u64, total_bytes ) 3074 __field( u64, bytes_used ) 3075 __field( u64, bytes_pinned ) 3076 __field( u64, bytes_reserved ) 3077 __field( u64, bytes_may_use ) 3078 __field( u64, bytes_readonly ) 3079 __field( u64, reclaim_size ) 3080 __field( int, clamp ) 3081 __field( u64, global_reserved ) 3082 __field( u64, trans_reserved ) 3083 __field( u64, delayed_refs_reserved ) 3084 __field( u64, delayed_reserved ) 3085 __field( u64, free_chunk_space ) 3086 __field( u64, delalloc_bytes ) 3087 __field( u64, ordered_bytes ) 3088 ), 3089 3090 TP_fast_assign_btrfs(fs_info, 3091 __entry->flags = sinfo->flags; 3092 __entry->total_bytes = sinfo->total_bytes; 3093 __entry->bytes_used = sinfo->bytes_used; 3094 __entry->bytes_pinned = sinfo->bytes_pinned; 3095 __entry->bytes_reserved = sinfo->bytes_reserved; 3096 __entry->bytes_may_use = sinfo->bytes_may_use; 3097 __entry->bytes_readonly = sinfo->bytes_readonly; 3098 __entry->reclaim_size = sinfo->reclaim_size; 3099 __entry->clamp = sinfo->clamp; 3100 __entry->global_reserved = fs_info->global_block_rsv.reserved; 3101 __entry->trans_reserved = fs_info->trans_block_rsv.reserved; 3102 __entry->delayed_refs_reserved = fs_info->delayed_refs_rsv.reserved; 3103 __entry->delayed_reserved = fs_info->delayed_block_rsv.reserved; 3104 __entry->free_chunk_space = atomic64_read(&fs_info->free_chunk_space); 3105 __entry->delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes); 3106 __entry->ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes); 3107 ), 3108 3109 TP_printk_btrfs("flags=%s total_bytes=%llu bytes_used=%llu " 3110 "bytes_pinned=%llu bytes_reserved=%llu " 3111 "bytes_may_use=%llu bytes_readonly=%llu " 3112 "reclaim_size=%llu clamp=%d global_reserved=%llu " 3113 "trans_reserved=%llu delayed_refs_reserved=%llu " 3114 "delayed_reserved=%llu chunk_free_space=%llu " 3115 "delalloc_bytes=%llu ordered_bytes=%llu", 3116 __print_flags(__entry->flags, "|", BTRFS_GROUP_FLAGS), 3117 __entry->total_bytes, __entry->bytes_used, 3118 __entry->bytes_pinned, __entry->bytes_reserved, 3119 __entry->bytes_may_use, __entry->bytes_readonly, 3120 __entry->reclaim_size, __entry->clamp, 3121 __entry->global_reserved, __entry->trans_reserved, 3122 __entry->delayed_refs_reserved, 3123 __entry->delayed_reserved, __entry->free_chunk_space, 3124 __entry->delalloc_bytes, __entry->ordered_bytes) 3125 ); 3126 3127 DEFINE_EVENT(btrfs_dump_space_info, btrfs_done_preemptive_reclaim, 3128 TP_PROTO(struct btrfs_fs_info *fs_info, 3129 const struct btrfs_space_info *sinfo), 3130 TP_ARGS(fs_info, sinfo) 3131 ); 3132 3133 DEFINE_EVENT(btrfs_dump_space_info, btrfs_fail_all_tickets, 3134 TP_PROTO(struct btrfs_fs_info *fs_info, 3135 const struct btrfs_space_info *sinfo), 3136 TP_ARGS(fs_info, sinfo) 3137 ); 3138 3139 TRACE_EVENT(btrfs_reserve_ticket, 3140 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes, 3141 u64 start_ns, int flush, int error), 3142 3143 TP_ARGS(fs_info, flags, bytes, start_ns, flush, error), 3144 3145 TP_STRUCT__entry_btrfs( 3146 __field( u64, flags ) 3147 __field( u64, bytes ) 3148 __field( u64, start_ns ) 3149 __field( int, flush ) 3150 __field( int, error ) 3151 ), 3152 3153 TP_fast_assign_btrfs(fs_info, 3154 __entry->flags = flags; 3155 __entry->bytes = bytes; 3156 __entry->start_ns = start_ns; 3157 __entry->flush = flush; 3158 __entry->error = error; 3159 ), 3160 3161 TP_printk_btrfs("flags=%s bytes=%llu start_ns=%llu flush=%s error=%d", 3162 __print_flags(__entry->flags, "|", BTRFS_GROUP_FLAGS), 3163 __entry->bytes, __entry->start_ns, 3164 __print_symbolic(__entry->flush, FLUSH_ACTIONS), 3165 __entry->error) 3166 ); 3167 3168 DECLARE_EVENT_CLASS(btrfs_sleep_tree_lock, 3169 TP_PROTO(const struct extent_buffer *eb, u64 start_ns), 3170 3171 TP_ARGS(eb, start_ns), 3172 3173 TP_STRUCT__entry_btrfs( 3174 __field( u64, block ) 3175 __field( u64, generation ) 3176 __field( u64, start_ns ) 3177 __field( u64, end_ns ) 3178 __field( u64, diff_ns ) 3179 __field( u64, owner ) 3180 __field( int, is_log_tree ) 3181 ), 3182 3183 TP_fast_assign_btrfs(eb->fs_info, 3184 __entry->block = eb->start; 3185 __entry->generation = btrfs_header_generation(eb); 3186 __entry->start_ns = start_ns; 3187 __entry->end_ns = ktime_get_ns(); 3188 __entry->diff_ns = __entry->end_ns - start_ns; 3189 __entry->owner = btrfs_header_owner(eb); 3190 __entry->is_log_tree = (eb->log_index >= 0); 3191 ), 3192 3193 TP_printk_btrfs( 3194 "block=%llu generation=%llu start_ns=%llu end_ns=%llu diff_ns=%llu owner=%llu is_log_tree=%d", 3195 __entry->block, __entry->generation, 3196 __entry->start_ns, __entry->end_ns, __entry->diff_ns, 3197 __entry->owner, __entry->is_log_tree) 3198 ); 3199 3200 DEFINE_EVENT(btrfs_sleep_tree_lock, btrfs_tree_read_lock, 3201 TP_PROTO(const struct extent_buffer *eb, u64 start_ns), 3202 3203 TP_ARGS(eb, start_ns) 3204 ); 3205 3206 DEFINE_EVENT(btrfs_sleep_tree_lock, btrfs_tree_lock, 3207 TP_PROTO(const struct extent_buffer *eb, u64 start_ns), 3208 3209 TP_ARGS(eb, start_ns) 3210 ); 3211 3212 DECLARE_EVENT_CLASS(btrfs_locking_events, 3213 TP_PROTO(const struct extent_buffer *eb), 3214 3215 TP_ARGS(eb), 3216 3217 TP_STRUCT__entry_btrfs( 3218 __field( u64, block ) 3219 __field( u64, generation ) 3220 __field( u64, owner ) 3221 __field( int, is_log_tree ) 3222 ), 3223 3224 TP_fast_assign_btrfs(eb->fs_info, 3225 __entry->block = eb->start; 3226 __entry->generation = btrfs_header_generation(eb); 3227 __entry->owner = btrfs_header_owner(eb); 3228 __entry->is_log_tree = (eb->log_index >= 0); 3229 ), 3230 3231 TP_printk_btrfs("block=%llu generation=%llu owner=%llu is_log_tree=%d", 3232 __entry->block, __entry->generation, 3233 __entry->owner, __entry->is_log_tree) 3234 ); 3235 3236 #define DEFINE_BTRFS_LOCK_EVENT(name) \ 3237 DEFINE_EVENT(btrfs_locking_events, name, \ 3238 TP_PROTO(const struct extent_buffer *eb), \ 3239 \ 3240 TP_ARGS(eb) \ 3241 ) 3242 3243 DEFINE_BTRFS_LOCK_EVENT(btrfs_tree_unlock); 3244 DEFINE_BTRFS_LOCK_EVENT(btrfs_tree_read_unlock); 3245 DEFINE_BTRFS_LOCK_EVENT(btrfs_try_tree_read_lock); 3246 3247 DECLARE_EVENT_CLASS(btrfs__space_info_update, 3248 3249 TP_PROTO(const struct btrfs_fs_info *fs_info, 3250 const struct btrfs_space_info *sinfo, u64 old, s64 diff), 3251 3252 TP_ARGS(fs_info, sinfo, old, diff), 3253 3254 TP_STRUCT__entry_btrfs( 3255 __field( u64, type ) 3256 __field( u64, old ) 3257 __field( s64, diff ) 3258 ), 3259 3260 TP_fast_assign_btrfs(fs_info, 3261 __entry->type = sinfo->flags; 3262 __entry->old = old; 3263 __entry->diff = diff; 3264 ), 3265 TP_printk_btrfs("type=%s old=%llu diff=%lld", 3266 __print_flags(__entry->type, "|", BTRFS_GROUP_FLAGS), 3267 __entry->old, __entry->diff) 3268 ); 3269 3270 DEFINE_EVENT(btrfs__space_info_update, update_bytes_may_use, 3271 3272 TP_PROTO(const struct btrfs_fs_info *fs_info, 3273 const struct btrfs_space_info *sinfo, u64 old, s64 diff), 3274 3275 TP_ARGS(fs_info, sinfo, old, diff) 3276 ); 3277 3278 DEFINE_EVENT(btrfs__space_info_update, update_bytes_pinned, 3279 3280 TP_PROTO(const struct btrfs_fs_info *fs_info, 3281 const struct btrfs_space_info *sinfo, u64 old, s64 diff), 3282 3283 TP_ARGS(fs_info, sinfo, old, diff) 3284 ); 3285 3286 DEFINE_EVENT(btrfs__space_info_update, update_bytes_zone_unusable, 3287 3288 TP_PROTO(const struct btrfs_fs_info *fs_info, 3289 const struct btrfs_space_info *sinfo, u64 old, s64 diff), 3290 3291 TP_ARGS(fs_info, sinfo, old, diff) 3292 ); 3293 3294 DECLARE_EVENT_CLASS(btrfs_raid56_bio, 3295 3296 TP_PROTO(const struct btrfs_raid_bio *rbio, 3297 const struct bio *bio, 3298 const struct raid56_bio_trace_info *trace_info), 3299 3300 TP_ARGS(rbio, bio, trace_info), 3301 3302 TP_STRUCT__entry_btrfs( 3303 __field( u64, full_stripe ) 3304 __field( u64, physical ) 3305 __field( u64, devid ) 3306 __field( u32, offset ) 3307 __field( u32, len ) 3308 __field( u8, opf ) 3309 __field( u8, total_stripes ) 3310 __field( u8, real_stripes ) 3311 __field( u8, nr_data ) 3312 __field( u8, stripe_nr ) 3313 ), 3314 3315 TP_fast_assign_btrfs(rbio->bioc->fs_info, 3316 __entry->full_stripe = rbio->bioc->full_stripe_logical; 3317 __entry->physical = bio->bi_iter.bi_sector << SECTOR_SHIFT; 3318 __entry->len = bio->bi_iter.bi_size; 3319 __entry->opf = bio_op(bio); 3320 __entry->devid = trace_info->devid; 3321 __entry->offset = trace_info->offset; 3322 __entry->stripe_nr = trace_info->stripe_nr; 3323 __entry->total_stripes = rbio->bioc->num_stripes; 3324 __entry->real_stripes = rbio->real_stripes; 3325 __entry->nr_data = rbio->nr_data; 3326 ), 3327 /* 3328 * For type output, we need to output things like "DATA1" 3329 * (the first data stripe), "DATA2" (the second data stripe), 3330 * "PQ1" (P stripe),"PQ2" (Q stripe), "REPLACE0" (replace target device). 3331 */ 3332 TP_printk_btrfs( 3333 "full_stripe=%llu devid=%lld type=%s%d offset=%d opf=0x%x physical=%llu len=%u", 3334 __entry->full_stripe, __entry->devid, 3335 (__entry->stripe_nr < __entry->nr_data) ? "DATA" : 3336 ((__entry->stripe_nr < __entry->real_stripes) ? "PQ" : 3337 "REPLACE"), 3338 (__entry->stripe_nr < __entry->nr_data) ? 3339 (__entry->stripe_nr + 1) : 3340 ((__entry->stripe_nr < __entry->real_stripes) ? 3341 (__entry->stripe_nr - __entry->nr_data + 1) : 0), 3342 __entry->offset, __entry->opf, __entry->physical, __entry->len) 3343 ); 3344 3345 DEFINE_EVENT(btrfs_raid56_bio, raid56_read, 3346 TP_PROTO(const struct btrfs_raid_bio *rbio, 3347 const struct bio *bio, 3348 const struct raid56_bio_trace_info *trace_info), 3349 3350 TP_ARGS(rbio, bio, trace_info) 3351 ); 3352 3353 DEFINE_EVENT(btrfs_raid56_bio, raid56_write, 3354 TP_PROTO(const struct btrfs_raid_bio *rbio, 3355 const struct bio *bio, 3356 const struct raid56_bio_trace_info *trace_info), 3357 3358 TP_ARGS(rbio, bio, trace_info) 3359 ); 3360 3361 TRACE_EVENT(btrfs_insert_one_raid_extent, 3362 3363 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length, 3364 int num_stripes), 3365 3366 TP_ARGS(fs_info, logical, length, num_stripes), 3367 3368 TP_STRUCT__entry_btrfs( 3369 __field( u64, logical ) 3370 __field( u64, length ) 3371 __field( int, num_stripes ) 3372 ), 3373 3374 TP_fast_assign_btrfs(fs_info, 3375 __entry->logical = logical; 3376 __entry->length = length; 3377 __entry->num_stripes = num_stripes; 3378 ), 3379 3380 TP_printk_btrfs("logical=%llu length=%llu num_stripes=%d", 3381 __entry->logical, __entry->length, 3382 __entry->num_stripes) 3383 ); 3384 3385 TRACE_EVENT(btrfs_raid_extent_delete, 3386 3387 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 end, 3388 u64 found_start, u64 found_end), 3389 3390 TP_ARGS(fs_info, start, end, found_start, found_end), 3391 3392 TP_STRUCT__entry_btrfs( 3393 __field( u64, start ) 3394 __field( u64, end ) 3395 __field( u64, found_start ) 3396 __field( u64, found_end ) 3397 ), 3398 3399 TP_fast_assign_btrfs(fs_info, 3400 __entry->start = start; 3401 __entry->end = end; 3402 __entry->found_start = found_start; 3403 __entry->found_end = found_end; 3404 ), 3405 3406 TP_printk_btrfs("start=%llu end=%llu found_start=%llu found_end=%llu", 3407 __entry->start, __entry->end, __entry->found_start, 3408 __entry->found_end) 3409 ); 3410 3411 TRACE_EVENT(btrfs_get_raid_extent_offset, 3412 3413 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length, 3414 u64 physical, u64 devid), 3415 3416 TP_ARGS(fs_info, logical, length, physical, devid), 3417 3418 TP_STRUCT__entry_btrfs( 3419 __field( u64, logical ) 3420 __field( u64, length ) 3421 __field( u64, physical ) 3422 __field( u64, devid ) 3423 ), 3424 3425 TP_fast_assign_btrfs(fs_info, 3426 __entry->logical = logical; 3427 __entry->length = length; 3428 __entry->physical = physical; 3429 __entry->devid = devid; 3430 ), 3431 3432 TP_printk_btrfs("logical=%llu length=%llu physical=%llu devid=%llu", 3433 __entry->logical, __entry->length, __entry->physical, 3434 __entry->devid) 3435 ); 3436 3437 TRACE_EVENT(btrfs_extent_map_shrinker_count, 3438 3439 TP_PROTO(const struct btrfs_fs_info *fs_info, long nr), 3440 3441 TP_ARGS(fs_info, nr), 3442 3443 TP_STRUCT__entry_btrfs( 3444 __field( long, nr ) 3445 ), 3446 3447 TP_fast_assign_btrfs(fs_info, 3448 __entry->nr = nr; 3449 ), 3450 3451 TP_printk_btrfs("nr=%ld", __entry->nr) 3452 ); 3453 3454 TRACE_EVENT(btrfs_extent_map_shrinker_scan_enter, 3455 3456 TP_PROTO(const struct btrfs_fs_info *fs_info, long nr), 3457 3458 TP_ARGS(fs_info, nr), 3459 3460 TP_STRUCT__entry_btrfs( 3461 __field( long, nr_to_scan ) 3462 __field( long, nr ) 3463 __field( u64, last_root_id ) 3464 __field( u64, last_ino ) 3465 ), 3466 3467 TP_fast_assign_btrfs(fs_info, 3468 __entry->nr_to_scan = \ 3469 atomic64_read(&fs_info->em_shrinker_nr_to_scan); 3470 __entry->nr = nr; 3471 __entry->last_root_id = fs_info->em_shrinker_last_root; 3472 __entry->last_ino = fs_info->em_shrinker_last_ino; 3473 ), 3474 3475 TP_printk_btrfs("nr_to_scan=%ld nr=%ld last_root=%llu(%s) last_ino=%llu", 3476 __entry->nr_to_scan, __entry->nr, 3477 show_root_type(__entry->last_root_id), __entry->last_ino) 3478 ); 3479 3480 TRACE_EVENT(btrfs_extent_map_shrinker_scan_exit, 3481 3482 TP_PROTO(const struct btrfs_fs_info *fs_info, long nr_dropped, long nr), 3483 3484 TP_ARGS(fs_info, nr_dropped, nr), 3485 3486 TP_STRUCT__entry_btrfs( 3487 __field( long, nr_dropped ) 3488 __field( long, nr ) 3489 __field( u64, last_root_id ) 3490 __field( u64, last_ino ) 3491 ), 3492 3493 TP_fast_assign_btrfs(fs_info, 3494 __entry->nr_dropped = nr_dropped; 3495 __entry->nr = nr; 3496 __entry->last_root_id = fs_info->em_shrinker_last_root; 3497 __entry->last_ino = fs_info->em_shrinker_last_ino; 3498 ), 3499 3500 TP_printk_btrfs("nr_dropped=%ld nr=%ld last_root=%llu(%s) last_ino=%llu", 3501 __entry->nr_dropped, __entry->nr, 3502 show_root_type(__entry->last_root_id), __entry->last_ino) 3503 ); 3504 3505 TRACE_EVENT(btrfs_extent_map_shrinker_remove_em, 3506 3507 TP_PROTO(const struct btrfs_inode *inode, const struct extent_map *em), 3508 3509 TP_ARGS(inode, em), 3510 3511 TP_STRUCT__entry_btrfs( 3512 __field( u64, ino ) 3513 __field( u64, root_id ) 3514 __field( u64, start ) 3515 __field( u64, len ) 3516 __field( u32, flags ) 3517 ), 3518 3519 TP_fast_assign_btrfs(inode->root->fs_info, 3520 __entry->ino = btrfs_ino(inode); 3521 __entry->root_id = btrfs_root_id(inode->root); 3522 __entry->start = em->start; 3523 __entry->len = em->len; 3524 __entry->flags = em->flags; 3525 ), 3526 3527 TP_printk_btrfs("ino=%llu root=%llu(%s) start=%llu len=%llu flags=%s", 3528 __entry->ino, show_root_type(__entry->root_id), 3529 __entry->start, __entry->len, 3530 show_map_flags(__entry->flags)) 3531 ); 3532 3533 #endif /* _TRACE_BTRFS_H */ 3534 3535 /* This part must be outside protection */ 3536 #include <trace/define_trace.h> 3537