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