fs/btrfs/ctree.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 2007 Oracle.  All rights reserved.
   4  */
   5
   6 #ifndef BTRFS_CTREE_H
   7 #define BTRFS_CTREE_H
   8
   9 #include <linux/mm.h>
  10 #include <linux/sched/signal.h>
  11 #include <linux/highmem.h>
  12 #include <linux/fs.h>
  13 #include <linux/rwsem.h>
  14 #include <linux/semaphore.h>
  15 #include <linux/completion.h>
  16 #include <linux/backing-dev.h>
  17 #include <linux/wait.h>
  18 #include <linux/slab.h>
  19 #include <trace/events/btrfs.h>
  20 #include <asm/unaligned.h>
  21 #include <linux/pagemap.h>
  22 #include <linux/btrfs.h>
  23 #include <linux/btrfs_tree.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/security.h>
  26 #include <linux/sizes.h>
  27 #include <linux/dynamic_debug.h>
  28 #include <linux/refcount.h>
  29 #include <linux/crc32c.h>
  30 #include <linux/iomap.h>
  31 #include "extent-io-tree.h"
  32 #include "extent_io.h"
  33 #include "extent_map.h"
  34 #include "async-thread.h"
  35 #include "block-rsv.h"
  36 #include "locking.h"
  37
  38 struct btrfs_trans_handle;
  39 struct btrfs_transaction;
  40 struct btrfs_pending_snapshot;
  41 struct btrfs_delayed_ref_root;
  42 struct btrfs_space_info;
  43 struct btrfs_block_group;
  44 extern struct kmem_cache *btrfs_trans_handle_cachep;
  45 extern struct kmem_cache *btrfs_bit_radix_cachep;
  46 extern struct kmem_cache *btrfs_path_cachep;
  47 extern struct kmem_cache *btrfs_free_space_cachep;
  48 extern struct kmem_cache *btrfs_free_space_bitmap_cachep;
  49 struct btrfs_ordered_sum;
  50 struct btrfs_ref;
  51 struct btrfs_bio;
  52 struct btrfs_ioctl_encoded_io_args;
  53
  54 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
  55
  56 /*
  57  * Maximum number of mirrors that can be available for all profiles counting
  58  * the target device of dev-replace as one. During an active device replace
  59  * procedure, the target device of the copy operation is a mirror for the
  60  * filesystem data as well that can be used to read data in order to repair
  61  * read errors on other disks.
  62  *
  63  * Current value is derived from RAID1C4 with 4 copies.
  64  */
  65 #define BTRFS_MAX_MIRRORS (4 + 1)
  66
  67 #define BTRFS_MAX_LEVEL 8
  68
  69 #define BTRFS_OLDEST_GENERATION 0ULL
  70
  71 /*
  72  * we can actually store much bigger names, but lets not confuse the rest
  73  * of linux
  74  */
  75 #define BTRFS_NAME_LEN 255
  76
  77 /*
  78  * Theoretical limit is larger, but we keep this down to a sane
  79  * value. That should limit greatly the possibility of collisions on
  80  * inode ref items.
  81  */
  82 #define BTRFS_LINK_MAX 65535U
  83
  84 #define BTRFS_EMPTY_DIR_SIZE 0
  85
  86 /* ioprio of readahead is set to idle */
  87 #define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
  88
  89 #define BTRFS_DIRTY_METADATA_THRESH     SZ_32M
  90
  91 /*
  92  * Use large batch size to reduce overhead of metadata updates.  On the reader
  93  * side, we only read it when we are close to ENOSPC and the read overhead is
  94  * mostly related to the number of CPUs, so it is OK to use arbitrary large
  95  * value here.
  96  */
  97 #define BTRFS_TOTAL_BYTES_PINNED_BATCH  SZ_128M
  98
  99 #define BTRFS_MAX_EXTENT_SIZE SZ_128M
 100
 101 /*
 102  * Deltas are an effective way to populate global statistics.  Give macro names
 103  * to make it clear what we're doing.  An example is discard_extents in
 104  * btrfs_free_space_ctl.
 105  */
 106 #define BTRFS_STAT_NR_ENTRIES   2
 107 #define BTRFS_STAT_CURR         0
 108 #define BTRFS_STAT_PREV         1
 109
 110 /*
 111  * Count how many BTRFS_MAX_EXTENT_SIZE cover the @size
 112  */
 113 static inline u32 count_max_extents(u64 size)
 114 {
 115         return div_u64(size + BTRFS_MAX_EXTENT_SIZE - 1, BTRFS_MAX_EXTENT_SIZE);
 116 }
 117
 118 static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 119 {
 120         BUG_ON(num_stripes == 0);
 121         return sizeof(struct btrfs_chunk) +
 122                 sizeof(struct btrfs_stripe) * (num_stripes - 1);
 123 }
 124
 125 /*
 126  * Runtime (in-memory) states of filesystem
 127  */
 128 enum {
 129         /* Global indicator of serious filesystem errors */
 130         BTRFS_FS_STATE_ERROR,
 131         /*
 132          * Filesystem is being remounted, allow to skip some operations, like
 133          * defrag
 134          */
 135         BTRFS_FS_STATE_REMOUNTING,
 136         /* Filesystem in RO mode */
 137         BTRFS_FS_STATE_RO,
 138         /* Track if a transaction abort has been reported on this filesystem */
 139         BTRFS_FS_STATE_TRANS_ABORTED,
 140         /*
 141          * Bio operations should be blocked on this filesystem because a source
 142          * or target device is being destroyed as part of a device replace
 143          */
 144         BTRFS_FS_STATE_DEV_REPLACING,
 145         /* The btrfs_fs_info created for self-tests */
 146         BTRFS_FS_STATE_DUMMY_FS_INFO,
 147
 148         BTRFS_FS_STATE_NO_CSUMS,
 149
 150         /* Indicates there was an error cleaning up a log tree. */
 151         BTRFS_FS_STATE_LOG_CLEANUP_ERROR,
 152
 153         BTRFS_FS_STATE_COUNT
 154 };
 155
 156 #define BTRFS_BACKREF_REV_MAX           256
 157 #define BTRFS_BACKREF_REV_SHIFT         56
 158 #define BTRFS_BACKREF_REV_MASK          (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
 159                                          BTRFS_BACKREF_REV_SHIFT)
 160
 161 #define BTRFS_OLD_BACKREF_REV           0
 162 #define BTRFS_MIXED_BACKREF_REV         1
 163
 164 /*
 165  * every tree block (leaf or node) starts with this header.
 166  */
 167 struct btrfs_header {
 168         /* these first four must match the super block */
 169         u8 csum[BTRFS_CSUM_SIZE];
 170         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 171         __le64 bytenr; /* which block this node is supposed to live in */
 172         __le64 flags;
 173
 174         /* allowed to be different from the super from here on down */
 175         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 176         __le64 generation;
 177         __le64 owner;
 178         __le32 nritems;
 179         u8 level;
 180 } __attribute__ ((__packed__));
 181
 182 /*
 183  * this is a very generous portion of the super block, giving us
 184  * room to translate 14 chunks with 3 stripes each.
 185  */
 186 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
 187
 188 /*
 189  * just in case we somehow lose the roots and are not able to mount,
 190  * we store an array of the roots from previous transactions
 191  * in the super.
 192  */
 193 #define BTRFS_NUM_BACKUP_ROOTS 4
 194 struct btrfs_root_backup {
 195         __le64 tree_root;
 196         __le64 tree_root_gen;
 197
 198         __le64 chunk_root;
 199         __le64 chunk_root_gen;
 200
 201         __le64 extent_root;
 202         __le64 extent_root_gen;
 203
 204         __le64 fs_root;
 205         __le64 fs_root_gen;
 206
 207         __le64 dev_root;
 208         __le64 dev_root_gen;
 209
 210         __le64 csum_root;
 211         __le64 csum_root_gen;
 212
 213         __le64 total_bytes;
 214         __le64 bytes_used;
 215         __le64 num_devices;
 216         /* future */
 217         __le64 unused_64[4];
 218
 219         u8 tree_root_level;
 220         u8 chunk_root_level;
 221         u8 extent_root_level;
 222         u8 fs_root_level;
 223         u8 dev_root_level;
 224         u8 csum_root_level;
 225         /* future and to align */
 226         u8 unused_8[10];
 227 } __attribute__ ((__packed__));
 228
 229 #define BTRFS_SUPER_INFO_OFFSET                 SZ_64K
 230 #define BTRFS_SUPER_INFO_SIZE                   4096
 231
 232 /*
 233  * the super block basically lists the main trees of the FS
 234  * it currently lacks any block count etc etc
 235  */
 236 struct btrfs_super_block {
 237         /* the first 4 fields must match struct btrfs_header */
 238         u8 csum[BTRFS_CSUM_SIZE];
 239         /* FS specific UUID, visible to user */
 240         u8 fsid[BTRFS_FSID_SIZE];
 241         __le64 bytenr; /* this block number */
 242         __le64 flags;
 243
 244         /* allowed to be different from the btrfs_header from here own down */
 245         __le64 magic;
 246         __le64 generation;
 247         __le64 root;
 248         __le64 chunk_root;
 249         __le64 log_root;
 250
 251         /* this will help find the new super based on the log root */
 252         __le64 log_root_transid;
 253         __le64 total_bytes;
 254         __le64 bytes_used;
 255         __le64 root_dir_objectid;
 256         __le64 num_devices;
 257         __le32 sectorsize;
 258         __le32 nodesize;
 259         __le32 __unused_leafsize;
 260         __le32 stripesize;
 261         __le32 sys_chunk_array_size;
 262         __le64 chunk_root_generation;
 263         __le64 compat_flags;
 264         __le64 compat_ro_flags;
 265         __le64 incompat_flags;
 266         __le16 csum_type;
 267         u8 root_level;
 268         u8 chunk_root_level;
 269         u8 log_root_level;
 270         struct btrfs_dev_item dev_item;
 271
 272         char label[BTRFS_LABEL_SIZE];
 273
 274         __le64 cache_generation;
 275         __le64 uuid_tree_generation;
 276
 277         /* the UUID written into btree blocks */
 278         u8 metadata_uuid[BTRFS_FSID_SIZE];
 279
 280         /* Extent tree v2 */
 281         __le64 block_group_root;
 282         __le64 block_group_root_generation;
 283         u8 block_group_root_level;
 284
 285         /* future expansion */
 286         u8 reserved8[7];
 287         __le64 reserved[25];
 288         u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
 289         struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
 290
 291         /* Padded to 4096 bytes */
 292         u8 padding[565];
 293 } __attribute__ ((__packed__));
 294 static_assert(sizeof(struct btrfs_super_block) == BTRFS_SUPER_INFO_SIZE);
 295
 296 /*
 297  * Compat flags that we support.  If any incompat flags are set other than the
 298  * ones specified below then we will fail to mount
 299  */
 300 #define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 301 #define BTRFS_FEATURE_COMPAT_SAFE_SET           0ULL
 302 #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR         0ULL
 303
 304 #define BTRFS_FEATURE_COMPAT_RO_SUPP                    \
 305         (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE |      \
 306          BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID | \
 307          BTRFS_FEATURE_COMPAT_RO_VERITY)
 308
 309 #define BTRFS_FEATURE_COMPAT_RO_SAFE_SET        0ULL
 310 #define BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR      0ULL
 311
 312 #ifdef CONFIG_BTRFS_DEBUG
 313 /*
 314  * Extent tree v2 supported only with CONFIG_BTRFS_DEBUG
 315  */
 316 #define BTRFS_FEATURE_INCOMPAT_SUPP                     \
 317         (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |         \
 318          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
 319          BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
 320          BTRFS_FEATURE_INCOMPAT_BIG_METADATA |          \
 321          BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |          \
 322          BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |         \
 323          BTRFS_FEATURE_INCOMPAT_RAID56 |                \
 324          BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |         \
 325          BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |       \
 326          BTRFS_FEATURE_INCOMPAT_NO_HOLES        |       \
 327          BTRFS_FEATURE_INCOMPAT_METADATA_UUID   |       \
 328          BTRFS_FEATURE_INCOMPAT_RAID1C34        |       \
 329          BTRFS_FEATURE_INCOMPAT_ZONED           |       \
 330          BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2)
 331 #else
 332 #define BTRFS_FEATURE_INCOMPAT_SUPP                     \
 333         (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |         \
 334          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
 335          BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
 336          BTRFS_FEATURE_INCOMPAT_BIG_METADATA |          \
 337          BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |          \
 338          BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |         \
 339          BTRFS_FEATURE_INCOMPAT_RAID56 |                \
 340          BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |         \
 341          BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |       \
 342          BTRFS_FEATURE_INCOMPAT_NO_HOLES        |       \
 343          BTRFS_FEATURE_INCOMPAT_METADATA_UUID   |       \
 344          BTRFS_FEATURE_INCOMPAT_RAID1C34        |       \
 345          BTRFS_FEATURE_INCOMPAT_ZONED)
 346 #endif
 347
 348 #define BTRFS_FEATURE_INCOMPAT_SAFE_SET                 \
 349         (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
 350 #define BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR               0ULL
 351
 352 /*
 353  * A leaf is full of items. offset and size tell us where to find
 354  * the item in the leaf (relative to the start of the data area)
 355  */
 356 struct btrfs_item {
 357         struct btrfs_disk_key key;
 358         __le32 offset;
 359         __le32 size;
 360 } __attribute__ ((__packed__));
 361
 362 /*
 363  * leaves have an item area and a data area:
 364  * [item0, item1....itemN] [free space] [dataN...data1, data0]
 365  *
 366  * The data is separate from the items to get the keys closer together
 367  * during searches.
 368  */
 369 struct btrfs_leaf {
 370         struct btrfs_header header;
 371         struct btrfs_item items[];
 372 } __attribute__ ((__packed__));
 373
 374 /*
 375  * all non-leaf blocks are nodes, they hold only keys and pointers to
 376  * other blocks
 377  */
 378 struct btrfs_key_ptr {
 379         struct btrfs_disk_key key;
 380         __le64 blockptr;
 381         __le64 generation;
 382 } __attribute__ ((__packed__));
 383
 384 struct btrfs_node {
 385         struct btrfs_header header;
 386         struct btrfs_key_ptr ptrs[];
 387 } __attribute__ ((__packed__));
 388
 389 /* Read ahead values for struct btrfs_path.reada */
 390 enum {
 391         READA_NONE,
 392         READA_BACK,
 393         READA_FORWARD,
 394         /*
 395          * Similar to READA_FORWARD but unlike it:
 396          *
 397          * 1) It will trigger readahead even for leaves that are not close to
 398          *    each other on disk;
 399          * 2) It also triggers readahead for nodes;
 400          * 3) During a search, even when a node or leaf is already in memory, it
 401          *    will still trigger readahead for other nodes and leaves that follow
 402          *    it.
 403          *
 404          * This is meant to be used only when we know we are iterating over the
 405          * entire tree or a very large part of it.
 406          */
 407         READA_FORWARD_ALWAYS,
 408 };
 409
 410 /*
 411  * btrfs_paths remember the path taken from the root down to the leaf.
 412  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 413  * to any other levels that are present.
 414  *
 415  * The slots array records the index of the item or block pointer
 416  * used while walking the tree.
 417  */
 418 struct btrfs_path {
 419         struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
 420         int slots[BTRFS_MAX_LEVEL];
 421         /* if there is real range locking, this locks field will change */
 422         u8 locks[BTRFS_MAX_LEVEL];
 423         u8 reada;
 424         /* keep some upper locks as we walk down */
 425         u8 lowest_level;
 426
 427         /*
 428          * set by btrfs_split_item, tells search_slot to keep all locks
 429          * and to force calls to keep space in the nodes
 430          */
 431         unsigned int search_for_split:1;
 432         unsigned int keep_locks:1;
 433         unsigned int skip_locking:1;
 434         unsigned int search_commit_root:1;
 435         unsigned int need_commit_sem:1;
 436         unsigned int skip_release_on_error:1;
 437         /*
 438          * Indicate that new item (btrfs_search_slot) is extending already
 439          * existing item and ins_len contains only the data size and not item
 440          * header (ie. sizeof(struct btrfs_item) is not included).
 441          */
 442         unsigned int search_for_extension:1;
 443 };
 444 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r->fs_info) >> 4) - \
 445                                         sizeof(struct btrfs_item))
 446 struct btrfs_dev_replace {
 447         u64 replace_state;      /* see #define above */
 448         time64_t time_started;  /* seconds since 1-Jan-1970 */
 449         time64_t time_stopped;  /* seconds since 1-Jan-1970 */
 450         atomic64_t num_write_errors;
 451         atomic64_t num_uncorrectable_read_errors;
 452
 453         u64 cursor_left;
 454         u64 committed_cursor_left;
 455         u64 cursor_left_last_write_of_item;
 456         u64 cursor_right;
 457
 458         u64 cont_reading_from_srcdev_mode;      /* see #define above */
 459
 460         int is_valid;
 461         int item_needs_writeback;
 462         struct btrfs_device *srcdev;
 463         struct btrfs_device *tgtdev;
 464
 465         struct mutex lock_finishing_cancel_unmount;
 466         struct rw_semaphore rwsem;
 467
 468         struct btrfs_scrub_progress scrub_progress;
 469
 470         struct percpu_counter bio_counter;
 471         wait_queue_head_t replace_wait;
 472 };
 473
 474 /*
 475  * free clusters are used to claim free space in relatively large chunks,
 476  * allowing us to do less seeky writes. They are used for all metadata
 477  * allocations. In ssd_spread mode they are also used for data allocations.
 478  */
 479 struct btrfs_free_cluster {
 480         spinlock_t lock;
 481         spinlock_t refill_lock;
 482         struct rb_root root;
 483
 484         /* largest extent in this cluster */
 485         u64 max_size;
 486
 487         /* first extent starting offset */
 488         u64 window_start;
 489
 490         /* We did a full search and couldn't create a cluster */
 491         bool fragmented;
 492
 493         struct btrfs_block_group *block_group;
 494         /*
 495          * when a cluster is allocated from a block group, we put the
 496          * cluster onto a list in the block group so that it can
 497          * be freed before the block group is freed.
 498          */
 499         struct list_head block_group_list;
 500 };
 501
 502 enum btrfs_caching_type {
 503         BTRFS_CACHE_NO,
 504         BTRFS_CACHE_STARTED,
 505         BTRFS_CACHE_FAST,
 506         BTRFS_CACHE_FINISHED,
 507         BTRFS_CACHE_ERROR,
 508 };
 509
 510 /*
 511  * Tree to record all locked full stripes of a RAID5/6 block group
 512  */
 513 struct btrfs_full_stripe_locks_tree {
 514         struct rb_root root;
 515         struct mutex lock;
 516 };
 517
 518 /* Discard control. */
 519 /*
 520  * Async discard uses multiple lists to differentiate the discard filter
 521  * parameters.  Index 0 is for completely free block groups where we need to
 522  * ensure the entire block group is trimmed without being lossy.  Indices
 523  * afterwards represent monotonically decreasing discard filter sizes to
 524  * prioritize what should be discarded next.
 525  */
 526 #define BTRFS_NR_DISCARD_LISTS          3
 527 #define BTRFS_DISCARD_INDEX_UNUSED      0
 528 #define BTRFS_DISCARD_INDEX_START       1
 529
 530 struct btrfs_discard_ctl {
 531         struct workqueue_struct *discard_workers;
 532         struct delayed_work work;
 533         spinlock_t lock;
 534         struct btrfs_block_group *block_group;
 535         struct list_head discard_list[BTRFS_NR_DISCARD_LISTS];
 536         u64 prev_discard;
 537         u64 prev_discard_time;
 538         atomic_t discardable_extents;
 539         atomic64_t discardable_bytes;
 540         u64 max_discard_size;
 541         u64 delay_ms;
 542         u32 iops_limit;
 543         u32 kbps_limit;
 544         u64 discard_extent_bytes;
 545         u64 discard_bitmap_bytes;
 546         atomic64_t discard_bytes_saved;
 547 };
 548
 549 void btrfs_init_async_reclaim_work(struct btrfs_fs_info *fs_info);
 550
 551 /* fs_info */
 552 struct reloc_control;
 553 struct btrfs_device;
 554 struct btrfs_fs_devices;
 555 struct btrfs_balance_control;
 556 struct btrfs_delayed_root;
 557
 558 /*
 559  * Block group or device which contains an active swapfile. Used for preventing
 560  * unsafe operations while a swapfile is active.
 561  *
 562  * These are sorted on (ptr, inode) (note that a block group or device can
 563  * contain more than one swapfile). We compare the pointer values because we
 564  * don't actually care what the object is, we just need a quick check whether
 565  * the object exists in the rbtree.
 566  */
 567 struct btrfs_swapfile_pin {
 568         struct rb_node node;
 569         void *ptr;
 570         struct inode *inode;
 571         /*
 572          * If true, ptr points to a struct btrfs_block_group. Otherwise, ptr
 573          * points to a struct btrfs_device.
 574          */
 575         bool is_block_group;
 576         /*
 577          * Only used when 'is_block_group' is true and it is the number of
 578          * extents used by a swapfile for this block group ('ptr' field).
 579          */
 580         int bg_extent_count;
 581 };
 582
 583 bool btrfs_pinned_by_swapfile(struct btrfs_fs_info *fs_info, void *ptr);
 584
 585 enum {
 586         BTRFS_FS_CLOSING_START,
 587         BTRFS_FS_CLOSING_DONE,
 588         BTRFS_FS_LOG_RECOVERING,
 589         BTRFS_FS_OPEN,
 590         BTRFS_FS_QUOTA_ENABLED,
 591         BTRFS_FS_UPDATE_UUID_TREE_GEN,
 592         BTRFS_FS_CREATING_FREE_SPACE_TREE,
 593         BTRFS_FS_BTREE_ERR,
 594         BTRFS_FS_LOG1_ERR,
 595         BTRFS_FS_LOG2_ERR,
 596         BTRFS_FS_QUOTA_OVERRIDE,
 597         /* Used to record internally whether fs has been frozen */
 598         BTRFS_FS_FROZEN,
 599         /*
 600          * Indicate that balance has been set up from the ioctl and is in the
 601          * main phase. The fs_info::balance_ctl is initialized.
 602          */
 603         BTRFS_FS_BALANCE_RUNNING,
 604
 605         /*
 606          * Indicate that relocation of a chunk has started, it's set per chunk
 607          * and is toggled between chunks.
 608          */
 609         BTRFS_FS_RELOC_RUNNING,
 610
 611         /* Indicate that the cleaner thread is awake and doing something. */
 612         BTRFS_FS_CLEANER_RUNNING,
 613
 614         /*
 615          * The checksumming has an optimized version and is considered fast,
 616          * so we don't need to offload checksums to workqueues.
 617          */
 618         BTRFS_FS_CSUM_IMPL_FAST,
 619
 620         /* Indicate that the discard workqueue can service discards. */
 621         BTRFS_FS_DISCARD_RUNNING,
 622
 623         /* Indicate that we need to cleanup space cache v1 */
 624         BTRFS_FS_CLEANUP_SPACE_CACHE_V1,
 625
 626         /* Indicate that we can't trust the free space tree for caching yet */
 627         BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED,
 628
 629         /* Indicate whether there are any tree modification log users */
 630         BTRFS_FS_TREE_MOD_LOG_USERS,
 631
 632         /* Indicate that we want the transaction kthread to commit right now. */
 633         BTRFS_FS_COMMIT_TRANS,
 634
 635         /* Indicate we have half completed snapshot deletions pending. */
 636         BTRFS_FS_UNFINISHED_DROPS,
 637
 638 #if BITS_PER_LONG == 32
 639         /* Indicate if we have error/warn message printed on 32bit systems */
 640         BTRFS_FS_32BIT_ERROR,
 641         BTRFS_FS_32BIT_WARN,
 642 #endif
 643 };
 644
 645 /*
 646  * Exclusive operations (device replace, resize, device add/remove, balance)
 647  */
 648 enum btrfs_exclusive_operation {
 649         BTRFS_EXCLOP_NONE,
 650         BTRFS_EXCLOP_BALANCE_PAUSED,
 651         BTRFS_EXCLOP_BALANCE,
 652         BTRFS_EXCLOP_DEV_ADD,
 653         BTRFS_EXCLOP_DEV_REMOVE,
 654         BTRFS_EXCLOP_DEV_REPLACE,
 655         BTRFS_EXCLOP_RESIZE,
 656         BTRFS_EXCLOP_SWAP_ACTIVATE,
 657 };
 658
 659 struct btrfs_fs_info {
 660         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 661         unsigned long flags;
 662         struct btrfs_root *tree_root;
 663         struct btrfs_root *chunk_root;
 664         struct btrfs_root *dev_root;
 665         struct btrfs_root *fs_root;
 666         struct btrfs_root *quota_root;
 667         struct btrfs_root *uuid_root;
 668         struct btrfs_root *data_reloc_root;
 669         struct btrfs_root *block_group_root;
 670
 671         /* the log root tree is a directory of all the other log roots */
 672         struct btrfs_root *log_root_tree;
 673
 674         /* The tree that holds the global roots (csum, extent, etc) */
 675         rwlock_t global_root_lock;
 676         struct rb_root global_root_tree;
 677
 678         /* The xarray that holds all the FS roots */
 679         spinlock_t fs_roots_lock;
 680         struct xarray fs_roots;
 681
 682         /* block group cache stuff */
 683         rwlock_t block_group_cache_lock;
 684         struct rb_root_cached block_group_cache_tree;
 685
 686         /* keep track of unallocated space */
 687         atomic64_t free_chunk_space;
 688
 689         /* Track ranges which are used by log trees blocks/logged data extents */
 690         struct extent_io_tree excluded_extents;
 691
 692         /* logical->physical extent mapping */
 693         struct extent_map_tree mapping_tree;
 694
 695         /*
 696          * block reservation for extent, checksum, root tree and
 697          * delayed dir index item
 698          */
 699         struct btrfs_block_rsv global_block_rsv;
 700         /* block reservation for metadata operations */
 701         struct btrfs_block_rsv trans_block_rsv;
 702         /* block reservation for chunk tree */
 703         struct btrfs_block_rsv chunk_block_rsv;
 704         /* block reservation for delayed operations */
 705         struct btrfs_block_rsv delayed_block_rsv;
 706         /* block reservation for delayed refs */
 707         struct btrfs_block_rsv delayed_refs_rsv;
 708
 709         struct btrfs_block_rsv empty_block_rsv;
 710
 711         u64 generation;
 712         u64 last_trans_committed;
 713         /*
 714          * Generation of the last transaction used for block group relocation
 715          * since the filesystem was last mounted (or 0 if none happened yet).
 716          * Must be written and read while holding btrfs_fs_info::commit_root_sem.
 717          */
 718         u64 last_reloc_trans;
 719         u64 avg_delayed_ref_runtime;
 720
 721         /*
 722          * this is updated to the current trans every time a full commit
 723          * is required instead of the faster short fsync log commits
 724          */
 725         u64 last_trans_log_full_commit;
 726         unsigned long mount_opt;
 727         /*
 728          * Track requests for actions that need to be done during transaction
 729          * commit (like for some mount options).
 730          */
 731         unsigned long pending_changes;
 732         unsigned long compress_type:4;
 733         unsigned int compress_level;
 734         u32 commit_interval;
 735         /*
 736          * It is a suggestive number, the read side is safe even it gets a
 737          * wrong number because we will write out the data into a regular
 738          * extent. The write side(mount/remount) is under ->s_umount lock,
 739          * so it is also safe.
 740          */
 741         u64 max_inline;
 742
 743         struct btrfs_transaction *running_transaction;
 744         wait_queue_head_t transaction_throttle;
 745         wait_queue_head_t transaction_wait;
 746         wait_queue_head_t transaction_blocked_wait;
 747         wait_queue_head_t async_submit_wait;
 748
 749         /*
 750          * Used to protect the incompat_flags, compat_flags, compat_ro_flags
 751          * when they are updated.
 752          *
 753          * Because we do not clear the flags for ever, so we needn't use
 754          * the lock on the read side.
 755          *
 756          * We also needn't use the lock when we mount the fs, because
 757          * there is no other task which will update the flag.
 758          */
 759         spinlock_t super_lock;
 760         struct btrfs_super_block *super_copy;
 761         struct btrfs_super_block *super_for_commit;
 762         struct super_block *sb;
 763         struct inode *btree_inode;
 764         struct mutex tree_log_mutex;
 765         struct mutex transaction_kthread_mutex;
 766         struct mutex cleaner_mutex;
 767         struct mutex chunk_mutex;
 768
 769         /*
 770          * this is taken to make sure we don't set block groups ro after
 771          * the free space cache has been allocated on them
 772          */
 773         struct mutex ro_block_group_mutex;
 774
 775         /* this is used during read/modify/write to make sure
 776          * no two ios are trying to mod the same stripe at the same
 777          * time
 778          */
 779         struct btrfs_stripe_hash_table *stripe_hash_table;
 780
 781         /*
 782          * this protects the ordered operations list only while we are
 783          * processing all of the entries on it.  This way we make
 784          * sure the commit code doesn't find the list temporarily empty
 785          * because another function happens to be doing non-waiting preflush
 786          * before jumping into the main commit.
 787          */
 788         struct mutex ordered_operations_mutex;
 789
 790         struct rw_semaphore commit_root_sem;
 791
 792         struct rw_semaphore cleanup_work_sem;
 793
 794         struct rw_semaphore subvol_sem;
 795
 796         spinlock_t trans_lock;
 797         /*
 798          * the reloc mutex goes with the trans lock, it is taken
 799          * during commit to protect us from the relocation code
 800          */
 801         struct mutex reloc_mutex;
 802
 803         struct list_head trans_list;
 804         struct list_head dead_roots;
 805         struct list_head caching_block_groups;
 806
 807         spinlock_t delayed_iput_lock;
 808         struct list_head delayed_iputs;
 809         atomic_t nr_delayed_iputs;
 810         wait_queue_head_t delayed_iputs_wait;
 811
 812         atomic64_t tree_mod_seq;
 813
 814         /* this protects tree_mod_log and tree_mod_seq_list */
 815         rwlock_t tree_mod_log_lock;
 816         struct rb_root tree_mod_log;
 817         struct list_head tree_mod_seq_list;
 818
 819         atomic_t async_delalloc_pages;
 820
 821         /*
 822          * this is used to protect the following list -- ordered_roots.
 823          */
 824         spinlock_t ordered_root_lock;
 825
 826         /*
 827          * all fs/file tree roots in which there are data=ordered extents
 828          * pending writeback are added into this list.
 829          *
 830          * these can span multiple transactions and basically include
 831          * every dirty data page that isn't from nodatacow
 832          */
 833         struct list_head ordered_roots;
 834
 835         struct mutex delalloc_root_mutex;
 836         spinlock_t delalloc_root_lock;
 837         /* all fs/file tree roots that have delalloc inodes. */
 838         struct list_head delalloc_roots;
 839
 840         /*
 841          * there is a pool of worker threads for checksumming during writes
 842          * and a pool for checksumming after reads.  This is because readers
 843          * can run with FS locks held, and the writers may be waiting for
 844          * those locks.  We don't want ordering in the pending list to cause
 845          * deadlocks, and so the two are serviced separately.
 846          *
 847          * A third pool does submit_bio to avoid deadlocking with the other
 848          * two
 849          */
 850         struct btrfs_workqueue *workers;
 851         struct btrfs_workqueue *hipri_workers;
 852         struct btrfs_workqueue *delalloc_workers;
 853         struct btrfs_workqueue *flush_workers;
 854         struct btrfs_workqueue *endio_workers;
 855         struct btrfs_workqueue *endio_meta_workers;
 856         struct btrfs_workqueue *endio_raid56_workers;
 857         struct workqueue_struct *rmw_workers;
 858         struct btrfs_workqueue *endio_meta_write_workers;
 859         struct btrfs_workqueue *endio_write_workers;
 860         struct btrfs_workqueue *endio_freespace_worker;
 861         struct btrfs_workqueue *caching_workers;
 862
 863         /*
 864          * fixup workers take dirty pages that didn't properly go through
 865          * the cow mechanism and make them safe to write.  It happens
 866          * for the sys_munmap function call path
 867          */
 868         struct btrfs_workqueue *fixup_workers;
 869         struct btrfs_workqueue *delayed_workers;
 870
 871         struct task_struct *transaction_kthread;
 872         struct task_struct *cleaner_kthread;
 873         u32 thread_pool_size;
 874
 875         struct kobject *space_info_kobj;
 876         struct kobject *qgroups_kobj;
 877
 878         /* used to keep from writing metadata until there is a nice batch */
 879         struct percpu_counter dirty_metadata_bytes;
 880         struct percpu_counter delalloc_bytes;
 881         struct percpu_counter ordered_bytes;
 882         s32 dirty_metadata_batch;
 883         s32 delalloc_batch;
 884
 885         struct list_head dirty_cowonly_roots;
 886
 887         struct btrfs_fs_devices *fs_devices;
 888
 889         /*
 890          * The space_info list is effectively read only after initial
 891          * setup.  It is populated at mount time and cleaned up after
 892          * all block groups are removed.  RCU is used to protect it.
 893          */
 894         struct list_head space_info;
 895
 896         struct btrfs_space_info *data_sinfo;
 897
 898         struct reloc_control *reloc_ctl;
 899
 900         /* data_alloc_cluster is only used in ssd_spread mode */
 901         struct btrfs_free_cluster data_alloc_cluster;
 902
 903         /* all metadata allocations go through this cluster */
 904         struct btrfs_free_cluster meta_alloc_cluster;
 905
 906         /* auto defrag inodes go here */
 907         spinlock_t defrag_inodes_lock;
 908         struct rb_root defrag_inodes;
 909         atomic_t defrag_running;
 910
 911         /* Used to protect avail_{data, metadata, system}_alloc_bits */
 912         seqlock_t profiles_lock;
 913         /*
 914          * these three are in extended format (availability of single
 915          * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
 916          * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
 917          */
 918         u64 avail_data_alloc_bits;
 919         u64 avail_metadata_alloc_bits;
 920         u64 avail_system_alloc_bits;
 921
 922         /* restriper state */
 923         spinlock_t balance_lock;
 924         struct mutex balance_mutex;
 925         atomic_t balance_pause_req;
 926         atomic_t balance_cancel_req;
 927         struct btrfs_balance_control *balance_ctl;
 928         wait_queue_head_t balance_wait_q;
 929
 930         /* Cancellation requests for chunk relocation */
 931         atomic_t reloc_cancel_req;
 932
 933         u32 data_chunk_allocations;
 934         u32 metadata_ratio;
 935
 936         void *bdev_holder;
 937
 938         /* private scrub information */
 939         struct mutex scrub_lock;
 940         atomic_t scrubs_running;
 941         atomic_t scrub_pause_req;
 942         atomic_t scrubs_paused;
 943         atomic_t scrub_cancel_req;
 944         wait_queue_head_t scrub_pause_wait;
 945         /*
 946          * The worker pointers are NULL iff the refcount is 0, ie. scrub is not
 947          * running.
 948          */
 949         refcount_t scrub_workers_refcnt;
 950         struct workqueue_struct *scrub_workers;
 951         struct workqueue_struct *scrub_wr_completion_workers;
 952         struct workqueue_struct *scrub_parity_workers;
 953         struct btrfs_subpage_info *subpage_info;
 954
 955         struct btrfs_discard_ctl discard_ctl;
 956
 957 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
 958         u32 check_integrity_print_mask;
 959 #endif
 960         /* is qgroup tracking in a consistent state? */
 961         u64 qgroup_flags;
 962
 963         /* holds configuration and tracking. Protected by qgroup_lock */
 964         struct rb_root qgroup_tree;
 965         spinlock_t qgroup_lock;
 966
 967         /*
 968          * used to avoid frequently calling ulist_alloc()/ulist_free()
 969          * when doing qgroup accounting, it must be protected by qgroup_lock.
 970          */
 971         struct ulist *qgroup_ulist;
 972
 973         /*
 974          * Protect user change for quota operations. If a transaction is needed,
 975          * it must be started before locking this lock.
 976          */
 977         struct mutex qgroup_ioctl_lock;
 978
 979         /* list of dirty qgroups to be written at next commit */
 980         struct list_head dirty_qgroups;
 981
 982         /* used by qgroup for an efficient tree traversal */
 983         u64 qgroup_seq;
 984
 985         /* qgroup rescan items */
 986         struct mutex qgroup_rescan_lock; /* protects the progress item */
 987         struct btrfs_key qgroup_rescan_progress;
 988         struct btrfs_workqueue *qgroup_rescan_workers;
 989         struct completion qgroup_rescan_completion;
 990         struct btrfs_work qgroup_rescan_work;
 991         bool qgroup_rescan_running;     /* protected by qgroup_rescan_lock */
 992
 993         /* filesystem state */
 994         unsigned long fs_state;
 995
 996         struct btrfs_delayed_root *delayed_root;
 997
 998         /* Extent buffer xarray */
 999         spinlock_t buffer_lock;
1000         /* Entries are eb->start / sectorsize */
1001         struct xarray extent_buffers;
1002
1003         /* next backup root to be overwritten */
1004         int backup_root_index;
1005
1006         /* device replace state */
1007         struct btrfs_dev_replace dev_replace;
1008
1009         struct semaphore uuid_tree_rescan_sem;
1010
1011         /* Used to reclaim the metadata space in the background. */
1012         struct work_struct async_reclaim_work;
1013         struct work_struct async_data_reclaim_work;
1014         struct work_struct preempt_reclaim_work;
1015
1016         /* Reclaim partially filled block groups in the background */
1017         struct work_struct reclaim_bgs_work;
1018         struct list_head reclaim_bgs;
1019         int bg_reclaim_threshold;
1020
1021         spinlock_t unused_bgs_lock;
1022         struct list_head unused_bgs;
1023         struct mutex unused_bg_unpin_mutex;
1024         /* Protect block groups that are going to be deleted */
1025         struct mutex reclaim_bgs_lock;
1026
1027         /* Cached block sizes */
1028         u32 nodesize;
1029         u32 sectorsize;
1030         /* ilog2 of sectorsize, use to avoid 64bit division */
1031         u32 sectorsize_bits;
1032         u32 csum_size;
1033         u32 csums_per_leaf;
1034         u32 stripesize;
1035
1036         /* Block groups and devices containing active swapfiles. */
1037         spinlock_t swapfile_pins_lock;
1038         struct rb_root swapfile_pins;
1039
1040         struct crypto_shash *csum_shash;
1041
1042         /* Type of exclusive operation running, protected by super_lock */
1043         enum btrfs_exclusive_operation exclusive_operation;
1044
1045         /*
1046          * Zone size > 0 when in ZONED mode, otherwise it's used for a check
1047          * if the mode is enabled
1048          */
1049         u64 zone_size;
1050
1051         struct mutex zoned_meta_io_lock;
1052         spinlock_t treelog_bg_lock;
1053         u64 treelog_bg;
1054
1055         /*
1056          * Start of the dedicated data relocation block group, protected by
1057          * relocation_bg_lock.
1058          */
1059         spinlock_t relocation_bg_lock;
1060         u64 data_reloc_bg;
1061         struct mutex zoned_data_reloc_io_lock;
1062
1063         u64 nr_global_roots;
1064
1065         spinlock_t zone_active_bgs_lock;
1066         struct list_head zone_active_bgs;
1067
1068 #ifdef CONFIG_BTRFS_FS_REF_VERIFY
1069         spinlock_t ref_verify_lock;
1070         struct rb_root block_tree;
1071 #endif
1072
1073 #ifdef CONFIG_BTRFS_DEBUG
1074         struct kobject *debug_kobj;
1075         struct kobject *discard_debug_kobj;
1076         struct list_head allocated_roots;
1077
1078         spinlock_t eb_leak_lock;
1079         struct list_head allocated_ebs;
1080 #endif
1081 };
1082
1083 static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
1084 {
1085         return sb->s_fs_info;
1086 }
1087
1088 /*
1089  * The state of btrfs root
1090  */
1091 enum {
1092         /*
1093          * btrfs_record_root_in_trans is a multi-step process, and it can race
1094          * with the balancing code.   But the race is very small, and only the
1095          * first time the root is added to each transaction.  So IN_TRANS_SETUP
1096          * is used to tell us when more checks are required
1097          */
1098         BTRFS_ROOT_IN_TRANS_SETUP,
1099
1100         /*
1101          * Set if tree blocks of this root can be shared by other roots.
1102          * Only subvolume trees and their reloc trees have this bit set.
1103          * Conflicts with TRACK_DIRTY bit.
1104          *
1105          * This affects two things:
1106          *
1107          * - How balance works
1108          *   For shareable roots, we need to use reloc tree and do path
1109          *   replacement for balance, and need various pre/post hooks for
1110          *   snapshot creation to handle them.
1111          *
1112          *   While for non-shareable trees, we just simply do a tree search
1113          *   with COW.
1114          *
1115          * - How dirty roots are tracked
1116          *   For shareable roots, btrfs_record_root_in_trans() is needed to
1117          *   track them, while non-subvolume roots have TRACK_DIRTY bit, they
1118          *   don't need to set this manually.
1119          */
1120         BTRFS_ROOT_SHAREABLE,
1121         BTRFS_ROOT_TRACK_DIRTY,
1122         /* The root is tracked in fs_info::fs_roots */
1123         BTRFS_ROOT_REGISTERED,
1124         BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
1125         BTRFS_ROOT_DEFRAG_RUNNING,
1126         BTRFS_ROOT_FORCE_COW,
1127         BTRFS_ROOT_MULTI_LOG_TASKS,
1128         BTRFS_ROOT_DIRTY,
1129         BTRFS_ROOT_DELETING,
1130
1131         /*
1132          * Reloc tree is orphan, only kept here for qgroup delayed subtree scan
1133          *
1134          * Set for the subvolume tree owning the reloc tree.
1135          */
1136         BTRFS_ROOT_DEAD_RELOC_TREE,
1137         /* Mark dead root stored on device whose cleanup needs to be resumed */
1138         BTRFS_ROOT_DEAD_TREE,
1139         /* The root has a log tree. Used for subvolume roots and the tree root. */
1140         BTRFS_ROOT_HAS_LOG_TREE,
1141         /* Qgroup flushing is in progress */
1142         BTRFS_ROOT_QGROUP_FLUSHING,
1143         /* We started the orphan cleanup for this root. */
1144         BTRFS_ROOT_ORPHAN_CLEANUP,
1145         /* This root has a drop operation that was started previously. */
1146         BTRFS_ROOT_UNFINISHED_DROP,
1147 };
1148
1149 static inline void btrfs_wake_unfinished_drop(struct btrfs_fs_info *fs_info)
1150 {
1151         clear_and_wake_up_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags);
1152 }
1153
1154 /*
1155  * Record swapped tree blocks of a subvolume tree for delayed subtree trace
1156  * code. For detail check comment in fs/btrfs/qgroup.c.
1157  */
1158 struct btrfs_qgroup_swapped_blocks {
1159         spinlock_t lock;
1160         /* RM_EMPTY_ROOT() of above blocks[] */
1161         bool swapped;
1162         struct rb_root blocks[BTRFS_MAX_LEVEL];
1163 };
1164
1165 /*
1166  * in ram representation of the tree.  extent_root is used for all allocations
1167  * and for the extent tree extent_root root.
1168  */
1169 struct btrfs_root {
1170         struct rb_node rb_node;
1171
1172         struct extent_buffer *node;
1173
1174         struct extent_buffer *commit_root;
1175         struct btrfs_root *log_root;
1176         struct btrfs_root *reloc_root;
1177
1178         unsigned long state;
1179         struct btrfs_root_item root_item;
1180         struct btrfs_key root_key;
1181         struct btrfs_fs_info *fs_info;
1182         struct extent_io_tree dirty_log_pages;
1183
1184         struct mutex objectid_mutex;
1185
1186         spinlock_t accounting_lock;
1187         struct btrfs_block_rsv *block_rsv;
1188
1189         struct mutex log_mutex;
1190         wait_queue_head_t log_writer_wait;
1191         wait_queue_head_t log_commit_wait[2];
1192         struct list_head log_ctxs[2];
1193         /* Used only for log trees of subvolumes, not for the log root tree */
1194         atomic_t log_writers;
1195         atomic_t log_commit[2];
1196         /* Used only for log trees of subvolumes, not for the log root tree */
1197         atomic_t log_batch;
1198         int log_transid;
1199         /* No matter the commit succeeds or not*/
1200         int log_transid_committed;
1201         /* Just be updated when the commit succeeds. */
1202         int last_log_commit;
1203         pid_t log_start_pid;
1204
1205         u64 last_trans;
1206
1207         u32 type;
1208
1209         u64 free_objectid;
1210
1211         struct btrfs_key defrag_progress;
1212         struct btrfs_key defrag_max;
1213
1214         /* The dirty list is only used by non-shareable roots */
1215         struct list_head dirty_list;
1216
1217         struct list_head root_list;
1218
1219         spinlock_t log_extents_lock[2];
1220         struct list_head logged_list[2];
1221
1222         spinlock_t inode_lock;
1223         /* red-black tree that keeps track of in-memory inodes */
1224         struct rb_root inode_tree;
1225
1226         /*
1227          * Xarray that keeps track of delayed nodes of every inode, protected
1228          * by inode_lock
1229          */
1230         struct xarray delayed_nodes;
1231         /*
1232          * right now this just gets used so that a root has its own devid
1233          * for stat.  It may be used for more later
1234          */
1235         dev_t anon_dev;
1236
1237         spinlock_t root_item_lock;
1238         refcount_t refs;
1239
1240         struct mutex delalloc_mutex;
1241         spinlock_t delalloc_lock;
1242         /*
1243          * all of the inodes that have delalloc bytes.  It is possible for
1244          * this list to be empty even when there is still dirty data=ordered
1245          * extents waiting to finish IO.
1246          */
1247         struct list_head delalloc_inodes;
1248         struct list_head delalloc_root;
1249         u64 nr_delalloc_inodes;
1250
1251         struct mutex ordered_extent_mutex;
1252         /*
1253          * this is used by the balancing code to wait for all the pending
1254          * ordered extents
1255          */
1256         spinlock_t ordered_extent_lock;
1257
1258         /*
1259          * all of the data=ordered extents pending writeback
1260          * these can span multiple transactions and basically include
1261          * every dirty data page that isn't from nodatacow
1262          */
1263         struct list_head ordered_extents;
1264         struct list_head ordered_root;
1265         u64 nr_ordered_extents;
1266
1267         /*
1268          * Not empty if this subvolume root has gone through tree block swap
1269          * (relocation)
1270          *
1271          * Will be used by reloc_control::dirty_subvol_roots.
1272          */
1273         struct list_head reloc_dirty_list;
1274
1275         /*
1276          * Number of currently running SEND ioctls to prevent
1277          * manipulation with the read-only status via SUBVOL_SETFLAGS
1278          */
1279         int send_in_progress;
1280         /*
1281          * Number of currently running deduplication operations that have a
1282          * destination inode belonging to this root. Protected by the lock
1283          * root_item_lock.
1284          */
1285         int dedupe_in_progress;
1286         /* For exclusion of snapshot creation and nocow writes */
1287         struct btrfs_drew_lock snapshot_lock;
1288
1289         atomic_t snapshot_force_cow;
1290
1291         /* For qgroup metadata reserved space */
1292         spinlock_t qgroup_meta_rsv_lock;
1293         u64 qgroup_meta_rsv_pertrans;
1294         u64 qgroup_meta_rsv_prealloc;
1295         wait_queue_head_t qgroup_flush_wait;
1296
1297         /* Number of active swapfiles */
1298         atomic_t nr_swapfiles;
1299
1300         /* Record pairs of swapped blocks for qgroup */
1301         struct btrfs_qgroup_swapped_blocks swapped_blocks;
1302
1303         /* Used only by log trees, when logging csum items */
1304         struct extent_io_tree log_csum_range;
1305
1306 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1307         u64 alloc_bytenr;
1308 #endif
1309
1310 #ifdef CONFIG_BTRFS_DEBUG
1311         struct list_head leak_list;
1312 #endif
1313 };
1314
1315 /*
1316  * Structure that conveys information about an extent that is going to replace
1317  * all the extents in a file range.
1318  */
1319 struct btrfs_replace_extent_info {
1320         u64 disk_offset;
1321         u64 disk_len;
1322         u64 data_offset;
1323         u64 data_len;
1324         u64 file_offset;
1325         /* Pointer to a file extent item of type regular or prealloc. */
1326         char *extent_buf;
1327         /*
1328          * Set to true when attempting to replace a file range with a new extent
1329          * described by this structure, set to false when attempting to clone an
1330          * existing extent into a file range.
1331          */
1332         bool is_new_extent;
1333         /* Indicate if we should update the inode's mtime and ctime. */
1334         bool update_times;
1335         /* Meaningful only if is_new_extent is true. */
1336         int qgroup_reserved;
1337         /*
1338          * Meaningful only if is_new_extent is true.
1339          * Used to track how many extent items we have already inserted in a
1340          * subvolume tree that refer to the extent described by this structure,
1341          * so that we know when to create a new delayed ref or update an existing
1342          * one.
1343          */
1344         int insertions;
1345 };
1346
1347 /* Arguments for btrfs_drop_extents() */
1348 struct btrfs_drop_extents_args {
1349         /* Input parameters */
1350
1351         /*
1352          * If NULL, btrfs_drop_extents() will allocate and free its own path.
1353          * If 'replace_extent' is true, this must not be NULL. Also the path
1354          * is always released except if 'replace_extent' is true and
1355          * btrfs_drop_extents() sets 'extent_inserted' to true, in which case
1356          * the path is kept locked.
1357          */
1358         struct btrfs_path *path;
1359         /* Start offset of the range to drop extents from */
1360         u64 start;
1361         /* End (exclusive, last byte + 1) of the range to drop extents from */
1362         u64 end;
1363         /* If true drop all the extent maps in the range */
1364         bool drop_cache;
1365         /*
1366          * If true it means we want to insert a new extent after dropping all
1367          * the extents in the range. If this is true, the 'extent_item_size'
1368          * parameter must be set as well and the 'extent_inserted' field will
1369          * be set to true by btrfs_drop_extents() if it could insert the new
1370          * extent.
1371          * Note: when this is set to true the path must not be NULL.
1372          */
1373         bool replace_extent;
1374         /*
1375          * Used if 'replace_extent' is true. Size of the file extent item to
1376          * insert after dropping all existing extents in the range
1377          */
1378         u32 extent_item_size;
1379
1380         /* Output parameters */
1381
1382         /*
1383          * Set to the minimum between the input parameter 'end' and the end
1384          * (exclusive, last byte + 1) of the last dropped extent. This is always
1385          * set even if btrfs_drop_extents() returns an error.
1386          */
1387         u64 drop_end;
1388         /*
1389          * The number of allocated bytes found in the range. This can be smaller
1390          * than the range's length when there are holes in the range.
1391          */
1392         u64 bytes_found;
1393         /*
1394          * Only set if 'replace_extent' is true. Set to true if we were able
1395          * to insert a replacement extent after dropping all extents in the
1396          * range, otherwise set to false by btrfs_drop_extents().
1397          * Also, if btrfs_drop_extents() has set this to true it means it
1398          * returned with the path locked, otherwise if it has set this to
1399          * false it has returned with the path released.
1400          */
1401         bool extent_inserted;
1402 };
1403
1404 struct btrfs_file_private {
1405         void *filldir_buf;
1406 };
1407
1408
1409 static inline u32 BTRFS_LEAF_DATA_SIZE(const struct btrfs_fs_info *info)
1410 {
1411
1412         return info->nodesize - sizeof(struct btrfs_header);
1413 }
1414
1415 #define BTRFS_LEAF_DATA_OFFSET          offsetof(struct btrfs_leaf, items)
1416
1417 static inline u32 BTRFS_MAX_ITEM_SIZE(const struct btrfs_fs_info *info)
1418 {
1419         return BTRFS_LEAF_DATA_SIZE(info) - sizeof(struct btrfs_item);
1420 }
1421
1422 static inline u32 BTRFS_NODEPTRS_PER_BLOCK(const struct btrfs_fs_info *info)
1423 {
1424         return BTRFS_LEAF_DATA_SIZE(info) / sizeof(struct btrfs_key_ptr);
1425 }
1426
1427 #define BTRFS_FILE_EXTENT_INLINE_DATA_START             \
1428                 (offsetof(struct btrfs_file_extent_item, disk_bytenr))
1429 static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
1430 {
1431         return BTRFS_MAX_ITEM_SIZE(info) -
1432                BTRFS_FILE_EXTENT_INLINE_DATA_START;
1433 }
1434
1435 static inline u32 BTRFS_MAX_XATTR_SIZE(const struct btrfs_fs_info *info)
1436 {
1437         return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_dir_item);
1438 }
1439
1440 /*
1441  * Flags for mount options.
1442  *
1443  * Note: don't forget to add new options to btrfs_show_options()
1444  */
1445 enum {
1446         BTRFS_MOUNT_NODATASUM                   = (1UL << 0),
1447         BTRFS_MOUNT_NODATACOW                   = (1UL << 1),
1448         BTRFS_MOUNT_NOBARRIER                   = (1UL << 2),
1449         BTRFS_MOUNT_SSD                         = (1UL << 3),
1450         BTRFS_MOUNT_DEGRADED                    = (1UL << 4),
1451         BTRFS_MOUNT_COMPRESS                    = (1UL << 5),
1452         BTRFS_MOUNT_NOTREELOG                   = (1UL << 6),
1453         BTRFS_MOUNT_FLUSHONCOMMIT               = (1UL << 7),
1454         BTRFS_MOUNT_SSD_SPREAD                  = (1UL << 8),
1455         BTRFS_MOUNT_NOSSD                       = (1UL << 9),
1456         BTRFS_MOUNT_DISCARD_SYNC                = (1UL << 10),
1457         BTRFS_MOUNT_FORCE_COMPRESS              = (1UL << 11),
1458         BTRFS_MOUNT_SPACE_CACHE                 = (1UL << 12),
1459         BTRFS_MOUNT_CLEAR_CACHE                 = (1UL << 13),
1460         BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED      = (1UL << 14),
1461         BTRFS_MOUNT_ENOSPC_DEBUG                = (1UL << 15),
1462         BTRFS_MOUNT_AUTO_DEFRAG                 = (1UL << 16),
1463         BTRFS_MOUNT_USEBACKUPROOT               = (1UL << 17),
1464         BTRFS_MOUNT_SKIP_BALANCE                = (1UL << 18),
1465         BTRFS_MOUNT_CHECK_INTEGRITY             = (1UL << 19),
1466         BTRFS_MOUNT_CHECK_INTEGRITY_DATA        = (1UL << 20),
1467         BTRFS_MOUNT_PANIC_ON_FATAL_ERROR        = (1UL << 21),
1468         BTRFS_MOUNT_RESCAN_UUID_TREE            = (1UL << 22),
1469         BTRFS_MOUNT_FRAGMENT_DATA               = (1UL << 23),
1470         BTRFS_MOUNT_FRAGMENT_METADATA           = (1UL << 24),
1471         BTRFS_MOUNT_FREE_SPACE_TREE             = (1UL << 25),
1472         BTRFS_MOUNT_NOLOGREPLAY                 = (1UL << 26),
1473         BTRFS_MOUNT_REF_VERIFY                  = (1UL << 27),
1474         BTRFS_MOUNT_DISCARD_ASYNC               = (1UL << 28),
1475         BTRFS_MOUNT_IGNOREBADROOTS              = (1UL << 29),
1476         BTRFS_MOUNT_IGNOREDATACSUMS             = (1UL << 30),
1477 };
1478
1479 #define BTRFS_DEFAULT_COMMIT_INTERVAL   (30)
1480 #define BTRFS_DEFAULT_MAX_INLINE        (2048)
1481
1482 #define btrfs_clear_opt(o, opt)         ((o) &= ~BTRFS_MOUNT_##opt)
1483 #define btrfs_set_opt(o, opt)           ((o) |= BTRFS_MOUNT_##opt)
1484 #define btrfs_raw_test_opt(o, opt)      ((o) & BTRFS_MOUNT_##opt)
1485 #define btrfs_test_opt(fs_info, opt)    ((fs_info)->mount_opt & \
1486                                          BTRFS_MOUNT_##opt)
1487
1488 #define btrfs_set_and_info(fs_info, opt, fmt, args...)                  \
1489 do {                                                                    \
1490         if (!btrfs_test_opt(fs_info, opt))                              \
1491                 btrfs_info(fs_info, fmt, ##args);                       \
1492         btrfs_set_opt(fs_info->mount_opt, opt);                         \
1493 } while (0)
1494
1495 #define btrfs_clear_and_info(fs_info, opt, fmt, args...)                \
1496 do {                                                                    \
1497         if (btrfs_test_opt(fs_info, opt))                               \
1498                 btrfs_info(fs_info, fmt, ##args);                       \
1499         btrfs_clear_opt(fs_info->mount_opt, opt);                       \
1500 } while (0)
1501
1502 /*
1503  * Requests for changes that need to be done during transaction commit.
1504  *
1505  * Internal mount options that are used for special handling of the real
1506  * mount options (eg. cannot be set during remount and have to be set during
1507  * transaction commit)
1508  */
1509
1510 #define BTRFS_PENDING_COMMIT                    (0)
1511
1512 #define btrfs_test_pending(info, opt)   \
1513         test_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1514 #define btrfs_set_pending(info, opt)    \
1515         set_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1516 #define btrfs_clear_pending(info, opt)  \
1517         clear_bit(BTRFS_PENDING_##opt, &(info)->pending_changes)
1518
1519 /*
1520  * Helpers for setting pending mount option changes.
1521  *
1522  * Expects corresponding macros
1523  * BTRFS_PENDING_SET_ and CLEAR_ + short mount option name
1524  */
1525 #define btrfs_set_pending_and_info(info, opt, fmt, args...)            \
1526 do {                                                                   \
1527        if (!btrfs_raw_test_opt((info)->mount_opt, opt)) {              \
1528                btrfs_info((info), fmt, ##args);                        \
1529                btrfs_set_pending((info), SET_##opt);                   \
1530                btrfs_clear_pending((info), CLEAR_##opt);               \
1531        }                                                               \
1532 } while(0)
1533
1534 #define btrfs_clear_pending_and_info(info, opt, fmt, args...)          \
1535 do {                                                                   \
1536        if (btrfs_raw_test_opt((info)->mount_opt, opt)) {               \
1537                btrfs_info((info), fmt, ##args);                        \
1538                btrfs_set_pending((info), CLEAR_##opt);                 \
1539                btrfs_clear_pending((info), SET_##opt);                 \
1540        }                                                               \
1541 } while(0)
1542
1543 /*
1544  * Inode flags
1545  */
1546 #define BTRFS_INODE_NODATASUM           (1U << 0)
1547 #define BTRFS_INODE_NODATACOW           (1U << 1)
1548 #define BTRFS_INODE_READONLY            (1U << 2)
1549 #define BTRFS_INODE_NOCOMPRESS          (1U << 3)
1550 #define BTRFS_INODE_PREALLOC            (1U << 4)
1551 #define BTRFS_INODE_SYNC                (1U << 5)
1552 #define BTRFS_INODE_IMMUTABLE           (1U << 6)
1553 #define BTRFS_INODE_APPEND              (1U << 7)
1554 #define BTRFS_INODE_NODUMP              (1U << 8)
1555 #define BTRFS_INODE_NOATIME             (1U << 9)
1556 #define BTRFS_INODE_DIRSYNC             (1U << 10)
1557 #define BTRFS_INODE_COMPRESS            (1U << 11)
1558
1559 #define BTRFS_INODE_ROOT_ITEM_INIT      (1U << 31)
1560
1561 #define BTRFS_INODE_FLAG_MASK                                           \
1562         (BTRFS_INODE_NODATASUM |                                        \
1563          BTRFS_INODE_NODATACOW |                                        \
1564          BTRFS_INODE_READONLY |                                         \
1565          BTRFS_INODE_NOCOMPRESS |                                       \
1566          BTRFS_INODE_PREALLOC |                                         \
1567          BTRFS_INODE_SYNC |                                             \
1568          BTRFS_INODE_IMMUTABLE |                                        \
1569          BTRFS_INODE_APPEND |                                           \
1570          BTRFS_INODE_NODUMP |                                           \
1571          BTRFS_INODE_NOATIME |                                          \
1572          BTRFS_INODE_DIRSYNC |                                          \
1573          BTRFS_INODE_COMPRESS |                                         \
1574          BTRFS_INODE_ROOT_ITEM_INIT)
1575
1576 #define BTRFS_INODE_RO_VERITY           (1U << 0)
1577
1578 #define BTRFS_INODE_RO_FLAG_MASK        (BTRFS_INODE_RO_VERITY)
1579
1580 struct btrfs_map_token {
1581         struct extent_buffer *eb;
1582         char *kaddr;
1583         unsigned long offset;
1584 };
1585
1586 #define BTRFS_BYTES_TO_BLKS(fs_info, bytes) \
1587                                 ((bytes) >> (fs_info)->sectorsize_bits)
1588
1589 static inline void btrfs_init_map_token(struct btrfs_map_token *token,
1590                                         struct extent_buffer *eb)
1591 {
1592         token->eb = eb;
1593         token->kaddr = page_address(eb->pages[0]);
1594         token->offset = 0;
1595 }
1596
1597 /* some macros to generate set/get functions for the struct fields.  This
1598  * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1599  * one for u8:
1600  */
1601 #define le8_to_cpu(v) (v)
1602 #define cpu_to_le8(v) (v)
1603 #define __le8 u8
1604
1605 static inline u8 get_unaligned_le8(const void *p)
1606 {
1607        return *(u8 *)p;
1608 }
1609
1610 static inline void put_unaligned_le8(u8 val, void *p)
1611 {
1612        *(u8 *)p = val;
1613 }
1614
1615 #define read_eb_member(eb, ptr, type, member, result) (\
1616         read_extent_buffer(eb, (char *)(result),                        \
1617                            ((unsigned long)(ptr)) +                     \
1618                             offsetof(type, member),                     \
1619                            sizeof(((type *)0)->member)))
1620
1621 #define write_eb_member(eb, ptr, type, member, result) (\
1622         write_extent_buffer(eb, (char *)(result),                       \
1623                            ((unsigned long)(ptr)) +                     \
1624                             offsetof(type, member),                     \
1625                            sizeof(((type *)0)->member)))
1626
1627 #define DECLARE_BTRFS_SETGET_BITS(bits)                                 \
1628 u##bits btrfs_get_token_##bits(struct btrfs_map_token *token,           \
1629                                const void *ptr, unsigned long off);     \
1630 void btrfs_set_token_##bits(struct btrfs_map_token *token,              \
1631                             const void *ptr, unsigned long off,         \
1632                             u##bits val);                               \
1633 u##bits btrfs_get_##bits(const struct extent_buffer *eb,                \
1634                          const void *ptr, unsigned long off);           \
1635 void btrfs_set_##bits(const struct extent_buffer *eb, void *ptr,        \
1636                       unsigned long off, u##bits val);
1637
1638 DECLARE_BTRFS_SETGET_BITS(8)
1639 DECLARE_BTRFS_SETGET_BITS(16)
1640 DECLARE_BTRFS_SETGET_BITS(32)
1641 DECLARE_BTRFS_SETGET_BITS(64)
1642
1643 #define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
1644 static inline u##bits btrfs_##name(const struct extent_buffer *eb,      \
1645                                    const type *s)                       \
1646 {                                                                       \
1647         static_assert(sizeof(u##bits) == sizeof(((type *)0))->member);  \
1648         return btrfs_get_##bits(eb, s, offsetof(type, member));         \
1649 }                                                                       \
1650 static inline void btrfs_set_##name(const struct extent_buffer *eb, type *s, \
1651                                     u##bits val)                        \
1652 {                                                                       \
1653         static_assert(sizeof(u##bits) == sizeof(((type *)0))->member);  \
1654         btrfs_set_##bits(eb, s, offsetof(type, member), val);           \
1655 }                                                                       \
1656 static inline u##bits btrfs_token_##name(struct btrfs_map_token *token, \
1657                                          const type *s)                 \
1658 {                                                                       \
1659         static_assert(sizeof(u##bits) == sizeof(((type *)0))->member);  \
1660         return btrfs_get_token_##bits(token, s, offsetof(type, member));\
1661 }                                                                       \
1662 static inline void btrfs_set_token_##name(struct btrfs_map_token *token,\
1663                                           type *s, u##bits val)         \
1664 {                                                                       \
1665         static_assert(sizeof(u##bits) == sizeof(((type *)0))->member);  \
1666         btrfs_set_token_##bits(token, s, offsetof(type, member), val);  \
1667 }
1668
1669 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
1670 static inline u##bits btrfs_##name(const struct extent_buffer *eb)      \
1671 {                                                                       \
1672         const type *p = page_address(eb->pages[0]) +                    \
1673                         offset_in_page(eb->start);                      \
1674         return get_unaligned_le##bits(&p->member);                      \
1675 }                                                                       \
1676 static inline void btrfs_set_##name(const struct extent_buffer *eb,     \
1677                                     u##bits val)                        \
1678 {                                                                       \
1679         type *p = page_address(eb->pages[0]) + offset_in_page(eb->start); \
1680         put_unaligned_le##bits(val, &p->member);                        \
1681 }
1682
1683 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
1684 static inline u##bits btrfs_##name(const type *s)                       \
1685 {                                                                       \
1686         return get_unaligned_le##bits(&s->member);                      \
1687 }                                                                       \
1688 static inline void btrfs_set_##name(type *s, u##bits val)               \
1689 {                                                                       \
1690         put_unaligned_le##bits(val, &s->member);                        \
1691 }
1692
1693 static inline u64 btrfs_device_total_bytes(const struct extent_buffer *eb,
1694                                            struct btrfs_dev_item *s)
1695 {
1696         static_assert(sizeof(u64) ==
1697                       sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1698         return btrfs_get_64(eb, s, offsetof(struct btrfs_dev_item,
1699                                             total_bytes));
1700 }
1701 static inline void btrfs_set_device_total_bytes(const struct extent_buffer *eb,
1702                                                 struct btrfs_dev_item *s,
1703                                                 u64 val)
1704 {
1705         static_assert(sizeof(u64) ==
1706                       sizeof(((struct btrfs_dev_item *)0))->total_bytes);
1707         WARN_ON(!IS_ALIGNED(val, eb->fs_info->sectorsize));
1708         btrfs_set_64(eb, s, offsetof(struct btrfs_dev_item, total_bytes), val);
1709 }
1710
1711
1712 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1713 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1714 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1715 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1716 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1717                    start_offset, 64);
1718 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1719 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1720 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1721 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1722 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1723 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1724
1725 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1726 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1727                          total_bytes, 64);
1728 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1729                          bytes_used, 64);
1730 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1731                          io_align, 32);
1732 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1733                          io_width, 32);
1734 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1735                          sector_size, 32);
1736 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1737 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1738                          dev_group, 32);
1739 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1740                          seek_speed, 8);
1741 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1742                          bandwidth, 8);
1743 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1744                          generation, 64);
1745
1746 static inline unsigned long btrfs_device_uuid(struct btrfs_dev_item *d)
1747 {
1748         return (unsigned long)d + offsetof(struct btrfs_dev_item, uuid);
1749 }
1750
1751 static inline unsigned long btrfs_device_fsid(struct btrfs_dev_item *d)
1752 {
1753         return (unsigned long)d + offsetof(struct btrfs_dev_item, fsid);
1754 }
1755
1756 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1757 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1758 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1759 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1760 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1761 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1762 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1763 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1764 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1765 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1766 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1767
1768 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1769 {
1770         return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1771 }
1772
1773 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1774 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1775 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1776                          stripe_len, 64);
1777 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1778                          io_align, 32);
1779 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1780                          io_width, 32);
1781 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1782                          sector_size, 32);
1783 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1784 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1785                          num_stripes, 16);
1786 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1787                          sub_stripes, 16);
1788 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1789 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1790
1791 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1792                                                    int nr)
1793 {
1794         unsigned long offset = (unsigned long)c;
1795         offset += offsetof(struct btrfs_chunk, stripe);
1796         offset += nr * sizeof(struct btrfs_stripe);
1797         return (struct btrfs_stripe *)offset;
1798 }
1799
1800 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1801 {
1802         return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1803 }
1804
1805 static inline u64 btrfs_stripe_offset_nr(const struct extent_buffer *eb,
1806                                          struct btrfs_chunk *c, int nr)
1807 {
1808         return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1809 }
1810
1811 static inline u64 btrfs_stripe_devid_nr(const struct extent_buffer *eb,
1812                                          struct btrfs_chunk *c, int nr)
1813 {
1814         return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1815 }
1816
1817 /* struct btrfs_block_group_item */
1818 BTRFS_SETGET_STACK_FUNCS(stack_block_group_used, struct btrfs_block_group_item,
1819                          used, 64);
1820 BTRFS_SETGET_FUNCS(block_group_used, struct btrfs_block_group_item,
1821                          used, 64);
1822 BTRFS_SETGET_STACK_FUNCS(stack_block_group_chunk_objectid,
1823                         struct btrfs_block_group_item, chunk_objectid, 64);
1824
1825 BTRFS_SETGET_FUNCS(block_group_chunk_objectid,
1826                    struct btrfs_block_group_item, chunk_objectid, 64);
1827 BTRFS_SETGET_FUNCS(block_group_flags,
1828                    struct btrfs_block_group_item, flags, 64);
1829 BTRFS_SETGET_STACK_FUNCS(stack_block_group_flags,
1830                         struct btrfs_block_group_item, flags, 64);
1831
1832 /* struct btrfs_free_space_info */
1833 BTRFS_SETGET_FUNCS(free_space_extent_count, struct btrfs_free_space_info,
1834                    extent_count, 32);
1835 BTRFS_SETGET_FUNCS(free_space_flags, struct btrfs_free_space_info, flags, 32);
1836
1837 /* struct btrfs_inode_ref */
1838 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1839 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1840
1841 /* struct btrfs_inode_extref */
1842 BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
1843                    parent_objectid, 64);
1844 BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
1845                    name_len, 16);
1846 BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
1847
1848 /* struct btrfs_inode_item */
1849 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1850 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1851 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1852 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1853 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1854 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1855 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1856 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1857 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1858 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1859 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1860 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1861 BTRFS_SETGET_STACK_FUNCS(stack_inode_generation, struct btrfs_inode_item,
1862                          generation, 64);
1863 BTRFS_SETGET_STACK_FUNCS(stack_inode_sequence, struct btrfs_inode_item,
1864                          sequence, 64);
1865 BTRFS_SETGET_STACK_FUNCS(stack_inode_transid, struct btrfs_inode_item,
1866                          transid, 64);
1867 BTRFS_SETGET_STACK_FUNCS(stack_inode_size, struct btrfs_inode_item, size, 64);
1868 BTRFS_SETGET_STACK_FUNCS(stack_inode_nbytes, struct btrfs_inode_item,
1869                          nbytes, 64);
1870 BTRFS_SETGET_STACK_FUNCS(stack_inode_block_group, struct btrfs_inode_item,
1871                          block_group, 64);
1872 BTRFS_SETGET_STACK_FUNCS(stack_inode_nlink, struct btrfs_inode_item, nlink, 32);
1873 BTRFS_SETGET_STACK_FUNCS(stack_inode_uid, struct btrfs_inode_item, uid, 32);
1874 BTRFS_SETGET_STACK_FUNCS(stack_inode_gid, struct btrfs_inode_item, gid, 32);
1875 BTRFS_SETGET_STACK_FUNCS(stack_inode_mode, struct btrfs_inode_item, mode, 32);
1876 BTRFS_SETGET_STACK_FUNCS(stack_inode_rdev, struct btrfs_inode_item, rdev, 64);
1877 BTRFS_SETGET_STACK_FUNCS(stack_inode_flags, struct btrfs_inode_item, flags, 64);
1878 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1879 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1880 BTRFS_SETGET_STACK_FUNCS(stack_timespec_sec, struct btrfs_timespec, sec, 64);
1881 BTRFS_SETGET_STACK_FUNCS(stack_timespec_nsec, struct btrfs_timespec, nsec, 32);
1882
1883 /* struct btrfs_dev_extent */
1884 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1885                    chunk_tree, 64);
1886 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1887                    chunk_objectid, 64);
1888 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1889                    chunk_offset, 64);
1890 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1891 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1892 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1893                    generation, 64);
1894 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1895
1896 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1897
1898 static inline void btrfs_tree_block_key(const struct extent_buffer *eb,
1899                                         struct btrfs_tree_block_info *item,
1900                                         struct btrfs_disk_key *key)
1901 {
1902         read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1903 }
1904
1905 static inline void btrfs_set_tree_block_key(const struct extent_buffer *eb,
1906                                             struct btrfs_tree_block_info *item,
1907                                             struct btrfs_disk_key *key)
1908 {
1909         write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1910 }
1911
1912 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1913                    root, 64);
1914 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1915                    objectid, 64);
1916 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1917                    offset, 64);
1918 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1919                    count, 32);
1920
1921 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1922                    count, 32);
1923
1924 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1925                    type, 8);
1926 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1927                    offset, 64);
1928
1929 static inline u32 btrfs_extent_inline_ref_size(int type)
1930 {
1931         if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1932             type == BTRFS_SHARED_BLOCK_REF_KEY)
1933                 return sizeof(struct btrfs_extent_inline_ref);
1934         if (type == BTRFS_SHARED_DATA_REF_KEY)
1935                 return sizeof(struct btrfs_shared_data_ref) +
1936                        sizeof(struct btrfs_extent_inline_ref);
1937         if (type == BTRFS_EXTENT_DATA_REF_KEY)
1938                 return sizeof(struct btrfs_extent_data_ref) +
1939                        offsetof(struct btrfs_extent_inline_ref, offset);
1940         return 0;
1941 }
1942
1943 /* struct btrfs_node */
1944 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1945 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1946 BTRFS_SETGET_STACK_FUNCS(stack_key_blockptr, struct btrfs_key_ptr,
1947                          blockptr, 64);
1948 BTRFS_SETGET_STACK_FUNCS(stack_key_generation, struct btrfs_key_ptr,
1949                          generation, 64);
1950
1951 static inline u64 btrfs_node_blockptr(const struct extent_buffer *eb, int nr)
1952 {
1953         unsigned long ptr;
1954         ptr = offsetof(struct btrfs_node, ptrs) +
1955                 sizeof(struct btrfs_key_ptr) * nr;
1956         return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1957 }
1958
1959 static inline void btrfs_set_node_blockptr(const struct extent_buffer *eb,
1960                                            int nr, u64 val)
1961 {
1962         unsigned long ptr;
1963         ptr = offsetof(struct btrfs_node, ptrs) +
1964                 sizeof(struct btrfs_key_ptr) * nr;
1965         btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1966 }
1967
1968 static inline u64 btrfs_node_ptr_generation(const struct extent_buffer *eb, int nr)
1969 {
1970         unsigned long ptr;
1971         ptr = offsetof(struct btrfs_node, ptrs) +
1972                 sizeof(struct btrfs_key_ptr) * nr;
1973         return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1974 }
1975
1976 static inline void btrfs_set_node_ptr_generation(const struct extent_buffer *eb,
1977                                                  int nr, u64 val)
1978 {
1979         unsigned long ptr;
1980         ptr = offsetof(struct btrfs_node, ptrs) +
1981                 sizeof(struct btrfs_key_ptr) * nr;
1982         btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1983 }
1984
1985 static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1986 {
1987         return offsetof(struct btrfs_node, ptrs) +
1988                 sizeof(struct btrfs_key_ptr) * nr;
1989 }
1990
1991 void btrfs_node_key(const struct extent_buffer *eb,
1992                     struct btrfs_disk_key *disk_key, int nr);
1993
1994 static inline void btrfs_set_node_key(const struct extent_buffer *eb,
1995                                       struct btrfs_disk_key *disk_key, int nr)
1996 {
1997         unsigned long ptr;
1998         ptr = btrfs_node_key_ptr_offset(nr);
1999         write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
2000                        struct btrfs_key_ptr, key, disk_key);
2001 }
2002
2003 /* struct btrfs_item */
2004 BTRFS_SETGET_FUNCS(raw_item_offset, struct btrfs_item, offset, 32);
2005 BTRFS_SETGET_FUNCS(raw_item_size, struct btrfs_item, size, 32);
2006 BTRFS_SETGET_STACK_FUNCS(stack_item_offset, struct btrfs_item, offset, 32);
2007 BTRFS_SETGET_STACK_FUNCS(stack_item_size, struct btrfs_item, size, 32);
2008
2009 static inline unsigned long btrfs_item_nr_offset(int nr)
2010 {
2011         return offsetof(struct btrfs_leaf, items) +
2012                 sizeof(struct btrfs_item) * nr;
2013 }
2014
2015 static inline struct btrfs_item *btrfs_item_nr(int nr)
2016 {
2017         return (struct btrfs_item *)btrfs_item_nr_offset(nr);
2018 }
2019
2020 #define BTRFS_ITEM_SETGET_FUNCS(member)                                         \
2021 static inline u32 btrfs_item_##member(const struct extent_buffer *eb,           \
2022                                       int slot)                                 \
2023 {                                                                               \
2024         return btrfs_raw_item_##member(eb, btrfs_item_nr(slot));                \
2025 }                                                                               \
2026 static inline void btrfs_set_item_##member(const struct extent_buffer *eb,      \
2027                                            int slot, u32 val)                   \
2028 {                                                                               \
2029         btrfs_set_raw_item_##member(eb, btrfs_item_nr(slot), val);              \
2030 }                                                                               \
2031 static inline u32 btrfs_token_item_##member(struct btrfs_map_token *token,      \
2032                                             int slot)                           \
2033 {                                                                               \
2034         struct btrfs_item *item = btrfs_item_nr(slot);                          \
2035         return btrfs_token_raw_item_##member(token, item);                      \
2036 }                                                                               \
2037 static inline void btrfs_set_token_item_##member(struct btrfs_map_token *token, \
2038                                                  int slot, u32 val)             \
2039 {                                                                               \
2040         struct btrfs_item *item = btrfs_item_nr(slot);                          \
2041         btrfs_set_token_raw_item_##member(token, item, val);                    \
2042 }
2043
2044 BTRFS_ITEM_SETGET_FUNCS(offset)
2045 BTRFS_ITEM_SETGET_FUNCS(size);
2046
2047 static inline u32 btrfs_item_data_end(const struct extent_buffer *eb, int nr)
2048 {
2049         return btrfs_item_offset(eb, nr) + btrfs_item_size(eb, nr);
2050 }
2051
2052 static inline void btrfs_item_key(const struct extent_buffer *eb,
2053                            struct btrfs_disk_key *disk_key, int nr)
2054 {
2055         struct btrfs_item *item = btrfs_item_nr(nr);
2056         read_eb_member(eb, item, struct btrfs_item, key, disk_key);
2057 }
2058
2059 static inline void btrfs_set_item_key(struct extent_buffer *eb,
2060                                struct btrfs_disk_key *disk_key, int nr)
2061 {
2062         struct btrfs_item *item = btrfs_item_nr(nr);
2063         write_eb_member(eb, item, struct btrfs_item, key, disk_key);
2064 }
2065
2066 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
2067
2068 /*
2069  * struct btrfs_root_ref
2070  */
2071 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
2072 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
2073 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
2074
2075 /* struct btrfs_dir_item */
2076 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
2077 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
2078 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
2079 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
2080 BTRFS_SETGET_STACK_FUNCS(stack_dir_type, struct btrfs_dir_item, type, 8);
2081 BTRFS_SETGET_STACK_FUNCS(stack_dir_data_len, struct btrfs_dir_item,
2082                          data_len, 16);
2083 BTRFS_SETGET_STACK_FUNCS(stack_dir_name_len, struct btrfs_dir_item,
2084                          name_len, 16);
2085 BTRFS_SETGET_STACK_FUNCS(stack_dir_transid, struct btrfs_dir_item,
2086                          transid, 64);
2087
2088 static inline void btrfs_dir_item_key(const struct extent_buffer *eb,
2089                                       const struct btrfs_dir_item *item,
2090                                       struct btrfs_disk_key *key)
2091 {
2092         read_eb_member(eb, item, struct btrfs_dir_item, location, key);
2093 }
2094
2095 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
2096                                           struct btrfs_dir_item *item,
2097                                           const struct btrfs_disk_key *key)
2098 {
2099         write_eb_member(eb, item, struct btrfs_dir_item, location, key);
2100 }
2101
2102 BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
2103                    num_entries, 64);
2104 BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
2105                    num_bitmaps, 64);
2106 BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
2107                    generation, 64);
2108
2109 static inline void btrfs_free_space_key(const struct extent_buffer *eb,
2110                                         const struct btrfs_free_space_header *h,
2111                                         struct btrfs_disk_key *key)
2112 {
2113         read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2114 }
2115
2116 static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
2117                                             struct btrfs_free_space_header *h,
2118                                             const struct btrfs_disk_key *key)
2119 {
2120         write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2121 }
2122
2123 /* struct btrfs_disk_key */
2124 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
2125                          objectid, 64);
2126 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2127 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2128
2129 #ifdef __LITTLE_ENDIAN
2130
2131 /*
2132  * Optimized helpers for little-endian architectures where CPU and on-disk
2133  * structures have the same endianness and we can skip conversions.
2134  */
2135
2136 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu_key,
2137                                          const struct btrfs_disk_key *disk_key)
2138 {
2139         memcpy(cpu_key, disk_key, sizeof(struct btrfs_key));
2140 }
2141
2142 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk_key,
2143                                          const struct btrfs_key *cpu_key)
2144 {
2145         memcpy(disk_key, cpu_key, sizeof(struct btrfs_key));
2146 }
2147
2148 static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
2149                                          struct btrfs_key *cpu_key, int nr)
2150 {
2151         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
2152
2153         btrfs_node_key(eb, disk_key, nr);
2154 }
2155
2156 static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
2157                                          struct btrfs_key *cpu_key, int nr)
2158 {
2159         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
2160
2161         btrfs_item_key(eb, disk_key, nr);
2162 }
2163
2164 static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
2165                                              const struct btrfs_dir_item *item,
2166                                              struct btrfs_key *cpu_key)
2167 {
2168         struct btrfs_disk_key *disk_key = (struct btrfs_disk_key *)cpu_key;
2169
2170         btrfs_dir_item_key(eb, item, disk_key);
2171 }
2172
2173 #else
2174
2175 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2176                                          const struct btrfs_disk_key *disk)
2177 {
2178         cpu->offset = le64_to_cpu(disk->offset);
2179         cpu->type = disk->type;
2180         cpu->objectid = le64_to_cpu(disk->objectid);
2181 }
2182
2183 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
2184                                          const struct btrfs_key *cpu)
2185 {
2186         disk->offset = cpu_to_le64(cpu->offset);
2187         disk->type = cpu->type;
2188         disk->objectid = cpu_to_le64(cpu->objectid);
2189 }
2190
2191 static inline void btrfs_node_key_to_cpu(const struct extent_buffer *eb,
2192                                          struct btrfs_key *key, int nr)
2193 {
2194         struct btrfs_disk_key disk_key;
2195         btrfs_node_key(eb, &disk_key, nr);
2196         btrfs_disk_key_to_cpu(key, &disk_key);
2197 }
2198
2199 static inline void btrfs_item_key_to_cpu(const struct extent_buffer *eb,
2200                                          struct btrfs_key *key, int nr)
2201 {
2202         struct btrfs_disk_key disk_key;
2203         btrfs_item_key(eb, &disk_key, nr);
2204         btrfs_disk_key_to_cpu(key, &disk_key);
2205 }
2206
2207 static inline void btrfs_dir_item_key_to_cpu(const struct extent_buffer *eb,
2208                                              const struct btrfs_dir_item *item,
2209                                              struct btrfs_key *key)
2210 {
2211         struct btrfs_disk_key disk_key;
2212         btrfs_dir_item_key(eb, item, &disk_key);
2213         btrfs_disk_key_to_cpu(key, &disk_key);
2214 }
2215
2216 #endif
2217
2218 /* struct btrfs_header */
2219 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2220 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2221                           generation, 64);
2222 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2223 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
2224 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2225 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2226 BTRFS_SETGET_STACK_FUNCS(stack_header_generation, struct btrfs_header,
2227                          generation, 64);
2228 BTRFS_SETGET_STACK_FUNCS(stack_header_owner, struct btrfs_header, owner, 64);
2229 BTRFS_SETGET_STACK_FUNCS(stack_header_nritems, struct btrfs_header,
2230                          nritems, 32);
2231 BTRFS_SETGET_STACK_FUNCS(stack_header_bytenr, struct btrfs_header, bytenr, 64);
2232
2233 static inline int btrfs_header_flag(const struct extent_buffer *eb, u64 flag)
2234 {
2235         return (btrfs_header_flags(eb) & flag) == flag;
2236 }
2237
2238 static inline void btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2239 {
2240         u64 flags = btrfs_header_flags(eb);
2241         btrfs_set_header_flags(eb, flags | flag);
2242 }
2243
2244 static inline void btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2245 {
2246         u64 flags = btrfs_header_flags(eb);
2247         btrfs_set_header_flags(eb, flags & ~flag);
2248 }
2249
2250 static inline int btrfs_header_backref_rev(const struct extent_buffer *eb)
2251 {
2252         u64 flags = btrfs_header_flags(eb);
2253         return flags >> BTRFS_BACKREF_REV_SHIFT;
2254 }
2255
2256 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2257                                                 int rev)
2258 {
2259         u64 flags = btrfs_header_flags(eb);
2260         flags &= ~BTRFS_BACKREF_REV_MASK;
2261         flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2262         btrfs_set_header_flags(eb, flags);
2263 }
2264
2265 static inline int btrfs_is_leaf(const struct extent_buffer *eb)
2266 {
2267         return btrfs_header_level(eb) == 0;
2268 }
2269
2270 /* struct btrfs_root_item */
2271 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2272                    generation, 64);
2273 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2274 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2275 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2276
2277 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2278                          generation, 64);
2279 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2280 BTRFS_SETGET_STACK_FUNCS(root_drop_level, struct btrfs_root_item, drop_level, 8);
2281 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2282 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2283 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2284 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2285 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2286 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
2287 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2288                          last_snapshot, 64);
2289 BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2290                          generation_v2, 64);
2291 BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2292                          ctransid, 64);
2293 BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2294                          otransid, 64);
2295 BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2296                          stransid, 64);
2297 BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2298                          rtransid, 64);
2299
2300 static inline bool btrfs_root_readonly(const struct btrfs_root *root)
2301 {
2302         /* Byte-swap the constant at compile time, root_item::flags is LE */
2303         return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
2304 }
2305
2306 static inline bool btrfs_root_dead(const struct btrfs_root *root)
2307 {
2308         /* Byte-swap the constant at compile time, root_item::flags is LE */
2309         return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_DEAD)) != 0;
2310 }
2311
2312 static inline u64 btrfs_root_id(const struct btrfs_root *root)
2313 {
2314         return root->root_key.objectid;
2315 }
2316
2317 /* struct btrfs_root_backup */
2318 BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2319                    tree_root, 64);
2320 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2321                    tree_root_gen, 64);
2322 BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2323                    tree_root_level, 8);
2324
2325 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2326                    chunk_root, 64);
2327 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2328                    chunk_root_gen, 64);
2329 BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2330                    chunk_root_level, 8);
2331
2332 BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2333                    extent_root, 64);
2334 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2335                    extent_root_gen, 64);
2336 BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2337                    extent_root_level, 8);
2338
2339 BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2340                    fs_root, 64);
2341 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2342                    fs_root_gen, 64);
2343 BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2344                    fs_root_level, 8);
2345
2346 BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2347                    dev_root, 64);
2348 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2349                    dev_root_gen, 64);
2350 BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2351                    dev_root_level, 8);
2352
2353 BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2354                    csum_root, 64);
2355 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2356                    csum_root_gen, 64);
2357 BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2358                    csum_root_level, 8);
2359 BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2360                    total_bytes, 64);
2361 BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2362                    bytes_used, 64);
2363 BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2364                    num_devices, 64);
2365
2366 /*
2367  * For extent tree v2 we overload the extent root with the block group root, as
2368  * we will have multiple extent roots.
2369  */
2370 BTRFS_SETGET_STACK_FUNCS(backup_block_group_root, struct btrfs_root_backup,
2371                          extent_root, 64);
2372 BTRFS_SETGET_STACK_FUNCS(backup_block_group_root_gen, struct btrfs_root_backup,
2373                          extent_root_gen, 64);
2374 BTRFS_SETGET_STACK_FUNCS(backup_block_group_root_level,
2375                          struct btrfs_root_backup, extent_root_level, 8);
2376
2377 /* struct btrfs_balance_item */
2378 BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2379
2380 static inline void btrfs_balance_data(const struct extent_buffer *eb,
2381                                       const struct btrfs_balance_item *bi,
2382                                       struct btrfs_disk_balance_args *ba)
2383 {
2384         read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2385 }
2386
2387 static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2388                                   struct btrfs_balance_item *bi,
2389                                   const struct btrfs_disk_balance_args *ba)
2390 {
2391         write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2392 }
2393
2394 static inline void btrfs_balance_meta(const struct extent_buffer *eb,
2395                                       const struct btrfs_balance_item *bi,
2396                                       struct btrfs_disk_balance_args *ba)
2397 {
2398         read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2399 }
2400
2401 static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2402                                   struct btrfs_balance_item *bi,
2403                                   const struct btrfs_disk_balance_args *ba)
2404 {
2405         write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2406 }
2407
2408 static inline void btrfs_balance_sys(const struct extent_buffer *eb,
2409                                      const struct btrfs_balance_item *bi,
2410                                      struct btrfs_disk_balance_args *ba)
2411 {
2412         read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2413 }
2414
2415 static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2416                                  struct btrfs_balance_item *bi,
2417                                  const struct btrfs_disk_balance_args *ba)
2418 {
2419         write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2420 }
2421
2422 static inline void
2423 btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2424                                const struct btrfs_disk_balance_args *disk)
2425 {
2426         memset(cpu, 0, sizeof(*cpu));
2427
2428         cpu->profiles = le64_to_cpu(disk->profiles);
2429         cpu->usage = le64_to_cpu(disk->usage);
2430         cpu->devid = le64_to_cpu(disk->devid);
2431         cpu->pstart = le64_to_cpu(disk->pstart);
2432         cpu->pend = le64_to_cpu(disk->pend);
2433         cpu->vstart = le64_to_cpu(disk->vstart);
2434         cpu->vend = le64_to_cpu(disk->vend);
2435         cpu->target = le64_to_cpu(disk->target);
2436         cpu->flags = le64_to_cpu(disk->flags);
2437         cpu->limit = le64_to_cpu(disk->limit);
2438         cpu->stripes_min = le32_to_cpu(disk->stripes_min);
2439         cpu->stripes_max = le32_to_cpu(disk->stripes_max);
2440 }
2441
2442 static inline void
2443 btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2444                                const struct btrfs_balance_args *cpu)
2445 {
2446         memset(disk, 0, sizeof(*disk));
2447
2448         disk->profiles = cpu_to_le64(cpu->profiles);
2449         disk->usage = cpu_to_le64(cpu->usage);
2450         disk->devid = cpu_to_le64(cpu->devid);
2451         disk->pstart = cpu_to_le64(cpu->pstart);
2452         disk->pend = cpu_to_le64(cpu->pend);
2453         disk->vstart = cpu_to_le64(cpu->vstart);
2454         disk->vend = cpu_to_le64(cpu->vend);
2455         disk->target = cpu_to_le64(cpu->target);
2456         disk->flags = cpu_to_le64(cpu->flags);
2457         disk->limit = cpu_to_le64(cpu->limit);
2458         disk->stripes_min = cpu_to_le32(cpu->stripes_min);
2459         disk->stripes_max = cpu_to_le32(cpu->stripes_max);
2460 }
2461
2462 /* struct btrfs_super_block */
2463 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2464 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2465 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2466                          generation, 64);
2467 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2468 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2469                          struct btrfs_super_block, sys_chunk_array_size, 32);
2470 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2471                          struct btrfs_super_block, chunk_root_generation, 64);
2472 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2473                          root_level, 8);
2474 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2475                          chunk_root, 64);
2476 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2477                          chunk_root_level, 8);
2478 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2479                          log_root, 64);
2480 BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2481                          log_root_transid, 64);
2482 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2483                          log_root_level, 8);
2484 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2485                          total_bytes, 64);
2486 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2487                          bytes_used, 64);
2488 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2489                          sectorsize, 32);
2490 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2491                          nodesize, 32);
2492 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2493                          stripesize, 32);
2494 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2495                          root_dir_objectid, 64);
2496 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2497                          num_devices, 64);
2498 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2499                          compat_flags, 64);
2500 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2501                          compat_ro_flags, 64);
2502 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2503                          incompat_flags, 64);
2504 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2505                          csum_type, 16);
2506 BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2507                          cache_generation, 64);
2508 BTRFS_SETGET_STACK_FUNCS(super_magic, struct btrfs_super_block, magic, 64);
2509 BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
2510                          uuid_tree_generation, 64);
2511 BTRFS_SETGET_STACK_FUNCS(super_block_group_root, struct btrfs_super_block,
2512                          block_group_root, 64);
2513 BTRFS_SETGET_STACK_FUNCS(super_block_group_root_generation,
2514                          struct btrfs_super_block,
2515                          block_group_root_generation, 64);
2516 BTRFS_SETGET_STACK_FUNCS(super_block_group_root_level, struct btrfs_super_block,
2517                          block_group_root_level, 8);
2518
2519 int btrfs_super_csum_size(const struct btrfs_super_block *s);
2520 const char *btrfs_super_csum_name(u16 csum_type);
2521 const char *btrfs_super_csum_driver(u16 csum_type);
2522 size_t __attribute_const__ btrfs_get_num_csums(void);
2523
2524
2525 /*
2526  * The leaf data grows from end-to-front in the node.
2527  * this returns the address of the start of the last item,
2528  * which is the stop of the leaf data stack
2529  */
2530 static inline unsigned int leaf_data_end(const struct extent_buffer *leaf)
2531 {
2532         u32 nr = btrfs_header_nritems(leaf);
2533
2534         if (nr == 0)
2535                 return BTRFS_LEAF_DATA_SIZE(leaf->fs_info);
2536         return btrfs_item_offset(leaf, nr - 1);
2537 }
2538
2539 /* struct btrfs_file_extent_item */
2540 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
2541                          type, 8);
2542 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_bytenr,
2543                          struct btrfs_file_extent_item, disk_bytenr, 64);
2544 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_offset,
2545                          struct btrfs_file_extent_item, offset, 64);
2546 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_generation,
2547                          struct btrfs_file_extent_item, generation, 64);
2548 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_num_bytes,
2549                          struct btrfs_file_extent_item, num_bytes, 64);
2550 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_ram_bytes,
2551                          struct btrfs_file_extent_item, ram_bytes, 64);
2552 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_disk_num_bytes,
2553                          struct btrfs_file_extent_item, disk_num_bytes, 64);
2554 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_compression,
2555                          struct btrfs_file_extent_item, compression, 8);
2556
2557 static inline unsigned long
2558 btrfs_file_extent_inline_start(const struct btrfs_file_extent_item *e)
2559 {
2560         return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
2561 }
2562
2563 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2564 {
2565         return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
2566 }
2567
2568 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2569 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2570                    disk_bytenr, 64);
2571 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2572                    generation, 64);
2573 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2574                    disk_num_bytes, 64);
2575 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2576                   offset, 64);
2577 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2578                    num_bytes, 64);
2579 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2580                    ram_bytes, 64);
2581 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2582                    compression, 8);
2583 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2584                    encryption, 8);
2585 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2586                    other_encoding, 16);
2587
2588 /*
2589  * this returns the number of bytes used by the item on disk, minus the
2590  * size of any extent headers.  If a file is compressed on disk, this is
2591  * the compressed size
2592  */
2593 static inline u32 btrfs_file_extent_inline_item_len(
2594                                                 const struct extent_buffer *eb,
2595                                                 int nr)
2596 {
2597         return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
2598 }
2599
2600 /* btrfs_qgroup_status_item */
2601 BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2602                    generation, 64);
2603 BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2604                    version, 64);
2605 BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2606                    flags, 64);
2607 BTRFS_SETGET_FUNCS(qgroup_status_rescan, struct btrfs_qgroup_status_item,
2608                    rescan, 64);
2609
2610 /* btrfs_qgroup_info_item */
2611 BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2612                    generation, 64);
2613 BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2614 BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2615                    rfer_cmpr, 64);
2616 BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2617 BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2618                    excl_cmpr, 64);
2619
2620 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2621                          struct btrfs_qgroup_info_item, generation, 64);
2622 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2623                          rfer, 64);
2624 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2625                          struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2626 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2627                          excl, 64);
2628 BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2629                          struct btrfs_qgroup_info_item, excl_cmpr, 64);
2630
2631 /* btrfs_qgroup_limit_item */
2632 BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2633                    flags, 64);
2634 BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2635                    max_rfer, 64);
2636 BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2637                    max_excl, 64);
2638 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2639                    rsv_rfer, 64);
2640 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2641                    rsv_excl, 64);
2642
2643 /* btrfs_dev_replace_item */
2644 BTRFS_SETGET_FUNCS(dev_replace_src_devid,
2645                    struct btrfs_dev_replace_item, src_devid, 64);
2646 BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
2647                    struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
2648                    64);
2649 BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
2650                    replace_state, 64);
2651 BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
2652                    time_started, 64);
2653 BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
2654                    time_stopped, 64);
2655 BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
2656                    num_write_errors, 64);
2657 BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
2658                    struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
2659                    64);
2660 BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
2661                    cursor_left, 64);
2662 BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
2663                    cursor_right, 64);
2664
2665 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
2666                          struct btrfs_dev_replace_item, src_devid, 64);
2667 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
2668                          struct btrfs_dev_replace_item,
2669                          cont_reading_from_srcdev_mode, 64);
2670 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
2671                          struct btrfs_dev_replace_item, replace_state, 64);
2672 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
2673                          struct btrfs_dev_replace_item, time_started, 64);
2674 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
2675                          struct btrfs_dev_replace_item, time_stopped, 64);
2676 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
2677                          struct btrfs_dev_replace_item, num_write_errors, 64);
2678 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
2679                          struct btrfs_dev_replace_item,
2680                          num_uncorrectable_read_errors, 64);
2681 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
2682                          struct btrfs_dev_replace_item, cursor_left, 64);
2683 BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
2684                          struct btrfs_dev_replace_item, cursor_right, 64);
2685
2686 /* helper function to cast into the data area of the leaf. */
2687 #define btrfs_item_ptr(leaf, slot, type) \
2688         ((type *)(BTRFS_LEAF_DATA_OFFSET + \
2689         btrfs_item_offset(leaf, slot)))
2690
2691 #define btrfs_item_ptr_offset(leaf, slot) \
2692         ((unsigned long)(BTRFS_LEAF_DATA_OFFSET + \
2693         btrfs_item_offset(leaf, slot)))
2694
2695 static inline u32 btrfs_crc32c(u32 crc, const void *address, unsigned length)
2696 {
2697         return crc32c(crc, address, length);
2698 }
2699
2700 static inline void btrfs_crc32c_final(u32 crc, u8 *result)
2701 {
2702         put_unaligned_le32(~crc, result);
2703 }
2704
2705 static inline u64 btrfs_name_hash(const char *name, int len)
2706 {
2707        return crc32c((u32)~1, name, len);
2708 }
2709
2710 /*
2711  * Figure the key offset of an extended inode ref
2712  */
2713 static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,
2714                                    int len)
2715 {
2716        return (u64) crc32c(parent_objectid, name, len);
2717 }
2718
2719 static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2720 {
2721         return mapping_gfp_constraint(mapping, ~__GFP_FS);
2722 }
2723
2724 /* extent-tree.c */
2725
2726 enum btrfs_inline_ref_type {
2727         BTRFS_REF_TYPE_INVALID,
2728         BTRFS_REF_TYPE_BLOCK,
2729         BTRFS_REF_TYPE_DATA,
2730         BTRFS_REF_TYPE_ANY,
2731 };
2732
2733 int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
2734                                      struct btrfs_extent_inline_ref *iref,
2735                                      enum btrfs_inline_ref_type is_data);
2736 u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset);
2737
2738 /*
2739  * Take the number of bytes to be checksummmed and figure out how many leaves
2740  * it would require to store the csums for that many bytes.
2741  */
2742 static inline u64 btrfs_csum_bytes_to_leaves(
2743                         const struct btrfs_fs_info *fs_info, u64 csum_bytes)
2744 {
2745         const u64 num_csums = csum_bytes >> fs_info->sectorsize_bits;
2746
2747         return DIV_ROUND_UP_ULL(num_csums, fs_info->csums_per_leaf);
2748 }
2749
2750 /*
2751  * Use this if we would be adding new items, as we could split nodes as we cow
2752  * down the tree.
2753  */
2754 static inline u64 btrfs_calc_insert_metadata_size(struct btrfs_fs_info *fs_info,
2755                                                   unsigned num_items)
2756 {
2757         return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * 2 * num_items;
2758 }
2759
2760 /*
2761  * Doing a truncate or a modification won't result in new nodes or leaves, just
2762  * what we need for COW.
2763  */
2764 static inline u64 btrfs_calc_metadata_size(struct btrfs_fs_info *fs_info,
2765                                                  unsigned num_items)
2766 {
2767         return (u64)fs_info->nodesize * BTRFS_MAX_LEVEL * num_items;
2768 }
2769
2770 int btrfs_add_excluded_extent(struct btrfs_fs_info *fs_info,
2771                               u64 start, u64 num_bytes);
2772 void btrfs_free_excluded_extents(struct btrfs_block_group *cache);
2773 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2774                            unsigned long count);
2775 void btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,
2776                                   struct btrfs_delayed_ref_root *delayed_refs,
2777                                   struct btrfs_delayed_ref_head *head);
2778 int btrfs_lookup_data_extent(struct btrfs_fs_info *fs_info, u64 start, u64 len);
2779 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2780                              struct btrfs_fs_info *fs_info, u64 bytenr,
2781                              u64 offset, int metadata, u64 *refs, u64 *flags);
2782 int btrfs_pin_extent(struct btrfs_trans_handle *trans, u64 bytenr, u64 num,
2783                      int reserved);
2784 int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2785                                     u64 bytenr, u64 num_bytes);
2786 int btrfs_exclude_logged_extents(struct extent_buffer *eb);
2787 int btrfs_cross_ref_exist(struct btrfs_root *root,
2788                           u64 objectid, u64 offset, u64 bytenr, bool strict,
2789                           struct btrfs_path *path);
2790 struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
2791                                              struct btrfs_root *root,
2792                                              u64 parent, u64 root_objectid,
2793                                              const struct btrfs_disk_key *key,
2794                                              int level, u64 hint,
2795                                              u64 empty_size,
2796                                              enum btrfs_lock_nesting nest);
2797 void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2798                            u64 root_id,
2799                            struct extent_buffer *buf,
2800                            u64 parent, int last_ref);
2801 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
2802                                      struct btrfs_root *root, u64 owner,
2803                                      u64 offset, u64 ram_bytes,
2804                                      struct btrfs_key *ins);
2805 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2806                                    u64 root_objectid, u64 owner, u64 offset,
2807                                    struct btrfs_key *ins);
2808 int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes, u64 num_bytes,
2809                          u64 min_alloc_size, u64 empty_size, u64 hint_byte,
2810                          struct btrfs_key *ins, int is_data, int delalloc);
2811 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2812                   struct extent_buffer *buf, int full_backref);
2813 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2814                   struct extent_buffer *buf, int full_backref);
2815 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2816                                 struct extent_buffer *eb, u64 flags, int level);
2817 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_ref *ref);
2818
2819 int btrfs_free_reserved_extent(struct btrfs_fs_info *fs_info,
2820                                u64 start, u64 len, int delalloc);
2821 int btrfs_pin_reserved_extent(struct btrfs_trans_handle *trans, u64 start,
2822                               u64 len);
2823 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans);
2824 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2825                          struct btrfs_ref *generic_ref);
2826
2827 void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2828
2829 /*
2830  * Different levels for to flush space when doing space reservations.
2831  *
2832  * The higher the level, the more methods we try to reclaim space.
2833  */
2834 enum btrfs_reserve_flush_enum {
2835         /* If we are in the transaction, we can't flush anything.*/
2836         BTRFS_RESERVE_NO_FLUSH,
2837
2838         /*
2839          * Flush space by:
2840          * - Running delayed inode items
2841          * - Allocating a new chunk
2842          */
2843         BTRFS_RESERVE_FLUSH_LIMIT,
2844
2845         /*
2846          * Flush space by:
2847          * - Running delayed inode items
2848          * - Running delayed refs
2849          * - Running delalloc and waiting for ordered extents
2850          * - Allocating a new chunk
2851          */
2852         BTRFS_RESERVE_FLUSH_EVICT,
2853
2854         /*
2855          * Flush space by above mentioned methods and by:
2856          * - Running delayed iputs
2857          * - Committing transaction
2858          *
2859          * Can be interrupted by a fatal signal.
2860          */
2861         BTRFS_RESERVE_FLUSH_DATA,
2862         BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE,
2863         BTRFS_RESERVE_FLUSH_ALL,
2864
2865         /*
2866          * Pretty much the same as FLUSH_ALL, but can also steal space from
2867          * global rsv.
2868          *
2869          * Can be interrupted by a fatal signal.
2870          */
2871         BTRFS_RESERVE_FLUSH_ALL_STEAL,
2872 };
2873
2874 enum btrfs_flush_state {
2875         FLUSH_DELAYED_ITEMS_NR  =       1,
2876         FLUSH_DELAYED_ITEMS     =       2,
2877         FLUSH_DELAYED_REFS_NR   =       3,
2878         FLUSH_DELAYED_REFS      =       4,
2879         FLUSH_DELALLOC          =       5,
2880         FLUSH_DELALLOC_WAIT     =       6,
2881         FLUSH_DELALLOC_FULL     =       7,
2882         ALLOC_CHUNK             =       8,
2883         ALLOC_CHUNK_FORCE       =       9,
2884         RUN_DELAYED_IPUTS       =       10,
2885         COMMIT_TRANS            =       11,
2886 };
2887
2888 int btrfs_subvolume_reserve_metadata(struct btrfs_root *root,
2889                                      struct btrfs_block_rsv *rsv,
2890                                      int nitems, bool use_global_rsv);
2891 void btrfs_subvolume_release_metadata(struct btrfs_root *root,
2892                                       struct btrfs_block_rsv *rsv);
2893 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes);
2894
2895 int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes,
2896                                     u64 disk_num_bytes, bool noflush);
2897 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2898 int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
2899                                    u64 start, u64 end);
2900 int btrfs_discard_extent(struct btrfs_fs_info *fs_info, u64 bytenr,
2901                          u64 num_bytes, u64 *actual_bytes);
2902 int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range);
2903
2904 int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
2905 int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2906                                          struct btrfs_fs_info *fs_info);
2907 int btrfs_start_write_no_snapshotting(struct btrfs_root *root);
2908 void btrfs_end_write_no_snapshotting(struct btrfs_root *root);
2909 void btrfs_wait_for_snapshot_creation(struct btrfs_root *root);
2910
2911 /* ctree.c */
2912 int btrfs_bin_search(struct extent_buffer *eb, const struct btrfs_key *key,
2913                      int *slot);
2914 int __pure btrfs_comp_cpu_keys(const struct btrfs_key *k1, const struct btrfs_key *k2);
2915 int btrfs_previous_item(struct btrfs_root *root,
2916                         struct btrfs_path *path, u64 min_objectid,
2917                         int type);
2918 int btrfs_previous_extent_item(struct btrfs_root *root,
2919                         struct btrfs_path *path, u64 min_objectid);
2920 void btrfs_set_item_key_safe(struct btrfs_fs_info *fs_info,
2921                              struct btrfs_path *path,
2922                              const struct btrfs_key *new_key);
2923 struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2924 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2925                         struct btrfs_key *key, int lowest_level,
2926                         u64 min_trans);
2927 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2928                          struct btrfs_path *path,
2929                          u64 min_trans);
2930 struct extent_buffer *btrfs_read_node_slot(struct extent_buffer *parent,
2931                                            int slot);
2932
2933 int btrfs_cow_block(struct btrfs_trans_handle *trans,
2934                     struct btrfs_root *root, struct extent_buffer *buf,
2935                     struct extent_buffer *parent, int parent_slot,
2936                     struct extent_buffer **cow_ret,
2937                     enum btrfs_lock_nesting nest);
2938 int btrfs_copy_root(struct btrfs_trans_handle *trans,
2939                       struct btrfs_root *root,
2940                       struct extent_buffer *buf,
2941                       struct extent_buffer **cow_ret, u64 new_root_objectid);
2942 int btrfs_block_can_be_shared(struct btrfs_root *root,
2943                               struct extent_buffer *buf);
2944 void btrfs_extend_item(struct btrfs_path *path, u32 data_size);
2945 void btrfs_truncate_item(struct btrfs_path *path, u32 new_size, int from_end);
2946 int btrfs_split_item(struct btrfs_trans_handle *trans,
2947                      struct btrfs_root *root,
2948                      struct btrfs_path *path,
2949                      const struct btrfs_key *new_key,
2950                      unsigned long split_offset);
2951 int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2952                          struct btrfs_root *root,
2953                          struct btrfs_path *path,
2954                          const struct btrfs_key *new_key);
2955 int btrfs_find_item(struct btrfs_root *fs_root, struct btrfs_path *path,
2956                 u64 inum, u64 ioff, u8 key_type, struct btrfs_key *found_key);
2957 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2958                       const struct btrfs_key *key, struct btrfs_path *p,
2959                       int ins_len, int cow);
2960 int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
2961                           struct btrfs_path *p, u64 time_seq);
2962 int btrfs_search_slot_for_read(struct btrfs_root *root,
2963                                const struct btrfs_key *key,
2964                                struct btrfs_path *p, int find_higher,
2965                                int return_any);
2966 int btrfs_realloc_node(struct btrfs_trans_handle *trans,
2967                        struct btrfs_root *root, struct extent_buffer *parent,
2968                        int start_slot, u64 *last_ret,
2969                        struct btrfs_key *progress);
2970 void btrfs_release_path(struct btrfs_path *p);
2971 struct btrfs_path *btrfs_alloc_path(void);
2972 void btrfs_free_path(struct btrfs_path *p);
2973
2974 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2975                    struct btrfs_path *path, int slot, int nr);
2976 static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2977                                  struct btrfs_root *root,
2978                                  struct btrfs_path *path)
2979 {
2980         return btrfs_del_items(trans, root, path, path->slots[0], 1);
2981 }
2982
2983 /*
2984  * Describes a batch of items to insert in a btree. This is used by
2985  * btrfs_insert_empty_items().
2986  */
2987 struct btrfs_item_batch {
2988         /*
2989          * Pointer to an array containing the keys of the items to insert (in
2990          * sorted order).
2991          */
2992         const struct btrfs_key *keys;
2993         /* Pointer to an array containing the data size for each item to insert. */
2994         const u32 *data_sizes;
2995         /*
2996          * The sum of data sizes for all items. The caller can compute this while
2997          * setting up the data_sizes array, so it ends up being more efficient
2998          * than having btrfs_insert_empty_items() or setup_item_for_insert()
2999          * doing it, as it would avoid an extra loop over a potentially large
3000          * array, and in the case of setup_item_for_insert(), we would be doing
3001          * it while holding a write lock on a leaf and often on upper level nodes
3002          * too, unnecessarily increasing the size of a critical section.
3003          */
3004         u32 total_data_size;
3005         /* Size of the keys and data_sizes arrays (number of items in the batch). */
3006         int nr;
3007 };
3008
3009 void btrfs_setup_item_for_insert(struct btrfs_root *root,
3010                                  struct btrfs_path *path,
3011                                  const struct btrfs_key *key,
3012                                  u32 data_size);
3013 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3014                       const struct btrfs_key *key, void *data, u32 data_size);
3015 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
3016                              struct btrfs_root *root,
3017                              struct btrfs_path *path,
3018                              const struct btrfs_item_batch *batch);
3019
3020 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
3021                                           struct btrfs_root *root,
3022                                           struct btrfs_path *path,
3023                                           const struct btrfs_key *key,
3024                                           u32 data_size)
3025 {
3026         struct btrfs_item_batch batch;
3027
3028         batch.keys = key;
3029         batch.data_sizes = &data_size;
3030         batch.total_data_size = data_size;
3031         batch.nr = 1;
3032
3033         return btrfs_insert_empty_items(trans, root, path, &batch);
3034 }
3035
3036 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
3037 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
3038                         u64 time_seq);
3039
3040 int btrfs_search_backwards(struct btrfs_root *root, struct btrfs_key *key,
3041                            struct btrfs_path *path);
3042
3043 int btrfs_get_next_valid_item(struct btrfs_root *root, struct btrfs_key *key,
3044                               struct btrfs_path *path);
3045
3046 /*
3047  * Search in @root for a given @key, and store the slot found in @found_key.
3048  *
3049  * @root:       The root node of the tree.
3050  * @key:        The key we are looking for.
3051  * @found_key:  Will hold the found item.
3052  * @path:       Holds the current slot/leaf.
3053  * @iter_ret:   Contains the value returned from btrfs_search_slot or
3054  *              btrfs_get_next_valid_item, whichever was executed last.
3055  *
3056  * The @iter_ret is an output variable that will contain the return value of
3057  * btrfs_search_slot, if it encountered an error, or the value returned from
3058  * btrfs_get_next_valid_item otherwise. That return value can be 0, if a valid
3059  * slot was found, 1 if there were no more leaves, and <0 if there was an error.
3060  *
3061  * It's recommended to use a separate variable for iter_ret and then use it to
3062  * set the function return value so there's no confusion of the 0/1/errno
3063  * values stemming from btrfs_search_slot.
3064  */
3065 #define btrfs_for_each_slot(root, key, found_key, path, iter_ret)               \
3066         for (iter_ret = btrfs_search_slot(NULL, (root), (key), (path), 0, 0);   \
3067                 (iter_ret) >= 0 &&                                              \
3068                 (iter_ret = btrfs_get_next_valid_item((root), (found_key), (path))) == 0; \
3069                 (path)->slots[0]++                                              \
3070         )
3071
3072 static inline int btrfs_next_old_item(struct btrfs_root *root,
3073                                       struct btrfs_path *p, u64 time_seq)
3074 {
3075         ++p->slots[0];
3076         if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
3077                 return btrfs_next_old_leaf(root, p, time_seq);
3078         return 0;
3079 }
3080
3081 /*
3082  * Search the tree again to find a leaf with greater keys.
3083  *
3084  * Returns 0 if it found something or 1 if there are no greater leaves.
3085  * Returns < 0 on error.
3086  */
3087 static inline int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
3088 {
3089         return btrfs_next_old_leaf(root, path, 0);
3090 }
3091
3092 static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
3093 {
3094         return btrfs_next_old_item(root, p, 0);
3095 }
3096 int btrfs_leaf_free_space(struct extent_buffer *leaf);
3097 int __must_check btrfs_drop_snapshot(struct btrfs_root *root, int update_ref,
3098                                      int for_reloc);
3099 int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
3100                         struct btrfs_root *root,
3101                         struct extent_buffer *node,
3102                         struct extent_buffer *parent);
3103 static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
3104 {
3105         /*
3106          * Do it this way so we only ever do one test_bit in the normal case.
3107          */
3108         if (test_bit(BTRFS_FS_CLOSING_START, &fs_info->flags)) {
3109                 if (test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags))
3110                         return 2;
3111                 return 1;
3112         }
3113         return 0;
3114 }
3115
3116 /*
3117  * If we remount the fs to be R/O or umount the fs, the cleaner needn't do
3118  * anything except sleeping. This function is used to check the status of
3119  * the fs.
3120  * We check for BTRFS_FS_STATE_RO to avoid races with a concurrent remount,
3121  * since setting and checking for SB_RDONLY in the superblock's flags is not
3122  * atomic.
3123  */
3124 static inline int btrfs_need_cleaner_sleep(struct btrfs_fs_info *fs_info)
3125 {
3126         return test_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state) ||
3127                 btrfs_fs_closing(fs_info);
3128 }
3129
3130 static inline void btrfs_set_sb_rdonly(struct super_block *sb)
3131 {
3132         sb->s_flags |= SB_RDONLY;
3133         set_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
3134 }
3135
3136 static inline void btrfs_clear_sb_rdonly(struct super_block *sb)
3137 {
3138         sb->s_flags &= ~SB_RDONLY;
3139         clear_bit(BTRFS_FS_STATE_RO, &btrfs_sb(sb)->fs_state);
3140 }
3141
3142 /* root-item.c */
3143 int btrfs_add_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
3144                        u64 ref_id, u64 dirid, u64 sequence, const char *name,
3145                        int name_len);
3146 int btrfs_del_root_ref(struct btrfs_trans_handle *trans, u64 root_id,
3147                        u64 ref_id, u64 dirid, u64 *sequence, const char *name,
3148                        int name_len);
3149 int btrfs_del_root(struct btrfs_trans_handle *trans,
3150                    const struct btrfs_key *key);
3151 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3152                       const struct btrfs_key *key,
3153                       struct btrfs_root_item *item);
3154 int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
3155                                    struct btrfs_root *root,
3156                                    struct btrfs_key *key,
3157                                    struct btrfs_root_item *item);
3158 int btrfs_find_root(struct btrfs_root *root, const struct btrfs_key *search_key,
3159                     struct btrfs_path *path, struct btrfs_root_item *root_item,
3160                     struct btrfs_key *root_key);
3161 int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info);
3162 void btrfs_set_root_node(struct btrfs_root_item *item,
3163                          struct extent_buffer *node);
3164 void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
3165 void btrfs_update_root_times(struct btrfs_trans_handle *trans,
3166                              struct btrfs_root *root);
3167
3168 /* uuid-tree.c */
3169 int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
3170                         u64 subid);
3171 int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type,
3172                         u64 subid);
3173 int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info);
3174
3175 /* dir-item.c */
3176 int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
3177                           const char *name, int name_len);
3178 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, const char *name,
3179                           int name_len, struct btrfs_inode *dir,
3180                           struct btrfs_key *location, u8 type, u64 index);
3181 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
3182                                              struct btrfs_root *root,
3183                                              struct btrfs_path *path, u64 dir,
3184                                              const char *name, int name_len,
3185                                              int mod);
3186 struct btrfs_dir_item *
3187 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
3188                             struct btrfs_root *root,
3189                             struct btrfs_path *path, u64 dir,
3190                             u64 index, const char *name, int name_len,
3191                             int mod);
3192 struct btrfs_dir_item *
3193 btrfs_search_dir_index_item(struct btrfs_root *root,
3194                             struct btrfs_path *path, u64 dirid,
3195                             const char *name, int name_len);
3196 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
3197                               struct btrfs_root *root,
3198                               struct btrfs_path *path,
3199                               struct btrfs_dir_item *di);
3200 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3201                             struct btrfs_root *root,
3202                             struct btrfs_path *path, u64 objectid,
3203                             const char *name, u16 name_len,
3204                             const void *data, u16 data_len);
3205 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3206                                           struct btrfs_root *root,
3207                                           struct btrfs_path *path, u64 dir,
3208                                           const char *name, u16 name_len,
3209                                           int mod);
3210 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,
3211                                                  struct btrfs_path *path,
3212                                                  const char *name,
3213                                                  int name_len);
3214
3215 /* orphan.c */
3216 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3217                              struct btrfs_root *root, u64 offset);
3218 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3219                           struct btrfs_root *root, u64 offset);
3220 int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3221
3222 /* file-item.c */
3223 int btrfs_del_csums(struct btrfs_trans_handle *trans,
3224                     struct btrfs_root *root, u64 bytenr, u64 len);
3225 blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u8 *dst);
3226 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3227                              struct btrfs_root *root,
3228                              u64 objectid, u64 pos,
3229                              u64 disk_offset, u64 disk_num_bytes,
3230                              u64 num_bytes, u64 offset, u64 ram_bytes,
3231                              u8 compression, u8 encryption, u16 other_encoding);
3232 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3233                              struct btrfs_root *root,
3234                              struct btrfs_path *path, u64 objectid,
3235                              u64 bytenr, int mod);
3236 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3237                            struct btrfs_root *root,
3238                            struct btrfs_ordered_sum *sums);
3239 blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
3240                                 u64 offset, bool one_ordered);
3241 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3242                              struct list_head *list, int search_commit);
3243 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
3244                                      const struct btrfs_path *path,
3245                                      struct btrfs_file_extent_item *fi,
3246                                      const bool new_inline,
3247                                      struct extent_map *em);
3248 int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
3249                                         u64 len);
3250 int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
3251                                       u64 len);
3252 void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_size);
3253 u64 btrfs_file_extent_end(const struct btrfs_path *path);
3254
3255 /* inode.c */
3256 void btrfs_submit_data_bio(struct inode *inode, struct bio *bio,
3257                            int mirror_num, enum btrfs_compression_type compress_type);
3258 unsigned int btrfs_verify_data_csum(struct btrfs_bio *bbio,
3259                                     u32 bio_offset, struct page *page,
3260                                     u64 start, u64 end);
3261 struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
3262                                            u64 start, u64 len);
3263 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
3264                               u64 *orig_start, u64 *orig_block_len,
3265                               u64 *ram_bytes, bool strict);
3266
3267 void __btrfs_del_delalloc_inode(struct btrfs_root *root,
3268                                 struct btrfs_inode *inode);
3269 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3270 int btrfs_set_inode_index(struct btrfs_inode *dir, u64 *index);
3271 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3272                        struct btrfs_inode *dir, struct btrfs_inode *inode,
3273                        const char *name, int name_len);
3274 int btrfs_add_link(struct btrfs_trans_handle *trans,
3275                    struct btrfs_inode *parent_inode, struct btrfs_inode *inode,
3276                    const char *name, int name_len, int add_backref, u64 index);
3277 int btrfs_delete_subvolume(struct inode *dir, struct dentry *dentry);
3278 int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,
3279                          int front);
3280
3281 int btrfs_start_delalloc_snapshot(struct btrfs_root *root, bool in_reclaim_context);
3282 int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, long nr,
3283                                bool in_reclaim_context);
3284 int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
3285                               unsigned int extra_bits,
3286                               struct extent_state **cached_state);
3287 struct btrfs_new_inode_args {
3288         /* Input */
3289         struct inode *dir;
3290         struct dentry *dentry;
3291         struct inode *inode;
3292         bool orphan;
3293         bool subvol;
3294
3295         /*
3296          * Output from btrfs_new_inode_prepare(), input to
3297          * btrfs_create_new_inode().
3298          */
3299         struct posix_acl *default_acl;
3300         struct posix_acl *acl;
3301 };
3302 int btrfs_new_inode_prepare(struct btrfs_new_inode_args *args,
3303                             unsigned int *trans_num_items);
3304 int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
3305                            struct btrfs_new_inode_args *args);
3306 void btrfs_new_inode_args_destroy(struct btrfs_new_inode_args *args);
3307 struct inode *btrfs_new_subvol_inode(struct user_namespace *mnt_userns,
3308                                      struct inode *dir);
3309  void btrfs_set_delalloc_extent(struct inode *inode, struct extent_state *state,
3310                                unsigned *bits);
3311 void btrfs_clear_delalloc_extent(struct inode *inode,
3312                                  struct extent_state *state, unsigned *bits);
3313 void btrfs_merge_delalloc_extent(struct inode *inode, struct extent_state *new,
3314                                  struct extent_state *other);
3315 void btrfs_split_delalloc_extent(struct inode *inode,
3316                                  struct extent_state *orig, u64 split);
3317 void btrfs_set_range_writeback(struct btrfs_inode *inode, u64 start, u64 end);
3318 vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf);
3319 void btrfs_evict_inode(struct inode *inode);
3320 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
3321 struct inode *btrfs_alloc_inode(struct super_block *sb);
3322 void btrfs_destroy_inode(struct inode *inode);
3323 void btrfs_free_inode(struct inode *inode);
3324 int btrfs_drop_inode(struct inode *inode);
3325 int __init btrfs_init_cachep(void);
3326 void __cold btrfs_destroy_cachep(void);
3327 struct inode *btrfs_iget_path(struct super_block *s, u64 ino,
3328                               struct btrfs_root *root, struct btrfs_path *path);
3329 struct inode *btrfs_iget(struct super_block *s, u64 ino, struct btrfs_root *root);
3330 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
3331                                     struct page *page, size_t pg_offset,
3332                                     u64 start, u64 end);
3333 int btrfs_update_inode(struct btrfs_trans_handle *trans,
3334                        struct btrfs_root *root, struct btrfs_inode *inode);
3335 int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3336                                 struct btrfs_root *root, struct btrfs_inode *inode);
3337 int btrfs_orphan_add(struct btrfs_trans_handle *trans,
3338                 struct btrfs_inode *inode);
3339 int btrfs_orphan_cleanup(struct btrfs_root *root);
3340 int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size);
3341 void btrfs_add_delayed_iput(struct inode *inode);
3342 void btrfs_run_delayed_iputs(struct btrfs_fs_info *fs_info);
3343 int btrfs_wait_on_delayed_iputs(struct btrfs_fs_info *fs_info);
3344 int btrfs_prealloc_file_range(struct inode *inode, int mode,
3345                               u64 start, u64 num_bytes, u64 min_size,
3346                               loff_t actual_len, u64 *alloc_hint);
3347 int btrfs_prealloc_file_range_trans(struct inode *inode,
3348                                     struct btrfs_trans_handle *trans, int mode,
3349                                     u64 start, u64 num_bytes, u64 min_size,
3350                                     loff_t actual_len, u64 *alloc_hint);
3351 int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct page *locked_page,
3352                 u64 start, u64 end, int *page_started, unsigned long *nr_written,
3353                 struct writeback_control *wbc);
3354 int btrfs_writepage_cow_fixup(struct page *page);
3355 void btrfs_writepage_endio_finish_ordered(struct btrfs_inode *inode,
3356                                           struct page *page, u64 start,
3357                                           u64 end, bool uptodate);
3358 ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,
3359                            struct btrfs_ioctl_encoded_io_args *encoded);
3360 ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from,
3361                              const struct btrfs_ioctl_encoded_io_args *encoded);
3362
3363 ssize_t btrfs_dio_rw(struct kiocb *iocb, struct iov_iter *iter, size_t done_before);
3364
3365 extern const struct dentry_operations btrfs_dentry_operations;
3366
3367 /* Inode locking type flags, by default the exclusive lock is taken */
3368 #define BTRFS_ILOCK_SHARED      (1U << 0)
3369 #define BTRFS_ILOCK_TRY         (1U << 1)
3370 #define BTRFS_ILOCK_MMAP        (1U << 2)
3371
3372 int btrfs_inode_lock(struct inode *inode, unsigned int ilock_flags);
3373 void btrfs_inode_unlock(struct inode *inode, unsigned int ilock_flags);
3374 void btrfs_update_inode_bytes(struct btrfs_inode *inode,
3375                               const u64 add_bytes,
3376                               const u64 del_bytes);
3377 void btrfs_assert_inode_range_clean(struct btrfs_inode *inode, u64 start, u64 end);
3378
3379 /* ioctl.c */
3380 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3381 long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3382 int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa);
3383 int btrfs_fileattr_set(struct user_namespace *mnt_userns,
3384                        struct dentry *dentry, struct fileattr *fa);
3385 int btrfs_ioctl_get_supported_features(void __user *arg);
3386 void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);
3387 int __pure btrfs_is_empty_uuid(u8 *uuid);
3388 int btrfs_defrag_file(struct inode *inode, struct file_ra_state *ra,
3389                       struct btrfs_ioctl_defrag_range_args *range,
3390                       u64 newer_than, unsigned long max_to_defrag);
3391 void btrfs_get_block_group_info(struct list_head *groups_list,
3392                                 struct btrfs_ioctl_space_info *space);
3393 void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info,
3394                                struct btrfs_ioctl_balance_args *bargs);
3395 bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
3396                         enum btrfs_exclusive_operation type);
3397 bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,
3398                                  enum btrfs_exclusive_operation type);
3399 void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info);
3400 void btrfs_exclop_finish(struct btrfs_fs_info *fs_info);
3401 void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,
3402                           enum btrfs_exclusive_operation op);
3403
3404
3405 /* file.c */
3406 int __init btrfs_auto_defrag_init(void);
3407 void __cold btrfs_auto_defrag_exit(void);
3408 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3409                            struct btrfs_inode *inode, u32 extent_thresh);
3410 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3411 void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
3412 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3413 void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
3414                              int skip_pinned);
3415 extern const struct file_operations btrfs_file_operations;
3416 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3417                        struct btrfs_root *root, struct btrfs_inode *inode,
3418                        struct btrfs_drop_extents_args *args);
3419 int btrfs_replace_file_extents(struct btrfs_inode *inode,
3420                            struct btrfs_path *path, const u64 start,
3421                            const u64 end,
3422                            struct btrfs_replace_extent_info *extent_info,
3423                            struct btrfs_trans_handle **trans_out);
3424 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3425                               struct btrfs_inode *inode, u64 start, u64 end);
3426 ssize_t btrfs_do_write_iter(struct kiocb *iocb, struct iov_iter *from,
3427                             const struct btrfs_ioctl_encoded_io_args *encoded);
3428 int btrfs_release_file(struct inode *inode, struct file *file);
3429 int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages,
3430                       size_t num_pages, loff_t pos, size_t write_bytes,
3431                       struct extent_state **cached, bool noreserve);
3432 int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end);
3433 int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,
3434                            size_t *write_bytes);
3435 void btrfs_check_nocow_unlock(struct btrfs_inode *inode);
3436
3437 /* tree-defrag.c */
3438 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3439                         struct btrfs_root *root);
3440
3441 /* super.c */
3442 int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
3443                         unsigned long new_flags);
3444 int btrfs_sync_fs(struct super_block *sb, int wait);
3445 char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
3446                                           u64 subvol_objectid);
3447
3448 static inline __printf(2, 3) __cold
3449 void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
3450 {
3451 }
3452
3453 #ifdef CONFIG_PRINTK_INDEX
3454
3455 #define btrfs_printk(fs_info, fmt, args...)                                     \
3456 do {                                                                            \
3457         printk_index_subsys_emit("%sBTRFS %s (device %s): ", NULL, fmt);        \
3458         _btrfs_printk(fs_info, fmt, ##args);                                    \
3459 } while (0)
3460
3461 __printf(2, 3)
3462 __cold
3463 void _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3464
3465 #elif defined(CONFIG_PRINTK)
3466
3467 #define btrfs_printk(fs_info, fmt, args...)                             \
3468         _btrfs_printk(fs_info, fmt, ##args)
3469
3470 __printf(2, 3)
3471 __cold
3472 void _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
3473
3474 #else
3475
3476 #define btrfs_printk(fs_info, fmt, args...) \
3477         btrfs_no_printk(fs_info, fmt, ##args)
3478 #endif
3479
3480 #define btrfs_emerg(fs_info, fmt, args...) \
3481         btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
3482 #define btrfs_alert(fs_info, fmt, args...) \
3483         btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
3484 #define btrfs_crit(fs_info, fmt, args...) \
3485         btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
3486 #define btrfs_err(fs_info, fmt, args...) \
3487         btrfs_printk(fs_info, KERN_ERR fmt, ##args)
3488 #define btrfs_warn(fs_info, fmt, args...) \
3489         btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
3490 #define btrfs_notice(fs_info, fmt, args...) \
3491         btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
3492 #define btrfs_info(fs_info, fmt, args...) \
3493         btrfs_printk(fs_info, KERN_INFO fmt, ##args)
3494
3495 /*
3496  * Wrappers that use printk_in_rcu
3497  */
3498 #define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
3499         btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3500 #define btrfs_alert_in_rcu(fs_info, fmt, args...) \
3501         btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3502 #define btrfs_crit_in_rcu(fs_info, fmt, args...) \
3503         btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3504 #define btrfs_err_in_rcu(fs_info, fmt, args...) \
3505         btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
3506 #define btrfs_warn_in_rcu(fs_info, fmt, args...) \
3507         btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3508 #define btrfs_notice_in_rcu(fs_info, fmt, args...) \
3509         btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3510 #define btrfs_info_in_rcu(fs_info, fmt, args...) \
3511         btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)
3512
3513 /*
3514  * Wrappers that use a ratelimited printk_in_rcu
3515  */
3516 #define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
3517         btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
3518 #define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
3519         btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
3520 #define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
3521         btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
3522 #define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
3523         btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
3524 #define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
3525         btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
3526 #define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
3527         btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
3528 #define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
3529         btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)
3530
3531 /*
3532  * Wrappers that use a ratelimited printk
3533  */
3534 #define btrfs_emerg_rl(fs_info, fmt, args...) \
3535         btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
3536 #define btrfs_alert_rl(fs_info, fmt, args...) \
3537         btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
3538 #define btrfs_crit_rl(fs_info, fmt, args...) \
3539         btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
3540 #define btrfs_err_rl(fs_info, fmt, args...) \
3541         btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
3542 #define btrfs_warn_rl(fs_info, fmt, args...) \
3543         btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
3544 #define btrfs_notice_rl(fs_info, fmt, args...) \
3545         btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
3546 #define btrfs_info_rl(fs_info, fmt, args...) \
3547         btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
3548
3549 #if defined(CONFIG_DYNAMIC_DEBUG)
3550 #define btrfs_debug(fs_info, fmt, args...)                              \
3551         _dynamic_func_call_no_desc(fmt, btrfs_printk,                   \
3552                                    fs_info, KERN_DEBUG fmt, ##args)
3553 #define btrfs_debug_in_rcu(fs_info, fmt, args...)                       \
3554         _dynamic_func_call_no_desc(fmt, btrfs_printk_in_rcu,            \
3555                                    fs_info, KERN_DEBUG fmt, ##args)
3556 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...)                    \
3557         _dynamic_func_call_no_desc(fmt, btrfs_printk_rl_in_rcu,         \
3558                                    fs_info, KERN_DEBUG fmt, ##args)
3559 #define btrfs_debug_rl(fs_info, fmt, args...)                           \
3560         _dynamic_func_call_no_desc(fmt, btrfs_printk_ratelimited,       \
3561                                    fs_info, KERN_DEBUG fmt, ##args)
3562 #elif defined(DEBUG)
3563 #define btrfs_debug(fs_info, fmt, args...) \
3564         btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
3565 #define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3566         btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3567 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3568         btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3569 #define btrfs_debug_rl(fs_info, fmt, args...) \
3570         btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
3571 #else
3572 #define btrfs_debug(fs_info, fmt, args...) \
3573         btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3574 #define btrfs_debug_in_rcu(fs_info, fmt, args...) \
3575         btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3576 #define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
3577         btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
3578 #define btrfs_debug_rl(fs_info, fmt, args...) \
3579         btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
3580 #endif
3581
3582 #define btrfs_printk_in_rcu(fs_info, fmt, args...)      \
3583 do {                                                    \
3584         rcu_read_lock();                                \
3585         btrfs_printk(fs_info, fmt, ##args);             \
3586         rcu_read_unlock();                              \
3587 } while (0)
3588
3589 #define btrfs_no_printk_in_rcu(fs_info, fmt, args...)   \
3590 do {                                                    \
3591         rcu_read_lock();                                \
3592         btrfs_no_printk(fs_info, fmt, ##args);          \
3593         rcu_read_unlock();                              \
3594 } while (0)
3595
3596 #define btrfs_printk_ratelimited(fs_info, fmt, args...)         \
3597 do {                                                            \
3598         static DEFINE_RATELIMIT_STATE(_rs,                      \
3599                 DEFAULT_RATELIMIT_INTERVAL,                     \
3600                 DEFAULT_RATELIMIT_BURST);                       \
3601         if (__ratelimit(&_rs))                                  \
3602                 btrfs_printk(fs_info, fmt, ##args);             \
3603 } while (0)
3604
3605 #define btrfs_printk_rl_in_rcu(fs_info, fmt, args...)           \
3606 do {                                                            \
3607         rcu_read_lock();                                        \
3608         btrfs_printk_ratelimited(fs_info, fmt, ##args);         \
3609         rcu_read_unlock();                                      \
3610 } while (0)
3611
3612 #ifdef CONFIG_BTRFS_ASSERT
3613 __cold __noreturn
3614 static inline void assertfail(const char *expr, const char *file, int line)
3615 {
3616         pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
3617         BUG();
3618 }
3619
3620 #define ASSERT(expr)                                            \
3621         (likely(expr) ? (void)0 : assertfail(#expr, __FILE__, __LINE__))
3622
3623 #else
3624 static inline void assertfail(const char *expr, const char* file, int line) { }
3625 #define ASSERT(expr)    (void)(expr)
3626 #endif
3627
3628 #if BITS_PER_LONG == 32
3629 #define BTRFS_32BIT_MAX_FILE_SIZE (((u64)ULONG_MAX + 1) << PAGE_SHIFT)
3630 /*
3631  * The warning threshold is 5/8th of the MAX_LFS_FILESIZE that limits the logical
3632  * addresses of extents.
3633  *
3634  * For 4K page size it's about 10T, for 64K it's 160T.
3635  */
3636 #define BTRFS_32BIT_EARLY_WARN_THRESHOLD (BTRFS_32BIT_MAX_FILE_SIZE * 5 / 8)
3637 void btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info);
3638 void btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info);
3639 #endif
3640
3641 /*
3642  * Get the correct offset inside the page of extent buffer.
3643  *
3644  * @eb:         target extent buffer
3645  * @start:      offset inside the extent buffer
3646  *
3647  * Will handle both sectorsize == PAGE_SIZE and sectorsize < PAGE_SIZE cases.
3648  */
3649 static inline size_t get_eb_offset_in_page(const struct extent_buffer *eb,
3650                                            unsigned long offset)
3651 {
3652         /*
3653          * For sectorsize == PAGE_SIZE case, eb->start will always be aligned
3654          * to PAGE_SIZE, thus adding it won't cause any difference.
3655          *
3656          * For sectorsize < PAGE_SIZE, we must only read the data that belongs
3657          * to the eb, thus we have to take the eb->start into consideration.
3658          */
3659         return offset_in_page(offset + eb->start);
3660 }
3661
3662 static inline unsigned long get_eb_page_index(unsigned long offset)
3663 {
3664         /*
3665          * For sectorsize == PAGE_SIZE case, plain >> PAGE_SHIFT is enough.
3666          *
3667          * For sectorsize < PAGE_SIZE case, we only support 64K PAGE_SIZE,
3668          * and have ensured that all tree blocks are contained in one page,
3669          * thus we always get index == 0.
3670          */
3671         return offset >> PAGE_SHIFT;
3672 }
3673
3674 /*
3675  * Use that for functions that are conditionally exported for sanity tests but
3676  * otherwise static
3677  */
3678 #ifndef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3679 #define EXPORT_FOR_TESTS static
3680 #else
3681 #define EXPORT_FOR_TESTS
3682 #endif
3683
3684 __cold
3685 static inline void btrfs_print_v0_err(struct btrfs_fs_info *fs_info)
3686 {
3687         btrfs_err(fs_info,
3688 "Unsupported V0 extent filesystem detected. Aborting. Please re-create your filesystem with a newer kernel");
3689 }
3690
3691 __printf(5, 6)
3692 __cold
3693 void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
3694                      unsigned int line, int errno, const char *fmt, ...);
3695
3696 const char * __attribute_const__ btrfs_decode_error(int errno);
3697
3698 __cold
3699 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3700                                const char *function,
3701                                unsigned int line, int errno);
3702
3703 /*
3704  * Call btrfs_abort_transaction as early as possible when an error condition is
3705  * detected, that way the exact line number is reported.
3706  */
3707 #define btrfs_abort_transaction(trans, errno)           \
3708 do {                                                            \
3709         /* Report first abort since mount */                    \
3710         if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,     \
3711                         &((trans)->fs_info->fs_state))) {       \
3712                 if ((errno) != -EIO && (errno) != -EROFS) {             \
3713                         WARN(1, KERN_DEBUG                              \
3714                         "BTRFS: Transaction aborted (error %d)\n",      \
3715                         (errno));                                       \
3716                 } else {                                                \
3717                         btrfs_debug((trans)->fs_info,                   \
3718                                     "Transaction aborted (error %d)", \
3719                                   (errno));                     \
3720                 }                                               \
3721         }                                                       \
3722         __btrfs_abort_transaction((trans), __func__,            \
3723                                   __LINE__, (errno));           \
3724 } while (0)
3725
3726 #ifdef CONFIG_PRINTK_INDEX
3727
3728 #define btrfs_handle_fs_error(fs_info, errno, fmt, args...)             \
3729 do {                                                                    \
3730         printk_index_subsys_emit(                                       \
3731                 "BTRFS: error (device %s%s) in %s:%d: errno=%d %s",     \
3732                 KERN_CRIT, fmt);                                        \
3733         __btrfs_handle_fs_error((fs_info), __func__, __LINE__,          \
3734                                 (errno), fmt, ##args);                  \
3735 } while (0)
3736
3737 #else
3738
3739 #define btrfs_handle_fs_error(fs_info, errno, fmt, args...)             \
3740         __btrfs_handle_fs_error((fs_info), __func__, __LINE__,          \
3741                                 (errno), fmt, ##args)
3742
3743 #endif
3744
3745 #define BTRFS_FS_ERROR(fs_info) (unlikely(test_bit(BTRFS_FS_STATE_ERROR, \
3746                                                    &(fs_info)->fs_state)))
3747 #define BTRFS_FS_LOG_CLEANUP_ERROR(fs_info)                             \
3748         (unlikely(test_bit(BTRFS_FS_STATE_LOG_CLEANUP_ERROR,            \
3749                            &(fs_info)->fs_state)))
3750
3751 __printf(5, 6)
3752 __cold
3753 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3754                    unsigned int line, int errno, const char *fmt, ...);
3755 /*
3756  * If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
3757  * will panic().  Otherwise we BUG() here.
3758  */
3759 #define btrfs_panic(fs_info, errno, fmt, args...)                       \
3760 do {                                                                    \
3761         __btrfs_panic(fs_info, __func__, __LINE__, errno, fmt, ##args); \
3762         BUG();                                                          \
3763 } while (0)
3764
3765
3766 /* compatibility and incompatibility defines */
3767
3768 #define btrfs_set_fs_incompat(__fs_info, opt) \
3769         __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
3770                                 #opt)
3771
3772 static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3773                                            u64 flag, const char* name)
3774 {
3775         struct btrfs_super_block *disk_super;
3776         u64 features;
3777
3778         disk_super = fs_info->super_copy;
3779         features = btrfs_super_incompat_flags(disk_super);
3780         if (!(features & flag)) {
3781                 spin_lock(&fs_info->super_lock);
3782                 features = btrfs_super_incompat_flags(disk_super);
3783                 if (!(features & flag)) {
3784                         features |= flag;
3785                         btrfs_set_super_incompat_flags(disk_super, features);
3786                         btrfs_info(fs_info,
3787                                 "setting incompat feature flag for %s (0x%llx)",
3788                                 name, flag);
3789                 }
3790                 spin_unlock(&fs_info->super_lock);
3791         }
3792 }
3793
3794 #define btrfs_clear_fs_incompat(__fs_info, opt) \
3795         __btrfs_clear_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt, \
3796                                   #opt)
3797
3798 static inline void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info,
3799                                              u64 flag, const char* name)
3800 {
3801         struct btrfs_super_block *disk_super;
3802         u64 features;
3803
3804         disk_super = fs_info->super_copy;
3805         features = btrfs_super_incompat_flags(disk_super);
3806         if (features & flag) {
3807                 spin_lock(&fs_info->super_lock);
3808                 features = btrfs_super_incompat_flags(disk_super);
3809                 if (features & flag) {
3810                         features &= ~flag;
3811                         btrfs_set_super_incompat_flags(disk_super, features);
3812                         btrfs_info(fs_info,
3813                                 "clearing incompat feature flag for %s (0x%llx)",
3814                                 name, flag);
3815                 }
3816                 spin_unlock(&fs_info->super_lock);
3817         }
3818 }
3819
3820 #define btrfs_fs_incompat(fs_info, opt) \
3821         __btrfs_fs_incompat((fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3822
3823 static inline bool __btrfs_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag)
3824 {
3825         struct btrfs_super_block *disk_super;
3826         disk_super = fs_info->super_copy;
3827         return !!(btrfs_super_incompat_flags(disk_super) & flag);
3828 }
3829
3830 #define btrfs_set_fs_compat_ro(__fs_info, opt) \
3831         __btrfs_set_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
3832                                  #opt)
3833
3834 static inline void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info,
3835                                             u64 flag, const char *name)
3836 {
3837         struct btrfs_super_block *disk_super;
3838         u64 features;
3839
3840         disk_super = fs_info->super_copy;
3841         features = btrfs_super_compat_ro_flags(disk_super);
3842         if (!(features & flag)) {
3843                 spin_lock(&fs_info->super_lock);
3844                 features = btrfs_super_compat_ro_flags(disk_super);
3845                 if (!(features & flag)) {
3846                         features |= flag;
3847                         btrfs_set_super_compat_ro_flags(disk_super, features);
3848                         btrfs_info(fs_info,
3849                                 "setting compat-ro feature flag for %s (0x%llx)",
3850                                 name, flag);
3851                 }
3852                 spin_unlock(&fs_info->super_lock);
3853         }
3854 }
3855
3856 #define btrfs_clear_fs_compat_ro(__fs_info, opt) \
3857         __btrfs_clear_fs_compat_ro((__fs_info), BTRFS_FEATURE_COMPAT_RO_##opt, \
3858                                    #opt)
3859
3860 static inline void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info,
3861                                               u64 flag, const char *name)
3862 {
3863         struct btrfs_super_block *disk_super;
3864         u64 features;
3865
3866         disk_super = fs_info->super_copy;
3867         features = btrfs_super_compat_ro_flags(disk_super);
3868         if (features & flag) {
3869                 spin_lock(&fs_info->super_lock);
3870                 features = btrfs_super_compat_ro_flags(disk_super);
3871                 if (features & flag) {
3872                         features &= ~flag;
3873                         btrfs_set_super_compat_ro_flags(disk_super, features);
3874                         btrfs_info(fs_info,
3875                                 "clearing compat-ro feature flag for %s (0x%llx)",
3876                                 name, flag);
3877                 }
3878                 spin_unlock(&fs_info->super_lock);
3879         }
3880 }
3881
3882 #define btrfs_fs_compat_ro(fs_info, opt) \
3883         __btrfs_fs_compat_ro((fs_info), BTRFS_FEATURE_COMPAT_RO_##opt)
3884
3885 static inline int __btrfs_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag)
3886 {
3887         struct btrfs_super_block *disk_super;
3888         disk_super = fs_info->super_copy;
3889         return !!(btrfs_super_compat_ro_flags(disk_super) & flag);
3890 }
3891
3892 /* acl.c */
3893 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
3894 struct posix_acl *btrfs_get_acl(struct inode *inode, int type, bool rcu);
3895 int btrfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
3896                   struct posix_acl *acl, int type);
3897 int __btrfs_set_acl(struct btrfs_trans_handle *trans, struct inode *inode,
3898                     struct posix_acl *acl, int type);
3899 #else
3900 #define btrfs_get_acl NULL
3901 #define btrfs_set_acl NULL
3902 static inline int __btrfs_set_acl(struct btrfs_trans_handle *trans,
3903                                   struct inode *inode, struct posix_acl *acl,
3904                                   int type)
3905 {
3906         return -EOPNOTSUPP;
3907 }
3908 #endif
3909
3910 /* relocation.c */
3911 int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 group_start);
3912 int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3913                           struct btrfs_root *root);
3914 int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3915                             struct btrfs_root *root);
3916 int btrfs_recover_relocation(struct btrfs_fs_info *fs_info);
3917 int btrfs_reloc_clone_csums(struct btrfs_inode *inode, u64 file_pos, u64 len);
3918 int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3919                           struct btrfs_root *root, struct extent_buffer *buf,
3920                           struct extent_buffer *cow);
3921 void btrfs_reloc_pre_snapshot(struct btrfs_pending_snapshot *pending,
3922                               u64 *bytes_to_reserve);
3923 int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3924                               struct btrfs_pending_snapshot *pending);
3925 int btrfs_should_cancel_balance(struct btrfs_fs_info *fs_info);
3926 struct btrfs_root *find_reloc_root(struct btrfs_fs_info *fs_info,
3927                                    u64 bytenr);
3928 int btrfs_should_ignore_reloc_root(struct btrfs_root *root);
3929
3930 /* scrub.c */
3931 int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
3932                     u64 end, struct btrfs_scrub_progress *progress,
3933                     int readonly, int is_dev_replace);
3934 void btrfs_scrub_pause(struct btrfs_fs_info *fs_info);
3935 void btrfs_scrub_continue(struct btrfs_fs_info *fs_info);
3936 int btrfs_scrub_cancel(struct btrfs_fs_info *info);
3937 int btrfs_scrub_cancel_dev(struct btrfs_device *dev);
3938 int btrfs_scrub_progress(struct btrfs_fs_info *fs_info, u64 devid,
3939                          struct btrfs_scrub_progress *progress);
3940 static inline void btrfs_init_full_stripe_locks_tree(
3941                         struct btrfs_full_stripe_locks_tree *locks_root)
3942 {
3943         locks_root->root = RB_ROOT;
3944         mutex_init(&locks_root->lock);
3945 }
3946
3947 /* dev-replace.c */
3948 void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info);
3949 void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info);
3950 void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount);
3951
3952 static inline void btrfs_bio_counter_dec(struct btrfs_fs_info *fs_info)
3953 {
3954         btrfs_bio_counter_sub(fs_info, 1);
3955 }
3956
3957 static inline int is_fstree(u64 rootid)
3958 {
3959         if (rootid == BTRFS_FS_TREE_OBJECTID ||
3960             ((s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID &&
3961               !btrfs_qgroup_level(rootid)))
3962                 return 1;
3963         return 0;
3964 }
3965
3966 static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
3967 {
3968         return signal_pending(current);
3969 }
3970
3971 /* verity.c */
3972 #ifdef CONFIG_FS_VERITY
3973
3974 extern const struct fsverity_operations btrfs_verityops;
3975 int btrfs_drop_verity_items(struct btrfs_inode *inode);
3976
3977 BTRFS_SETGET_FUNCS(verity_descriptor_encryption, struct btrfs_verity_descriptor_item,
3978                    encryption, 8);
3979 BTRFS_SETGET_FUNCS(verity_descriptor_size, struct btrfs_verity_descriptor_item,
3980                    size, 64);
3981 BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_encryption,
3982                          struct btrfs_verity_descriptor_item, encryption, 8);
3983 BTRFS_SETGET_STACK_FUNCS(stack_verity_descriptor_size,
3984                          struct btrfs_verity_descriptor_item, size, 64);
3985
3986 #else
3987
3988 static inline int btrfs_drop_verity_items(struct btrfs_inode *inode)
3989 {
3990         return 0;
3991 }
3992
3993 #endif
3994
3995 /* Sanity test specific functions */
3996 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3997 void btrfs_test_destroy_inode(struct inode *inode);
3998 static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
3999 {
4000         return test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
4001 }
4002 #else
4003 static inline int btrfs_is_testing(struct btrfs_fs_info *fs_info)
4004 {
4005         return 0;
4006 }
4007 #endif
4008
4009 static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)
4010 {
4011         return fs_info->zone_size > 0;
4012 }
4013
4014 static inline bool btrfs_is_data_reloc_root(const struct btrfs_root *root)
4015 {
4016         return root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID;
4017 }
4018
4019 /*
4020  * We use page status Private2 to indicate there is an ordered extent with
4021  * unfinished IO.
4022  *
4023  * Rename the Private2 accessors to Ordered, to improve readability.
4024  */
4025 #define PageOrdered(page)               PagePrivate2(page)
4026 #define SetPageOrdered(page)            SetPagePrivate2(page)
4027 #define ClearPageOrdered(page)          ClearPagePrivate2(page)
4028 #define folio_test_ordered(folio)       folio_test_private_2(folio)
4029 #define folio_set_ordered(folio)        folio_set_private_2(folio)
4030 #define folio_clear_ordered(folio)      folio_clear_private_2(folio)
4031
4032 #endif