include/trace/events/btrfs.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM btrfs
   3
   4 #if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_BTRFS_H
   6
   7 #include <linux/writeback.h>
   8 #include <linux/tracepoint.h>
   9 #include <trace/events/mmflags.h>
  10
  11 struct btrfs_root;
  12 struct btrfs_fs_info;
  13 struct btrfs_inode;
  14 struct extent_map;
  15 struct btrfs_ordered_extent;
  16 struct btrfs_delayed_ref_node;
  17 struct btrfs_delayed_tree_ref;
  18 struct btrfs_delayed_data_ref;
  19 struct btrfs_delayed_ref_head;
  20 struct btrfs_block_group_cache;
  21 struct btrfs_free_cluster;
  22 struct map_lookup;
  23 struct extent_buffer;
  24 struct btrfs_work;
  25 struct __btrfs_workqueue;
  26 struct btrfs_qgroup_extent_record;
  27
  28 #define show_ref_type(type)                                             \
  29         __print_symbolic(type,                                          \
  30                 { BTRFS_TREE_BLOCK_REF_KEY,     "TREE_BLOCK_REF" },     \
  31                 { BTRFS_EXTENT_DATA_REF_KEY,    "EXTENT_DATA_REF" },    \
  32                 { BTRFS_EXTENT_REF_V0_KEY,      "EXTENT_REF_V0" },      \
  33                 { BTRFS_SHARED_BLOCK_REF_KEY,   "SHARED_BLOCK_REF" },   \
  34                 { BTRFS_SHARED_DATA_REF_KEY,    "SHARED_DATA_REF" })
  35
  36 #define __show_root_type(obj)                                           \
  37         __print_symbolic_u64(obj,                                       \
  38                 { BTRFS_ROOT_TREE_OBJECTID,     "ROOT_TREE"     },      \
  39                 { BTRFS_EXTENT_TREE_OBJECTID,   "EXTENT_TREE"   },      \
  40                 { BTRFS_CHUNK_TREE_OBJECTID,    "CHUNK_TREE"    },      \
  41                 { BTRFS_DEV_TREE_OBJECTID,      "DEV_TREE"      },      \
  42                 { BTRFS_FS_TREE_OBJECTID,       "FS_TREE"       },      \
  43                 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" },      \
  44                 { BTRFS_CSUM_TREE_OBJECTID,     "CSUM_TREE"     },      \
  45                 { BTRFS_TREE_LOG_OBJECTID,      "TREE_LOG"      },      \
  46                 { BTRFS_QUOTA_TREE_OBJECTID,    "QUOTA_TREE"    },      \
  47                 { BTRFS_TREE_RELOC_OBJECTID,    "TREE_RELOC"    },      \
  48                 { BTRFS_UUID_TREE_OBJECTID,     "UUID_TREE"     },      \
  49                 { BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" },  \
  50                 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
  51
  52 #define show_root_type(obj)                                             \
  53         obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) ||                \
  54               (obj >= BTRFS_ROOT_TREE_OBJECTID &&                       \
  55                obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
  56
  57 #define BTRFS_GROUP_FLAGS       \
  58         { BTRFS_BLOCK_GROUP_DATA,       "DATA"},        \
  59         { BTRFS_BLOCK_GROUP_SYSTEM,     "SYSTEM"},      \
  60         { BTRFS_BLOCK_GROUP_METADATA,   "METADATA"},    \
  61         { BTRFS_BLOCK_GROUP_RAID0,      "RAID0"},       \
  62         { BTRFS_BLOCK_GROUP_RAID1,      "RAID1"},       \
  63         { BTRFS_BLOCK_GROUP_DUP,        "DUP"},         \
  64         { BTRFS_BLOCK_GROUP_RAID10,     "RAID10"},      \
  65         { BTRFS_BLOCK_GROUP_RAID5,      "RAID5"},       \
  66         { BTRFS_BLOCK_GROUP_RAID6,      "RAID6"}
  67
  68 #define BTRFS_UUID_SIZE 16
  69 #define TP_STRUCT__entry_fsid __array(u8, fsid, BTRFS_UUID_SIZE)
  70
  71 #define TP_fast_assign_fsid(fs_info)                                    \
  72         memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE)
  73
  74 #define TP_STRUCT__entry_btrfs(args...)                                 \
  75         TP_STRUCT__entry(                                               \
  76                 TP_STRUCT__entry_fsid                                   \
  77                 args)
  78 #define TP_fast_assign_btrfs(fs_info, args...)                          \
  79         TP_fast_assign(                                                 \
  80                 TP_fast_assign_fsid(fs_info);                           \
  81                 args)
  82 #define TP_printk_btrfs(fmt, args...) \
  83         TP_printk("%pU: " fmt, __entry->fsid, args)
  84
  85 TRACE_EVENT(btrfs_transaction_commit,
  86
  87         TP_PROTO(struct btrfs_root *root),
  88
  89         TP_ARGS(root),
  90
  91         TP_STRUCT__entry_btrfs(
  92                 __field(        u64,  generation                )
  93                 __field(        u64,  root_objectid             )
  94         ),
  95
  96         TP_fast_assign_btrfs(root->fs_info,
  97                 __entry->generation     = root->fs_info->generation;
  98                 __entry->root_objectid  = root->root_key.objectid;
  99         ),
 100
 101         TP_printk_btrfs("root = %llu(%s), gen = %llu",
 102                   show_root_type(__entry->root_objectid),
 103                   (unsigned long long)__entry->generation)
 104 );
 105
 106 DECLARE_EVENT_CLASS(btrfs__inode,
 107
 108         TP_PROTO(struct inode *inode),
 109
 110         TP_ARGS(inode),
 111
 112         TP_STRUCT__entry_btrfs(
 113                 __field(        ino_t,  ino                     )
 114                 __field(        blkcnt_t,  blocks               )
 115                 __field(        u64,  disk_i_size               )
 116                 __field(        u64,  generation                )
 117                 __field(        u64,  last_trans                )
 118                 __field(        u64,  logged_trans              )
 119                 __field(        u64,  root_objectid             )
 120         ),
 121
 122         TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
 123                 __entry->ino    = inode->i_ino;
 124                 __entry->blocks = inode->i_blocks;
 125                 __entry->disk_i_size  = BTRFS_I(inode)->disk_i_size;
 126                 __entry->generation = BTRFS_I(inode)->generation;
 127                 __entry->last_trans = BTRFS_I(inode)->last_trans;
 128                 __entry->logged_trans = BTRFS_I(inode)->logged_trans;
 129                 __entry->root_objectid =
 130                                 BTRFS_I(inode)->root->root_key.objectid;
 131         ),
 132
 133         TP_printk_btrfs("root=%llu(%s) gen=%llu ino=%lu blocks=%llu "
 134                   "disk_i_size=%llu last_trans=%llu logged_trans=%llu",
 135                   show_root_type(__entry->root_objectid),
 136                   (unsigned long long)__entry->generation,
 137                   (unsigned long)__entry->ino,
 138                   (unsigned long long)__entry->blocks,
 139                   (unsigned long long)__entry->disk_i_size,
 140                   (unsigned long long)__entry->last_trans,
 141                   (unsigned long long)__entry->logged_trans)
 142 );
 143
 144 DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
 145
 146         TP_PROTO(struct inode *inode),
 147
 148         TP_ARGS(inode)
 149 );
 150
 151 DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
 152
 153         TP_PROTO(struct inode *inode),
 154
 155         TP_ARGS(inode)
 156 );
 157
 158 DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
 159
 160         TP_PROTO(struct inode *inode),
 161
 162         TP_ARGS(inode)
 163 );
 164
 165 #define __show_map_type(type)                                           \
 166         __print_symbolic_u64(type,                                      \
 167                 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE"     },              \
 168                 { EXTENT_MAP_HOLE,      "HOLE"          },              \
 169                 { EXTENT_MAP_INLINE,    "INLINE"        },              \
 170                 { EXTENT_MAP_DELALLOC,  "DELALLOC"      })
 171
 172 #define show_map_type(type)                     \
 173         type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" :  __show_map_type(type)
 174
 175 #define show_map_flags(flag)                                            \
 176         __print_flags(flag, "|",                                        \
 177                 { (1 << EXTENT_FLAG_PINNED),            "PINNED"        },\
 178                 { (1 << EXTENT_FLAG_COMPRESSED),        "COMPRESSED"    },\
 179                 { (1 << EXTENT_FLAG_VACANCY),           "VACANCY"       },\
 180                 { (1 << EXTENT_FLAG_PREALLOC),          "PREALLOC"      },\
 181                 { (1 << EXTENT_FLAG_LOGGING),           "LOGGING"       },\
 182                 { (1 << EXTENT_FLAG_FILLING),           "FILLING"       },\
 183                 { (1 << EXTENT_FLAG_FS_MAPPING),        "FS_MAPPING"    })
 184
 185 TRACE_EVENT_CONDITION(btrfs_get_extent,
 186
 187         TP_PROTO(struct btrfs_root *root, struct inode *inode,
 188                  struct extent_map *map),
 189
 190         TP_ARGS(root, inode, map),
 191
 192         TP_CONDITION(map),
 193
 194         TP_STRUCT__entry_btrfs(
 195                 __field(        u64,  root_objectid     )
 196                 __field(        u64,  ino               )
 197                 __field(        u64,  start             )
 198                 __field(        u64,  len               )
 199                 __field(        u64,  orig_start        )
 200                 __field(        u64,  block_start       )
 201                 __field(        u64,  block_len         )
 202                 __field(        unsigned long,  flags   )
 203                 __field(        int,  refs              )
 204                 __field(        unsigned int,  compress_type    )
 205         ),
 206
 207         TP_fast_assign_btrfs(root->fs_info,
 208                 __entry->root_objectid  = root->root_key.objectid;
 209                 __entry->ino            = btrfs_ino(inode);
 210                 __entry->start          = map->start;
 211                 __entry->len            = map->len;
 212                 __entry->orig_start     = map->orig_start;
 213                 __entry->block_start    = map->block_start;
 214                 __entry->block_len      = map->block_len;
 215                 __entry->flags          = map->flags;
 216                 __entry->refs           = atomic_read(&map->refs);
 217                 __entry->compress_type  = map->compress_type;
 218         ),
 219
 220         TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu "
 221                   "orig_start=%llu block_start=%llu(%s) "
 222                   "block_len=%llu flags=%s refs=%u "
 223                   "compress_type=%u",
 224                   show_root_type(__entry->root_objectid),
 225                   (unsigned long long)__entry->ino,
 226                   (unsigned long long)__entry->start,
 227                   (unsigned long long)__entry->len,
 228                   (unsigned long long)__entry->orig_start,
 229                   show_map_type(__entry->block_start),
 230                   (unsigned long long)__entry->block_len,
 231                   show_map_flags(__entry->flags),
 232                   __entry->refs, __entry->compress_type)
 233 );
 234
 235 #define show_ordered_flags(flags)                                          \
 236         __print_flags(flags, "|",                                          \
 237                 { (1 << BTRFS_ORDERED_IO_DONE),         "IO_DONE"       }, \
 238                 { (1 << BTRFS_ORDERED_COMPLETE),        "COMPLETE"      }, \
 239                 { (1 << BTRFS_ORDERED_NOCOW),           "NOCOW"         }, \
 240                 { (1 << BTRFS_ORDERED_COMPRESSED),      "COMPRESSED"    }, \
 241                 { (1 << BTRFS_ORDERED_PREALLOC),        "PREALLOC"      }, \
 242                 { (1 << BTRFS_ORDERED_DIRECT),          "DIRECT"        }, \
 243                 { (1 << BTRFS_ORDERED_IOERR),           "IOERR"         }, \
 244                 { (1 << BTRFS_ORDERED_UPDATED_ISIZE),   "UPDATED_ISIZE" }, \
 245                 { (1 << BTRFS_ORDERED_LOGGED_CSUM),     "LOGGED_CSUM"   }, \
 246                 { (1 << BTRFS_ORDERED_TRUNCATED),       "TRUNCATED"     })
 247
 248
 249 DECLARE_EVENT_CLASS(btrfs__ordered_extent,
 250
 251         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 252
 253         TP_ARGS(inode, ordered),
 254
 255         TP_STRUCT__entry_btrfs(
 256                 __field(        ino_t,  ino             )
 257                 __field(        u64,  file_offset       )
 258                 __field(        u64,  start             )
 259                 __field(        u64,  len               )
 260                 __field(        u64,  disk_len          )
 261                 __field(        u64,  bytes_left        )
 262                 __field(        unsigned long,  flags   )
 263                 __field(        int,  compress_type     )
 264                 __field(        int,  refs              )
 265                 __field(        u64,  root_objectid     )
 266                 __field(        u64,  truncated_len     )
 267         ),
 268
 269         TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
 270                 __entry->ino            = inode->i_ino;
 271                 __entry->file_offset    = ordered->file_offset;
 272                 __entry->start          = ordered->start;
 273                 __entry->len            = ordered->len;
 274                 __entry->disk_len       = ordered->disk_len;
 275                 __entry->bytes_left     = ordered->bytes_left;
 276                 __entry->flags          = ordered->flags;
 277                 __entry->compress_type  = ordered->compress_type;
 278                 __entry->refs           = atomic_read(&ordered->refs);
 279                 __entry->root_objectid  =
 280                                 BTRFS_I(inode)->root->root_key.objectid;
 281                 __entry->truncated_len  = ordered->truncated_len;
 282         ),
 283
 284         TP_printk_btrfs("root=%llu(%s) ino=%llu file_offset=%llu "
 285                   "start=%llu len=%llu disk_len=%llu "
 286                   "truncated_len=%llu "
 287                   "bytes_left=%llu flags=%s compress_type=%d "
 288                   "refs=%d",
 289                   show_root_type(__entry->root_objectid),
 290                   (unsigned long long)__entry->ino,
 291                   (unsigned long long)__entry->file_offset,
 292                   (unsigned long long)__entry->start,
 293                   (unsigned long long)__entry->len,
 294                   (unsigned long long)__entry->disk_len,
 295                   (unsigned long long)__entry->truncated_len,
 296                   (unsigned long long)__entry->bytes_left,
 297                   show_ordered_flags(__entry->flags),
 298                   __entry->compress_type, __entry->refs)
 299 );
 300
 301 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
 302
 303         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 304
 305         TP_ARGS(inode, ordered)
 306 );
 307
 308 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
 309
 310         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 311
 312         TP_ARGS(inode, ordered)
 313 );
 314
 315 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
 316
 317         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 318
 319         TP_ARGS(inode, ordered)
 320 );
 321
 322 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
 323
 324         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 325
 326         TP_ARGS(inode, ordered)
 327 );
 328
 329 DECLARE_EVENT_CLASS(btrfs__writepage,
 330
 331         TP_PROTO(struct page *page, struct inode *inode,
 332                  struct writeback_control *wbc),
 333
 334         TP_ARGS(page, inode, wbc),
 335
 336         TP_STRUCT__entry_btrfs(
 337                 __field(        ino_t,  ino                     )
 338                 __field(        pgoff_t,  index                 )
 339                 __field(        long,   nr_to_write             )
 340                 __field(        long,   pages_skipped           )
 341                 __field(        loff_t, range_start             )
 342                 __field(        loff_t, range_end               )
 343                 __field(        char,   for_kupdate             )
 344                 __field(        char,   for_reclaim             )
 345                 __field(        char,   range_cyclic            )
 346                 __field(        pgoff_t,  writeback_index       )
 347                 __field(        u64,    root_objectid           )
 348         ),
 349
 350         TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
 351                 __entry->ino            = inode->i_ino;
 352                 __entry->index          = page->index;
 353                 __entry->nr_to_write    = wbc->nr_to_write;
 354                 __entry->pages_skipped  = wbc->pages_skipped;
 355                 __entry->range_start    = wbc->range_start;
 356                 __entry->range_end      = wbc->range_end;
 357                 __entry->for_kupdate    = wbc->for_kupdate;
 358                 __entry->for_reclaim    = wbc->for_reclaim;
 359                 __entry->range_cyclic   = wbc->range_cyclic;
 360                 __entry->writeback_index = inode->i_mapping->writeback_index;
 361                 __entry->root_objectid  =
 362                                  BTRFS_I(inode)->root->root_key.objectid;
 363         ),
 364
 365         TP_printk_btrfs("root=%llu(%s) ino=%lu page_index=%lu "
 366                   "nr_to_write=%ld pages_skipped=%ld range_start=%llu "
 367                   "range_end=%llu for_kupdate=%d "
 368                   "for_reclaim=%d range_cyclic=%d writeback_index=%lu",
 369                   show_root_type(__entry->root_objectid),
 370                   (unsigned long)__entry->ino, __entry->index,
 371                   __entry->nr_to_write, __entry->pages_skipped,
 372                   __entry->range_start, __entry->range_end,
 373                   __entry->for_kupdate,
 374                   __entry->for_reclaim, __entry->range_cyclic,
 375                   (unsigned long)__entry->writeback_index)
 376 );
 377
 378 DEFINE_EVENT(btrfs__writepage, __extent_writepage,
 379
 380         TP_PROTO(struct page *page, struct inode *inode,
 381                  struct writeback_control *wbc),
 382
 383         TP_ARGS(page, inode, wbc)
 384 );
 385
 386 TRACE_EVENT(btrfs_writepage_end_io_hook,
 387
 388         TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
 389
 390         TP_ARGS(page, start, end, uptodate),
 391
 392         TP_STRUCT__entry_btrfs(
 393                 __field(        ino_t,   ino            )
 394                 __field(        pgoff_t, index          )
 395                 __field(        u64,     start          )
 396                 __field(        u64,     end            )
 397                 __field(        int,     uptodate       )
 398                 __field(        u64,    root_objectid   )
 399         ),
 400
 401         TP_fast_assign_btrfs(btrfs_sb(page->mapping->host->i_sb),
 402                 __entry->ino    = page->mapping->host->i_ino;
 403                 __entry->index  = page->index;
 404                 __entry->start  = start;
 405                 __entry->end    = end;
 406                 __entry->uptodate = uptodate;
 407                 __entry->root_objectid  =
 408                          BTRFS_I(page->mapping->host)->root->root_key.objectid;
 409         ),
 410
 411         TP_printk_btrfs("root=%llu(%s) ino=%lu page_index=%lu start=%llu "
 412                   "end=%llu uptodate=%d",
 413                   show_root_type(__entry->root_objectid),
 414                   (unsigned long)__entry->ino, (unsigned long)__entry->index,
 415                   (unsigned long long)__entry->start,
 416                   (unsigned long long)__entry->end, __entry->uptodate)
 417 );
 418
 419 TRACE_EVENT(btrfs_sync_file,
 420
 421         TP_PROTO(struct file *file, int datasync),
 422
 423         TP_ARGS(file, datasync),
 424
 425         TP_STRUCT__entry_btrfs(
 426                 __field(        ino_t,  ino             )
 427                 __field(        ino_t,  parent          )
 428                 __field(        int,    datasync        )
 429                 __field(        u64,    root_objectid   )
 430         ),
 431
 432         TP_fast_assign(
 433                 struct dentry *dentry = file->f_path.dentry;
 434                 struct inode *inode = d_inode(dentry);
 435
 436                 TP_fast_assign_fsid(btrfs_sb(file->f_path.dentry->d_sb));
 437                 __entry->ino            = inode->i_ino;
 438                 __entry->parent         = d_inode(dentry->d_parent)->i_ino;
 439                 __entry->datasync       = datasync;
 440                 __entry->root_objectid  =
 441                                  BTRFS_I(inode)->root->root_key.objectid;
 442         ),
 443
 444         TP_printk_btrfs("root=%llu(%s) ino=%ld parent=%ld datasync=%d",
 445                   show_root_type(__entry->root_objectid),
 446                   (unsigned long)__entry->ino, (unsigned long)__entry->parent,
 447                   __entry->datasync)
 448 );
 449
 450 TRACE_EVENT(btrfs_sync_fs,
 451
 452         TP_PROTO(struct btrfs_fs_info *fs_info, int wait),
 453
 454         TP_ARGS(fs_info, wait),
 455
 456         TP_STRUCT__entry_btrfs(
 457                 __field(        int,  wait              )
 458         ),
 459
 460         TP_fast_assign_btrfs(fs_info,
 461                 __entry->wait   = wait;
 462         ),
 463
 464         TP_printk_btrfs("wait = %d", __entry->wait)
 465 );
 466
 467 TRACE_EVENT(btrfs_add_block_group,
 468
 469         TP_PROTO(struct btrfs_fs_info *fs_info,
 470                  struct btrfs_block_group_cache *block_group, int create),
 471
 472         TP_ARGS(fs_info, block_group, create),
 473
 474         TP_STRUCT__entry(
 475                 __array(        u8,     fsid,   BTRFS_UUID_SIZE )
 476                 __field(        u64,    offset                  )
 477                 __field(        u64,    size                    )
 478                 __field(        u64,    flags                   )
 479                 __field(        u64,    bytes_used              )
 480                 __field(        u64,    bytes_super             )
 481                 __field(        int,    create                  )
 482         ),
 483
 484         TP_fast_assign(
 485                 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
 486                 __entry->offset         = block_group->key.objectid;
 487                 __entry->size           = block_group->key.offset;
 488                 __entry->flags          = block_group->flags;
 489                 __entry->bytes_used     =
 490                         btrfs_block_group_used(&block_group->item);
 491                 __entry->bytes_super    = block_group->bytes_super;
 492                 __entry->create         = create;
 493         ),
 494
 495         TP_printk("%pU: block_group offset=%llu size=%llu "
 496                   "flags=%llu(%s) bytes_used=%llu bytes_super=%llu "
 497                   "create=%d", __entry->fsid,
 498                   (unsigned long long)__entry->offset,
 499                   (unsigned long long)__entry->size,
 500                   (unsigned long long)__entry->flags,
 501                   __print_flags((unsigned long)__entry->flags, "|",
 502                                 BTRFS_GROUP_FLAGS),
 503                   (unsigned long long)__entry->bytes_used,
 504                   (unsigned long long)__entry->bytes_super, __entry->create)
 505 );
 506
 507 #define show_ref_action(action)                                         \
 508         __print_symbolic(action,                                        \
 509                 { BTRFS_ADD_DELAYED_REF,    "ADD_DELAYED_REF" },        \
 510                 { BTRFS_DROP_DELAYED_REF,   "DROP_DELAYED_REF" },       \
 511                 { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" },     \
 512                 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
 513
 514
 515 DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
 516
 517         TP_PROTO(struct btrfs_fs_info *fs_info,
 518                  struct btrfs_delayed_ref_node *ref,
 519                  struct btrfs_delayed_tree_ref *full_ref,
 520                  int action),
 521
 522         TP_ARGS(fs_info, ref, full_ref, action),
 523
 524         TP_STRUCT__entry_btrfs(
 525                 __field(        u64,  bytenr            )
 526                 __field(        u64,  num_bytes         )
 527                 __field(        int,  action            )
 528                 __field(        u64,  parent            )
 529                 __field(        u64,  ref_root          )
 530                 __field(        int,  level             )
 531                 __field(        int,  type              )
 532                 __field(        u64,  seq               )
 533         ),
 534
 535         TP_fast_assign_btrfs(fs_info,
 536                 __entry->bytenr         = ref->bytenr;
 537                 __entry->num_bytes      = ref->num_bytes;
 538                 __entry->action         = action;
 539                 __entry->parent         = full_ref->parent;
 540                 __entry->ref_root       = full_ref->root;
 541                 __entry->level          = full_ref->level;
 542                 __entry->type           = ref->type;
 543                 __entry->seq            = ref->seq;
 544         ),
 545
 546         TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
 547                   "parent=%llu(%s) ref_root=%llu(%s) level=%d "
 548                   "type=%s seq=%llu",
 549                   (unsigned long long)__entry->bytenr,
 550                   (unsigned long long)__entry->num_bytes,
 551                   show_ref_action(__entry->action),
 552                   show_root_type(__entry->parent),
 553                   show_root_type(__entry->ref_root),
 554                   __entry->level, show_ref_type(__entry->type),
 555                   (unsigned long long)__entry->seq)
 556 );
 557
 558 DEFINE_EVENT(btrfs_delayed_tree_ref,  add_delayed_tree_ref,
 559
 560         TP_PROTO(struct btrfs_fs_info *fs_info,
 561                  struct btrfs_delayed_ref_node *ref,
 562                  struct btrfs_delayed_tree_ref *full_ref,
 563                  int action),
 564
 565         TP_ARGS(fs_info, ref, full_ref, action)
 566 );
 567
 568 DEFINE_EVENT(btrfs_delayed_tree_ref,  run_delayed_tree_ref,
 569
 570         TP_PROTO(struct btrfs_fs_info *fs_info,
 571                  struct btrfs_delayed_ref_node *ref,
 572                  struct btrfs_delayed_tree_ref *full_ref,
 573                  int action),
 574
 575         TP_ARGS(fs_info, ref, full_ref, action)
 576 );
 577
 578 DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,
 579
 580         TP_PROTO(struct btrfs_fs_info *fs_info,
 581                  struct btrfs_delayed_ref_node *ref,
 582                  struct btrfs_delayed_data_ref *full_ref,
 583                  int action),
 584
 585         TP_ARGS(fs_info, ref, full_ref, action),
 586
 587         TP_STRUCT__entry_btrfs(
 588                 __field(        u64,  bytenr            )
 589                 __field(        u64,  num_bytes         )
 590                 __field(        int,  action            )
 591                 __field(        u64,  parent            )
 592                 __field(        u64,  ref_root          )
 593                 __field(        u64,  owner             )
 594                 __field(        u64,  offset            )
 595                 __field(        int,  type              )
 596                 __field(        u64,  seq               )
 597         ),
 598
 599         TP_fast_assign_btrfs(fs_info,
 600                 __entry->bytenr         = ref->bytenr;
 601                 __entry->num_bytes      = ref->num_bytes;
 602                 __entry->action         = action;
 603                 __entry->parent         = full_ref->parent;
 604                 __entry->ref_root       = full_ref->root;
 605                 __entry->owner          = full_ref->objectid;
 606                 __entry->offset         = full_ref->offset;
 607                 __entry->type           = ref->type;
 608                 __entry->seq            = ref->seq;
 609         ),
 610
 611         TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
 612                   "parent=%llu(%s) ref_root=%llu(%s) owner=%llu "
 613                   "offset=%llu type=%s seq=%llu",
 614                   (unsigned long long)__entry->bytenr,
 615                   (unsigned long long)__entry->num_bytes,
 616                   show_ref_action(__entry->action),
 617                   show_root_type(__entry->parent),
 618                   show_root_type(__entry->ref_root),
 619                   (unsigned long long)__entry->owner,
 620                   (unsigned long long)__entry->offset,
 621                   show_ref_type(__entry->type),
 622                   (unsigned long long)__entry->seq)
 623 );
 624
 625 DEFINE_EVENT(btrfs_delayed_data_ref,  add_delayed_data_ref,
 626
 627         TP_PROTO(struct btrfs_fs_info *fs_info,
 628                  struct btrfs_delayed_ref_node *ref,
 629                  struct btrfs_delayed_data_ref *full_ref,
 630                  int action),
 631
 632         TP_ARGS(fs_info, ref, full_ref, action)
 633 );
 634
 635 DEFINE_EVENT(btrfs_delayed_data_ref,  run_delayed_data_ref,
 636
 637         TP_PROTO(struct btrfs_fs_info *fs_info,
 638                  struct btrfs_delayed_ref_node *ref,
 639                  struct btrfs_delayed_data_ref *full_ref,
 640                  int action),
 641
 642         TP_ARGS(fs_info, ref, full_ref, action)
 643 );
 644
 645 DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,
 646
 647         TP_PROTO(struct btrfs_fs_info *fs_info,
 648                  struct btrfs_delayed_ref_node *ref,
 649                  struct btrfs_delayed_ref_head *head_ref,
 650                  int action),
 651
 652         TP_ARGS(fs_info, ref, head_ref, action),
 653
 654         TP_STRUCT__entry_btrfs(
 655                 __field(        u64,  bytenr            )
 656                 __field(        u64,  num_bytes         )
 657                 __field(        int,  action            )
 658                 __field(        int,  is_data           )
 659         ),
 660
 661         TP_fast_assign_btrfs(fs_info,
 662                 __entry->bytenr         = ref->bytenr;
 663                 __entry->num_bytes      = ref->num_bytes;
 664                 __entry->action         = action;
 665                 __entry->is_data        = head_ref->is_data;
 666         ),
 667
 668         TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s is_data=%d",
 669                   (unsigned long long)__entry->bytenr,
 670                   (unsigned long long)__entry->num_bytes,
 671                   show_ref_action(__entry->action),
 672                   __entry->is_data)
 673 );
 674
 675 DEFINE_EVENT(btrfs_delayed_ref_head,  add_delayed_ref_head,
 676
 677         TP_PROTO(struct btrfs_fs_info *fs_info,
 678                  struct btrfs_delayed_ref_node *ref,
 679                  struct btrfs_delayed_ref_head *head_ref,
 680                  int action),
 681
 682         TP_ARGS(fs_info, ref, head_ref, action)
 683 );
 684
 685 DEFINE_EVENT(btrfs_delayed_ref_head,  run_delayed_ref_head,
 686
 687         TP_PROTO(struct btrfs_fs_info *fs_info,
 688                  struct btrfs_delayed_ref_node *ref,
 689                  struct btrfs_delayed_ref_head *head_ref,
 690                  int action),
 691
 692         TP_ARGS(fs_info, ref, head_ref, action)
 693 );
 694
 695 #define show_chunk_type(type)                                   \
 696         __print_flags(type, "|",                                \
 697                 { BTRFS_BLOCK_GROUP_DATA,       "DATA"  },      \
 698                 { BTRFS_BLOCK_GROUP_SYSTEM,     "SYSTEM"},      \
 699                 { BTRFS_BLOCK_GROUP_METADATA,   "METADATA"},    \
 700                 { BTRFS_BLOCK_GROUP_RAID0,      "RAID0" },      \
 701                 { BTRFS_BLOCK_GROUP_RAID1,      "RAID1" },      \
 702                 { BTRFS_BLOCK_GROUP_DUP,        "DUP"   },      \
 703                 { BTRFS_BLOCK_GROUP_RAID10,     "RAID10"},      \
 704                 { BTRFS_BLOCK_GROUP_RAID5,      "RAID5" },      \
 705                 { BTRFS_BLOCK_GROUP_RAID6,      "RAID6" })
 706
 707 DECLARE_EVENT_CLASS(btrfs__chunk,
 708
 709         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
 710                  u64 offset, u64 size),
 711
 712         TP_ARGS(fs_info, map, offset, size),
 713
 714         TP_STRUCT__entry_btrfs(
 715                 __field(        int,  num_stripes               )
 716                 __field(        u64,  type                      )
 717                 __field(        int,  sub_stripes               )
 718                 __field(        u64,  offset                    )
 719                 __field(        u64,  size                      )
 720                 __field(        u64,  root_objectid             )
 721         ),
 722
 723         TP_fast_assign_btrfs(fs_info,
 724                 __entry->num_stripes    = map->num_stripes;
 725                 __entry->type           = map->type;
 726                 __entry->sub_stripes    = map->sub_stripes;
 727                 __entry->offset         = offset;
 728                 __entry->size           = size;
 729                 __entry->root_objectid  = fs_info->chunk_root->root_key.objectid;
 730         ),
 731
 732         TP_printk_btrfs("root=%llu(%s) offset=%llu size=%llu "
 733                   "num_stripes=%d sub_stripes=%d type=%s",
 734                   show_root_type(__entry->root_objectid),
 735                   (unsigned long long)__entry->offset,
 736                   (unsigned long long)__entry->size,
 737                   __entry->num_stripes, __entry->sub_stripes,
 738                   show_chunk_type(__entry->type))
 739 );
 740
 741 DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_alloc,
 742
 743         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
 744                  u64 offset, u64 size),
 745
 746         TP_ARGS(fs_info, map, offset, size)
 747 );
 748
 749 DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_free,
 750
 751         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
 752                  u64 offset, u64 size),
 753
 754         TP_ARGS(fs_info, map, offset, size)
 755 );
 756
 757 TRACE_EVENT(btrfs_cow_block,
 758
 759         TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
 760                  struct extent_buffer *cow),
 761
 762         TP_ARGS(root, buf, cow),
 763
 764         TP_STRUCT__entry_btrfs(
 765                 __field(        u64,  root_objectid             )
 766                 __field(        u64,  buf_start                 )
 767                 __field(        int,  refs                      )
 768                 __field(        u64,  cow_start                 )
 769                 __field(        int,  buf_level                 )
 770                 __field(        int,  cow_level                 )
 771         ),
 772
 773         TP_fast_assign_btrfs(root->fs_info,
 774                 __entry->root_objectid  = root->root_key.objectid;
 775                 __entry->buf_start      = buf->start;
 776                 __entry->refs           = atomic_read(&buf->refs);
 777                 __entry->cow_start      = cow->start;
 778                 __entry->buf_level      = btrfs_header_level(buf);
 779                 __entry->cow_level      = btrfs_header_level(cow);
 780         ),
 781
 782         TP_printk_btrfs("root=%llu(%s) refs=%d orig_buf=%llu "
 783                   "(orig_level=%d) cow_buf=%llu (cow_level=%d)",
 784                   show_root_type(__entry->root_objectid),
 785                   __entry->refs,
 786                   (unsigned long long)__entry->buf_start,
 787                   __entry->buf_level,
 788                   (unsigned long long)__entry->cow_start,
 789                   __entry->cow_level)
 790 );
 791
 792 TRACE_EVENT(btrfs_space_reservation,
 793
 794         TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
 795                  u64 bytes, int reserve),
 796
 797         TP_ARGS(fs_info, type, val, bytes, reserve),
 798
 799         TP_STRUCT__entry_btrfs(
 800                 __string(       type,   type                    )
 801                 __field(        u64,    val                     )
 802                 __field(        u64,    bytes                   )
 803                 __field(        int,    reserve                 )
 804         ),
 805
 806         TP_fast_assign_btrfs(fs_info,
 807                 __assign_str(type, type);
 808                 __entry->val            = val;
 809                 __entry->bytes          = bytes;
 810                 __entry->reserve        = reserve;
 811         ),
 812
 813         TP_printk_btrfs("%s: %Lu %s %Lu", __get_str(type), __entry->val,
 814                         __entry->reserve ? "reserve" : "release",
 815                         __entry->bytes)
 816 );
 817
 818 #define show_flush_action(action)                                               \
 819         __print_symbolic(action,                                                \
 820                 { BTRFS_RESERVE_NO_FLUSH,       "BTRFS_RESERVE_NO_FLUSH"},      \
 821                 { BTRFS_RESERVE_FLUSH_LIMIT,    "BTRFS_RESERVE_FLUSH_LIMIT"},   \
 822                 { BTRFS_RESERVE_FLUSH_ALL,      "BTRFS_RESERVE_FLUSH_ALL"})
 823
 824 TRACE_EVENT(btrfs_trigger_flush,
 825
 826         TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
 827                  int flush, char *reason),
 828
 829         TP_ARGS(fs_info, flags, bytes, flush, reason),
 830
 831         TP_STRUCT__entry(
 832                 __array(        u8,     fsid,   BTRFS_UUID_SIZE )
 833                 __field(        u64,    flags                   )
 834                 __field(        u64,    bytes                   )
 835                 __field(        int,    flush                   )
 836                 __string(       reason, reason                  )
 837         ),
 838
 839         TP_fast_assign(
 840                 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
 841                 __entry->flags  = flags;
 842                 __entry->bytes  = bytes;
 843                 __entry->flush  = flush;
 844                 __assign_str(reason, reason)
 845         ),
 846
 847         TP_printk("%pU: %s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
 848                   __entry->fsid, __get_str(reason), __entry->flush,
 849                   show_flush_action(__entry->flush),
 850                   (unsigned long long)__entry->flags,
 851                   __print_flags((unsigned long)__entry->flags, "|",
 852                                 BTRFS_GROUP_FLAGS),
 853                   (unsigned long long)__entry->bytes)
 854 );
 855
 856 #define show_flush_state(state)                                                 \
 857         __print_symbolic(state,                                                 \
 858                 { FLUSH_DELAYED_ITEMS_NR,       "FLUSH_DELAYED_ITEMS_NR"},      \
 859                 { FLUSH_DELAYED_ITEMS,          "FLUSH_DELAYED_ITEMS"},         \
 860                 { FLUSH_DELALLOC,               "FLUSH_DELALLOC"},              \
 861                 { FLUSH_DELALLOC_WAIT,          "FLUSH_DELALLOC_WAIT"},         \
 862                 { ALLOC_CHUNK,                  "ALLOC_CHUNK"},                 \
 863                 { COMMIT_TRANS,                 "COMMIT_TRANS"})
 864
 865 TRACE_EVENT(btrfs_flush_space,
 866
 867         TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,
 868                  u64 orig_bytes, int state, int ret),
 869
 870         TP_ARGS(fs_info, flags, num_bytes, orig_bytes, state, ret),
 871
 872         TP_STRUCT__entry(
 873                 __array(        u8,     fsid,   BTRFS_UUID_SIZE )
 874                 __field(        u64,    flags                   )
 875                 __field(        u64,    num_bytes               )
 876                 __field(        u64,    orig_bytes              )
 877                 __field(        int,    state                   )
 878                 __field(        int,    ret                     )
 879         ),
 880
 881         TP_fast_assign(
 882                 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
 883                 __entry->flags          =       flags;
 884                 __entry->num_bytes      =       num_bytes;
 885                 __entry->orig_bytes     =       orig_bytes;
 886                 __entry->state          =       state;
 887                 __entry->ret            =       ret;
 888         ),
 889
 890         TP_printk("%pU: state=%d(%s) flags=%llu(%s) num_bytes=%llu "
 891                   "orig_bytes=%llu ret=%d", __entry->fsid, __entry->state,
 892                   show_flush_state(__entry->state),
 893                   (unsigned long long)__entry->flags,
 894                   __print_flags((unsigned long)__entry->flags, "|",
 895                                 BTRFS_GROUP_FLAGS),
 896                   (unsigned long long)__entry->num_bytes,
 897                   (unsigned long long)__entry->orig_bytes, __entry->ret)
 898 );
 899
 900 DECLARE_EVENT_CLASS(btrfs__reserved_extent,
 901
 902         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
 903
 904         TP_ARGS(fs_info, start, len),
 905
 906         TP_STRUCT__entry_btrfs(
 907                 __field(        u64,  start                     )
 908                 __field(        u64,  len                       )
 909         ),
 910
 911         TP_fast_assign_btrfs(fs_info,
 912                 __entry->start          = start;
 913                 __entry->len            = len;
 914         ),
 915
 916         TP_printk_btrfs("root=%llu(%s) start=%llu len=%llu",
 917                   show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
 918                   (unsigned long long)__entry->start,
 919                   (unsigned long long)__entry->len)
 920 );
 921
 922 DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
 923
 924         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
 925
 926         TP_ARGS(fs_info, start, len)
 927 );
 928
 929 DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_free,
 930
 931         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
 932
 933         TP_ARGS(fs_info, start, len)
 934 );
 935
 936 TRACE_EVENT(find_free_extent,
 937
 938         TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
 939                  u64 data),
 940
 941         TP_ARGS(fs_info, num_bytes, empty_size, data),
 942
 943         TP_STRUCT__entry_btrfs(
 944                 __field(        u64,    num_bytes               )
 945                 __field(        u64,    empty_size              )
 946                 __field(        u64,    data                    )
 947         ),
 948
 949         TP_fast_assign_btrfs(fs_info,
 950                 __entry->num_bytes      = num_bytes;
 951                 __entry->empty_size     = empty_size;
 952                 __entry->data           = data;
 953         ),
 954
 955         TP_printk_btrfs("root=%Lu(%s) len=%Lu empty_size=%Lu flags=%Lu(%s)",
 956                   show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
 957                   __entry->num_bytes, __entry->empty_size, __entry->data,
 958                   __print_flags((unsigned long)__entry->data, "|",
 959                                  BTRFS_GROUP_FLAGS))
 960 );
 961
 962 DECLARE_EVENT_CLASS(btrfs__reserve_extent,
 963
 964         TP_PROTO(struct btrfs_fs_info *fs_info,
 965                  struct btrfs_block_group_cache *block_group, u64 start,
 966                  u64 len),
 967
 968         TP_ARGS(fs_info, block_group, start, len),
 969
 970         TP_STRUCT__entry_btrfs(
 971                 __field(        u64,    bg_objectid             )
 972                 __field(        u64,    flags                   )
 973                 __field(        u64,    start                   )
 974                 __field(        u64,    len                     )
 975         ),
 976
 977         TP_fast_assign_btrfs(fs_info,
 978                 __entry->bg_objectid    = block_group->key.objectid;
 979                 __entry->flags          = block_group->flags;
 980                 __entry->start          = start;
 981                 __entry->len            = len;
 982         ),
 983
 984         TP_printk_btrfs("root=%Lu(%s) block_group=%Lu flags=%Lu(%s) "
 985                   "start=%Lu len=%Lu",
 986                   show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
 987                   __entry->bg_objectid,
 988                   __entry->flags, __print_flags((unsigned long)__entry->flags,
 989                                                 "|", BTRFS_GROUP_FLAGS),
 990                   __entry->start, __entry->len)
 991 );
 992
 993 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
 994
 995         TP_PROTO(struct btrfs_fs_info *fs_info,
 996                  struct btrfs_block_group_cache *block_group, u64 start,
 997                  u64 len),
 998
 999         TP_ARGS(fs_info, block_group, start, len)
1000 );
1001
1002 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1003
1004         TP_PROTO(struct btrfs_fs_info *fs_info,
1005                  struct btrfs_block_group_cache *block_group, u64 start,
1006                  u64 len),
1007
1008         TP_ARGS(fs_info, block_group, start, len)
1009 );
1010
1011 TRACE_EVENT(btrfs_find_cluster,
1012
1013         TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
1014                  u64 bytes, u64 empty_size, u64 min_bytes),
1015
1016         TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1017
1018         TP_STRUCT__entry_btrfs(
1019                 __field(        u64,    bg_objectid             )
1020                 __field(        u64,    flags                   )
1021                 __field(        u64,    start                   )
1022                 __field(        u64,    bytes                   )
1023                 __field(        u64,    empty_size              )
1024                 __field(        u64,    min_bytes               )
1025         ),
1026
1027         TP_fast_assign_btrfs(block_group->fs_info,
1028                 __entry->bg_objectid    = block_group->key.objectid;
1029                 __entry->flags          = block_group->flags;
1030                 __entry->start          = start;
1031                 __entry->bytes          = bytes;
1032                 __entry->empty_size     = empty_size;
1033                 __entry->min_bytes      = min_bytes;
1034         ),
1035
1036         TP_printk_btrfs("block_group=%Lu flags=%Lu(%s) start=%Lu len=%Lu "
1037                   "empty_size=%Lu min_bytes=%Lu", __entry->bg_objectid,
1038                   __entry->flags,
1039                   __print_flags((unsigned long)__entry->flags, "|",
1040                                 BTRFS_GROUP_FLAGS), __entry->start,
1041                   __entry->bytes, __entry->empty_size,  __entry->min_bytes)
1042 );
1043
1044 TRACE_EVENT(btrfs_failed_cluster_setup,
1045
1046         TP_PROTO(struct btrfs_block_group_cache *block_group),
1047
1048         TP_ARGS(block_group),
1049
1050         TP_STRUCT__entry_btrfs(
1051                 __field(        u64,    bg_objectid             )
1052         ),
1053
1054         TP_fast_assign_btrfs(block_group->fs_info,
1055                 __entry->bg_objectid    = block_group->key.objectid;
1056         ),
1057
1058         TP_printk_btrfs("block_group=%Lu", __entry->bg_objectid)
1059 );
1060
1061 TRACE_EVENT(btrfs_setup_cluster,
1062
1063         TP_PROTO(struct btrfs_block_group_cache *block_group,
1064                  struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1065
1066         TP_ARGS(block_group, cluster, size, bitmap),
1067
1068         TP_STRUCT__entry_btrfs(
1069                 __field(        u64,    bg_objectid             )
1070                 __field(        u64,    flags                   )
1071                 __field(        u64,    start                   )
1072                 __field(        u64,    max_size                )
1073                 __field(        u64,    size                    )
1074                 __field(        int,    bitmap                  )
1075         ),
1076
1077         TP_fast_assign_btrfs(block_group->fs_info,
1078                 __entry->bg_objectid    = block_group->key.objectid;
1079                 __entry->flags          = block_group->flags;
1080                 __entry->start          = cluster->window_start;
1081                 __entry->max_size       = cluster->max_size;
1082                 __entry->size           = size;
1083                 __entry->bitmap         = bitmap;
1084         ),
1085
1086         TP_printk_btrfs("block_group=%Lu flags=%Lu(%s) window_start=%Lu "
1087                   "size=%Lu max_size=%Lu bitmap=%d",
1088                   __entry->bg_objectid,
1089                   __entry->flags,
1090                   __print_flags((unsigned long)__entry->flags, "|",
1091                                 BTRFS_GROUP_FLAGS), __entry->start,
1092                   __entry->size, __entry->max_size, __entry->bitmap)
1093 );
1094
1095 struct extent_state;
1096 TRACE_EVENT(alloc_extent_state,
1097
1098         TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
1099
1100         TP_ARGS(state, mask, IP),
1101
1102         TP_STRUCT__entry(
1103                 __field(struct extent_state *, state)
1104                 __field(gfp_t, mask)
1105                 __field(unsigned long, ip)
1106         ),
1107
1108         TP_fast_assign(
1109                 __entry->state  = state,
1110                 __entry->mask   = mask,
1111                 __entry->ip     = IP
1112         ),
1113
1114         TP_printk("state=%p mask=%s caller=%pS", __entry->state,
1115                   show_gfp_flags(__entry->mask), (void *)__entry->ip)
1116 );
1117
1118 TRACE_EVENT(free_extent_state,
1119
1120         TP_PROTO(struct extent_state *state, unsigned long IP),
1121
1122         TP_ARGS(state, IP),
1123
1124         TP_STRUCT__entry(
1125                 __field(struct extent_state *, state)
1126                 __field(unsigned long, ip)
1127         ),
1128
1129         TP_fast_assign(
1130                 __entry->state  = state,
1131                 __entry->ip = IP
1132         ),
1133
1134         TP_printk("state=%p caller=%pS", __entry->state,
1135                   (void *)__entry->ip)
1136 );
1137
1138 DECLARE_EVENT_CLASS(btrfs__work,
1139
1140         TP_PROTO(struct btrfs_work *work),
1141
1142         TP_ARGS(work),
1143
1144         TP_STRUCT__entry_btrfs(
1145                 __field(        void *, work                    )
1146                 __field(        void *, wq                      )
1147                 __field(        void *, func                    )
1148                 __field(        void *, ordered_func            )
1149                 __field(        void *, ordered_free            )
1150                 __field(        void *, normal_work             )
1151         ),
1152
1153         TP_fast_assign_btrfs(btrfs_work_owner(work),
1154                 __entry->work           = work;
1155                 __entry->wq             = work->wq;
1156                 __entry->func           = work->func;
1157                 __entry->ordered_func   = work->ordered_func;
1158                 __entry->ordered_free   = work->ordered_free;
1159                 __entry->normal_work    = &work->normal_work;
1160         ),
1161
1162         TP_printk_btrfs("work=%p (normal_work=%p) wq=%p func=%pf ordered_func=%p "
1163                   "ordered_free=%p",
1164                   __entry->work, __entry->normal_work, __entry->wq,
1165                    __entry->func, __entry->ordered_func, __entry->ordered_free)
1166 );
1167
1168 /*
1169  * For situiations when the work is freed, we pass fs_info and a tag that that
1170  * matches address of the work structure so it can be paired with the
1171  * scheduling event.
1172  */
1173 DECLARE_EVENT_CLASS(btrfs__work__done,
1174
1175         TP_PROTO(struct btrfs_fs_info *fs_info, void *wtag),
1176
1177         TP_ARGS(fs_info, wtag),
1178
1179         TP_STRUCT__entry_btrfs(
1180                 __field(        void *, wtag                    )
1181         ),
1182
1183         TP_fast_assign_btrfs(fs_info,
1184                 __entry->wtag           = wtag;
1185         ),
1186
1187         TP_printk_btrfs("work->%p", __entry->wtag)
1188 );
1189
1190 DEFINE_EVENT(btrfs__work, btrfs_work_queued,
1191
1192         TP_PROTO(struct btrfs_work *work),
1193
1194         TP_ARGS(work)
1195 );
1196
1197 DEFINE_EVENT(btrfs__work, btrfs_work_sched,
1198
1199         TP_PROTO(struct btrfs_work *work),
1200
1201         TP_ARGS(work)
1202 );
1203
1204 DEFINE_EVENT(btrfs__work__done, btrfs_all_work_done,
1205
1206         TP_PROTO(struct btrfs_fs_info *fs_info, void *wtag),
1207
1208         TP_ARGS(fs_info, wtag)
1209 );
1210
1211 DEFINE_EVENT(btrfs__work, btrfs_ordered_sched,
1212
1213         TP_PROTO(struct btrfs_work *work),
1214
1215         TP_ARGS(work)
1216 );
1217
1218 DECLARE_EVENT_CLASS(btrfs__workqueue,
1219
1220         TP_PROTO(struct __btrfs_workqueue *wq, const char *name, int high),
1221
1222         TP_ARGS(wq, name, high),
1223
1224         TP_STRUCT__entry_btrfs(
1225                 __field(        void *, wq                      )
1226                 __string(       name,   name                    )
1227                 __field(        int ,   high                    )
1228         ),
1229
1230         TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1231                 __entry->wq             = wq;
1232                 __assign_str(name, name);
1233                 __entry->high           = high;
1234         ),
1235
1236         TP_printk_btrfs("name=%s%s wq=%p", __get_str(name),
1237                   __print_flags(__entry->high, "",
1238                                 {(WQ_HIGHPRI),  "-high"}),
1239                   __entry->wq)
1240 );
1241
1242 DEFINE_EVENT(btrfs__workqueue, btrfs_workqueue_alloc,
1243
1244         TP_PROTO(struct __btrfs_workqueue *wq, const char *name, int high),
1245
1246         TP_ARGS(wq, name, high)
1247 );
1248
1249 DECLARE_EVENT_CLASS(btrfs__workqueue_done,
1250
1251         TP_PROTO(struct __btrfs_workqueue *wq),
1252
1253         TP_ARGS(wq),
1254
1255         TP_STRUCT__entry_btrfs(
1256                 __field(        void *, wq                      )
1257         ),
1258
1259         TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1260                 __entry->wq             = wq;
1261         ),
1262
1263         TP_printk_btrfs("wq=%p", __entry->wq)
1264 );
1265
1266 DEFINE_EVENT(btrfs__workqueue_done, btrfs_workqueue_destroy,
1267
1268         TP_PROTO(struct __btrfs_workqueue *wq),
1269
1270         TP_ARGS(wq)
1271 );
1272
1273 DECLARE_EVENT_CLASS(btrfs__qgroup_data_map,
1274
1275         TP_PROTO(struct inode *inode, u64 free_reserved),
1276
1277         TP_ARGS(inode, free_reserved),
1278
1279         TP_STRUCT__entry_btrfs(
1280                 __field(        u64,            rootid          )
1281                 __field(        unsigned long,  ino             )
1282                 __field(        u64,            free_reserved   )
1283         ),
1284
1285         TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
1286                 __entry->rootid         =       BTRFS_I(inode)->root->objectid;
1287                 __entry->ino            =       inode->i_ino;
1288                 __entry->free_reserved  =       free_reserved;
1289         ),
1290
1291         TP_printk_btrfs("rootid=%llu ino=%lu free_reserved=%llu",
1292                   __entry->rootid, __entry->ino, __entry->free_reserved)
1293 );
1294
1295 DEFINE_EVENT(btrfs__qgroup_data_map, btrfs_qgroup_init_data_rsv_map,
1296
1297         TP_PROTO(struct inode *inode, u64 free_reserved),
1298
1299         TP_ARGS(inode, free_reserved)
1300 );
1301
1302 DEFINE_EVENT(btrfs__qgroup_data_map, btrfs_qgroup_free_data_rsv_map,
1303
1304         TP_PROTO(struct inode *inode, u64 free_reserved),
1305
1306         TP_ARGS(inode, free_reserved)
1307 );
1308
1309 #define BTRFS_QGROUP_OPERATIONS                         \
1310         { QGROUP_RESERVE,       "reserve"       },      \
1311         { QGROUP_RELEASE,       "release"       },      \
1312         { QGROUP_FREE,          "free"          }
1313
1314 DECLARE_EVENT_CLASS(btrfs__qgroup_rsv_data,
1315
1316         TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1317
1318         TP_ARGS(inode, start, len, reserved, op),
1319
1320         TP_STRUCT__entry_btrfs(
1321                 __field(        u64,            rootid          )
1322                 __field(        unsigned long,  ino             )
1323                 __field(        u64,            start           )
1324                 __field(        u64,            len             )
1325                 __field(        u64,            reserved        )
1326                 __field(        int,            op              )
1327         ),
1328
1329         TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
1330                 __entry->rootid         = BTRFS_I(inode)->root->objectid;
1331                 __entry->ino            = inode->i_ino;
1332                 __entry->start          = start;
1333                 __entry->len            = len;
1334                 __entry->reserved       = reserved;
1335                 __entry->op             = op;
1336         ),
1337
1338         TP_printk_btrfs("root=%llu ino=%lu start=%llu len=%llu reserved=%llu op=%s",
1339                   __entry->rootid, __entry->ino, __entry->start, __entry->len,
1340                   __entry->reserved,
1341                   __print_flags((unsigned long)__entry->op, "",
1342                                 BTRFS_QGROUP_OPERATIONS)
1343         )
1344 );
1345
1346 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_reserve_data,
1347
1348         TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1349
1350         TP_ARGS(inode, start, len, reserved, op)
1351 );
1352
1353 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_release_data,
1354
1355         TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1356
1357         TP_ARGS(inode, start, len, reserved, op)
1358 );
1359
1360 DECLARE_EVENT_CLASS(btrfs__qgroup_delayed_ref,
1361
1362         TP_PROTO(struct btrfs_fs_info *fs_info, u64 ref_root, u64 reserved),
1363
1364         TP_ARGS(fs_info, ref_root, reserved),
1365
1366         TP_STRUCT__entry_btrfs(
1367                 __field(        u64,            ref_root        )
1368                 __field(        u64,            reserved        )
1369         ),
1370
1371         TP_fast_assign_btrfs(fs_info,
1372                 __entry->ref_root       = ref_root;
1373                 __entry->reserved       = reserved;
1374         ),
1375
1376         TP_printk_btrfs("root=%llu reserved=%llu op=free",
1377                   __entry->ref_root, __entry->reserved)
1378 );
1379
1380 DEFINE_EVENT(btrfs__qgroup_delayed_ref, btrfs_qgroup_free_delayed_ref,
1381
1382         TP_PROTO(struct btrfs_fs_info *fs_info, u64 ref_root, u64 reserved),
1383
1384         TP_ARGS(fs_info, ref_root, reserved)
1385 );
1386
1387 DECLARE_EVENT_CLASS(btrfs_qgroup_extent,
1388         TP_PROTO(struct btrfs_fs_info *fs_info,
1389                  struct btrfs_qgroup_extent_record *rec),
1390
1391         TP_ARGS(fs_info, rec),
1392
1393         TP_STRUCT__entry_btrfs(
1394                 __field(        u64,  bytenr            )
1395                 __field(        u64,  num_bytes         )
1396         ),
1397
1398         TP_fast_assign_btrfs(fs_info,
1399                 __entry->bytenr         = rec->bytenr,
1400                 __entry->num_bytes      = rec->num_bytes;
1401         ),
1402
1403         TP_printk_btrfs("bytenr=%llu num_bytes=%llu",
1404                   (unsigned long long)__entry->bytenr,
1405                   (unsigned long long)__entry->num_bytes)
1406 );
1407
1408 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_account_extents,
1409
1410         TP_PROTO(struct btrfs_fs_info *fs_info,
1411                  struct btrfs_qgroup_extent_record *rec),
1412
1413         TP_ARGS(fs_info, rec)
1414 );
1415
1416 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_trace_extent,
1417
1418         TP_PROTO(struct btrfs_fs_info *fs_info,
1419                  struct btrfs_qgroup_extent_record *rec),
1420
1421         TP_ARGS(fs_info, rec)
1422 );
1423
1424 TRACE_EVENT(btrfs_qgroup_account_extent,
1425
1426         TP_PROTO(struct btrfs_fs_info *fs_info, u64 bytenr,
1427                  u64 num_bytes, u64 nr_old_roots, u64 nr_new_roots),
1428
1429         TP_ARGS(fs_info, bytenr, num_bytes, nr_old_roots, nr_new_roots),
1430
1431         TP_STRUCT__entry_btrfs(
1432                 __field(        u64,  bytenr                    )
1433                 __field(        u64,  num_bytes                 )
1434                 __field(        u64,  nr_old_roots              )
1435                 __field(        u64,  nr_new_roots              )
1436         ),
1437
1438         TP_fast_assign_btrfs(fs_info,
1439                 __entry->bytenr         = bytenr;
1440                 __entry->num_bytes      = num_bytes;
1441                 __entry->nr_old_roots   = nr_old_roots;
1442                 __entry->nr_new_roots   = nr_new_roots;
1443         ),
1444
1445         TP_printk_btrfs("bytenr=%llu num_bytes=%llu nr_old_roots=%llu "
1446                   "nr_new_roots=%llu",
1447                   __entry->bytenr,
1448                   __entry->num_bytes,
1449                   __entry->nr_old_roots,
1450                   __entry->nr_new_roots)
1451 );
1452
1453 TRACE_EVENT(qgroup_update_counters,
1454
1455         TP_PROTO(struct btrfs_fs_info *fs_info, u64 qgid,
1456                  u64 cur_old_count, u64 cur_new_count),
1457
1458         TP_ARGS(fs_info, qgid, cur_old_count, cur_new_count),
1459
1460         TP_STRUCT__entry_btrfs(
1461                 __field(        u64,  qgid                      )
1462                 __field(        u64,  cur_old_count             )
1463                 __field(        u64,  cur_new_count             )
1464         ),
1465
1466         TP_fast_assign_btrfs(fs_info,
1467                 __entry->qgid           = qgid;
1468                 __entry->cur_old_count  = cur_old_count;
1469                 __entry->cur_new_count  = cur_new_count;
1470         ),
1471
1472         TP_printk_btrfs("qgid=%llu cur_old_count=%llu cur_new_count=%llu",
1473                   __entry->qgid,
1474                   __entry->cur_old_count,
1475                   __entry->cur_new_count)
1476 );
1477
1478 #endif /* _TRACE_BTRFS_H */
1479
1480 /* This part must be outside protection */
1481 #include <trace/define_trace.h>