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