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