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