instrumentation/events/lttng-module/btrfs.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM btrfs
   3
   4 #if !defined(LTTNG_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define LTTNG_TRACE_BTRFS_H
   6
   7 #include <probes/lttng-tracepoint-event.h>
   8 #include <linux/writeback.h>
   9 #include <linux/version.h>
  10
  11 #ifndef _TRACE_BTRFS_DEF_
  12 #define _TRACE_BTRFS_DEF_
  13 struct btrfs_root;
  14 struct btrfs_fs_info;
  15 struct btrfs_inode;
  16 struct extent_map;
  17 struct btrfs_ordered_extent;
  18 struct btrfs_delayed_ref_node;
  19 struct btrfs_delayed_tree_ref;
  20 struct btrfs_delayed_data_ref;
  21 struct btrfs_delayed_ref_head;
  22 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
  23 struct btrfs_block_group;
  24 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
  25 struct btrfs_block_group_cache;
  26 #endif
  27 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
  28 struct btrfs_free_cluster;
  29 #endif
  30 struct map_lookup;
  31 struct extent_buffer;
  32 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
  33 struct extent_state;
  34 #endif
  35 #endif
  36
  37 #define BTRFS_UUID_SIZE 16
  38
  39 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0))
  40 #define lttng_fs_info_fsid fs_info->fs_devices->fsid
  41 #else
  42 #define lttng_fs_info_fsid fs_info->fsid
  43 #endif
  44
  45 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
  46         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
  47         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
  48         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
  49         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
  50 LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit,
  51
  52         TP_PROTO(const struct btrfs_root *root),
  53
  54         TP_ARGS(root),
  55
  56         TP_FIELDS(
  57                 ctf_integer(u64, generation, root->fs_info->generation)
  58                 ctf_integer(u64, root_objectid, root->root_key.objectid)
  59         )
  60 )
  61
  62 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode,
  63
  64         TP_PROTO(const struct inode *inode),
  65
  66         TP_ARGS(inode),
  67
  68         TP_FIELDS(
  69                 ctf_integer(ino_t, ino, inode->i_ino)
  70                 ctf_integer(blkcnt_t, blocks, inode->i_blocks)
  71                 ctf_integer(u64, disk_i_size, BTRFS_I(inode)->disk_i_size)
  72                 ctf_integer(u64, generation, BTRFS_I(inode)->generation)
  73                 ctf_integer(u64, last_trans, BTRFS_I(inode)->last_trans)
  74                 ctf_integer(u64, logged_trans, BTRFS_I(inode)->logged_trans)
  75                 ctf_integer(u64, root_objectid,
  76                                 BTRFS_I(inode)->root->root_key.objectid)
  77         )
  78 )
  79
  80 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new,
  81
  82         TP_PROTO(const struct inode *inode),
  83
  84         TP_ARGS(inode)
  85 )
  86
  87 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request,
  88
  89         TP_PROTO(const struct inode *inode),
  90
  91         TP_ARGS(inode)
  92 )
  93
  94 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict,
  95
  96         TP_PROTO(const struct inode *inode),
  97
  98         TP_ARGS(inode)
  99 )
 100 #else
 101 LTTNG_TRACEPOINT_EVENT(btrfs_transaction_commit,
 102
 103         TP_PROTO(struct btrfs_root *root),
 104
 105         TP_ARGS(root),
 106
 107         TP_FIELDS(
 108                 ctf_integer(u64, generation, root->fs_info->generation)
 109                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 110         )
 111 )
 112
 113 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__inode,
 114
 115         TP_PROTO(struct inode *inode),
 116
 117         TP_ARGS(inode),
 118
 119         TP_FIELDS(
 120                 ctf_integer(ino_t, ino, inode->i_ino)
 121                 ctf_integer(blkcnt_t, blocks, inode->i_blocks)
 122                 ctf_integer(u64, disk_i_size, BTRFS_I(inode)->disk_i_size)
 123                 ctf_integer(u64, generation, BTRFS_I(inode)->generation)
 124                 ctf_integer(u64, last_trans, BTRFS_I(inode)->last_trans)
 125                 ctf_integer(u64, logged_trans, BTRFS_I(inode)->logged_trans)
 126                 ctf_integer(u64, root_objectid,
 127                                 BTRFS_I(inode)->root->root_key.objectid)
 128         )
 129 )
 130
 131 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_new,
 132
 133         TP_PROTO(struct inode *inode),
 134
 135         TP_ARGS(inode)
 136 )
 137
 138 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_request,
 139
 140         TP_PROTO(struct inode *inode),
 141
 142         TP_ARGS(inode)
 143 )
 144
 145 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__inode, btrfs_inode_evict,
 146
 147         TP_PROTO(struct inode *inode),
 148
 149         TP_ARGS(inode)
 150 )
 151 #endif
 152
 153 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 154
 155 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 156
 157         TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode,
 158                 const struct extent_map *map),
 159
 160         TP_ARGS(root, inode, map),
 161
 162         TP_FIELDS(
 163                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 164                 ctf_integer(u64, ino, btrfs_ino(inode))
 165                 ctf_integer(u64, start, map->start)
 166                 ctf_integer(u64, len, map->len)
 167                 ctf_integer(u64, orig_start, map->orig_start)
 168                 ctf_integer(u64, block_start, map->block_start)
 169                 ctf_integer(u64, block_len, map->block_len)
 170                 ctf_integer(unsigned long, flags, map->flags)
 171                 ctf_integer(int, refs, refcount_read(&map->refs))
 172                 ctf_integer(unsigned int, compress_type, map->compress_type)
 173         )
 174 )
 175
 176 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 177
 178 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 179
 180         TP_PROTO(struct btrfs_root *root, struct btrfs_inode *inode,
 181                 struct extent_map *map),
 182
 183         TP_ARGS(root, inode, map),
 184
 185         TP_FIELDS(
 186                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 187                 ctf_integer(u64, ino, btrfs_ino(inode))
 188                 ctf_integer(u64, start, map->start)
 189                 ctf_integer(u64, len, map->len)
 190                 ctf_integer(u64, orig_start, map->orig_start)
 191                 ctf_integer(u64, block_start, map->block_start)
 192                 ctf_integer(u64, block_len, map->block_len)
 193                 ctf_integer(unsigned long, flags, map->flags)
 194                 ctf_integer(int, refs, refcount_read(&map->refs))
 195                 ctf_integer(unsigned int, compress_type, map->compress_type)
 196         )
 197 )
 198
 199 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,11,0))
 200
 201 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 202
 203         TP_PROTO(struct btrfs_root *root, struct btrfs_inode *inode,
 204                 struct extent_map *map),
 205
 206         TP_ARGS(root, inode, map),
 207
 208         TP_FIELDS(
 209                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 210                 ctf_integer(u64, ino, btrfs_ino(inode))
 211                 ctf_integer(u64, start, map->start)
 212                 ctf_integer(u64, len, map->len)
 213                 ctf_integer(u64, orig_start, map->orig_start)
 214                 ctf_integer(u64, block_start, map->block_start)
 215                 ctf_integer(u64, block_len, map->block_len)
 216                 ctf_integer(unsigned long, flags, map->flags)
 217                 ctf_integer(int, refs, atomic_read(&map->refs))
 218                 ctf_integer(unsigned int, compress_type, map->compress_type)
 219         )
 220 )
 221
 222 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
 223
 224 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 225
 226         TP_PROTO(struct btrfs_root *root, struct inode *inode,
 227                 struct extent_map *map),
 228
 229         TP_ARGS(root, inode, map),
 230
 231         TP_FIELDS(
 232                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 233                 ctf_integer(u64, ino, btrfs_ino(inode))
 234                 ctf_integer(u64, start, map->start)
 235                 ctf_integer(u64, len, map->len)
 236                 ctf_integer(u64, orig_start, map->orig_start)
 237                 ctf_integer(u64, block_start, map->block_start)
 238                 ctf_integer(u64, block_len, map->block_len)
 239                 ctf_integer(unsigned long, flags, map->flags)
 240                 ctf_integer(int, refs, atomic_read(&map->refs))
 241                 ctf_integer(unsigned int, compress_type, map->compress_type)
 242         )
 243 )
 244
 245 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 246         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 247         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 248         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
 249
 250 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 251
 252         TP_PROTO(const struct btrfs_root *root, const struct extent_map *map),
 253
 254         TP_ARGS(root, map),
 255
 256         TP_FIELDS(
 257                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 258                 ctf_integer(u64, start, map->start)
 259                 ctf_integer(u64, len, map->len)
 260                 ctf_integer(u64, orig_start, map->orig_start)
 261                 ctf_integer(u64, block_start, map->block_start)
 262                 ctf_integer(u64, block_len, map->block_len)
 263                 ctf_integer(unsigned long, flags, map->flags)
 264                 ctf_integer(int, refs, atomic_read(&map->refs))
 265                 ctf_integer(unsigned int, compress_type, map->compress_type)
 266         )
 267 )
 268
 269 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 270
 271 LTTNG_TRACEPOINT_EVENT(btrfs_get_extent,
 272
 273         TP_PROTO(struct btrfs_root *root, struct extent_map *map),
 274
 275         TP_ARGS(root, map),
 276
 277         TP_FIELDS(
 278                 ctf_integer(u64, root_objectid, root->root_key.objectid)
 279                 ctf_integer(u64, start, map->start)
 280                 ctf_integer(u64, len, map->len)
 281                 ctf_integer(u64, orig_start, map->orig_start)
 282                 ctf_integer(u64, block_start, map->block_start)
 283                 ctf_integer(u64, block_len, map->block_len)
 284                 ctf_integer(unsigned long, flags, map->flags)
 285                 ctf_integer(int, refs, atomic_read(&map->refs))
 286                 ctf_integer(unsigned int, compress_type, map->compress_type)
 287         )
 288 )
 289
 290 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
 291
 292 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,17,0))
 293 LTTNG_TRACEPOINT_EVENT(btrfs_handle_em_exist,
 294
 295         TP_PROTO(const struct extent_map *existing, const struct extent_map *map, u64 start, u64 len),
 296
 297         TP_ARGS(existing, map, start, len),
 298
 299         TP_FIELDS(
 300                 ctf_integer(u64, e_start, existing->start)
 301                 ctf_integer(u64, e_len, existing->len)
 302                 ctf_integer(u64, map_start, map->start)
 303                 ctf_integer(u64, map_len, map->len)
 304                 ctf_integer(u64, start, start)
 305                 ctf_integer(u64, len, len)
 306         )
 307 )
 308 #endif
 309
 310 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 311 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 312
 313         TP_PROTO(const struct inode *inode,
 314                  const struct btrfs_ordered_extent *ordered),
 315
 316         TP_ARGS(inode, ordered),
 317
 318         TP_FIELDS(
 319                 ctf_integer(ino_t, ino, inode->i_ino)
 320                 ctf_integer(u64, file_offset, ordered->file_offset)
 321                 ctf_integer(u64, start, ordered->start)
 322                 ctf_integer(u64, len, ordered->len)
 323                 ctf_integer(u64, disk_len, ordered->disk_len)
 324                 ctf_integer(u64, bytes_left, ordered->bytes_left)
 325                 ctf_integer(unsigned long, flags, ordered->flags)
 326                 ctf_integer(int, compress_type, ordered->compress_type)
 327                 ctf_integer(int, refs, refcount_read(&ordered->refs))
 328                 ctf_integer(u64, root_objectid,
 329                                 BTRFS_I(inode)->root->root_key.objectid)
 330         )
 331 )
 332 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,12,0))
 333 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 334
 335         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 336
 337         TP_ARGS(inode, ordered),
 338
 339         TP_FIELDS(
 340                 ctf_integer(ino_t, ino, inode->i_ino)
 341                 ctf_integer(u64, file_offset, ordered->file_offset)
 342                 ctf_integer(u64, start, ordered->start)
 343                 ctf_integer(u64, len, ordered->len)
 344                 ctf_integer(u64, disk_len, ordered->disk_len)
 345                 ctf_integer(u64, bytes_left, ordered->bytes_left)
 346                 ctf_integer(unsigned long, flags, ordered->flags)
 347                 ctf_integer(int, compress_type, ordered->compress_type)
 348                 ctf_integer(int, refs, refcount_read(&ordered->refs))
 349                 ctf_integer(u64, root_objectid,
 350                                 BTRFS_I(inode)->root->root_key.objectid)
 351         )
 352 )
 353 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 354         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 355         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 356         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
 357 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 358
 359         TP_PROTO(const struct inode *inode, const struct btrfs_ordered_extent *ordered),
 360
 361         TP_ARGS(inode, ordered),
 362
 363         TP_FIELDS(
 364                 ctf_integer(ino_t, ino, inode->i_ino)
 365                 ctf_integer(u64, file_offset, ordered->file_offset)
 366                 ctf_integer(u64, start, ordered->start)
 367                 ctf_integer(u64, len, ordered->len)
 368                 ctf_integer(u64, disk_len, ordered->disk_len)
 369                 ctf_integer(u64, bytes_left, ordered->bytes_left)
 370                 ctf_integer(unsigned long, flags, ordered->flags)
 371                 ctf_integer(int, compress_type, ordered->compress_type)
 372                 ctf_integer(int, refs, atomic_read(&ordered->refs))
 373                 ctf_integer(u64, root_objectid,
 374                                 BTRFS_I(inode)->root->root_key.objectid)
 375         )
 376 )
 377 #else
 378 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__ordered_extent,
 379
 380         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 381
 382         TP_ARGS(inode, ordered),
 383
 384         TP_FIELDS(
 385                 ctf_integer(ino_t, ino, inode->i_ino)
 386                 ctf_integer(u64, file_offset, ordered->file_offset)
 387                 ctf_integer(u64, start, ordered->start)
 388                 ctf_integer(u64, len, ordered->len)
 389                 ctf_integer(u64, disk_len, ordered->disk_len)
 390                 ctf_integer(u64, bytes_left, ordered->bytes_left)
 391                 ctf_integer(unsigned long, flags, ordered->flags)
 392                 ctf_integer(int, compress_type, ordered->compress_type)
 393                 ctf_integer(int, refs, atomic_read(&ordered->refs))
 394                 ctf_integer(u64, root_objectid,
 395                                 BTRFS_I(inode)->root->root_key.objectid)
 396         )
 397 )
 398 #endif
 399
 400 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
 401         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 402         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 403         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 404         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
 405 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
 406
 407         TP_PROTO(const struct inode *inode,
 408                  const struct btrfs_ordered_extent *ordered),
 409
 410         TP_ARGS(inode, ordered)
 411 )
 412
 413 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
 414
 415         TP_PROTO(const struct inode *inode,
 416                  const struct btrfs_ordered_extent *ordered),
 417
 418         TP_ARGS(inode, ordered)
 419 )
 420
 421 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
 422
 423         TP_PROTO(const struct inode *inode,
 424                  const struct btrfs_ordered_extent *ordered),
 425
 426         TP_ARGS(inode, ordered)
 427 )
 428
 429 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
 430
 431         TP_PROTO(const struct inode *inode,
 432                  const struct btrfs_ordered_extent *ordered),
 433
 434         TP_ARGS(inode, ordered)
 435 )
 436
 437 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
 438
 439         TP_PROTO(const struct page *page, const struct inode *inode,
 440                  const struct writeback_control *wbc),
 441
 442         TP_ARGS(page, inode, wbc),
 443
 444         TP_FIELDS(
 445                 ctf_integer(ino_t, ino, inode->i_ino)
 446                 ctf_integer(pgoff_t, index, page->index)
 447                 ctf_integer(long, nr_to_write, wbc->nr_to_write)
 448                 ctf_integer(long, pages_skipped, wbc->pages_skipped)
 449                 ctf_integer(loff_t, range_start, wbc->range_start)
 450                 ctf_integer(loff_t, range_end, wbc->range_end)
 451                 ctf_integer(char, for_kupdate, wbc->for_kupdate)
 452                 ctf_integer(char, for_reclaim, wbc->for_reclaim)
 453                 ctf_integer(char, range_cyclic, wbc->range_cyclic)
 454                 ctf_integer(pgoff_t, writeback_index,
 455                                 inode->i_mapping->writeback_index)
 456                 ctf_integer(u64, root_objectid,
 457                                 BTRFS_I(inode)->root->root_key.objectid)
 458         )
 459 )
 460
 461 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs__writepage,
 462
 463         __extent_writepage,
 464
 465         btrfs__extent_writepage,
 466
 467         TP_PROTO(const struct page *page, const struct inode *inode,
 468                  const struct writeback_control *wbc),
 469
 470         TP_ARGS(page, inode, wbc)
 471 )
 472
 473 LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook,
 474
 475         TP_PROTO(const struct page *page, u64 start, u64 end, int uptodate),
 476
 477         TP_ARGS(page, start, end, uptodate),
 478
 479         TP_FIELDS(
 480                 ctf_integer(ino_t, ino, page->mapping->host->i_ino)
 481                 ctf_integer(pgoff_t, index, page->index)
 482                 ctf_integer(u64, start, start)
 483                 ctf_integer(u64, end, end)
 484                 ctf_integer(int, uptodate, uptodate)
 485                 ctf_integer(u64, root_objectid,
 486                         BTRFS_I(page->mapping->host)->root->root_key.objectid)
 487         )
 488 )
 489
 490 LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
 491
 492         TP_PROTO(const struct file *file, int datasync),
 493
 494         TP_ARGS(file, datasync),
 495
 496         TP_FIELDS(
 497                 ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino)
 498                 ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino)
 499                 ctf_integer(int, datasync, datasync)
 500                 ctf_integer(u64, root_objectid,
 501                         BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
 502         )
 503 )
 504 #else
 505 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_add,
 506
 507         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 508
 509         TP_ARGS(inode, ordered)
 510 )
 511
 512 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_remove,
 513
 514         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 515
 516         TP_ARGS(inode, ordered)
 517 )
 518
 519 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_start,
 520
 521         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 522
 523         TP_ARGS(inode, ordered)
 524 )
 525
 526 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__ordered_extent, btrfs_ordered_extent_put,
 527
 528         TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
 529
 530         TP_ARGS(inode, ordered)
 531 )
 532
 533 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__writepage,
 534
 535         TP_PROTO(struct page *page, struct inode *inode,
 536                  struct writeback_control *wbc),
 537
 538         TP_ARGS(page, inode, wbc),
 539
 540         TP_FIELDS(
 541                 ctf_integer(ino_t, ino, inode->i_ino)
 542                 ctf_integer(pgoff_t, index, page->index)
 543                 ctf_integer(long, nr_to_write, wbc->nr_to_write)
 544                 ctf_integer(long, pages_skipped, wbc->pages_skipped)
 545                 ctf_integer(loff_t, range_start, wbc->range_start)
 546                 ctf_integer(loff_t, range_end, wbc->range_end)
 547 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
 548                 ctf_integer(char, nonblocking, wbc->nonblocking)
 549 #endif
 550                 ctf_integer(char, for_kupdate, wbc->for_kupdate)
 551                 ctf_integer(char, for_reclaim, wbc->for_reclaim)
 552                 ctf_integer(char, range_cyclic, wbc->range_cyclic)
 553                 ctf_integer(pgoff_t, writeback_index,
 554                                 inode->i_mapping->writeback_index)
 555                 ctf_integer(u64, root_objectid,
 556                                 BTRFS_I(inode)->root->root_key.objectid)
 557         )
 558 )
 559
 560 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs__writepage,
 561
 562         __extent_writepage,
 563
 564         btrfs__extent_writepage,
 565
 566         TP_PROTO(struct page *page, struct inode *inode,
 567                  struct writeback_control *wbc),
 568
 569         TP_ARGS(page, inode, wbc)
 570 )
 571
 572 LTTNG_TRACEPOINT_EVENT(btrfs_writepage_end_io_hook,
 573
 574         TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
 575
 576         TP_ARGS(page, start, end, uptodate),
 577
 578         TP_FIELDS(
 579                 ctf_integer(ino_t, ino, page->mapping->host->i_ino)
 580                 ctf_integer(pgoff_t, index, page->index)
 581                 ctf_integer(u64, start, start)
 582                 ctf_integer(u64, end, end)
 583                 ctf_integer(int, uptodate, uptodate)
 584                 ctf_integer(u64, root_objectid,
 585                         BTRFS_I(page->mapping->host)->root->root_key.objectid)
 586         )
 587 )
 588
 589 LTTNG_TRACEPOINT_EVENT(btrfs_sync_file,
 590
 591         TP_PROTO(struct file *file, int datasync),
 592
 593         TP_ARGS(file, datasync),
 594
 595         TP_FIELDS(
 596                 ctf_integer(ino_t, ino, file->f_path.dentry->d_inode->i_ino)
 597                 ctf_integer(ino_t, parent, file->f_path.dentry->d_parent->d_inode->i_ino)
 598                 ctf_integer(int, datasync, datasync)
 599                 ctf_integer(u64, root_objectid,
 600                         BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
 601         )
 602 )
 603 #endif
 604
 605 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
 606         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 607         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 608         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 609         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,4,103,7,0,0) || \
 610         LTTNG_SLE_KERNEL_RANGE(4,4,114,94,0,0, 4,4,114,95,0,0) || \
 611         LTTNG_SLE_KERNEL_RANGE(4,4,120,94,0,0, 4,4,120,95,0,0) || \
 612         LTTNG_SLE_KERNEL_RANGE(4,4,126,94,0,0, 4,5,0,0,0,0))
 613 LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
 614
 615         TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),
 616
 617         TP_ARGS(fs_info, wait),
 618
 619         TP_FIELDS(
 620                 ctf_integer(int, wait, wait)
 621         )
 622 )
 623 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 624 LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
 625
 626         TP_PROTO(struct btrfs_fs_info *fs_info, int wait),
 627
 628         TP_ARGS(fs_info, wait),
 629
 630         TP_FIELDS(
 631                 ctf_integer(int, wait, wait)
 632         )
 633 )
 634 #else
 635 LTTNG_TRACEPOINT_EVENT(btrfs_sync_fs,
 636
 637         TP_PROTO(int wait),
 638
 639         TP_ARGS(wait),
 640
 641         TP_FIELDS(
 642                 ctf_integer(int, wait, wait)
 643         )
 644 )
 645 #endif
 646
 647 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
 648 LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
 649
 650         TP_PROTO(const struct btrfs_fs_info *fs_info,
 651                  const struct btrfs_block_group *block_group, int create),
 652
 653         TP_ARGS(fs_info, block_group, create),
 654
 655         TP_FIELDS(
 656                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
 657                 ctf_integer(u64, offset, block_group->start)
 658                 ctf_integer(u64, size, block_group->length)
 659                 ctf_integer(u64, flags, block_group->flags)
 660                 ctf_integer(u64, bytes_used, block_group->used)
 661                 ctf_integer(u64, bytes_super, block_group->bytes_super)
 662                 ctf_integer(int, create, create)
 663         )
 664 )
 665 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
 666         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 667         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 668         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 669         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
 670 LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
 671
 672         TP_PROTO(const struct btrfs_fs_info *fs_info,
 673                  const struct btrfs_block_group_cache *block_group, int create),
 674
 675         TP_ARGS(fs_info, block_group, create),
 676
 677         TP_FIELDS(
 678                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
 679                 ctf_integer(u64, offset, block_group->key.objectid)
 680                 ctf_integer(u64, size, block_group->key.offset)
 681                 ctf_integer(u64, flags, block_group->flags)
 682                 ctf_integer(u64, bytes_used, btrfs_block_group_used(&block_group->item))
 683                 ctf_integer(u64, bytes_super, block_group->bytes_super)
 684                 ctf_integer(int, create, create)
 685         )
 686 )
 687 #else
 688 LTTNG_TRACEPOINT_EVENT(btrfs_add_block_group,
 689
 690         TP_PROTO(struct btrfs_fs_info *fs_info,
 691                 struct btrfs_block_group_cache *block_group, int create),
 692
 693         TP_ARGS(fs_info, block_group, create),
 694
 695         TP_FIELDS(
 696                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
 697                 ctf_integer(u64, offset, block_group->key.objectid)
 698                 ctf_integer(u64, size, block_group->key.offset)
 699                 ctf_integer(u64, flags, block_group->flags)
 700                 ctf_integer(u64, bytes_used, btrfs_block_group_used(&block_group->item))
 701                 ctf_integer(u64, bytes_super, block_group->bytes_super)
 702                 ctf_integer(int, create, create)
 703         )
 704 )
 705 #endif
 706
 707 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
 708 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
 709
 710         TP_PROTO(const struct btrfs_fs_info *fs_info,
 711                  const struct btrfs_delayed_ref_node *ref,
 712                  const struct btrfs_delayed_tree_ref *full_ref,
 713                  int action),
 714
 715         TP_ARGS(fs_info, ref, full_ref, action),
 716
 717         TP_FIELDS(
 718                 ctf_integer(u64, bytenr, ref->bytenr)
 719                 ctf_integer(u64, num_bytes, ref->num_bytes)
 720                 ctf_integer(int, action, action)
 721                 ctf_integer(u64, parent, full_ref->parent)
 722                 ctf_integer(u64, ref_root, full_ref->root)
 723                 ctf_integer(int, level, full_ref->level)
 724                 ctf_integer(int, type, ref->type)
 725                 ctf_integer(u64, seq, ref->seq)
 726         )
 727 )
 728 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 729 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
 730
 731         TP_PROTO(struct btrfs_fs_info *fs_info,
 732                  struct btrfs_delayed_ref_node *ref,
 733                  struct btrfs_delayed_tree_ref *full_ref,
 734                  int action),
 735
 736         TP_ARGS(fs_info, ref, full_ref, action),
 737
 738         TP_FIELDS(
 739                 ctf_integer(u64, bytenr, ref->bytenr)
 740                 ctf_integer(u64, num_bytes, ref->num_bytes)
 741                 ctf_integer(int, action, action)
 742                 ctf_integer(u64, parent, full_ref->parent)
 743                 ctf_integer(u64, ref_root, full_ref->root)
 744                 ctf_integer(int, level, full_ref->level)
 745                 ctf_integer(int, type, ref->type)
 746                 ctf_integer(u64, seq, ref->seq)
 747         )
 748 )
 749 #else
 750 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_tree_ref,
 751
 752         TP_PROTO(struct btrfs_delayed_ref_node *ref,
 753                  struct btrfs_delayed_tree_ref *full_ref,
 754                  int action),
 755
 756         TP_ARGS(ref, full_ref, action),
 757
 758         TP_FIELDS(
 759                 ctf_integer(u64, bytenr, ref->bytenr)
 760                 ctf_integer(u64, num_bytes, ref->num_bytes)
 761                 ctf_integer(int, action, action)
 762                 ctf_integer(u64, parent, full_ref->parent)
 763                 ctf_integer(u64, ref_root, full_ref->root)
 764                 ctf_integer(int, level, full_ref->level)
 765                 ctf_integer(int, type, ref->type)
 766 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
 767                 ctf_integer(u64, seq, ref->seq)
 768 #endif
 769         )
 770 )
 771 #endif
 772
 773 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_data_ref,
 774
 775         TP_PROTO(struct btrfs_delayed_ref_node *ref,
 776                  struct btrfs_delayed_data_ref *full_ref,
 777                  int action),
 778
 779         TP_ARGS(ref, full_ref, action),
 780
 781         TP_FIELDS(
 782                 ctf_integer(u64, bytenr, ref->bytenr)
 783                 ctf_integer(u64, num_bytes, ref->num_bytes)
 784                 ctf_integer(int, action, action)
 785                 ctf_integer(u64, parent, full_ref->parent)
 786                 ctf_integer(u64, ref_root, full_ref->root)
 787                 ctf_integer(u64, owner, full_ref->objectid)
 788                 ctf_integer(u64, offset, full_ref->offset)
 789                 ctf_integer(int, type, ref->type)
 790 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
 791                 ctf_integer(u64, seq, ref->seq)
 792 #endif
 793         )
 794 )
 795
 796 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,15,0))
 797 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
 798
 799         TP_PROTO(const struct btrfs_fs_info *fs_info,
 800                  const struct btrfs_delayed_ref_head *head_ref,
 801                  int action),
 802
 803         TP_ARGS(fs_info, head_ref, action),
 804
 805         TP_FIELDS(
 806                 ctf_integer(u64, bytenr, head_ref->bytenr)
 807                 ctf_integer(u64, num_bytes, head_ref->num_bytes)
 808                 ctf_integer(int, action, action)
 809                 ctf_integer(int, is_data, head_ref->is_data)
 810         )
 811 )
 812
 813 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 814
 815         add_delayed_ref_head,
 816
 817         btrfs_add_delayed_ref_head,
 818
 819         TP_PROTO(const struct btrfs_fs_info *fs_info,
 820                  const struct btrfs_delayed_ref_head *head_ref,
 821                  int action),
 822
 823         TP_ARGS(fs_info, head_ref, action)
 824 )
 825
 826 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 827
 828         run_delayed_ref_head,
 829
 830         btrfs_run_delayed_ref_head,
 831
 832         TP_PROTO(const struct btrfs_fs_info *fs_info,
 833                  const struct btrfs_delayed_ref_head *head_ref,
 834                  int action),
 835
 836         TP_ARGS(fs_info, head_ref, action)
 837 )
 838
 839 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
 840         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
 841         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
 842         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
 843         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,4,103,7,0,0) || \
 844         LTTNG_SLE_KERNEL_RANGE(4,4,114,94,0,0, 4,4,114,95,0,0) || \
 845         LTTNG_SLE_KERNEL_RANGE(4,4,120,94,0,0, 4,4,120,95,0,0) || \
 846         LTTNG_SLE_KERNEL_RANGE(4,4,126,94,0,0, 4,5,0,0,0,0))
 847
 848 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
 849
 850         TP_PROTO(const struct btrfs_fs_info *fs_info,
 851                  const struct btrfs_delayed_ref_node *ref,
 852                  const struct btrfs_delayed_ref_head *head_ref,
 853                  int action),
 854
 855         TP_ARGS(fs_info, ref, head_ref, action),
 856
 857         TP_FIELDS(
 858                 ctf_integer(u64, bytenr, ref->bytenr)
 859                 ctf_integer(u64, num_bytes, ref->num_bytes)
 860                 ctf_integer(int, action, action)
 861                 ctf_integer(int, is_data, head_ref->is_data)
 862         )
 863 )
 864
 865 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 866
 867         add_delayed_ref_head,
 868
 869         btrfs_add_delayed_ref_head,
 870
 871         TP_PROTO(const struct btrfs_fs_info *fs_info,
 872                  const struct btrfs_delayed_ref_node *ref,
 873                  const struct btrfs_delayed_ref_head *head_ref,
 874                  int action),
 875
 876         TP_ARGS(fs_info, ref, head_ref, action)
 877 )
 878
 879 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 880
 881         run_delayed_ref_head,
 882
 883         btrfs_run_delayed_ref_head,
 884
 885         TP_PROTO(const struct btrfs_fs_info *fs_info,
 886                  const struct btrfs_delayed_ref_node *ref,
 887                  const struct btrfs_delayed_ref_head *head_ref,
 888                  int action),
 889
 890         TP_ARGS(fs_info, ref, head_ref, action)
 891 )
 892
 893 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,8,0))
 894 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
 895
 896         TP_PROTO(struct btrfs_fs_info *fs_info,
 897                  struct btrfs_delayed_ref_node *ref,
 898                  struct btrfs_delayed_ref_head *head_ref,
 899                  int action),
 900
 901         TP_ARGS(fs_info, ref, head_ref, action),
 902
 903         TP_FIELDS(
 904                 ctf_integer(u64, bytenr, ref->bytenr)
 905                 ctf_integer(u64, num_bytes, ref->num_bytes)
 906                 ctf_integer(int, action, action)
 907                 ctf_integer(int, is_data, head_ref->is_data)
 908         )
 909 )
 910
 911 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 912
 913         add_delayed_ref_head,
 914
 915         btrfs_add_delayed_ref_head,
 916
 917         TP_PROTO(struct btrfs_fs_info *fs_info,
 918                  struct btrfs_delayed_ref_node *ref,
 919                  struct btrfs_delayed_ref_head *head_ref,
 920                  int action),
 921
 922         TP_ARGS(fs_info, ref, head_ref, action)
 923 )
 924
 925 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 926
 927         run_delayed_ref_head,
 928
 929         btrfs_run_delayed_ref_head,
 930
 931         TP_PROTO(struct btrfs_fs_info *fs_info,
 932                  struct btrfs_delayed_ref_node *ref,
 933                  struct btrfs_delayed_ref_head *head_ref,
 934                  int action),
 935
 936         TP_ARGS(fs_info, ref, head_ref, action)
 937 )
 938
 939 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,103,92,0,0, 4,5,0,0,0,0))
 940 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
 941
 942         TP_PROTO(const struct btrfs_delayed_ref_node *ref,
 943                  const struct btrfs_delayed_ref_head *head_ref,
 944                  int action),
 945
 946         TP_ARGS(ref, head_ref, action),
 947
 948         TP_FIELDS(
 949                 ctf_integer(u64, bytenr, ref->bytenr)
 950                 ctf_integer(u64, num_bytes, ref->num_bytes)
 951                 ctf_integer(int, action, action)
 952                 ctf_integer(int, is_data, head_ref->is_data)
 953         )
 954 )
 955
 956 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 957
 958         add_delayed_ref_head,
 959
 960         btrfs_add_delayed_ref_head,
 961
 962         TP_PROTO(const struct btrfs_delayed_ref_node *ref,
 963                  const struct btrfs_delayed_ref_head *head_ref,
 964                  int action),
 965
 966         TP_ARGS(ref, head_ref, action)
 967 )
 968
 969 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
 970
 971         run_delayed_ref_head,
 972
 973         btrfs_run_delayed_ref_head,
 974
 975         TP_PROTO(const struct btrfs_delayed_ref_node *ref,
 976                  const struct btrfs_delayed_ref_head *head_ref,
 977                  int action),
 978
 979         TP_ARGS(ref, head_ref, action)
 980 )
 981
 982 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
 983 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs_delayed_ref_head,
 984
 985         TP_PROTO(struct btrfs_delayed_ref_node *ref,
 986                  struct btrfs_delayed_ref_head *head_ref,
 987                  int action),
 988
 989         TP_ARGS(ref, head_ref, action),
 990
 991         TP_FIELDS(
 992                 ctf_integer(u64, bytenr, ref->bytenr)
 993                 ctf_integer(u64, num_bytes, ref->num_bytes)
 994                 ctf_integer(int, action, action)
 995                 ctf_integer(int, is_data, head_ref->is_data)
 996         )
 997 )
 998
 999 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
1000
1001         add_delayed_ref_head,
1002
1003         btrfs_add_delayed_ref_head,
1004
1005         TP_PROTO(struct btrfs_delayed_ref_node *ref,
1006                  struct btrfs_delayed_ref_head *head_ref,
1007                  int action),
1008
1009         TP_ARGS(ref, head_ref, action)
1010 )
1011
1012 LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(btrfs_delayed_ref_head,
1013
1014         run_delayed_ref_head,
1015
1016         btrfs_run_delayed_ref_head,
1017
1018         TP_PROTO(struct btrfs_delayed_ref_node *ref,
1019                  struct btrfs_delayed_ref_head *head_ref,
1020                  int action),
1021
1022         TP_ARGS(ref, head_ref, action)
1023 )
1024
1025 #else
1026 LTTNG_TRACEPOINT_EVENT(btrfs_delayed_ref_head,
1027
1028         TP_PROTO(struct btrfs_delayed_ref_node *ref,
1029                  struct btrfs_delayed_ref_head *head_ref,
1030                  int action),
1031
1032         TP_ARGS(ref, head_ref, action),
1033
1034         TP_FIELDS(
1035                 ctf_integer(u64, bytenr, ref->bytenr)
1036                 ctf_integer(u64, num_bytes, ref->num_bytes)
1037                 ctf_integer(int, action, action)
1038                 ctf_integer(int, is_data, head_ref->is_data)
1039         )
1040 )
1041 #endif
1042
1043 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1044
1045 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
1046
1047         TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
1048                  u64 offset, u64 size),
1049
1050         TP_ARGS(fs_info, map, offset, size),
1051
1052         TP_FIELDS(
1053                 ctf_integer(int, num_stripes, map->num_stripes)
1054                 ctf_integer(u64, type, map->type)
1055                 ctf_integer(int, sub_stripes, map->sub_stripes)
1056                 ctf_integer(u64, offset, offset)
1057                 ctf_integer(u64, size, size)
1058                 ctf_integer(u64, root_objectid, fs_info->chunk_root->root_key.objectid)
1059         )
1060 )
1061
1062 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_alloc,
1063
1064         TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
1065                  u64 offset, u64 size),
1066
1067         TP_ARGS(fs_info, map, offset, size)
1068 )
1069
1070 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
1071
1072         TP_PROTO(const struct btrfs_fs_info *fs_info, const struct map_lookup *map,
1073                  u64 offset, u64 size),
1074
1075         TP_ARGS(fs_info, map, offset, size)
1076 )
1077
1078 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
1079
1080 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
1081
1082         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
1083                  u64 offset, u64 size),
1084
1085         TP_ARGS(fs_info, map, offset, size),
1086
1087         TP_FIELDS(
1088                 ctf_integer(int, num_stripes, map->num_stripes)
1089                 ctf_integer(u64, type, map->type)
1090                 ctf_integer(int, sub_stripes, map->sub_stripes)
1091                 ctf_integer(u64, offset, offset)
1092                 ctf_integer(u64, size, size)
1093                 ctf_integer(u64, root_objectid, fs_info->chunk_root->root_key.objectid)
1094         )
1095 )
1096
1097 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_alloc,
1098
1099         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
1100                  u64 offset, u64 size),
1101
1102         TP_ARGS(fs_info, map, offset, size)
1103 )
1104
1105 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
1106
1107         TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
1108                  u64 offset, u64 size),
1109
1110         TP_ARGS(fs_info, map, offset, size)
1111 )
1112
1113 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1114         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1115         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1116         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1117
1118 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
1119
1120         TP_PROTO(const struct btrfs_root *root, const struct map_lookup *map,
1121                  u64 offset, u64 size),
1122
1123         TP_ARGS(root, map, offset, size),
1124
1125         TP_FIELDS(
1126                 ctf_integer(int, num_stripes, map->num_stripes)
1127                 ctf_integer(u64, type, map->type)
1128                 ctf_integer(int, sub_stripes, map->sub_stripes)
1129                 ctf_integer(u64, offset, offset)
1130                 ctf_integer(u64, size, size)
1131                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1132         )
1133 )
1134
1135 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_alloc,
1136
1137         TP_PROTO(const struct btrfs_root *root, const struct map_lookup *map,
1138                  u64 offset, u64 size),
1139
1140         TP_ARGS(root, map, offset, size)
1141 )
1142
1143 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
1144
1145         TP_PROTO(const struct btrfs_root *root, const struct map_lookup *map,
1146                  u64 offset, u64 size),
1147
1148         TP_ARGS(root, map, offset, size)
1149 )
1150
1151 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
1152
1153 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__chunk,
1154
1155         TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
1156                  u64 offset, u64 size),
1157
1158         TP_ARGS(root, map, offset, size),
1159
1160         TP_FIELDS(
1161                 ctf_integer(int, num_stripes, map->num_stripes)
1162                 ctf_integer(u64, type, map->type)
1163                 ctf_integer(int, sub_stripes, map->sub_stripes)
1164                 ctf_integer(u64, offset, offset)
1165                 ctf_integer(u64, size, size)
1166                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1167         )
1168 )
1169
1170 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_alloc,
1171
1172         TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
1173                  u64 offset, u64 size),
1174
1175         TP_ARGS(root, map, offset, size)
1176 )
1177
1178 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__chunk,  btrfs_chunk_free,
1179
1180         TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
1181                  u64 offset, u64 size),
1182
1183         TP_ARGS(root, map, offset, size)
1184 )
1185
1186 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
1187
1188 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
1189         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1190         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1191         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1192         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1193 LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
1194
1195         TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf,
1196                  const struct extent_buffer *cow),
1197
1198         TP_ARGS(root, buf, cow),
1199
1200         TP_FIELDS(
1201                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1202                 ctf_integer(u64, buf_start, buf->start)
1203                 ctf_integer(int, refs, atomic_read(&buf->refs))
1204                 ctf_integer(u64, cow_start, cow->start)
1205                 ctf_integer(int, buf_level, btrfs_header_level(buf))
1206                 ctf_integer(int, cow_level, btrfs_header_level(cow))
1207         )
1208 )
1209 #else
1210 LTTNG_TRACEPOINT_EVENT(btrfs_cow_block,
1211
1212         TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
1213                  struct extent_buffer *cow),
1214
1215         TP_ARGS(root, buf, cow),
1216
1217         TP_FIELDS(
1218                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1219                 ctf_integer(u64, buf_start, buf->start)
1220                 ctf_integer(int, refs, atomic_read(&buf->refs))
1221                 ctf_integer(u64, cow_start, cow->start)
1222                 ctf_integer(int, buf_level, btrfs_header_level(buf))
1223                 ctf_integer(int, cow_level, btrfs_header_level(cow))
1224         )
1225 )
1226 #endif
1227
1228 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
1229         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1230         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1231         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1232         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1233 LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
1234
1235         TP_PROTO(const struct btrfs_fs_info *fs_info, char *type, u64 val,
1236                  u64 bytes, int reserve),
1237
1238         TP_ARGS(fs_info, type, val, bytes, reserve),
1239
1240         TP_FIELDS(
1241                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1242                 ctf_string(type, type)
1243                 ctf_integer(u64, val, val)
1244                 ctf_integer(u64, bytes, bytes)
1245                 ctf_integer(int, reserve, reserve)
1246         )
1247 )
1248 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
1249 LTTNG_TRACEPOINT_EVENT(btrfs_space_reservation,
1250
1251         TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
1252                  u64 bytes, int reserve),
1253
1254         TP_ARGS(fs_info, type, val, bytes, reserve),
1255
1256         TP_FIELDS(
1257                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1258                 ctf_string(type, type)
1259                 ctf_integer(u64, val, val)
1260                 ctf_integer(u64, bytes, bytes)
1261                 ctf_integer(int, reserve, reserve)
1262         )
1263 )
1264 #endif
1265
1266 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1267
1268 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
1269
1270         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1271
1272         TP_ARGS(fs_info, start, len),
1273
1274         TP_FIELDS(
1275                 ctf_integer(u64, start, start)
1276                 ctf_integer(u64, len, len)
1277         )
1278 )
1279
1280 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
1281
1282         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1283
1284         TP_ARGS(fs_info, start, len)
1285 )
1286
1287 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_free,
1288
1289         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1290
1291         TP_ARGS(fs_info, start, len)
1292 )
1293
1294 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
1295
1296 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
1297
1298         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
1299
1300         TP_ARGS(fs_info, start, len),
1301
1302         TP_FIELDS(
1303                 ctf_integer(u64, start, start)
1304                 ctf_integer(u64, len, len)
1305         )
1306 )
1307
1308 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
1309
1310         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
1311
1312         TP_ARGS(fs_info, start, len)
1313 )
1314
1315 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_free,
1316
1317         TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
1318
1319         TP_ARGS(fs_info, start, len)
1320 )
1321
1322 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1323         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1324         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1325         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1326
1327 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
1328
1329         TP_PROTO(const struct btrfs_root *root, u64 start, u64 len),
1330
1331         TP_ARGS(root, start, len),
1332
1333         TP_FIELDS(
1334                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1335                 ctf_integer(u64, start, start)
1336                 ctf_integer(u64, len, len)
1337         )
1338 )
1339
1340 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
1341
1342         TP_PROTO(const struct btrfs_root *root, u64 start, u64 len),
1343
1344         TP_ARGS(root, start, len)
1345 )
1346
1347 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_free,
1348
1349         TP_PROTO(const struct btrfs_root *root, u64 start, u64 len),
1350
1351         TP_ARGS(root, start, len)
1352 )
1353
1354 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
1355
1356 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserved_extent,
1357
1358         TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
1359
1360         TP_ARGS(root, start, len),
1361
1362         TP_FIELDS(
1363                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1364                 ctf_integer(u64, start, start)
1365                 ctf_integer(u64, len, len)
1366         )
1367 )
1368
1369 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
1370
1371         TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
1372
1373         TP_ARGS(root, start, len)
1374 )
1375
1376 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserved_extent,  btrfs_reserved_extent_free,
1377
1378         TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
1379
1380         TP_ARGS(root, start, len)
1381 )
1382
1383 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
1384
1385 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
1386 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1387
1388         btrfs_find_free_extent,
1389
1390         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
1391                  u64 data),
1392
1393         TP_ARGS(fs_info, num_bytes, empty_size, data),
1394
1395         TP_FIELDS(
1396                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1397                 ctf_integer(u64, num_bytes, num_bytes)
1398                 ctf_integer(u64, empty_size, empty_size)
1399                 ctf_integer(u64, data, data)
1400         )
1401 )
1402
1403 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1404
1405         TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
1406                  u64 len),
1407
1408         TP_ARGS(block_group, start, len),
1409
1410         TP_FIELDS(
1411                 ctf_array(u8, fsid, block_group->lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1412                 ctf_integer(u64, bg_objectid, block_group->start)
1413                 ctf_integer(u64, flags, block_group->flags)
1414                 ctf_integer(u64, start, start)
1415                 ctf_integer(u64, len, len)
1416         )
1417 )
1418
1419 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1420
1421         TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
1422                  u64 len),
1423
1424         TP_ARGS(block_group, start, len)
1425 )
1426
1427 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1428
1429         TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
1430                  u64 len),
1431
1432         TP_ARGS(block_group, start, len)
1433 )
1434
1435 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,18,0))
1436 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1437
1438         btrfs_find_free_extent,
1439
1440         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
1441                  u64 data),
1442
1443         TP_ARGS(fs_info, num_bytes, empty_size, data),
1444
1445         TP_FIELDS(
1446                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1447                 ctf_integer(u64, num_bytes, num_bytes)
1448                 ctf_integer(u64, empty_size, empty_size)
1449                 ctf_integer(u64, data, data)
1450         )
1451 )
1452
1453 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1454
1455         TP_PROTO(const struct btrfs_block_group_cache *block_group, u64 start,
1456                  u64 len),
1457
1458         TP_ARGS(block_group, start, len),
1459
1460         TP_FIELDS(
1461                 ctf_array(u8, fsid, block_group->lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1462                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1463                 ctf_integer(u64, flags, block_group->flags)
1464                 ctf_integer(u64, start, start)
1465                 ctf_integer(u64, len, len)
1466         )
1467 )
1468
1469 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1470
1471         TP_PROTO(const struct btrfs_block_group_cache *block_group, u64 start,
1472                  u64 len),
1473
1474         TP_ARGS(block_group, start, len)
1475 )
1476
1477 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1478
1479         TP_PROTO(const struct btrfs_block_group_cache *block_group, u64 start,
1480                  u64 len),
1481
1482         TP_ARGS(block_group, start, len)
1483 )
1484
1485 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0))
1486 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1487
1488         btrfs_find_free_extent,
1489
1490         TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
1491                  u64 data),
1492
1493         TP_ARGS(fs_info, num_bytes, empty_size, data),
1494
1495         TP_FIELDS(
1496                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1497                 ctf_integer(u64, num_bytes, num_bytes)
1498                 ctf_integer(u64, empty_size, empty_size)
1499                 ctf_integer(u64, data, data)
1500         )
1501 )
1502
1503 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1504
1505         TP_PROTO(const struct btrfs_fs_info *fs_info,
1506                  const struct btrfs_block_group_cache *block_group, u64 start,
1507                  u64 len),
1508
1509         TP_ARGS(fs_info, block_group, start, len),
1510
1511         TP_FIELDS(
1512                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1513                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1514                 ctf_integer(u64, flags, block_group->flags)
1515                 ctf_integer(u64, start, start)
1516                 ctf_integer(u64, len, len)
1517         )
1518 )
1519
1520 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1521
1522         TP_PROTO(const struct btrfs_fs_info *fs_info,
1523                  const struct btrfs_block_group_cache *block_group, u64 start,
1524                  u64 len),
1525
1526         TP_ARGS(fs_info, block_group, start, len)
1527 )
1528
1529 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1530
1531         TP_PROTO(const struct btrfs_fs_info *fs_info,
1532                  const struct btrfs_block_group_cache *block_group, u64 start,
1533                  u64 len),
1534
1535         TP_ARGS(fs_info, block_group, start, len)
1536 )
1537
1538 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))
1539
1540 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1541
1542         btrfs_find_free_extent,
1543
1544         TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
1545                  u64 data),
1546
1547         TP_ARGS(fs_info, num_bytes, empty_size, data),
1548
1549         TP_FIELDS(
1550                 ctf_array(u8, fsid, lttng_fs_info_fsid, BTRFS_UUID_SIZE)
1551                 ctf_integer(u64, num_bytes, num_bytes)
1552                 ctf_integer(u64, empty_size, empty_size)
1553                 ctf_integer(u64, data, data)
1554         )
1555 )
1556
1557 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1558
1559         TP_PROTO(struct btrfs_fs_info *fs_info,
1560                  struct btrfs_block_group_cache *block_group, u64 start,
1561                  u64 len),
1562
1563         TP_ARGS(fs_info, block_group, start, len),
1564
1565         TP_FIELDS(
1566                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1567                 ctf_integer(u64, flags, block_group->flags)
1568                 ctf_integer(u64, start, start)
1569                 ctf_integer(u64, len, len)
1570         )
1571 )
1572
1573 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1574
1575         TP_PROTO(struct btrfs_fs_info *fs_info,
1576                  struct btrfs_block_group_cache *block_group, u64 start,
1577                  u64 len),
1578
1579         TP_ARGS(fs_info, block_group, start, len)
1580 )
1581
1582 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1583
1584         TP_PROTO(struct btrfs_fs_info *fs_info,
1585                  struct btrfs_block_group_cache *block_group, u64 start,
1586                  u64 len),
1587
1588         TP_ARGS(fs_info, block_group, start, len)
1589 )
1590 #elif (LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1591         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1592         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1593         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1594
1595 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1596
1597         btrfs_find_free_extent,
1598
1599         TP_PROTO(const struct btrfs_root *root, u64 num_bytes, u64 empty_size,
1600                  u64 data),
1601
1602         TP_ARGS(root, num_bytes, empty_size, data),
1603
1604         TP_FIELDS(
1605                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1606                 ctf_integer(u64, num_bytes, num_bytes)
1607                 ctf_integer(u64, empty_size, empty_size)
1608                 ctf_integer(u64, data, data)
1609         )
1610 )
1611
1612 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1613
1614         TP_PROTO(const struct btrfs_root *root,
1615                  const struct btrfs_block_group_cache *block_group, u64 start,
1616                  u64 len),
1617
1618         TP_ARGS(root, block_group, start, len),
1619
1620         TP_FIELDS(
1621                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1622                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1623                 ctf_integer(u64, flags, block_group->flags)
1624                 ctf_integer(u64, start, start)
1625                 ctf_integer(u64, len, len)
1626         )
1627 )
1628
1629 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1630
1631         TP_PROTO(const struct btrfs_root *root,
1632                  const struct btrfs_block_group_cache *block_group, u64 start,
1633                  u64 len),
1634
1635         TP_ARGS(root, block_group, start, len)
1636 )
1637
1638 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1639
1640         TP_PROTO(const struct btrfs_root *root,
1641                  const struct btrfs_block_group_cache *block_group, u64 start,
1642                  u64 len),
1643
1644         TP_ARGS(root, block_group, start, len)
1645 )
1646
1647 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
1648
1649 LTTNG_TRACEPOINT_EVENT_MAP(find_free_extent,
1650
1651         btrfs_find_free_extent,
1652
1653         TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
1654                  u64 data),
1655
1656         TP_ARGS(root, num_bytes, empty_size, data),
1657
1658         TP_FIELDS(
1659                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1660                 ctf_integer(u64, num_bytes, num_bytes)
1661                 ctf_integer(u64, empty_size, empty_size)
1662                 ctf_integer(u64, data, data)
1663         )
1664 )
1665
1666 LTTNG_TRACEPOINT_EVENT_CLASS(btrfs__reserve_extent,
1667
1668         TP_PROTO(struct btrfs_root *root,
1669                  struct btrfs_block_group_cache *block_group, u64 start,
1670                  u64 len),
1671
1672         TP_ARGS(root, block_group, start, len),
1673
1674         TP_FIELDS(
1675                 ctf_integer(u64, root_objectid, root->root_key.objectid)
1676                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1677                 ctf_integer(u64, flags, block_group->flags)
1678                 ctf_integer(u64, start, start)
1679                 ctf_integer(u64, len, len)
1680         )
1681 )
1682
1683 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent,
1684
1685         TP_PROTO(struct btrfs_root *root,
1686                  struct btrfs_block_group_cache *block_group, u64 start,
1687                  u64 len),
1688
1689         TP_ARGS(root, block_group, start, len)
1690 )
1691
1692 LTTNG_TRACEPOINT_EVENT_INSTANCE(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1693
1694         TP_PROTO(struct btrfs_root *root,
1695                  struct btrfs_block_group_cache *block_group, u64 start,
1696                  u64 len),
1697
1698         TP_ARGS(root, block_group, start, len)
1699 )
1700
1701 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)) */
1702
1703 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,5,0))
1704 LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
1705
1706         TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
1707                  u64 bytes, u64 empty_size, u64 min_bytes),
1708
1709         TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1710
1711         TP_FIELDS(
1712                 ctf_integer(u64, bg_objectid, block_group->start)
1713                 ctf_integer(u64, flags, block_group->flags)
1714                 ctf_integer(u64, start, start)
1715                 ctf_integer(u64, bytes, bytes)
1716                 ctf_integer(u64, empty_size, empty_size)
1717                 ctf_integer(u64, min_bytes, min_bytes)
1718         )
1719 )
1720
1721 LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup,
1722
1723         TP_PROTO(const struct btrfs_block_group *block_group),
1724
1725         TP_ARGS(block_group),
1726
1727         TP_FIELDS(
1728                 ctf_integer(u64, bg_objectid, block_group->start)
1729         )
1730 )
1731
1732 LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
1733
1734         TP_PROTO(const struct btrfs_block_group *block_group,
1735                  const struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1736
1737         TP_ARGS(block_group, cluster, size, bitmap),
1738
1739         TP_FIELDS(
1740                 ctf_integer(u64, bg_objectid, block_group->start)
1741                 ctf_integer(u64, flags, block_group->flags)
1742                 ctf_integer(u64, start, cluster->window_start)
1743                 ctf_integer(u64, max_size, cluster->max_size)
1744                 ctf_integer(u64, size, size)
1745                 ctf_integer(int, bitmap, bitmap)
1746         )
1747 )
1748 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
1749         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1750         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1751         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1752         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1753 LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
1754
1755         TP_PROTO(const struct btrfs_block_group_cache *block_group, u64 start,
1756                  u64 bytes, u64 empty_size, u64 min_bytes),
1757
1758         TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1759
1760         TP_FIELDS(
1761                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1762                 ctf_integer(u64, flags, block_group->flags)
1763                 ctf_integer(u64, start, start)
1764                 ctf_integer(u64, bytes, bytes)
1765                 ctf_integer(u64, empty_size, empty_size)
1766                 ctf_integer(u64, min_bytes, min_bytes)
1767         )
1768 )
1769
1770 LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup,
1771
1772         TP_PROTO(const struct btrfs_block_group_cache *block_group),
1773
1774         TP_ARGS(block_group),
1775
1776         TP_FIELDS(
1777                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1778         )
1779 )
1780
1781 LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
1782
1783         TP_PROTO(const struct btrfs_block_group_cache *block_group,
1784                  const struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1785
1786         TP_ARGS(block_group, cluster, size, bitmap),
1787
1788         TP_FIELDS(
1789                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1790                 ctf_integer(u64, flags, block_group->flags)
1791                 ctf_integer(u64, start, cluster->window_start)
1792                 ctf_integer(u64, max_size, cluster->max_size)
1793                 ctf_integer(u64, size, size)
1794                 ctf_integer(int, bitmap, bitmap)
1795         )
1796 )
1797 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
1798 LTTNG_TRACEPOINT_EVENT(btrfs_find_cluster,
1799
1800         TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
1801                  u64 bytes, u64 empty_size, u64 min_bytes),
1802
1803         TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1804
1805         TP_FIELDS(
1806                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1807                 ctf_integer(u64, flags, block_group->flags)
1808                 ctf_integer(u64, start, start)
1809                 ctf_integer(u64, bytes, bytes)
1810                 ctf_integer(u64, empty_size, empty_size)
1811                 ctf_integer(u64, min_bytes, min_bytes)
1812         )
1813 )
1814
1815 LTTNG_TRACEPOINT_EVENT(btrfs_failed_cluster_setup,
1816
1817         TP_PROTO(struct btrfs_block_group_cache *block_group),
1818
1819         TP_ARGS(block_group),
1820
1821         TP_FIELDS(
1822                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1823         )
1824 )
1825
1826 LTTNG_TRACEPOINT_EVENT(btrfs_setup_cluster,
1827
1828         TP_PROTO(struct btrfs_block_group_cache *block_group,
1829                  struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1830
1831         TP_ARGS(block_group, cluster, size, bitmap),
1832
1833         TP_FIELDS(
1834                 ctf_integer(u64, bg_objectid, block_group->key.objectid)
1835                 ctf_integer(u64, flags, block_group->flags)
1836                 ctf_integer(u64, start, cluster->window_start)
1837                 ctf_integer(u64, max_size, cluster->max_size)
1838                 ctf_integer(u64, size, size)
1839                 ctf_integer(int, bitmap, bitmap)
1840         )
1841 )
1842 #endif
1843
1844 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,14,0) || \
1845         LTTNG_SLE_KERNEL_RANGE(4,4,73,5,0,0, 4,4,73,6,0,0) || \
1846         LTTNG_SLE_KERNEL_RANGE(4,4,82,6,0,0, 4,4,82,7,0,0) || \
1847         LTTNG_SLE_KERNEL_RANGE(4,4,92,6,0,0, 4,4,92,7,0,0) || \
1848         LTTNG_SLE_KERNEL_RANGE(4,4,103,6,0,0, 4,5,0,0,0,0))
1849 LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state,
1850
1851         btrfs_alloc_extent_state,
1852
1853         TP_PROTO(const struct extent_state *state, gfp_t mask, unsigned long IP),
1854
1855         TP_ARGS(state, mask, IP),
1856
1857         TP_FIELDS(
1858                 ctf_integer_hex(const struct extent_state *, state, state)
1859                 ctf_integer(gfp_t, mask, mask)
1860                 ctf_integer(unsigned long, ip, IP)
1861         )
1862 )
1863
1864 LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state,
1865
1866         btrfs_free_extent_state,
1867
1868         TP_PROTO(const struct extent_state *state, unsigned long IP),
1869
1870         TP_ARGS(state, IP),
1871
1872         TP_FIELDS(
1873                 ctf_integer_hex(const struct extent_state *, state, state)
1874                 ctf_integer(unsigned long, ip, IP)
1875         )
1876 )
1877 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
1878 LTTNG_TRACEPOINT_EVENT_MAP(alloc_extent_state,
1879
1880         btrfs_alloc_extent_state,
1881
1882         TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
1883
1884         TP_ARGS(state, mask, IP),
1885
1886         TP_FIELDS(
1887                 ctf_integer_hex(struct extent_state *, state, state)
1888                 ctf_integer(gfp_t, mask, mask)
1889                 ctf_integer(unsigned long, ip, IP)
1890         )
1891 )
1892
1893 LTTNG_TRACEPOINT_EVENT_MAP(free_extent_state,
1894
1895         btrfs_free_extent_state,
1896
1897         TP_PROTO(struct extent_state *state, unsigned long IP),
1898
1899         TP_ARGS(state, IP),
1900
1901         TP_FIELDS(
1902                 ctf_integer_hex(struct extent_state *, state, state)
1903                 ctf_integer(unsigned long, ip, IP)
1904         )
1905 )
1906 #endif
1907
1908 #endif /* LTTNG_TRACE_BTRFS_H */
1909
1910 /* This part must be outside protection */
1911 #include <probes/define_trace.h>