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