linux/fs/btrfs/ctree.h
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2007 Oracle.  All rights reserved.
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public
   6 * License v2 as published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope that it will be useful,
   9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 * General Public License for more details.
  12 *
  13 * You should have received a copy of the GNU General Public
  14 * License along with this program; if not, write to the
  15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16 * Boston, MA 021110-1307, USA.
  17 */
  18
  19#ifndef __BTRFS_CTREE__
  20#define __BTRFS_CTREE__
  21
  22#include <linux/mm.h>
  23#include <linux/highmem.h>
  24#include <linux/fs.h>
  25#include <linux/rwsem.h>
  26#include <linux/completion.h>
  27#include <linux/backing-dev.h>
  28#include <linux/wait.h>
  29#include <linux/slab.h>
  30#include <linux/kobject.h>
  31#include <trace/events/btrfs.h>
  32#include <asm/kmap_types.h>
  33#include <linux/pagemap.h>
  34#include "extent_io.h"
  35#include "extent_map.h"
  36#include "async-thread.h"
  37#include "ioctl.h"
  38
  39struct btrfs_trans_handle;
  40struct btrfs_transaction;
  41struct btrfs_pending_snapshot;
  42extern struct kmem_cache *btrfs_trans_handle_cachep;
  43extern struct kmem_cache *btrfs_transaction_cachep;
  44extern struct kmem_cache *btrfs_bit_radix_cachep;
  45extern struct kmem_cache *btrfs_path_cachep;
  46extern struct kmem_cache *btrfs_free_space_cachep;
  47struct btrfs_ordered_sum;
  48
  49#define BTRFS_MAGIC "_BHRfS_M"
  50
  51#define BTRFS_MAX_MIRRORS 2
  52
  53#define BTRFS_MAX_LEVEL 8
  54
  55#define BTRFS_COMPAT_EXTENT_TREE_V0
  56
  57/*
  58 * files bigger than this get some pre-flushing when they are added
  59 * to the ordered operations list.  That way we limit the total
  60 * work done by the commit
  61 */
  62#define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
  63
  64/* holds pointers to all of the tree roots */
  65#define BTRFS_ROOT_TREE_OBJECTID 1ULL
  66
  67/* stores information about which extents are in use, and reference counts */
  68#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
  69
  70/*
  71 * chunk tree stores translations from logical -> physical block numbering
  72 * the super block points to the chunk tree
  73 */
  74#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
  75
  76/*
  77 * stores information about which areas of a given device are in use.
  78 * one per device.  The tree of tree roots points to the device tree
  79 */
  80#define BTRFS_DEV_TREE_OBJECTID 4ULL
  81
  82/* one per subvolume, storing files and directories */
  83#define BTRFS_FS_TREE_OBJECTID 5ULL
  84
  85/* directory objectid inside the root tree */
  86#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
  87
  88/* holds checksums of all the data extents */
  89#define BTRFS_CSUM_TREE_OBJECTID 7ULL
  90
  91/* for storing balance parameters in the root tree */
  92#define BTRFS_BALANCE_OBJECTID -4ULL
  93
  94/* holds quota configuration and tracking */
  95#define BTRFS_QUOTA_TREE_OBJECTID 8ULL
  96
  97/* orhpan objectid for tracking unlinked/truncated files */
  98#define BTRFS_ORPHAN_OBJECTID -5ULL
  99
 100/* does write ahead logging to speed up fsyncs */
 101#define BTRFS_TREE_LOG_OBJECTID -6ULL
 102#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
 103
 104/* for space balancing */
 105#define BTRFS_TREE_RELOC_OBJECTID -8ULL
 106#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
 107
 108/*
 109 * extent checksums all have this objectid
 110 * this allows them to share the logging tree
 111 * for fsyncs
 112 */
 113#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
 114
 115/* For storing free space cache */
 116#define BTRFS_FREE_SPACE_OBJECTID -11ULL
 117
 118/*
 119 * The inode number assigned to the special inode for storing
 120 * free ino cache
 121 */
 122#define BTRFS_FREE_INO_OBJECTID -12ULL
 123
 124/* dummy objectid represents multiple objectids */
 125#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
 126
 127/*
 128 * All files have objectids in this range.
 129 */
 130#define BTRFS_FIRST_FREE_OBJECTID 256ULL
 131#define BTRFS_LAST_FREE_OBJECTID -256ULL
 132#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
 133
 134
 135/*
 136 * the device items go into the chunk tree.  The key is in the form
 137 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
 138 */
 139#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
 140
 141#define BTRFS_BTREE_INODE_OBJECTID 1
 142
 143#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
 144
 145/*
 146 * the max metadata block size.  This limit is somewhat artificial,
 147 * but the memmove costs go through the roof for larger blocks.
 148 */
 149#define BTRFS_MAX_METADATA_BLOCKSIZE 65536
 150
 151/*
 152 * we can actually store much bigger names, but lets not confuse the rest
 153 * of linux
 154 */
 155#define BTRFS_NAME_LEN 255
 156
 157/*
 158 * Theoretical limit is larger, but we keep this down to a sane
 159 * value. That should limit greatly the possibility of collisions on
 160 * inode ref items.
 161 */
 162#define BTRFS_LINK_MAX 65535U
 163
 164/* 32 bytes in various csum fields */
 165#define BTRFS_CSUM_SIZE 32
 166
 167/* csum types */
 168#define BTRFS_CSUM_TYPE_CRC32   0
 169
 170static int btrfs_csum_sizes[] = { 4, 0 };
 171
 172/* four bytes for CRC32 */
 173#define BTRFS_EMPTY_DIR_SIZE 0
 174
 175#define BTRFS_FT_UNKNOWN        0
 176#define BTRFS_FT_REG_FILE       1
 177#define BTRFS_FT_DIR            2
 178#define BTRFS_FT_CHRDEV         3
 179#define BTRFS_FT_BLKDEV         4
 180#define BTRFS_FT_FIFO           5
 181#define BTRFS_FT_SOCK           6
 182#define BTRFS_FT_SYMLINK        7
 183#define BTRFS_FT_XATTR          8
 184#define BTRFS_FT_MAX            9
 185
 186/* ioprio of readahead is set to idle */
 187#define BTRFS_IOPRIO_READA (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 0))
 188
 189/*
 190 * The key defines the order in the tree, and so it also defines (optimal)
 191 * block layout.
 192 *
 193 * objectid corresponds to the inode number.
 194 *
 195 * type tells us things about the object, and is a kind of stream selector.
 196 * so for a given inode, keys with type of 1 might refer to the inode data,
 197 * type of 2 may point to file data in the btree and type == 3 may point to
 198 * extents.
 199 *
 200 * offset is the starting byte offset for this key in the stream.
 201 *
 202 * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
 203 * in cpu native order.  Otherwise they are identical and their sizes
 204 * should be the same (ie both packed)
 205 */
 206struct btrfs_disk_key {
 207        __le64 objectid;
 208        u8 type;
 209        __le64 offset;
 210} __attribute__ ((__packed__));
 211
 212struct btrfs_key {
 213        u64 objectid;
 214        u8 type;
 215        u64 offset;
 216} __attribute__ ((__packed__));
 217
 218struct btrfs_mapping_tree {
 219        struct extent_map_tree map_tree;
 220};
 221
 222struct btrfs_dev_item {
 223        /* the internal btrfs device id */
 224        __le64 devid;
 225
 226        /* size of the device */
 227        __le64 total_bytes;
 228
 229        /* bytes used */
 230        __le64 bytes_used;
 231
 232        /* optimal io alignment for this device */
 233        __le32 io_align;
 234
 235        /* optimal io width for this device */
 236        __le32 io_width;
 237
 238        /* minimal io size for this device */
 239        __le32 sector_size;
 240
 241        /* type and info about this device */
 242        __le64 type;
 243
 244        /* expected generation for this device */
 245        __le64 generation;
 246
 247        /*
 248         * starting byte of this partition on the device,
 249         * to allow for stripe alignment in the future
 250         */
 251        __le64 start_offset;
 252
 253        /* grouping information for allocation decisions */
 254        __le32 dev_group;
 255
 256        /* seek speed 0-100 where 100 is fastest */
 257        u8 seek_speed;
 258
 259        /* bandwidth 0-100 where 100 is fastest */
 260        u8 bandwidth;
 261
 262        /* btrfs generated uuid for this device */
 263        u8 uuid[BTRFS_UUID_SIZE];
 264
 265        /* uuid of FS who owns this device */
 266        u8 fsid[BTRFS_UUID_SIZE];
 267} __attribute__ ((__packed__));
 268
 269struct btrfs_stripe {
 270        __le64 devid;
 271        __le64 offset;
 272        u8 dev_uuid[BTRFS_UUID_SIZE];
 273} __attribute__ ((__packed__));
 274
 275struct btrfs_chunk {
 276        /* size of this chunk in bytes */
 277        __le64 length;
 278
 279        /* objectid of the root referencing this chunk */
 280        __le64 owner;
 281
 282        __le64 stripe_len;
 283        __le64 type;
 284
 285        /* optimal io alignment for this chunk */
 286        __le32 io_align;
 287
 288        /* optimal io width for this chunk */
 289        __le32 io_width;
 290
 291        /* minimal io size for this chunk */
 292        __le32 sector_size;
 293
 294        /* 2^16 stripes is quite a lot, a second limit is the size of a single
 295         * item in the btree
 296         */
 297        __le16 num_stripes;
 298
 299        /* sub stripes only matter for raid10 */
 300        __le16 sub_stripes;
 301        struct btrfs_stripe stripe;
 302        /* additional stripes go here */
 303} __attribute__ ((__packed__));
 304
 305#define BTRFS_FREE_SPACE_EXTENT 1
 306#define BTRFS_FREE_SPACE_BITMAP 2
 307
 308struct btrfs_free_space_entry {
 309        __le64 offset;
 310        __le64 bytes;
 311        u8 type;
 312} __attribute__ ((__packed__));
 313
 314struct btrfs_free_space_header {
 315        struct btrfs_disk_key location;
 316        __le64 generation;
 317        __le64 num_entries;
 318        __le64 num_bitmaps;
 319} __attribute__ ((__packed__));
 320
 321static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 322{
 323        BUG_ON(num_stripes == 0);
 324        return sizeof(struct btrfs_chunk) +
 325                sizeof(struct btrfs_stripe) * (num_stripes - 1);
 326}
 327
 328#define BTRFS_HEADER_FLAG_WRITTEN       (1ULL << 0)
 329#define BTRFS_HEADER_FLAG_RELOC         (1ULL << 1)
 330
 331/*
 332 * File system states
 333 */
 334
 335/* Errors detected */
 336#define BTRFS_SUPER_FLAG_ERROR          (1ULL << 2)
 337
 338#define BTRFS_SUPER_FLAG_SEEDING        (1ULL << 32)
 339#define BTRFS_SUPER_FLAG_METADUMP       (1ULL << 33)
 340
 341#define BTRFS_BACKREF_REV_MAX           256
 342#define BTRFS_BACKREF_REV_SHIFT         56
 343#define BTRFS_BACKREF_REV_MASK          (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
 344                                         BTRFS_BACKREF_REV_SHIFT)
 345
 346#define BTRFS_OLD_BACKREF_REV           0
 347#define BTRFS_MIXED_BACKREF_REV         1
 348
 349/*
 350 * every tree block (leaf or node) starts with this header.
 351 */
 352struct btrfs_header {
 353        /* these first four must match the super block */
 354        u8 csum[BTRFS_CSUM_SIZE];
 355        u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 356        __le64 bytenr; /* which block this node is supposed to live in */
 357        __le64 flags;
 358
 359        /* allowed to be different from the super from here on down */
 360        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 361        __le64 generation;
 362        __le64 owner;
 363        __le32 nritems;
 364        u8 level;
 365} __attribute__ ((__packed__));
 366
 367#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
 368                                      sizeof(struct btrfs_header)) / \
 369                                     sizeof(struct btrfs_key_ptr))
 370#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 371#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
 372#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 373                                        sizeof(struct btrfs_item) - \
 374                                        sizeof(struct btrfs_file_extent_item))
 375#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 376                                 sizeof(struct btrfs_item) -\
 377                                 sizeof(struct btrfs_dir_item))
 378
 379
 380/*
 381 * this is a very generous portion of the super block, giving us
 382 * room to translate 14 chunks with 3 stripes each.
 383 */
 384#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
 385#define BTRFS_LABEL_SIZE 256
 386
 387/*
 388 * just in case we somehow lose the roots and are not able to mount,
 389 * we store an array of the roots from previous transactions
 390 * in the super.
 391 */
 392#define BTRFS_NUM_BACKUP_ROOTS 4
 393struct btrfs_root_backup {
 394        __le64 tree_root;
 395        __le64 tree_root_gen;
 396
 397        __le64 chunk_root;
 398        __le64 chunk_root_gen;
 399
 400        __le64 extent_root;
 401        __le64 extent_root_gen;
 402
 403        __le64 fs_root;
 404        __le64 fs_root_gen;
 405
 406        __le64 dev_root;
 407        __le64 dev_root_gen;
 408
 409        __le64 csum_root;
 410        __le64 csum_root_gen;
 411
 412        __le64 total_bytes;
 413        __le64 bytes_used;
 414        __le64 num_devices;
 415        /* future */
 416        __le64 unsed_64[4];
 417
 418        u8 tree_root_level;
 419        u8 chunk_root_level;
 420        u8 extent_root_level;
 421        u8 fs_root_level;
 422        u8 dev_root_level;
 423        u8 csum_root_level;
 424        /* future and to align */
 425        u8 unused_8[10];
 426} __attribute__ ((__packed__));
 427
 428/*
 429 * the super block basically lists the main trees of the FS
 430 * it currently lacks any block count etc etc
 431 */
 432struct btrfs_super_block {
 433        u8 csum[BTRFS_CSUM_SIZE];
 434        /* the first 4 fields must match struct btrfs_header */
 435        u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
 436        __le64 bytenr; /* this block number */
 437        __le64 flags;
 438
 439        /* allowed to be different from the btrfs_header from here own down */
 440        __le64 magic;
 441        __le64 generation;
 442        __le64 root;
 443        __le64 chunk_root;
 444        __le64 log_root;
 445
 446        /* this will help find the new super based on the log root */
 447        __le64 log_root_transid;
 448        __le64 total_bytes;
 449        __le64 bytes_used;
 450        __le64 root_dir_objectid;
 451        __le64 num_devices;
 452        __le32 sectorsize;
 453        __le32 nodesize;
 454        __le32 leafsize;
 455        __le32 stripesize;
 456        __le32 sys_chunk_array_size;
 457        __le64 chunk_root_generation;
 458        __le64 compat_flags;
 459        __le64 compat_ro_flags;
 460        __le64 incompat_flags;
 461        __le16 csum_type;
 462        u8 root_level;
 463        u8 chunk_root_level;
 464        u8 log_root_level;
 465        struct btrfs_dev_item dev_item;
 466
 467        char label[BTRFS_LABEL_SIZE];
 468
 469        __le64 cache_generation;
 470
 471        /* future expansion */
 472        __le64 reserved[31];
 473        u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
 474        struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS];
 475} __attribute__ ((__packed__));
 476
 477/*
 478 * Compat flags that we support.  If any incompat flags are set other than the
 479 * ones specified below then we will fail to mount
 480 */
 481#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF    (1ULL << 0)
 482#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL   (1ULL << 1)
 483#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS     (1ULL << 2)
 484#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO     (1ULL << 3)
 485/*
 486 * some patches floated around with a second compression method
 487 * lets save that incompat here for when they do get in
 488 * Note we don't actually support it, we're just reserving the
 489 * number
 490 */
 491#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2   (1ULL << 4)
 492
 493/*
 494 * older kernels tried to do bigger metadata blocks, but the
 495 * code was pretty buggy.  Lets not let them try anymore.
 496 */
 497#define BTRFS_FEATURE_INCOMPAT_BIG_METADATA     (1ULL << 5)
 498
 499#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF    (1ULL << 6)
 500
 501#define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 502#define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
 503#define BTRFS_FEATURE_INCOMPAT_SUPP                     \
 504        (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF |         \
 505         BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
 506         BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
 507         BTRFS_FEATURE_INCOMPAT_BIG_METADATA |          \
 508         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |          \
 509         BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
 510
 511/*
 512 * A leaf is full of items. offset and size tell us where to find
 513 * the item in the leaf (relative to the start of the data area)
 514 */
 515struct btrfs_item {
 516        struct btrfs_disk_key key;
 517        __le32 offset;
 518        __le32 size;
 519} __attribute__ ((__packed__));
 520
 521/*
 522 * leaves have an item area and a data area:
 523 * [item0, item1....itemN] [free space] [dataN...data1, data0]
 524 *
 525 * The data is separate from the items to get the keys closer together
 526 * during searches.
 527 */
 528struct btrfs_leaf {
 529        struct btrfs_header header;
 530        struct btrfs_item items[];
 531} __attribute__ ((__packed__));
 532
 533/*
 534 * all non-leaf blocks are nodes, they hold only keys and pointers to
 535 * other blocks
 536 */
 537struct btrfs_key_ptr {
 538        struct btrfs_disk_key key;
 539        __le64 blockptr;
 540        __le64 generation;
 541} __attribute__ ((__packed__));
 542
 543struct btrfs_node {
 544        struct btrfs_header header;
 545        struct btrfs_key_ptr ptrs[];
 546} __attribute__ ((__packed__));
 547
 548/*
 549 * btrfs_paths remember the path taken from the root down to the leaf.
 550 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 551 * to any other levels that are present.
 552 *
 553 * The slots array records the index of the item or block pointer
 554 * used while walking the tree.
 555 */
 556struct btrfs_path {
 557        struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
 558        int slots[BTRFS_MAX_LEVEL];
 559        /* if there is real range locking, this locks field will change */
 560        int locks[BTRFS_MAX_LEVEL];
 561        int reada;
 562        /* keep some upper locks as we walk down */
 563        int lowest_level;
 564
 565        /*
 566         * set by btrfs_split_item, tells search_slot to keep all locks
 567         * and to force calls to keep space in the nodes
 568         */
 569        unsigned int search_for_split:1;
 570        unsigned int keep_locks:1;
 571        unsigned int skip_locking:1;
 572        unsigned int leave_spinning:1;
 573        unsigned int search_commit_root:1;
 574};
 575
 576/*
 577 * items in the extent btree are used to record the objectid of the
 578 * owner of the block and the number of references
 579 */
 580
 581struct btrfs_extent_item {
 582        __le64 refs;
 583        __le64 generation;
 584        __le64 flags;
 585} __attribute__ ((__packed__));
 586
 587struct btrfs_extent_item_v0 {
 588        __le32 refs;
 589} __attribute__ ((__packed__));
 590
 591#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
 592                                        sizeof(struct btrfs_item))
 593
 594#define BTRFS_EXTENT_FLAG_DATA          (1ULL << 0)
 595#define BTRFS_EXTENT_FLAG_TREE_BLOCK    (1ULL << 1)
 596
 597/* following flags only apply to tree blocks */
 598
 599/* use full backrefs for extent pointers in the block */
 600#define BTRFS_BLOCK_FLAG_FULL_BACKREF   (1ULL << 8)
 601
 602/*
 603 * this flag is only used internally by scrub and may be changed at any time
 604 * it is only declared here to avoid collisions
 605 */
 606#define BTRFS_EXTENT_FLAG_SUPER         (1ULL << 48)
 607
 608struct btrfs_tree_block_info {
 609        struct btrfs_disk_key key;
 610        u8 level;
 611} __attribute__ ((__packed__));
 612
 613struct btrfs_extent_data_ref {
 614        __le64 root;
 615        __le64 objectid;
 616        __le64 offset;
 617        __le32 count;
 618} __attribute__ ((__packed__));
 619
 620struct btrfs_shared_data_ref {
 621        __le32 count;
 622} __attribute__ ((__packed__));
 623
 624struct btrfs_extent_inline_ref {
 625        u8 type;
 626        __le64 offset;
 627} __attribute__ ((__packed__));
 628
 629/* old style backrefs item */
 630struct btrfs_extent_ref_v0 {
 631        __le64 root;
 632        __le64 generation;
 633        __le64 objectid;
 634        __le32 count;
 635} __attribute__ ((__packed__));
 636
 637
 638/* dev extents record free space on individual devices.  The owner
 639 * field points back to the chunk allocation mapping tree that allocated
 640 * the extent.  The chunk tree uuid field is a way to double check the owner
 641 */
 642struct btrfs_dev_extent {
 643        __le64 chunk_tree;
 644        __le64 chunk_objectid;
 645        __le64 chunk_offset;
 646        __le64 length;
 647        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 648} __attribute__ ((__packed__));
 649
 650struct btrfs_inode_ref {
 651        __le64 index;
 652        __le16 name_len;
 653        /* name goes here */
 654} __attribute__ ((__packed__));
 655
 656struct btrfs_inode_extref {
 657        __le64 parent_objectid;
 658        __le64 index;
 659        __le16 name_len;
 660        __u8   name[0];
 661        /* name goes here */
 662} __attribute__ ((__packed__));
 663
 664struct btrfs_timespec {
 665        __le64 sec;
 666        __le32 nsec;
 667} __attribute__ ((__packed__));
 668
 669enum btrfs_compression_type {
 670        BTRFS_COMPRESS_NONE  = 0,
 671        BTRFS_COMPRESS_ZLIB  = 1,
 672        BTRFS_COMPRESS_LZO   = 2,
 673        BTRFS_COMPRESS_TYPES = 2,
 674        BTRFS_COMPRESS_LAST  = 3,
 675};
 676
 677struct btrfs_inode_item {
 678        /* nfs style generation number */
 679        __le64 generation;
 680        /* transid that last touched this inode */
 681        __le64 transid;
 682        __le64 size;
 683        __le64 nbytes;
 684        __le64 block_group;
 685        __le32 nlink;
 686        __le32 uid;
 687        __le32 gid;
 688        __le32 mode;
 689        __le64 rdev;
 690        __le64 flags;
 691
 692        /* modification sequence number for NFS */
 693        __le64 sequence;
 694
 695        /*
 696         * a little future expansion, for more than this we can
 697         * just grow the inode item and version it
 698         */
 699        __le64 reserved[4];
 700        struct btrfs_timespec atime;
 701        struct btrfs_timespec ctime;
 702        struct btrfs_timespec mtime;
 703        struct btrfs_timespec otime;
 704} __attribute__ ((__packed__));
 705
 706struct btrfs_dir_log_item {
 707        __le64 end;
 708} __attribute__ ((__packed__));
 709
 710struct btrfs_dir_item {
 711        struct btrfs_disk_key location;
 712        __le64 transid;
 713        __le16 data_len;
 714        __le16 name_len;
 715        u8 type;
 716} __attribute__ ((__packed__));
 717
 718#define BTRFS_ROOT_SUBVOL_RDONLY        (1ULL << 0)
 719
 720struct btrfs_root_item {
 721        struct btrfs_inode_item inode;
 722        __le64 generation;
 723        __le64 root_dirid;
 724        __le64 bytenr;
 725        __le64 byte_limit;
 726        __le64 bytes_used;
 727        __le64 last_snapshot;
 728        __le64 flags;
 729        __le32 refs;
 730        struct btrfs_disk_key drop_progress;
 731        u8 drop_level;
 732        u8 level;
 733
 734        /*
 735         * The following fields appear after subvol_uuids+subvol_times
 736         * were introduced.
 737         */
 738
 739        /*
 740         * This generation number is used to test if the new fields are valid
 741         * and up to date while reading the root item. Everytime the root item
 742         * is written out, the "generation" field is copied into this field. If
 743         * anyone ever mounted the fs with an older kernel, we will have
 744         * mismatching generation values here and thus must invalidate the
 745         * new fields. See btrfs_update_root and btrfs_find_last_root for
 746         * details.
 747         * the offset of generation_v2 is also used as the start for the memset
 748         * when invalidating the fields.
 749         */
 750        __le64 generation_v2;
 751        u8 uuid[BTRFS_UUID_SIZE];
 752        u8 parent_uuid[BTRFS_UUID_SIZE];
 753        u8 received_uuid[BTRFS_UUID_SIZE];
 754        __le64 ctransid; /* updated when an inode changes */
 755        __le64 otransid; /* trans when created */
 756        __le64 stransid; /* trans when sent. non-zero for received subvol */
 757        __le64 rtransid; /* trans when received. non-zero for received subvol */
 758        struct btrfs_timespec ctime;
 759        struct btrfs_timespec otime;
 760        struct btrfs_timespec stime;
 761        struct btrfs_timespec rtime;
 762        __le64 reserved[8]; /* for future */
 763} __attribute__ ((__packed__));
 764
 765/*
 766 * this is used for both forward and backward root refs
 767 */
 768struct btrfs_root_ref {
 769        __le64 dirid;
 770        __le64 sequence;
 771        __le16 name_len;
 772} __attribute__ ((__packed__));
 773
 774struct btrfs_disk_balance_args {
 775        /*
 776         * profiles to operate on, single is denoted by
 777         * BTRFS_AVAIL_ALLOC_BIT_SINGLE
 778         */
 779        __le64 profiles;
 780
 781        /* usage filter */
 782        __le64 usage;
 783
 784        /* devid filter */
 785        __le64 devid;
 786
 787        /* devid subset filter [pstart..pend) */
 788        __le64 pstart;
 789        __le64 pend;
 790
 791        /* btrfs virtual address space subset filter [vstart..vend) */
 792        __le64 vstart;
 793        __le64 vend;
 794
 795        /*
 796         * profile to convert to, single is denoted by
 797         * BTRFS_AVAIL_ALLOC_BIT_SINGLE
 798         */
 799        __le64 target;
 800
 801        /* BTRFS_BALANCE_ARGS_* */
 802        __le64 flags;
 803
 804        __le64 unused[8];
 805} __attribute__ ((__packed__));
 806
 807/*
 808 * store balance parameters to disk so that balance can be properly
 809 * resumed after crash or unmount
 810 */
 811struct btrfs_balance_item {
 812        /* BTRFS_BALANCE_* */
 813        __le64 flags;
 814
 815        struct btrfs_disk_balance_args data;
 816        struct btrfs_disk_balance_args meta;
 817        struct btrfs_disk_balance_args sys;
 818
 819        __le64 unused[4];
 820} __attribute__ ((__packed__));
 821
 822#define BTRFS_FILE_EXTENT_INLINE 0
 823#define BTRFS_FILE_EXTENT_REG 1
 824#define BTRFS_FILE_EXTENT_PREALLOC 2
 825
 826struct btrfs_file_extent_item {
 827        /*
 828         * transaction id that created this extent
 829         */
 830        __le64 generation;
 831        /*
 832         * max number of bytes to hold this extent in ram
 833         * when we split a compressed extent we can't know how big
 834         * each of the resulting pieces will be.  So, this is
 835         * an upper limit on the size of the extent in ram instead of
 836         * an exact limit.
 837         */
 838        __le64 ram_bytes;
 839
 840        /*
 841         * 32 bits for the various ways we might encode the data,
 842         * including compression and encryption.  If any of these
 843         * are set to something a given disk format doesn't understand
 844         * it is treated like an incompat flag for reading and writing,
 845         * but not for stat.
 846         */
 847        u8 compression;
 848        u8 encryption;
 849        __le16 other_encoding; /* spare for later use */
 850
 851        /* are we inline data or a real extent? */
 852        u8 type;
 853
 854        /*
 855         * disk space consumed by the extent, checksum blocks are included
 856         * in these numbers
 857         */
 858        __le64 disk_bytenr;
 859        __le64 disk_num_bytes;
 860        /*
 861         * the logical offset in file blocks (no csums)
 862         * this extent record is for.  This allows a file extent to point
 863         * into the middle of an existing extent on disk, sharing it
 864         * between two snapshots (useful if some bytes in the middle of the
 865         * extent have changed
 866         */
 867        __le64 offset;
 868        /*
 869         * the logical number of file blocks (no csums included).  This
 870         * always reflects the size uncompressed and without encoding.
 871         */
 872        __le64 num_bytes;
 873
 874} __attribute__ ((__packed__));
 875
 876struct btrfs_csum_item {
 877        u8 csum;
 878} __attribute__ ((__packed__));
 879
 880struct btrfs_dev_stats_item {
 881        /*
 882         * grow this item struct at the end for future enhancements and keep
 883         * the existing values unchanged
 884         */
 885        __le64 values[BTRFS_DEV_STAT_VALUES_MAX];
 886} __attribute__ ((__packed__));
 887
 888/* different types of block groups (and chunks) */
 889#define BTRFS_BLOCK_GROUP_DATA          (1ULL << 0)
 890#define BTRFS_BLOCK_GROUP_SYSTEM        (1ULL << 1)
 891#define BTRFS_BLOCK_GROUP_METADATA      (1ULL << 2)
 892#define BTRFS_BLOCK_GROUP_RAID0         (1ULL << 3)
 893#define BTRFS_BLOCK_GROUP_RAID1         (1ULL << 4)
 894#define BTRFS_BLOCK_GROUP_DUP           (1ULL << 5)
 895#define BTRFS_BLOCK_GROUP_RAID10        (1ULL << 6)
 896#define BTRFS_BLOCK_GROUP_RESERVED      BTRFS_AVAIL_ALLOC_BIT_SINGLE
 897#define BTRFS_NR_RAID_TYPES             5
 898
 899#define BTRFS_BLOCK_GROUP_TYPE_MASK     (BTRFS_BLOCK_GROUP_DATA |    \
 900                                         BTRFS_BLOCK_GROUP_SYSTEM |  \
 901                                         BTRFS_BLOCK_GROUP_METADATA)
 902
 903#define BTRFS_BLOCK_GROUP_PROFILE_MASK  (BTRFS_BLOCK_GROUP_RAID0 |   \
 904                                         BTRFS_BLOCK_GROUP_RAID1 |   \
 905                                         BTRFS_BLOCK_GROUP_DUP |     \
 906                                         BTRFS_BLOCK_GROUP_RAID10)
 907/*
 908 * We need a bit for restriper to be able to tell when chunks of type
 909 * SINGLE are available.  This "extended" profile format is used in
 910 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields
 911 * (on-disk).  The corresponding on-disk bit in chunk.type is reserved
 912 * to avoid remappings between two formats in future.
 913 */
 914#define BTRFS_AVAIL_ALLOC_BIT_SINGLE    (1ULL << 48)
 915
 916#define BTRFS_EXTENDED_PROFILE_MASK     (BTRFS_BLOCK_GROUP_PROFILE_MASK | \
 917                                         BTRFS_AVAIL_ALLOC_BIT_SINGLE)
 918
 919static inline u64 chunk_to_extended(u64 flags)
 920{
 921        if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)
 922                flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
 923
 924        return flags;
 925}
 926static inline u64 extended_to_chunk(u64 flags)
 927{
 928        return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
 929}
 930
 931struct btrfs_block_group_item {
 932        __le64 used;
 933        __le64 chunk_objectid;
 934        __le64 flags;
 935} __attribute__ ((__packed__));
 936
 937/*
 938 * is subvolume quota turned on?
 939 */
 940#define BTRFS_QGROUP_STATUS_FLAG_ON             (1ULL << 0)
 941/*
 942 * SCANNING is set during the initialization phase
 943 */
 944#define BTRFS_QGROUP_STATUS_FLAG_SCANNING       (1ULL << 1)
 945/*
 946 * Some qgroup entries are known to be out of date,
 947 * either because the configuration has changed in a way that
 948 * makes a rescan necessary, or because the fs has been mounted
 949 * with a non-qgroup-aware version.
 950 * Turning qouta off and on again makes it inconsistent, too.
 951 */
 952#define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT   (1ULL << 2)
 953
 954#define BTRFS_QGROUP_STATUS_VERSION        1
 955
 956struct btrfs_qgroup_status_item {
 957        __le64 version;
 958        /*
 959         * the generation is updated during every commit. As older
 960         * versions of btrfs are not aware of qgroups, it will be
 961         * possible to detect inconsistencies by checking the
 962         * generation on mount time
 963         */
 964        __le64 generation;
 965
 966        /* flag definitions see above */
 967        __le64 flags;
 968
 969        /*
 970         * only used during scanning to record the progress
 971         * of the scan. It contains a logical address
 972         */
 973        __le64 scan;
 974} __attribute__ ((__packed__));
 975
 976struct btrfs_qgroup_info_item {
 977        __le64 generation;
 978        __le64 rfer;
 979        __le64 rfer_cmpr;
 980        __le64 excl;
 981        __le64 excl_cmpr;
 982} __attribute__ ((__packed__));
 983
 984/* flags definition for qgroup limits */
 985#define BTRFS_QGROUP_LIMIT_MAX_RFER     (1ULL << 0)
 986#define BTRFS_QGROUP_LIMIT_MAX_EXCL     (1ULL << 1)
 987#define BTRFS_QGROUP_LIMIT_RSV_RFER     (1ULL << 2)
 988#define BTRFS_QGROUP_LIMIT_RSV_EXCL     (1ULL << 3)
 989#define BTRFS_QGROUP_LIMIT_RFER_CMPR    (1ULL << 4)
 990#define BTRFS_QGROUP_LIMIT_EXCL_CMPR    (1ULL << 5)
 991
 992struct btrfs_qgroup_limit_item {
 993        /*
 994         * only updated when any of the other values change
 995         */
 996        __le64 flags;
 997        __le64 max_rfer;
 998        __le64 max_excl;
 999        __le64 rsv_rfer;
1000        __le64 rsv_excl;
1001} __attribute__ ((__packed__));
1002
1003struct btrfs_space_info {
1004        u64 flags;
1005
1006        u64 total_bytes;        /* total bytes in the space,
1007                                   this doesn't take mirrors into account */
1008        u64 bytes_used;         /* total bytes used,
1009                                   this doesn't take mirrors into account */
1010        u64 bytes_pinned;       /* total bytes pinned, will be freed when the
1011                                   transaction finishes */
1012        u64 bytes_reserved;     /* total bytes the allocator has reserved for
1013                                   current allocations */
1014        u64 bytes_readonly;     /* total bytes that are read only */
1015
1016        u64 bytes_may_use;      /* number of bytes that may be used for
1017                                   delalloc/allocations */
1018        u64 disk_used;          /* total bytes used on disk */
1019        u64 disk_total;         /* total bytes on disk, takes mirrors into
1020                                   account */
1021
1022        /*
1023         * we bump reservation progress every time we decrement
1024         * bytes_reserved.  This way people waiting for reservations
1025         * know something good has happened and they can check
1026         * for progress.  The number here isn't to be trusted, it
1027         * just shows reclaim activity
1028         */
1029        unsigned long reservation_progress;
1030
1031        unsigned int full:1;    /* indicates that we cannot allocate any more
1032                                   chunks for this space */
1033        unsigned int chunk_alloc:1;     /* set if we are allocating a chunk */
1034
1035        unsigned int flush:1;           /* set if we are trying to make space */
1036
1037        unsigned int force_alloc;       /* set if we need to force a chunk
1038                                           alloc for this space */
1039
1040        struct list_head list;
1041
1042        /* for block groups in our same type */
1043        struct list_head block_groups[BTRFS_NR_RAID_TYPES];
1044        spinlock_t lock;
1045        struct rw_semaphore groups_sem;
1046        wait_queue_head_t wait;
1047};
1048
1049#define BTRFS_BLOCK_RSV_GLOBAL          1
1050#define BTRFS_BLOCK_RSV_DELALLOC        2
1051#define BTRFS_BLOCK_RSV_TRANS           3
1052#define BTRFS_BLOCK_RSV_CHUNK           4
1053#define BTRFS_BLOCK_RSV_DELOPS          5
1054#define BTRFS_BLOCK_RSV_EMPTY           6
1055#define BTRFS_BLOCK_RSV_TEMP            7
1056
1057struct btrfs_block_rsv {
1058        u64 size;
1059        u64 reserved;
1060        struct btrfs_space_info *space_info;
1061        spinlock_t lock;
1062        unsigned short full;
1063        unsigned short type;
1064        unsigned short failfast;
1065};
1066
1067/*
1068 * free clusters are used to claim free space in relatively large chunks,
1069 * allowing us to do less seeky writes.  They are used for all metadata
1070 * allocations and data allocations in ssd mode.
1071 */
1072struct btrfs_free_cluster {
1073        spinlock_t lock;
1074        spinlock_t refill_lock;
1075        struct rb_root root;
1076
1077        /* largest extent in this cluster */
1078        u64 max_size;
1079
1080        /* first extent starting offset */
1081        u64 window_start;
1082
1083        struct btrfs_block_group_cache *block_group;
1084        /*
1085         * when a cluster is allocated from a block group, we put the
1086         * cluster onto a list in the block group so that it can
1087         * be freed before the block group is freed.
1088         */
1089        struct list_head block_group_list;
1090};
1091
1092enum btrfs_caching_type {
1093        BTRFS_CACHE_NO          = 0,
1094        BTRFS_CACHE_STARTED     = 1,
1095        BTRFS_CACHE_FAST        = 2,
1096        BTRFS_CACHE_FINISHED    = 3,
1097};
1098
1099enum btrfs_disk_cache_state {
1100        BTRFS_DC_WRITTEN        = 0,
1101        BTRFS_DC_ERROR          = 1,
1102        BTRFS_DC_CLEAR          = 2,
1103        BTRFS_DC_SETUP          = 3,
1104        BTRFS_DC_NEED_WRITE     = 4,
1105};
1106
1107struct btrfs_caching_control {
1108        struct list_head list;
1109        struct mutex mutex;
1110        wait_queue_head_t wait;
1111        struct btrfs_work work;
1112        struct btrfs_block_group_cache *block_group;
1113        u64 progress;
1114        atomic_t count;
1115};
1116
1117struct btrfs_block_group_cache {
1118        struct btrfs_key key;
1119        struct btrfs_block_group_item item;
1120        struct btrfs_fs_info *fs_info;
1121        struct inode *inode;
1122        spinlock_t lock;
1123        u64 pinned;
1124        u64 reserved;
1125        u64 bytes_super;
1126        u64 flags;
1127        u64 sectorsize;
1128        u64 cache_generation;
1129        unsigned int ro:1;
1130        unsigned int dirty:1;
1131        unsigned int iref:1;
1132
1133        int disk_cache_state;
1134
1135        /* cache tracking stuff */
1136        int cached;
1137        struct btrfs_caching_control *caching_ctl;
1138        u64 last_byte_to_unpin;
1139
1140        struct btrfs_space_info *space_info;
1141
1142        /* free space cache stuff */
1143        struct btrfs_free_space_ctl *free_space_ctl;
1144
1145        /* block group cache stuff */
1146        struct rb_node cache_node;
1147
1148        /* for block groups in the same raid type */
1149        struct list_head list;
1150
1151        /* usage count */
1152        atomic_t count;
1153
1154        /* List of struct btrfs_free_clusters for this block group.
1155         * Today it will only have one thing on it, but that may change
1156         */
1157        struct list_head cluster_list;
1158
1159        /* For delayed block group creation */
1160        struct list_head new_bg_list;
1161};
1162
1163/* delayed seq elem */
1164struct seq_list {
1165        struct list_head list;
1166        u64 seq;
1167};
1168
1169/* fs_info */
1170struct reloc_control;
1171struct btrfs_device;
1172struct btrfs_fs_devices;
1173struct btrfs_balance_control;
1174struct btrfs_delayed_root;
1175struct btrfs_fs_info {
1176        u8 fsid[BTRFS_FSID_SIZE];
1177        u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
1178        struct btrfs_root *extent_root;
1179        struct btrfs_root *tree_root;
1180        struct btrfs_root *chunk_root;
1181        struct btrfs_root *dev_root;
1182        struct btrfs_root *fs_root;
1183        struct btrfs_root *csum_root;
1184        struct btrfs_root *quota_root;
1185
1186        /* the log root tree is a directory of all the other log roots */
1187        struct btrfs_root *log_root_tree;
1188
1189        spinlock_t fs_roots_radix_lock;
1190        struct radix_tree_root fs_roots_radix;
1191
1192        /* block group cache stuff */
1193        spinlock_t block_group_cache_lock;
1194        struct rb_root block_group_cache_tree;
1195
1196        /* keep track of unallocated space */
1197        spinlock_t free_chunk_lock;
1198        u64 free_chunk_space;
1199
1200        struct extent_io_tree freed_extents[2];
1201        struct extent_io_tree *pinned_extents;
1202
1203        /* logical->physical extent mapping */
1204        struct btrfs_mapping_tree mapping_tree;
1205
1206        /*
1207         * block reservation for extent, checksum, root tree and
1208         * delayed dir index item
1209         */
1210        struct btrfs_block_rsv global_block_rsv;
1211        /* block reservation for delay allocation */
1212        struct btrfs_block_rsv delalloc_block_rsv;
1213        /* block reservation for metadata operations */
1214        struct btrfs_block_rsv trans_block_rsv;
1215        /* block reservation for chunk tree */
1216        struct btrfs_block_rsv chunk_block_rsv;
1217        /* block reservation for delayed operations */
1218        struct btrfs_block_rsv delayed_block_rsv;
1219
1220        struct btrfs_block_rsv empty_block_rsv;
1221
1222        u64 generation;
1223        u64 last_trans_committed;
1224
1225        /*
1226         * this is updated to the current trans every time a full commit
1227         * is required instead of the faster short fsync log commits
1228         */
1229        u64 last_trans_log_full_commit;
1230        unsigned long mount_opt;
1231        unsigned long compress_type:4;
1232        u64 max_inline;
1233        u64 alloc_start;
1234        struct btrfs_transaction *running_transaction;
1235        wait_queue_head_t transaction_throttle;
1236        wait_queue_head_t transaction_wait;
1237        wait_queue_head_t transaction_blocked_wait;
1238        wait_queue_head_t async_submit_wait;
1239
1240        struct btrfs_super_block *super_copy;
1241        struct btrfs_super_block *super_for_commit;
1242        struct block_device *__bdev;
1243        struct super_block *sb;
1244        struct inode *btree_inode;
1245        struct backing_dev_info bdi;
1246        struct mutex tree_log_mutex;
1247        struct mutex transaction_kthread_mutex;
1248        struct mutex cleaner_mutex;
1249        struct mutex chunk_mutex;
1250        struct mutex volume_mutex;
1251        /*
1252         * this protects the ordered operations list only while we are
1253         * processing all of the entries on it.  This way we make
1254         * sure the commit code doesn't find the list temporarily empty
1255         * because another function happens to be doing non-waiting preflush
1256         * before jumping into the main commit.
1257         */
1258        struct mutex ordered_operations_mutex;
1259        struct rw_semaphore extent_commit_sem;
1260
1261        struct rw_semaphore cleanup_work_sem;
1262
1263        struct rw_semaphore subvol_sem;
1264        struct srcu_struct subvol_srcu;
1265
1266        spinlock_t trans_lock;
1267        /*
1268         * the reloc mutex goes with the trans lock, it is taken
1269         * during commit to protect us from the relocation code
1270         */
1271        struct mutex reloc_mutex;
1272
1273        struct list_head trans_list;
1274        struct list_head dead_roots;
1275        struct list_head caching_block_groups;
1276
1277        spinlock_t delayed_iput_lock;
1278        struct list_head delayed_iputs;
1279
1280        /* this protects tree_mod_seq_list */
1281        spinlock_t tree_mod_seq_lock;
1282        atomic_t tree_mod_seq;
1283        struct list_head tree_mod_seq_list;
1284        struct seq_list tree_mod_seq_elem;
1285
1286        /* this protects tree_mod_log */
1287        rwlock_t tree_mod_log_lock;
1288        struct rb_root tree_mod_log;
1289
1290        atomic_t nr_async_submits;
1291        atomic_t async_submit_draining;
1292        atomic_t nr_async_bios;
1293        atomic_t async_delalloc_pages;
1294        atomic_t open_ioctl_trans;
1295
1296        /*
1297         * this is used by the balancing code to wait for all the pending
1298         * ordered extents
1299         */
1300        spinlock_t ordered_extent_lock;
1301
1302        /*
1303         * all of the data=ordered extents pending writeback
1304         * these can span multiple transactions and basically include
1305         * every dirty data page that isn't from nodatacow
1306         */
1307        struct list_head ordered_extents;
1308
1309        /*
1310         * all of the inodes that have delalloc bytes.  It is possible for
1311         * this list to be empty even when there is still dirty data=ordered
1312         * extents waiting to finish IO.
1313         */
1314        struct list_head delalloc_inodes;
1315
1316        /*
1317         * special rename and truncate targets that must be on disk before
1318         * we're allowed to commit.  This is basically the ext3 style
1319         * data=ordered list.
1320         */
1321        struct list_head ordered_operations;
1322
1323        /*
1324         * there is a pool of worker threads for checksumming during writes
1325         * and a pool for checksumming after reads.  This is because readers
1326         * can run with FS locks held, and the writers may be waiting for
1327         * those locks.  We don't want ordering in the pending list to cause
1328         * deadlocks, and so the two are serviced separately.
1329         *
1330         * A third pool does submit_bio to avoid deadlocking with the other
1331         * two
1332         */
1333        struct btrfs_workers generic_worker;
1334        struct btrfs_workers workers;
1335        struct btrfs_workers delalloc_workers;
1336        struct btrfs_workers endio_workers;
1337        struct btrfs_workers endio_meta_workers;
1338        struct btrfs_workers endio_meta_write_workers;
1339        struct btrfs_workers endio_write_workers;
1340        struct btrfs_workers endio_freespace_worker;
1341        struct btrfs_workers submit_workers;
1342        struct btrfs_workers caching_workers;
1343        struct btrfs_workers readahead_workers;
1344
1345        /*
1346         * fixup workers take dirty pages that didn't properly go through
1347         * the cow mechanism and make them safe to write.  It happens
1348         * for the sys_munmap function call path
1349         */
1350        struct btrfs_workers fixup_workers;
1351        struct btrfs_workers delayed_workers;
1352        struct task_struct *transaction_kthread;
1353        struct task_struct *cleaner_kthread;
1354        int thread_pool_size;
1355
1356        struct kobject super_kobj;
1357        struct completion kobj_unregister;
1358        int do_barriers;
1359        int closing;
1360        int log_root_recovering;
1361        int enospc_unlink;
1362        int trans_no_join;
1363
1364        u64 total_pinned;
1365
1366        /* protected by the delalloc lock, used to keep from writing
1367         * metadata until there is a nice batch
1368         */
1369        u64 dirty_metadata_bytes;
1370        struct list_head dirty_cowonly_roots;
1371
1372        struct btrfs_fs_devices *fs_devices;
1373
1374        /*
1375         * the space_info list is almost entirely read only.  It only changes
1376         * when we add a new raid type to the FS, and that happens
1377         * very rarely.  RCU is used to protect it.
1378         */
1379        struct list_head space_info;
1380
1381        struct btrfs_space_info *data_sinfo;
1382
1383        struct reloc_control *reloc_ctl;
1384
1385        spinlock_t delalloc_lock;
1386        u64 delalloc_bytes;
1387
1388        /* data_alloc_cluster is only used in ssd mode */
1389        struct btrfs_free_cluster data_alloc_cluster;
1390
1391        /* all metadata allocations go through this cluster */
1392        struct btrfs_free_cluster meta_alloc_cluster;
1393
1394        /* auto defrag inodes go here */
1395        spinlock_t defrag_inodes_lock;
1396        struct rb_root defrag_inodes;
1397        atomic_t defrag_running;
1398
1399        /*
1400         * these three are in extended format (availability of single
1401         * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
1402         * types are denoted by corresponding BTRFS_BLOCK_GROUP_* bits)
1403         */
1404        u64 avail_data_alloc_bits;
1405        u64 avail_metadata_alloc_bits;
1406        u64 avail_system_alloc_bits;
1407
1408        /* restriper state */
1409        spinlock_t balance_lock;
1410        struct mutex balance_mutex;
1411        atomic_t balance_running;
1412        atomic_t balance_pause_req;
1413        atomic_t balance_cancel_req;
1414        struct btrfs_balance_control *balance_ctl;
1415        wait_queue_head_t balance_wait_q;
1416
1417        unsigned data_chunk_allocations;
1418        unsigned metadata_ratio;
1419
1420        void *bdev_holder;
1421
1422        /* private scrub information */
1423        struct mutex scrub_lock;
1424        atomic_t scrubs_running;
1425        atomic_t scrub_pause_req;
1426        atomic_t scrubs_paused;
1427        atomic_t scrub_cancel_req;
1428        wait_queue_head_t scrub_pause_wait;
1429        struct rw_semaphore scrub_super_lock;
1430        int scrub_workers_refcnt;
1431        struct btrfs_workers scrub_workers;
1432
1433#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1434        u32 check_integrity_print_mask;
1435#endif
1436        /*
1437         * quota information
1438         */
1439        unsigned int quota_enabled:1;
1440
1441        /*
1442         * quota_enabled only changes state after a commit. This holds the
1443         * next state.
1444         */
1445        unsigned int pending_quota_state:1;
1446
1447        /* is qgroup tracking in a consistent state? */
1448        u64 qgroup_flags;
1449
1450        /* holds configuration and tracking. Protected by qgroup_lock */
1451        struct rb_root qgroup_tree;
1452        spinlock_t qgroup_lock;
1453
1454        /* list of dirty qgroups to be written at next commit */
1455        struct list_head dirty_qgroups;
1456
1457        /* used by btrfs_qgroup_record_ref for an efficient tree traversal */
1458        u64 qgroup_seq;
1459
1460        /* filesystem state */
1461        u64 fs_state;
1462
1463        struct btrfs_delayed_root *delayed_root;
1464
1465        /* readahead tree */
1466        spinlock_t reada_lock;
1467        struct radix_tree_root reada_tree;
1468
1469        /* next backup root to be overwritten */
1470        int backup_root_index;
1471
1472        int num_tolerated_disk_barrier_failures;
1473};
1474
1475/*
1476 * in ram representation of the tree.  extent_root is used for all allocations
1477 * and for the extent tree extent_root root.
1478 */
1479struct btrfs_root {
1480        struct extent_buffer *node;
1481
1482        struct extent_buffer *commit_root;
1483        struct btrfs_root *log_root;
1484        struct btrfs_root *reloc_root;
1485
1486        struct btrfs_root_item root_item;
1487        struct btrfs_key root_key;
1488        struct btrfs_fs_info *fs_info;
1489        struct extent_io_tree dirty_log_pages;
1490
1491        struct kobject root_kobj;
1492        struct completion kobj_unregister;
1493        struct mutex objectid_mutex;
1494
1495        spinlock_t accounting_lock;
1496        struct btrfs_block_rsv *block_rsv;
1497
1498        /* free ino cache stuff */
1499        struct mutex fs_commit_mutex;
1500        struct btrfs_free_space_ctl *free_ino_ctl;
1501        enum btrfs_caching_type cached;
1502        spinlock_t cache_lock;
1503        wait_queue_head_t cache_wait;
1504        struct btrfs_free_space_ctl *free_ino_pinned;
1505        u64 cache_progress;
1506        struct inode *cache_inode;
1507
1508        struct mutex log_mutex;
1509        wait_queue_head_t log_writer_wait;
1510        wait_queue_head_t log_commit_wait[2];
1511        atomic_t log_writers;
1512        atomic_t log_commit[2];
1513        atomic_t log_batch;
1514        unsigned long log_transid;
1515        unsigned long last_log_commit;
1516        pid_t log_start_pid;
1517        bool log_multiple_pids;
1518
1519        u64 objectid;
1520        u64 last_trans;
1521
1522        /* data allocations are done in sectorsize units */
1523        u32 sectorsize;
1524
1525        /* node allocations are done in nodesize units */
1526        u32 nodesize;
1527
1528        /* leaf allocations are done in leafsize units */
1529        u32 leafsize;
1530
1531        u32 stripesize;
1532
1533        u32 type;
1534
1535        u64 highest_objectid;
1536
1537        /* btrfs_record_root_in_trans is a multi-step process,
1538         * and it can race with the balancing code.   But the
1539         * race is very small, and only the first time the root
1540         * is added to each transaction.  So in_trans_setup
1541         * is used to tell us when more checks are required
1542         */
1543        unsigned long in_trans_setup;
1544        int ref_cows;
1545        int track_dirty;
1546        int in_radix;
1547
1548        u64 defrag_trans_start;
1549        struct btrfs_key defrag_progress;
1550        struct btrfs_key defrag_max;
1551        int defrag_running;
1552        char *name;
1553
1554        /* the dirty list is only used by non-reference counted roots */
1555        struct list_head dirty_list;
1556
1557        struct list_head root_list;
1558
1559        spinlock_t orphan_lock;
1560        atomic_t orphan_inodes;
1561        struct btrfs_block_rsv *orphan_block_rsv;
1562        int orphan_item_inserted;
1563        int orphan_cleanup_state;
1564
1565        spinlock_t inode_lock;
1566        /* red-black tree that keeps track of in-memory inodes */
1567        struct rb_root inode_tree;
1568
1569        /*
1570         * radix tree that keeps track of delayed nodes of every inode,
1571         * protected by inode_lock
1572         */
1573        struct radix_tree_root delayed_nodes_tree;
1574        /*
1575         * right now this just gets used so that a root has its own devid
1576         * for stat.  It may be used for more later
1577         */
1578        dev_t anon_dev;
1579
1580        int force_cow;
1581
1582        spinlock_t root_times_lock;
1583};
1584
1585struct btrfs_ioctl_defrag_range_args {
1586        /* start of the defrag operation */
1587        __u64 start;
1588
1589        /* number of bytes to defrag, use (u64)-1 to say all */
1590        __u64 len;
1591
1592        /*
1593         * flags for the operation, which can include turning
1594         * on compression for this one defrag
1595         */
1596        __u64 flags;
1597
1598        /*
1599         * any extent bigger than this will be considered
1600         * already defragged.  Use 0 to take the kernel default
1601         * Use 1 to say every single extent must be rewritten
1602         */
1603        __u32 extent_thresh;
1604
1605        /*
1606         * which compression method to use if turning on compression
1607         * for this defrag operation.  If unspecified, zlib will
1608         * be used
1609         */
1610        __u32 compress_type;
1611
1612        /* spare for later */
1613        __u32 unused[4];
1614};
1615
1616
1617/*
1618 * inode items have the data typically returned from stat and store other
1619 * info about object characteristics.  There is one for every file and dir in
1620 * the FS
1621 */
1622#define BTRFS_INODE_ITEM_KEY            1
1623#define BTRFS_INODE_REF_KEY             12
1624#define BTRFS_INODE_EXTREF_KEY          13
1625#define BTRFS_XATTR_ITEM_KEY            24
1626#define BTRFS_ORPHAN_ITEM_KEY           48
1627/* reserve 2-15 close to the inode for later flexibility */
1628
1629/*
1630 * dir items are the name -> inode pointers in a directory.  There is one
1631 * for every name in a directory.
1632 */
1633#define BTRFS_DIR_LOG_ITEM_KEY  60
1634#define BTRFS_DIR_LOG_INDEX_KEY 72
1635#define BTRFS_DIR_ITEM_KEY      84
1636#define BTRFS_DIR_INDEX_KEY     96
1637/*
1638 * extent data is for file data
1639 */
1640#define BTRFS_EXTENT_DATA_KEY   108
1641
1642/*
1643 * extent csums are stored in a separate tree and hold csums for
1644 * an entire extent on disk.
1645 */
1646#define BTRFS_EXTENT_CSUM_KEY   128
1647
1648/*
1649 * root items point to tree roots.  They are typically in the root
1650 * tree used by the super block to find all the other trees
1651 */
1652#define BTRFS_ROOT_ITEM_KEY     132
1653
1654/*
1655 * root backrefs tie subvols and snapshots to the directory entries that
1656 * reference them
1657 */
1658#define BTRFS_ROOT_BACKREF_KEY  144
1659
1660/*
1661 * root refs make a fast index for listing all of the snapshots and
1662 * subvolumes referenced by a given root.  They point directly to the
1663 * directory item in the root that references the subvol
1664 */
1665#define BTRFS_ROOT_REF_KEY      156
1666
1667/*
1668 * extent items are in the extent map tree.  These record which blocks
1669 * are used, and how many references there are to each block
1670 */
1671#define BTRFS_EXTENT_ITEM_KEY   168
1672
1673#define BTRFS_TREE_BLOCK_REF_KEY        176
1674
1675#define BTRFS_EXTENT_DATA_REF_KEY       178
1676
1677#define BTRFS_EXTENT_REF_V0_KEY         180
1678
1679#define BTRFS_SHARED_BLOCK_REF_KEY      182
1680
1681#define BTRFS_SHARED_DATA_REF_KEY       184
1682
1683/*
1684 * block groups give us hints into the extent allocation trees.  Which
1685 * blocks are free etc etc
1686 */
1687#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
1688
1689#define BTRFS_DEV_EXTENT_KEY    204
1690#define BTRFS_DEV_ITEM_KEY      216
1691#define BTRFS_CHUNK_ITEM_KEY    228
1692
1693/*
1694 * Records the overall state of the qgroups.
1695 * There's only one instance of this key present,
1696 * (0, BTRFS_QGROUP_STATUS_KEY, 0)
1697 */
1698#define BTRFS_QGROUP_STATUS_KEY         240
1699/*
1700 * Records the currently used space of the qgroup.
1701 * One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid).
1702 */
1703#define BTRFS_QGROUP_INFO_KEY           242
1704/*
1705 * Contains the user configured limits for the qgroup.
1706 * One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid).
1707 */
1708#define BTRFS_QGROUP_LIMIT_KEY          244
1709/*
1710 * Records the child-parent relationship of qgroups. For
1711 * each relation, 2 keys are present:
1712 * (childid, BTRFS_QGROUP_RELATION_KEY, parentid)
1713 * (parentid, BTRFS_QGROUP_RELATION_KEY, childid)
1714 */
1715#define BTRFS_QGROUP_RELATION_KEY       246
1716
1717#define BTRFS_BALANCE_ITEM_KEY  248
1718
1719/*
1720 * Persistantly stores the io stats in the device tree.
1721 * One key for all stats, (0, BTRFS_DEV_STATS_KEY, devid).
1722 */
1723#define BTRFS_DEV_STATS_KEY     249
1724
1725/*
1726 * string items are for debugging.  They just store a short string of
1727 * data in the FS
1728 */
1729#define BTRFS_STRING_ITEM_KEY   253
1730
1731/*
1732 * Flags for mount options.
1733 *
1734 * Note: don't forget to add new options to btrfs_show_options()
1735 */
1736#define BTRFS_MOUNT_NODATASUM           (1 << 0)
1737#define BTRFS_MOUNT_NODATACOW           (1 << 1)
1738#define BTRFS_MOUNT_NOBARRIER           (1 << 2)
1739#define BTRFS_MOUNT_SSD                 (1 << 3)
1740#define BTRFS_MOUNT_DEGRADED            (1 << 4)
1741#define BTRFS_MOUNT_COMPRESS            (1 << 5)
1742#define BTRFS_MOUNT_NOTREELOG           (1 << 6)
1743#define BTRFS_MOUNT_FLUSHONCOMMIT       (1 << 7)
1744#define BTRFS_MOUNT_SSD_SPREAD          (1 << 8)
1745#define BTRFS_MOUNT_NOSSD               (1 << 9)
1746#define BTRFS_MOUNT_DISCARD             (1 << 10)
1747#define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)
1748#define BTRFS_MOUNT_SPACE_CACHE         (1 << 12)
1749#define BTRFS_MOUNT_CLEAR_CACHE         (1 << 13)
1750#define BTRFS_MOUNT_USER_SUBVOL_RM_ALLOWED (1 << 14)
1751#define BTRFS_MOUNT_ENOSPC_DEBUG         (1 << 15)
1752#define BTRFS_MOUNT_AUTO_DEFRAG         (1 << 16)
1753#define BTRFS_MOUNT_INODE_MAP_CACHE     (1 << 17)
1754#define BTRFS_MOUNT_RECOVERY            (1 << 18)
1755#define BTRFS_MOUNT_SKIP_BALANCE        (1 << 19)
1756#define BTRFS_MOUNT_CHECK_INTEGRITY     (1 << 20)
1757#define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21)
1758#define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR        (1 << 22)
1759
1760#define btrfs_clear_opt(o, opt)         ((o) &= ~BTRFS_MOUNT_##opt)
1761#define btrfs_set_opt(o, opt)           ((o) |= BTRFS_MOUNT_##opt)
1762#define btrfs_test_opt(root, opt)       ((root)->fs_info->mount_opt & \
1763                                         BTRFS_MOUNT_##opt)
1764/*
1765 * Inode flags
1766 */
1767#define BTRFS_INODE_NODATASUM           (1 << 0)
1768#define BTRFS_INODE_NODATACOW           (1 << 1)
1769#define BTRFS_INODE_READONLY            (1 << 2)
1770#define BTRFS_INODE_NOCOMPRESS          (1 << 3)
1771#define BTRFS_INODE_PREALLOC            (1 << 4)
1772#define BTRFS_INODE_SYNC                (1 << 5)
1773#define BTRFS_INODE_IMMUTABLE           (1 << 6)
1774#define BTRFS_INODE_APPEND              (1 << 7)
1775#define BTRFS_INODE_NODUMP              (1 << 8)
1776#define BTRFS_INODE_NOATIME             (1 << 9)
1777#define BTRFS_INODE_DIRSYNC             (1 << 10)
1778#define BTRFS_INODE_COMPRESS            (1 << 11)
1779
1780#define BTRFS_INODE_ROOT_ITEM_INIT      (1 << 31)
1781
1782struct btrfs_map_token {
1783        struct extent_buffer *eb;
1784        char *kaddr;
1785        unsigned long offset;
1786};
1787
1788static inline void btrfs_init_map_token (struct btrfs_map_token *token)
1789{
1790        memset(token, 0, sizeof(*token));
1791}
1792
1793/* some macros to generate set/get funcs for the struct fields.  This
1794 * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1795 * one for u8:
1796 */
1797#define le8_to_cpu(v) (v)
1798#define cpu_to_le8(v) (v)
1799#define __le8 u8
1800
1801#define read_eb_member(eb, ptr, type, member, result) (                 \
1802        read_extent_buffer(eb, (char *)(result),                        \
1803                           ((unsigned long)(ptr)) +                     \
1804                            offsetof(type, member),                     \
1805                           sizeof(((type *)0)->member)))
1806
1807#define write_eb_member(eb, ptr, type, member, result) (                \
1808        write_extent_buffer(eb, (char *)(result),                       \
1809                           ((unsigned long)(ptr)) +                     \
1810                            offsetof(type, member),                     \
1811                           sizeof(((type *)0)->member)))
1812
1813#define DECLARE_BTRFS_SETGET_BITS(bits)                                 \
1814u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr,     \
1815                               unsigned long off,                       \
1816                              struct btrfs_map_token *token);           \
1817void btrfs_set_token_##bits(struct extent_buffer *eb, void *ptr,        \
1818                            unsigned long off, u##bits val,             \
1819                            struct btrfs_map_token *token);             \
1820static inline u##bits btrfs_get_##bits(struct extent_buffer *eb, void *ptr, \
1821                                       unsigned long off)               \
1822{                                                                       \
1823        return btrfs_get_token_##bits(eb, ptr, off, NULL);              \
1824}                                                                       \
1825static inline void btrfs_set_##bits(struct extent_buffer *eb, void *ptr, \
1826                                    unsigned long off, u##bits val)     \
1827{                                                                       \
1828       btrfs_set_token_##bits(eb, ptr, off, val, NULL);                 \
1829}
1830
1831DECLARE_BTRFS_SETGET_BITS(8)
1832DECLARE_BTRFS_SETGET_BITS(16)
1833DECLARE_BTRFS_SETGET_BITS(32)
1834DECLARE_BTRFS_SETGET_BITS(64)
1835
1836#define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
1837static inline u##bits btrfs_##name(struct extent_buffer *eb, type *s)   \
1838{                                                                       \
1839        BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);   \
1840        return btrfs_get_##bits(eb, s, offsetof(type, member));         \
1841}                                                                       \
1842static inline void btrfs_set_##name(struct extent_buffer *eb, type *s,  \
1843                                    u##bits val)                        \
1844{                                                                       \
1845        BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);   \
1846        btrfs_set_##bits(eb, s, offsetof(type, member), val);           \
1847}                                                                       \
1848static inline u##bits btrfs_token_##name(struct extent_buffer *eb, type *s, \
1849                                         struct btrfs_map_token *token) \
1850{                                                                       \
1851        BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);   \
1852        return btrfs_get_token_##bits(eb, s, offsetof(type, member), token); \
1853}                                                                       \
1854static inline void btrfs_set_token_##name(struct extent_buffer *eb,     \
1855                                          type *s, u##bits val,         \
1856                                         struct btrfs_map_token *token) \
1857{                                                                       \
1858        BUILD_BUG_ON(sizeof(u##bits) != sizeof(((type *)0))->member);   \
1859        btrfs_set_token_##bits(eb, s, offsetof(type, member), val, token); \
1860}
1861
1862#define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
1863static inline u##bits btrfs_##name(struct extent_buffer *eb)            \
1864{                                                                       \
1865        type *p = page_address(eb->pages[0]);                           \
1866        u##bits res = le##bits##_to_cpu(p->member);                     \
1867        return res;                                                     \
1868}                                                                       \
1869static inline void btrfs_set_##name(struct extent_buffer *eb,           \
1870                                    u##bits val)                        \
1871{                                                                       \
1872        type *p = page_address(eb->pages[0]);                           \
1873        p->member = cpu_to_le##bits(val);                               \
1874}
1875
1876#define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
1877static inline u##bits btrfs_##name(type *s)                             \
1878{                                                                       \
1879        return le##bits##_to_cpu(s->member);                            \
1880}                                                                       \
1881static inline void btrfs_set_##name(type *s, u##bits val)               \
1882{                                                                       \
1883        s->member = cpu_to_le##bits(val);                               \
1884}
1885
1886BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1887BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
1888BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1889BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1890BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1891BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1892                   start_offset, 64);
1893BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1894BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1895BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1896BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1897BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1898BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1899
1900BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1901BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1902                         total_bytes, 64);
1903BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1904                         bytes_used, 64);
1905BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1906                         io_align, 32);
1907BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1908                         io_width, 32);
1909BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1910                         sector_size, 32);
1911BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1912BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1913                         dev_group, 32);
1914BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1915                         seek_speed, 8);
1916BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1917                         bandwidth, 8);
1918BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1919                         generation, 64);
1920
1921static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
1922{
1923        return (char *)d + offsetof(struct btrfs_dev_item, uuid);
1924}
1925
1926static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
1927{
1928        return (char *)d + offsetof(struct btrfs_dev_item, fsid);
1929}
1930
1931BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1932BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1933BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1934BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1935BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1936BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1937BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1938BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1939BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1940BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1941BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1942
1943static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1944{
1945        return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1946}
1947
1948BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1949BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1950BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1951                         stripe_len, 64);
1952BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1953                         io_align, 32);
1954BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1955                         io_width, 32);
1956BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1957                         sector_size, 32);
1958BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1959BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1960                         num_stripes, 16);
1961BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1962                         sub_stripes, 16);
1963BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1964BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1965
1966static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1967                                                   int nr)
1968{
1969        unsigned long offset = (unsigned long)c;
1970        offset += offsetof(struct btrfs_chunk, stripe);
1971        offset += nr * sizeof(struct btrfs_stripe);
1972        return (struct btrfs_stripe *)offset;
1973}
1974
1975static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1976{
1977        return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1978}
1979
1980static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
1981                                         struct btrfs_chunk *c, int nr)
1982{
1983        return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1984}
1985
1986static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
1987                                         struct btrfs_chunk *c, int nr)
1988{
1989        return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1990}
1991
1992/* struct btrfs_block_group_item */
1993BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1994                         used, 64);
1995BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1996                         used, 64);
1997BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1998                        struct btrfs_block_group_item, chunk_objectid, 64);
1999
2000BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
2001                   struct btrfs_block_group_item, chunk_objectid, 64);
2002BTRFS_SETGET_FUNCS(disk_block_group_flags,
2003                   struct btrfs_block_group_item, flags, 64);
2004BTRFS_SETGET_STACK_FUNCS(block_group_flags,
2005                        struct btrfs_block_group_item, flags, 64);
2006
2007/* struct btrfs_inode_ref */
2008BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
2009BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
2010
2011/* struct btrfs_inode_extref */
2012BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
2013                   parent_objectid, 64);
2014BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
2015                   name_len, 16);
2016BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
2017
2018/* struct btrfs_inode_item */
2019BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
2020BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
2021BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
2022BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
2023BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
2024BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
2025BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
2026BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
2027BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
2028BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
2029BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
2030BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
2031
2032static inline struct btrfs_timespec *
2033btrfs_inode_atime(struct btrfs_inode_item *inode_item)
2034{
2035        unsigned long ptr = (unsigned long)inode_item;
2036        ptr += offsetof(struct btrfs_inode_item, atime);
2037        return (struct btrfs_timespec *)ptr;
2038}
2039
2040static inline struct btrfs_timespec *
2041btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
2042{
2043        unsigned long ptr = (unsigned long)inode_item;
2044        ptr += offsetof(struct btrfs_inode_item, mtime);
2045        return (struct btrfs_timespec *)ptr;
2046}
2047
2048static inline struct btrfs_timespec *
2049btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
2050{
2051        unsigned long ptr = (unsigned long)inode_item;
2052        ptr += offsetof(struct btrfs_inode_item, ctime);
2053        return (struct btrfs_timespec *)ptr;
2054}
2055
2056BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
2057BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
2058
2059/* struct btrfs_dev_extent */
2060BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
2061                   chunk_tree, 64);
2062BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
2063                   chunk_objectid, 64);
2064BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
2065                   chunk_offset, 64);
2066BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
2067
2068static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
2069{
2070        unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
2071        return (u8 *)((unsigned long)dev + ptr);
2072}
2073
2074BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
2075BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
2076                   generation, 64);
2077BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
2078
2079BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
2080
2081
2082BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
2083
2084static inline void btrfs_tree_block_key(struct extent_buffer *eb,
2085                                        struct btrfs_tree_block_info *item,
2086                                        struct btrfs_disk_key *key)
2087{
2088        read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2089}
2090
2091static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
2092                                            struct btrfs_tree_block_info *item,
2093                                            struct btrfs_disk_key *key)
2094{
2095        write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
2096}
2097
2098BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
2099                   root, 64);
2100BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
2101                   objectid, 64);
2102BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
2103                   offset, 64);
2104BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
2105                   count, 32);
2106
2107BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
2108                   count, 32);
2109
2110BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
2111                   type, 8);
2112BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
2113                   offset, 64);
2114
2115static inline u32 btrfs_extent_inline_ref_size(int type)
2116{
2117        if (type == BTRFS_TREE_BLOCK_REF_KEY ||
2118            type == BTRFS_SHARED_BLOCK_REF_KEY)
2119                return sizeof(struct btrfs_extent_inline_ref);
2120        if (type == BTRFS_SHARED_DATA_REF_KEY)
2121                return sizeof(struct btrfs_shared_data_ref) +
2122                       sizeof(struct btrfs_extent_inline_ref);
2123        if (type == BTRFS_EXTENT_DATA_REF_KEY)
2124                return sizeof(struct btrfs_extent_data_ref) +
2125                       offsetof(struct btrfs_extent_inline_ref, offset);
2126        BUG();
2127        return 0;
2128}
2129
2130BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
2131BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
2132                   generation, 64);
2133BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
2134BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
2135
2136/* struct btrfs_node */
2137BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
2138BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
2139
2140static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
2141{
2142        unsigned long ptr;
2143        ptr = offsetof(struct btrfs_node, ptrs) +
2144                sizeof(struct btrfs_key_ptr) * nr;
2145        return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
2146}
2147
2148static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
2149                                           int nr, u64 val)
2150{
2151        unsigned long ptr;
2152        ptr = offsetof(struct btrfs_node, ptrs) +
2153                sizeof(struct btrfs_key_ptr) * nr;
2154        btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
2155}
2156
2157static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
2158{
2159        unsigned long ptr;
2160        ptr = offsetof(struct btrfs_node, ptrs) +
2161                sizeof(struct btrfs_key_ptr) * nr;
2162        return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
2163}
2164
2165static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
2166                                                 int nr, u64 val)
2167{
2168        unsigned long ptr;
2169        ptr = offsetof(struct btrfs_node, ptrs) +
2170                sizeof(struct btrfs_key_ptr) * nr;
2171        btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
2172}
2173
2174static inline unsigned long btrfs_node_key_ptr_offset(int nr)
2175{
2176        return offsetof(struct btrfs_node, ptrs) +
2177                sizeof(struct btrfs_key_ptr) * nr;
2178}
2179
2180void btrfs_node_key(struct extent_buffer *eb,
2181                    struct btrfs_disk_key *disk_key, int nr);
2182
2183static inline void btrfs_set_node_key(struct extent_buffer *eb,
2184                                      struct btrfs_disk_key *disk_key, int nr)
2185{
2186        unsigned long ptr;
2187        ptr = btrfs_node_key_ptr_offset(nr);
2188        write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
2189                       struct btrfs_key_ptr, key, disk_key);
2190}
2191
2192/* struct btrfs_item */
2193BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
2194BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
2195
2196static inline unsigned long btrfs_item_nr_offset(int nr)
2197{
2198        return offsetof(struct btrfs_leaf, items) +
2199                sizeof(struct btrfs_item) * nr;
2200}
2201
2202static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
2203                                               int nr)
2204{
2205        return (struct btrfs_item *)btrfs_item_nr_offset(nr);
2206}
2207
2208static inline u32 btrfs_item_end(struct extent_buffer *eb,
2209                                 struct btrfs_item *item)
2210{
2211        return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
2212}
2213
2214static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
2215{
2216        return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
2217}
2218
2219static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
2220{
2221        return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
2222}
2223
2224static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
2225{
2226        return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
2227}
2228
2229static inline void btrfs_item_key(struct extent_buffer *eb,
2230                           struct btrfs_disk_key *disk_key, int nr)
2231{
2232        struct btrfs_item *item = btrfs_item_nr(eb, nr);
2233        read_eb_member(eb, item, struct btrfs_item, key, disk_key);
2234}
2235
2236static inline void btrfs_set_item_key(struct extent_buffer *eb,
2237                               struct btrfs_disk_key *disk_key, int nr)
2238{
2239        struct btrfs_item *item = btrfs_item_nr(eb, nr);
2240        write_eb_member(eb, item, struct btrfs_item, key, disk_key);
2241}
2242
2243BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
2244
2245/*
2246 * struct btrfs_root_ref
2247 */
2248BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
2249BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
2250BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
2251
2252/* struct btrfs_dir_item */
2253BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
2254BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
2255BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
2256BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
2257
2258static inline void btrfs_dir_item_key(struct extent_buffer *eb,
2259                                      struct btrfs_dir_item *item,
2260                                      struct btrfs_disk_key *key)
2261{
2262        read_eb_member(eb, item, struct btrfs_dir_item, location, key);
2263}
2264
2265static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
2266                                          struct btrfs_dir_item *item,
2267                                          struct btrfs_disk_key *key)
2268{
2269        write_eb_member(eb, item, struct btrfs_dir_item, location, key);
2270}
2271
2272BTRFS_SETGET_FUNCS(free_space_entries, struct btrfs_free_space_header,
2273                   num_entries, 64);
2274BTRFS_SETGET_FUNCS(free_space_bitmaps, struct btrfs_free_space_header,
2275                   num_bitmaps, 64);
2276BTRFS_SETGET_FUNCS(free_space_generation, struct btrfs_free_space_header,
2277                   generation, 64);
2278
2279static inline void btrfs_free_space_key(struct extent_buffer *eb,
2280                                        struct btrfs_free_space_header *h,
2281                                        struct btrfs_disk_key *key)
2282{
2283        read_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2284}
2285
2286static inline void btrfs_set_free_space_key(struct extent_buffer *eb,
2287                                            struct btrfs_free_space_header *h,
2288                                            struct btrfs_disk_key *key)
2289{
2290        write_eb_member(eb, h, struct btrfs_free_space_header, location, key);
2291}
2292
2293/* struct btrfs_disk_key */
2294BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
2295                         objectid, 64);
2296BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
2297BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
2298
2299static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
2300                                         struct btrfs_disk_key *disk)
2301{
2302        cpu->offset = le64_to_cpu(disk->offset);
2303        cpu->type = disk->type;
2304        cpu->objectid = le64_to_cpu(disk->objectid);
2305}
2306
2307static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
2308                                         struct btrfs_key *cpu)
2309{
2310        disk->offset = cpu_to_le64(cpu->offset);
2311        disk->type = cpu->type;
2312        disk->objectid = cpu_to_le64(cpu->objectid);
2313}
2314
2315static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
2316                                  struct btrfs_key *key, int nr)
2317{
2318        struct btrfs_disk_key disk_key;
2319        btrfs_node_key(eb, &disk_key, nr);
2320        btrfs_disk_key_to_cpu(key, &disk_key);
2321}
2322
2323static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
2324                                  struct btrfs_key *key, int nr)
2325{
2326        struct btrfs_disk_key disk_key;
2327        btrfs_item_key(eb, &disk_key, nr);
2328        btrfs_disk_key_to_cpu(key, &disk_key);
2329}
2330
2331static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
2332                                      struct btrfs_dir_item *item,
2333                                      struct btrfs_key *key)
2334{
2335        struct btrfs_disk_key disk_key;
2336        btrfs_dir_item_key(eb, item, &disk_key);
2337        btrfs_disk_key_to_cpu(key, &disk_key);
2338}
2339
2340
2341static inline u8 btrfs_key_type(struct btrfs_key *key)
2342{
2343        return key->type;
2344}
2345
2346static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
2347{
2348        key->type = val;
2349}
2350
2351/* struct btrfs_header */
2352BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
2353BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
2354                          generation, 64);
2355BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
2356BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
2357BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
2358BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
2359
2360static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
2361{
2362        return (btrfs_header_flags(eb) & flag) == flag;
2363}
2364
2365static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
2366{
2367        u64 flags = btrfs_header_flags(eb);
2368        btrfs_set_header_flags(eb, flags | flag);
2369        return (flags & flag) == flag;
2370}
2371
2372static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
2373{
2374        u64 flags = btrfs_header_flags(eb);
2375        btrfs_set_header_flags(eb, flags & ~flag);
2376        return (flags & flag) == flag;
2377}
2378
2379static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
2380{
2381        u64 flags = btrfs_header_flags(eb);
2382        return flags >> BTRFS_BACKREF_REV_SHIFT;
2383}
2384
2385static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
2386                                                int rev)
2387{
2388        u64 flags = btrfs_header_flags(eb);
2389        flags &= ~BTRFS_BACKREF_REV_MASK;
2390        flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
2391        btrfs_set_header_flags(eb, flags);
2392}
2393
2394static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
2395{
2396        unsigned long ptr = offsetof(struct btrfs_header, fsid);
2397        return (u8 *)ptr;
2398}
2399
2400static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
2401{
2402        unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);
2403        return (u8 *)ptr;
2404}
2405
2406static inline int btrfs_is_leaf(struct extent_buffer *eb)
2407{
2408        return btrfs_header_level(eb) == 0;
2409}
2410
2411/* struct btrfs_root_item */
2412BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
2413                   generation, 64);
2414BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
2415BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
2416BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
2417
2418BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
2419                         generation, 64);
2420BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
2421BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
2422BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
2423BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
2424BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
2425BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
2426BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
2427BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
2428                         last_snapshot, 64);
2429BTRFS_SETGET_STACK_FUNCS(root_generation_v2, struct btrfs_root_item,
2430                         generation_v2, 64);
2431BTRFS_SETGET_STACK_FUNCS(root_ctransid, struct btrfs_root_item,
2432                         ctransid, 64);
2433BTRFS_SETGET_STACK_FUNCS(root_otransid, struct btrfs_root_item,
2434                         otransid, 64);
2435BTRFS_SETGET_STACK_FUNCS(root_stransid, struct btrfs_root_item,
2436                         stransid, 64);
2437BTRFS_SETGET_STACK_FUNCS(root_rtransid, struct btrfs_root_item,
2438                         rtransid, 64);
2439
2440static inline bool btrfs_root_readonly(struct btrfs_root *root)
2441{
2442        return (root->root_item.flags & cpu_to_le64(BTRFS_ROOT_SUBVOL_RDONLY)) != 0;
2443}
2444
2445/* struct btrfs_root_backup */
2446BTRFS_SETGET_STACK_FUNCS(backup_tree_root, struct btrfs_root_backup,
2447                   tree_root, 64);
2448BTRFS_SETGET_STACK_FUNCS(backup_tree_root_gen, struct btrfs_root_backup,
2449                   tree_root_gen, 64);
2450BTRFS_SETGET_STACK_FUNCS(backup_tree_root_level, struct btrfs_root_backup,
2451                   tree_root_level, 8);
2452
2453BTRFS_SETGET_STACK_FUNCS(backup_chunk_root, struct btrfs_root_backup,
2454                   chunk_root, 64);
2455BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_gen, struct btrfs_root_backup,
2456                   chunk_root_gen, 64);
2457BTRFS_SETGET_STACK_FUNCS(backup_chunk_root_level, struct btrfs_root_backup,
2458                   chunk_root_level, 8);
2459
2460BTRFS_SETGET_STACK_FUNCS(backup_extent_root, struct btrfs_root_backup,
2461                   extent_root, 64);
2462BTRFS_SETGET_STACK_FUNCS(backup_extent_root_gen, struct btrfs_root_backup,
2463                   extent_root_gen, 64);
2464BTRFS_SETGET_STACK_FUNCS(backup_extent_root_level, struct btrfs_root_backup,
2465                   extent_root_level, 8);
2466
2467BTRFS_SETGET_STACK_FUNCS(backup_fs_root, struct btrfs_root_backup,
2468                   fs_root, 64);
2469BTRFS_SETGET_STACK_FUNCS(backup_fs_root_gen, struct btrfs_root_backup,
2470                   fs_root_gen, 64);
2471BTRFS_SETGET_STACK_FUNCS(backup_fs_root_level, struct btrfs_root_backup,
2472                   fs_root_level, 8);
2473
2474BTRFS_SETGET_STACK_FUNCS(backup_dev_root, struct btrfs_root_backup,
2475                   dev_root, 64);
2476BTRFS_SETGET_STACK_FUNCS(backup_dev_root_gen, struct btrfs_root_backup,
2477                   dev_root_gen, 64);
2478BTRFS_SETGET_STACK_FUNCS(backup_dev_root_level, struct btrfs_root_backup,
2479                   dev_root_level, 8);
2480
2481BTRFS_SETGET_STACK_FUNCS(backup_csum_root, struct btrfs_root_backup,
2482                   csum_root, 64);
2483BTRFS_SETGET_STACK_FUNCS(backup_csum_root_gen, struct btrfs_root_backup,
2484                   csum_root_gen, 64);
2485BTRFS_SETGET_STACK_FUNCS(backup_csum_root_level, struct btrfs_root_backup,
2486                   csum_root_level, 8);
2487BTRFS_SETGET_STACK_FUNCS(backup_total_bytes, struct btrfs_root_backup,
2488                   total_bytes, 64);
2489BTRFS_SETGET_STACK_FUNCS(backup_bytes_used, struct btrfs_root_backup,
2490                   bytes_used, 64);
2491BTRFS_SETGET_STACK_FUNCS(backup_num_devices, struct btrfs_root_backup,
2492                   num_devices, 64);
2493
2494/* struct btrfs_balance_item */
2495BTRFS_SETGET_FUNCS(balance_flags, struct btrfs_balance_item, flags, 64);
2496
2497static inline void btrfs_balance_data(struct extent_buffer *eb,
2498                                      struct btrfs_balance_item *bi,
2499                                      struct btrfs_disk_balance_args *ba)
2500{
2501        read_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2502}
2503
2504static inline void btrfs_set_balance_data(struct extent_buffer *eb,
2505                                          struct btrfs_balance_item *bi,
2506                                          struct btrfs_disk_balance_args *ba)
2507{
2508        write_eb_member(eb, bi, struct btrfs_balance_item, data, ba);
2509}
2510
2511static inline void btrfs_balance_meta(struct extent_buffer *eb,
2512                                      struct btrfs_balance_item *bi,
2513                                      struct btrfs_disk_balance_args *ba)
2514{
2515        read_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2516}
2517
2518static inline void btrfs_set_balance_meta(struct extent_buffer *eb,
2519                                          struct btrfs_balance_item *bi,
2520                                          struct btrfs_disk_balance_args *ba)
2521{
2522        write_eb_member(eb, bi, struct btrfs_balance_item, meta, ba);
2523}
2524
2525static inline void btrfs_balance_sys(struct extent_buffer *eb,
2526                                     struct btrfs_balance_item *bi,
2527                                     struct btrfs_disk_balance_args *ba)
2528{
2529        read_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2530}
2531
2532static inline void btrfs_set_balance_sys(struct extent_buffer *eb,
2533                                         struct btrfs_balance_item *bi,
2534                                         struct btrfs_disk_balance_args *ba)
2535{
2536        write_eb_member(eb, bi, struct btrfs_balance_item, sys, ba);
2537}
2538
2539static inline void
2540btrfs_disk_balance_args_to_cpu(struct btrfs_balance_args *cpu,
2541                               struct btrfs_disk_balance_args *disk)
2542{
2543        memset(cpu, 0, sizeof(*cpu));
2544
2545        cpu->profiles = le64_to_cpu(disk->profiles);
2546        cpu->usage = le64_to_cpu(disk->usage);
2547        cpu->devid = le64_to_cpu(disk->devid);
2548        cpu->pstart = le64_to_cpu(disk->pstart);
2549        cpu->pend = le64_to_cpu(disk->pend);
2550        cpu->vstart = le64_to_cpu(disk->vstart);
2551        cpu->vend = le64_to_cpu(disk->vend);
2552        cpu->target = le64_to_cpu(disk->target);
2553        cpu->flags = le64_to_cpu(disk->flags);
2554}
2555
2556static inline void
2557btrfs_cpu_balance_args_to_disk(struct btrfs_disk_balance_args *disk,
2558                               struct btrfs_balance_args *cpu)
2559{
2560        memset(disk, 0, sizeof(*disk));
2561
2562        disk->profiles = cpu_to_le64(cpu->profiles);
2563        disk->usage = cpu_to_le64(cpu->usage);
2564        disk->devid = cpu_to_le64(cpu->devid);
2565        disk->pstart = cpu_to_le64(cpu->pstart);
2566        disk->pend = cpu_to_le64(cpu->pend);
2567        disk->vstart = cpu_to_le64(cpu->vstart);
2568        disk->vend = cpu_to_le64(cpu->vend);
2569        disk->target = cpu_to_le64(cpu->target);
2570        disk->flags = cpu_to_le64(cpu->flags);
2571}
2572
2573/* struct btrfs_super_block */
2574BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
2575BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
2576BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
2577                         generation, 64);
2578BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
2579BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
2580                         struct btrfs_super_block, sys_chunk_array_size, 32);
2581BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
2582                         struct btrfs_super_block, chunk_root_generation, 64);
2583BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
2584                         root_level, 8);
2585BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
2586                         chunk_root, 64);
2587BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
2588                         chunk_root_level, 8);
2589BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
2590                         log_root, 64);
2591BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
2592                         log_root_transid, 64);
2593BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
2594                         log_root_level, 8);
2595BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
2596                         total_bytes, 64);
2597BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
2598                         bytes_used, 64);
2599BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
2600                         sectorsize, 32);
2601BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
2602                         nodesize, 32);
2603BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
2604                         leafsize, 32);
2605BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
2606                         stripesize, 32);
2607BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
2608                         root_dir_objectid, 64);
2609BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
2610                         num_devices, 64);
2611BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
2612                         compat_flags, 64);
2613BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
2614                         compat_ro_flags, 64);
2615BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
2616                         incompat_flags, 64);
2617BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
2618                         csum_type, 16);
2619BTRFS_SETGET_STACK_FUNCS(super_cache_generation, struct btrfs_super_block,
2620                         cache_generation, 64);
2621
2622static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
2623{
2624        int t = btrfs_super_csum_type(s);
2625        BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes));
2626        return btrfs_csum_sizes[t];
2627}
2628
2629static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
2630{
2631        return offsetof(struct btrfs_leaf, items);
2632}
2633
2634/* struct btrfs_file_extent_item */
2635BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
2636
2637static inline unsigned long
2638btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
2639{
2640        unsigned long offset = (unsigned long)e;
2641        offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
2642        return offset;
2643}
2644
2645static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
2646{
2647        return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
2648}
2649
2650BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
2651                   disk_bytenr, 64);
2652BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
2653                   generation, 64);
2654BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
2655                   disk_num_bytes, 64);
2656BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
2657                  offset, 64);
2658BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
2659                   num_bytes, 64);
2660BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
2661                   ram_bytes, 64);
2662BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
2663                   compression, 8);
2664BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
2665                   encryption, 8);
2666BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
2667                   other_encoding, 16);
2668
2669/* this returns the number of file bytes represented by the inline item.
2670 * If an item is compressed, this is the uncompressed size
2671 */
2672static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
2673                                               struct btrfs_file_extent_item *e)
2674{
2675        return btrfs_file_extent_ram_bytes(eb, e);
2676}
2677
2678/*
2679 * this returns the number of bytes used by the item on disk, minus the
2680 * size of any extent headers.  If a file is compressed on disk, this is
2681 * the compressed size
2682 */
2683static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
2684                                                    struct btrfs_item *e)
2685{
2686        unsigned long offset;
2687        offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
2688        return btrfs_item_size(eb, e) - offset;
2689}
2690
2691/* btrfs_dev_stats_item */
2692static inline u64 btrfs_dev_stats_value(struct extent_buffer *eb,
2693                                        struct btrfs_dev_stats_item *ptr,
2694                                        int index)
2695{
2696        u64 val;
2697
2698        read_extent_buffer(eb, &val,
2699                           offsetof(struct btrfs_dev_stats_item, values) +
2700                            ((unsigned long)ptr) + (index * sizeof(u64)),
2701                           sizeof(val));
2702        return val;
2703}
2704
2705static inline void btrfs_set_dev_stats_value(struct extent_buffer *eb,
2706                                             struct btrfs_dev_stats_item *ptr,
2707                                             int index, u64 val)
2708{
2709        write_extent_buffer(eb, &val,
2710                            offsetof(struct btrfs_dev_stats_item, values) +
2711                             ((unsigned long)ptr) + (index * sizeof(u64)),
2712                            sizeof(val));
2713}
2714
2715/* btrfs_qgroup_status_item */
2716BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
2717                   generation, 64);
2718BTRFS_SETGET_FUNCS(qgroup_status_version, struct btrfs_qgroup_status_item,
2719                   version, 64);
2720BTRFS_SETGET_FUNCS(qgroup_status_flags, struct btrfs_qgroup_status_item,
2721                   flags, 64);
2722BTRFS_SETGET_FUNCS(qgroup_status_scan, struct btrfs_qgroup_status_item,
2723                   scan, 64);
2724
2725/* btrfs_qgroup_info_item */
2726BTRFS_SETGET_FUNCS(qgroup_info_generation, struct btrfs_qgroup_info_item,
2727                   generation, 64);
2728BTRFS_SETGET_FUNCS(qgroup_info_rfer, struct btrfs_qgroup_info_item, rfer, 64);
2729BTRFS_SETGET_FUNCS(qgroup_info_rfer_cmpr, struct btrfs_qgroup_info_item,
2730                   rfer_cmpr, 64);
2731BTRFS_SETGET_FUNCS(qgroup_info_excl, struct btrfs_qgroup_info_item, excl, 64);
2732BTRFS_SETGET_FUNCS(qgroup_info_excl_cmpr, struct btrfs_qgroup_info_item,
2733                   excl_cmpr, 64);
2734
2735BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_generation,
2736                         struct btrfs_qgroup_info_item, generation, 64);
2737BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer, struct btrfs_qgroup_info_item,
2738                         rfer, 64);
2739BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_rfer_cmpr,
2740                         struct btrfs_qgroup_info_item, rfer_cmpr, 64);
2741BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl, struct btrfs_qgroup_info_item,
2742                         excl, 64);
2743BTRFS_SETGET_STACK_FUNCS(stack_qgroup_info_excl_cmpr,
2744                         struct btrfs_qgroup_info_item, excl_cmpr, 64);
2745
2746/* btrfs_qgroup_limit_item */
2747BTRFS_SETGET_FUNCS(qgroup_limit_flags, struct btrfs_qgroup_limit_item,
2748                   flags, 64);
2749BTRFS_SETGET_FUNCS(qgroup_limit_max_rfer, struct btrfs_qgroup_limit_item,
2750                   max_rfer, 64);
2751BTRFS_SETGET_FUNCS(qgroup_limit_max_excl, struct btrfs_qgroup_limit_item,
2752                   max_excl, 64);
2753BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
2754                   rsv_rfer, 64);
2755BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
2756                   rsv_excl, 64);
2757
2758static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
2759{
2760        return sb->s_fs_info;
2761}
2762
2763static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
2764{
2765        if (level == 0)
2766                return root->leafsize;
2767        return root->nodesize;
2768}
2769
2770/* helper function to cast into the data area of the leaf. */
2771#define btrfs_item_ptr(leaf, slot, type) \
2772        ((type *)(btrfs_leaf_data(leaf) + \
2773        btrfs_item_offset_nr(leaf, slot)))
2774
2775#define btrfs_item_ptr_offset(leaf, slot) \
2776        ((unsigned long)(btrfs_leaf_data(leaf) + \
2777        btrfs_item_offset_nr(leaf, slot)))
2778
2779static inline struct dentry *fdentry(struct file *file)
2780{
2781        return file->f_path.dentry;
2782}
2783
2784static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
2785{
2786        return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
2787                (space_info->flags & BTRFS_BLOCK_GROUP_DATA));
2788}
2789
2790static inline gfp_t btrfs_alloc_write_mask(struct address_space *mapping)
2791{
2792        return mapping_gfp_mask(mapping) & ~__GFP_FS;
2793}
2794
2795/* extent-tree.c */
2796static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
2797                                                 unsigned num_items)
2798{
2799        return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
2800                3 * num_items;
2801}
2802
2803/*
2804 * Doing a truncate won't result in new nodes or leaves, just what we need for
2805 * COW.
2806 */
2807static inline u64 btrfs_calc_trunc_metadata_size(struct btrfs_root *root,
2808                                                 unsigned num_items)
2809{
2810        return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
2811                num_items;
2812}
2813
2814void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2815int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2816                           struct btrfs_root *root, unsigned long count);
2817int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
2818int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
2819                             struct btrfs_root *root, u64 bytenr,
2820                             u64 num_bytes, u64 *refs, u64 *flags);
2821int btrfs_pin_extent(struct btrfs_root *root,
2822                     u64 bytenr, u64 num, int reserved);
2823int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans,
2824                                    struct btrfs_root *root,
2825                                    u64 bytenr, u64 num_bytes);
2826int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2827                          struct btrfs_root *root,
2828                          u64 objectid, u64 offset, u64 bytenr);
2829struct btrfs_block_group_cache *btrfs_lookup_block_group(
2830                                                 struct btrfs_fs_info *info,
2831                                                 u64 bytenr);
2832void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
2833u64 btrfs_find_block_group(struct btrfs_root *root,
2834                           u64 search_start, u64 search_hint, int owner);
2835struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
2836                                        struct btrfs_root *root, u32 blocksize,
2837                                        u64 parent, u64 root_objectid,
2838                                        struct btrfs_disk_key *key, int level,
2839                                        u64 hint, u64 empty_size);
2840void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
2841                           struct btrfs_root *root,
2842                           struct extent_buffer *buf,
2843                           u64 parent, int last_ref);
2844struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
2845                                            struct btrfs_root *root,
2846                                            u64 bytenr, u32 blocksize,
2847                                            int level);
2848int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
2849                                     struct btrfs_root *root,
2850                                     u64 root_objectid, u64 owner,
2851                                     u64 offset, struct btrfs_key *ins);
2852int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2853                                   struct btrfs_root *root,
2854                                   u64 root_objectid, u64 owner, u64 offset,
2855                                   struct btrfs_key *ins);
2856int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
2857                                  struct btrfs_root *root,
2858                                  u64 num_bytes, u64 min_alloc_size,
2859                                  u64 empty_size, u64 hint_byte,
2860                                  struct btrfs_key *ins, u64 data);
2861int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2862                  struct extent_buffer *buf, int full_backref, int for_cow);
2863int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2864                  struct extent_buffer *buf, int full_backref, int for_cow);
2865int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2866                                struct btrfs_root *root,
2867                                u64 bytenr, u64 num_bytes, u64 flags,
2868                                int is_data);
2869int btrfs_free_extent(struct btrfs_trans_handle *trans,
2870                      struct btrfs_root *root,
2871                      u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
2872                      u64 owner, u64 offset, int for_cow);
2873
2874int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
2875int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root,
2876                                       u64 start, u64 len);
2877void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
2878                                 struct btrfs_root *root);
2879int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
2880                               struct btrfs_root *root);
2881int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2882                         struct btrfs_root *root,
2883                         u64 bytenr, u64 num_bytes, u64 parent,
2884                         u64 root_objectid, u64 owner, u64 offset, int for_cow);
2885
2886int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2887                                    struct btrfs_root *root);
2888int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
2889int btrfs_free_block_groups(struct btrfs_fs_info *info);
2890int btrfs_read_block_groups(struct btrfs_root *root);
2891int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
2892int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2893                           struct btrfs_root *root, u64 bytes_used,
2894                           u64 type, u64 chunk_objectid, u64 chunk_offset,
2895                           u64 size);
2896int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2897                             struct btrfs_root *root, u64 group_start);
2898void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
2899                                       struct btrfs_root *root);
2900u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
2901u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
2902void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2903int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
2904void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
2905void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
2906                                struct btrfs_root *root);
2907int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
2908                                  struct inode *inode);
2909void btrfs_orphan_release_metadata(struct inode *inode);
2910int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
2911                                struct btrfs_pending_snapshot *pending);
2912int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
2913void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
2914int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
2915void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
2916void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
2917struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
2918                                              unsigned short type);
2919void btrfs_free_block_rsv(struct btrfs_root *root,
2920                          struct btrfs_block_rsv *rsv);
2921int btrfs_block_rsv_add(struct btrfs_root *root,
2922                        struct btrfs_block_rsv *block_rsv,
2923                        u64 num_bytes);
2924int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
2925                                struct btrfs_block_rsv *block_rsv,
2926                                u64 num_bytes);
2927int btrfs_block_rsv_check(struct btrfs_root *root,
2928                          struct btrfs_block_rsv *block_rsv, int min_factor);
2929int btrfs_block_rsv_refill(struct btrfs_root *root,
2930                          struct btrfs_block_rsv *block_rsv,
2931                          u64 min_reserved);
2932int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
2933                                   struct btrfs_block_rsv *block_rsv,
2934                                   u64 min_reserved);
2935int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
2936                            struct btrfs_block_rsv *dst_rsv,
2937                            u64 num_bytes);
2938void btrfs_block_rsv_release(struct btrfs_root *root,
2939                             struct btrfs_block_rsv *block_rsv,
2940                             u64 num_bytes);
2941int btrfs_set_block_group_ro(struct btrfs_root *root,
2942                             struct btrfs_block_group_cache *cache);
2943void btrfs_set_block_group_rw(struct btrfs_root *root,
2944                              struct btrfs_block_group_cache *cache);
2945void btrfs_put_block_group_cache(struct btrfs_fs_info *info);
2946u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
2947int btrfs_error_unpin_extent_range(struct btrfs_root *root,
2948                                   u64 start, u64 end);
2949int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
2950                               u64 num_bytes, u64 *actual_bytes);
2951int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
2952                            struct btrfs_root *root, u64 type);
2953int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
2954
2955int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
2956int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
2957                                         struct btrfs_fs_info *fs_info);
2958/* ctree.c */
2959int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
2960                     int level, int *slot);
2961int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
2962int btrfs_previous_item(struct btrfs_root *root,
2963                        struct btrfs_path *path, u64 min_objectid,
2964                        int type);
2965void btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
2966                             struct btrfs_root *root, struct btrfs_path *path,
2967                             struct btrfs_key *new_key);
2968struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2969struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2970int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2971                        struct btrfs_key *key, int lowest_level,
2972                        int cache_only, u64 min_trans);
2973int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2974                         struct btrfs_key *max_key,
2975                         struct btrfs_path *path, int cache_only,
2976                         u64 min_trans);
2977enum btrfs_compare_tree_result {
2978        BTRFS_COMPARE_TREE_NEW,
2979        BTRFS_COMPARE_TREE_DELETED,
2980        BTRFS_COMPARE_TREE_CHANGED,
2981};
2982typedef int (*btrfs_changed_cb_t)(struct btrfs_root *left_root,
2983                                  struct btrfs_root *right_root,
2984                                  struct btrfs_path *left_path,
2985                                  struct btrfs_path *right_path,
2986                                  struct btrfs_key *key,
2987                                  enum btrfs_compare_tree_result result,
2988                                  void *ctx);
2989int btrfs_compare_trees(struct btrfs_root *left_root,
2990                        struct btrfs_root *right_root,
2991                        btrfs_changed_cb_t cb, void *ctx);
2992int btrfs_cow_block(struct btrfs_trans_handle *trans,
2993                    struct btrfs_root *root, struct extent_buffer *buf,
2994                    struct extent_buffer *parent, int parent_slot,
2995                    struct extent_buffer **cow_ret);
2996int btrfs_copy_root(struct btrfs_trans_handle *trans,
2997                      struct btrfs_root *root,
2998                      struct extent_buffer *buf,
2999                      struct extent_buffer **cow_ret, u64 new_root_objectid);
3000int btrfs_block_can_be_shared(struct btrfs_root *root,
3001                              struct extent_buffer *buf);
3002void btrfs_extend_item(struct btrfs_trans_handle *trans,
3003                       struct btrfs_root *root, struct btrfs_path *path,
3004                       u32 data_size);
3005void btrfs_truncate_item(struct btrfs_trans_handle *trans,
3006                         struct btrfs_root *root,
3007                         struct btrfs_path *path,
3008                         u32 new_size, int from_end);
3009int btrfs_split_item(struct btrfs_trans_handle *trans,
3010                     struct btrfs_root *root,
3011                     struct btrfs_path *path,
3012                     struct btrfs_key *new_key,
3013                     unsigned long split_offset);
3014int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
3015                         struct btrfs_root *root,
3016                         struct btrfs_path *path,
3017                         struct btrfs_key *new_key);
3018int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
3019                      *root, struct btrfs_key *key, struct btrfs_path *p, int
3020                      ins_len, int cow);
3021int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
3022                          struct btrfs_path *p, u64 time_seq);
3023int btrfs_search_slot_for_read(struct btrfs_root *root,
3024                               struct btrfs_key *key, struct btrfs_path *p,
3025                               int find_higher, int return_any);
3026int btrfs_realloc_node(struct btrfs_trans_handle *trans,
3027                       struct btrfs_root *root, struct extent_buffer *parent,
3028                       int start_slot, int cache_only, u64 *last_ret,
3029                       struct btrfs_key *progress);
3030void btrfs_release_path(struct btrfs_path *p);
3031struct btrfs_path *btrfs_alloc_path(void);
3032void btrfs_free_path(struct btrfs_path *p);
3033void btrfs_set_path_blocking(struct btrfs_path *p);
3034void btrfs_clear_path_blocking(struct btrfs_path *p,
3035                               struct extent_buffer *held, int held_rw);
3036void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
3037
3038int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3039                   struct btrfs_path *path, int slot, int nr);
3040static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
3041                                 struct btrfs_root *root,
3042                                 struct btrfs_path *path)
3043{
3044        return btrfs_del_items(trans, root, path, path->slots[0], 1);
3045}
3046
3047void setup_items_for_insert(struct btrfs_trans_handle *trans,
3048                            struct btrfs_root *root, struct btrfs_path *path,
3049                            struct btrfs_key *cpu_key, u32 *data_size,
3050                            u32 total_data, u32 total_size, int nr);
3051int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
3052                      *root, struct btrfs_key *key, void *data, u32 data_size);
3053int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
3054                             struct btrfs_root *root,
3055                             struct btrfs_path *path,
3056                             struct btrfs_key *cpu_key, u32 *data_size, int nr);
3057
3058static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
3059                                          struct btrfs_root *root,
3060                                          struct btrfs_path *path,
3061                                          struct btrfs_key *key,
3062                                          u32 data_size)
3063{
3064        return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
3065}
3066
3067int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
3068int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
3069                        u64 time_seq);
3070static inline int btrfs_next_old_item(struct btrfs_root *root,
3071                                      struct btrfs_path *p, u64 time_seq)
3072{
3073        ++p->slots[0];
3074        if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
3075                return btrfs_next_old_leaf(root, p, time_seq);
3076        return 0;
3077}
3078static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
3079{
3080        return btrfs_next_old_item(root, p, 0);
3081}
3082int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
3083int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
3084int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
3085                                     struct btrfs_block_rsv *block_rsv,
3086                                     int update_ref, int for_reloc);
3087int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
3088                        struct btrfs_root *root,
3089                        struct extent_buffer *node,
3090                        struct extent_buffer *parent);
3091static inline int btrfs_fs_closing(struct btrfs_fs_info *fs_info)
3092{
3093        /*
3094         * Get synced with close_ctree()
3095         */
3096        smp_mb();
3097        return fs_info->closing;
3098}
3099static inline void free_fs_info(struct btrfs_fs_info *fs_info)
3100{
3101        kfree(fs_info->balance_ctl);
3102        kfree(fs_info->delayed_root);
3103        kfree(fs_info->extent_root);
3104        kfree(fs_info->tree_root);
3105        kfree(fs_info->chunk_root);
3106        kfree(fs_info->dev_root);
3107        kfree(fs_info->csum_root);
3108        kfree(fs_info->quota_root);
3109        kfree(fs_info->super_copy);
3110        kfree(fs_info->super_for_commit);
3111        kfree(fs_info);
3112}
3113
3114/* tree mod log functions from ctree.c */
3115u64 btrfs_get_tree_mod_seq(struct btrfs_fs_info *fs_info,
3116                           struct seq_list *elem);
3117void btrfs_put_tree_mod_seq(struct btrfs_fs_info *fs_info,
3118                            struct seq_list *elem);
3119static inline u64 btrfs_inc_tree_mod_seq(struct btrfs_fs_info *fs_info)
3120{
3121        return atomic_inc_return(&fs_info->tree_mod_seq);
3122}
3123int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
3124
3125/* root-item.c */
3126int btrfs_find_root_ref(struct btrfs_root *tree_root,
3127                        struct btrfs_path *path,
3128                        u64 root_id, u64 ref_id);
3129int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
3130                       struct btrfs_root *tree_root,
3131                       u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
3132                       const char *name, int name_len);
3133int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
3134                       struct btrfs_root *tree_root,
3135                       u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
3136                       const char *name, int name_len);
3137int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3138                   struct btrfs_key *key);
3139int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
3140                      *root, struct btrfs_key *key, struct btrfs_root_item
3141                      *item);
3142int __must_check btrfs_update_root(struct btrfs_trans_handle *trans,
3143                                   struct btrfs_root *root,
3144                                   struct btrfs_key *key,
3145                                   struct btrfs_root_item *item);
3146void btrfs_read_root_item(struct btrfs_root *root,
3147                         struct extent_buffer *eb, int slot,
3148                         struct btrfs_root_item *item);
3149int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
3150                         btrfs_root_item *item, struct btrfs_key *key);
3151int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
3152int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
3153void btrfs_set_root_node(struct btrfs_root_item *item,
3154                         struct extent_buffer *node);
3155void btrfs_check_and_init_root_item(struct btrfs_root_item *item);
3156void btrfs_update_root_times(struct btrfs_trans_handle *trans,
3157                             struct btrfs_root *root);
3158
3159/* dir-item.c */
3160int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
3161                          struct btrfs_root *root, const char *name,
3162                          int name_len, struct inode *dir,
3163                          struct btrfs_key *location, u8 type, u64 index);
3164struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
3165                                             struct btrfs_root *root,
3166                                             struct btrfs_path *path, u64 dir,
3167                                             const char *name, int name_len,
3168                                             int mod);
3169struct btrfs_dir_item *
3170btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
3171                            struct btrfs_root *root,
3172                            struct btrfs_path *path, u64 dir,
3173                            u64 objectid, const char *name, int name_len,
3174                            int mod);
3175struct btrfs_dir_item *
3176btrfs_search_dir_index_item(struct btrfs_root *root,
3177                            struct btrfs_path *path, u64 dirid,
3178                            const char *name, int name_len);
3179struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
3180                              struct btrfs_path *path,
3181                              const char *name, int name_len);
3182int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
3183                              struct btrfs_root *root,
3184                              struct btrfs_path *path,
3185                              struct btrfs_dir_item *di);
3186int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
3187                            struct btrfs_root *root,
3188                            struct btrfs_path *path, u64 objectid,
3189                            const char *name, u16 name_len,
3190                            const void *data, u16 data_len);
3191struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
3192                                          struct btrfs_root *root,
3193                                          struct btrfs_path *path, u64 dir,
3194                                          const char *name, u16 name_len,
3195                                          int mod);
3196int verify_dir_item(struct btrfs_root *root,
3197                    struct extent_buffer *leaf,
3198                    struct btrfs_dir_item *dir_item);
3199
3200/* orphan.c */
3201int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
3202                             struct btrfs_root *root, u64 offset);
3203int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
3204                          struct btrfs_root *root, u64 offset);
3205int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
3206
3207/* inode-item.c */
3208int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
3209                           struct btrfs_root *root,
3210                           const char *name, int name_len,
3211                           u64 inode_objectid, u64 ref_objectid, u64 index);
3212int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
3213                           struct btrfs_root *root,
3214                           const char *name, int name_len,
3215                           u64 inode_objectid, u64 ref_objectid, u64 *index);
3216int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
3217                              struct btrfs_root *root,
3218                              struct btrfs_path *path,
3219                              const char *name, int name_len,
3220                              u64 inode_objectid, u64 ref_objectid, int mod,
3221                              u64 *ret_index);
3222int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
3223                             struct btrfs_root *root,
3224                             struct btrfs_path *path, u64 objectid);
3225int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
3226                       *root, struct btrfs_path *path,
3227                       struct btrfs_key *location, int mod);
3228
3229struct btrfs_inode_extref *
3230btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
3231                          struct btrfs_root *root,
3232                          struct btrfs_path *path,
3233                          const char *name, int name_len,
3234                          u64 inode_objectid, u64 ref_objectid, int ins_len,
3235                          int cow);
3236
3237int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
3238                                   u64 ref_objectid, const char *name,
3239                                   int name_len,
3240                                   struct btrfs_inode_extref **extref_ret);
3241
3242/* file-item.c */
3243int btrfs_del_csums(struct btrfs_trans_handle *trans,
3244                    struct btrfs_root *root, u64 bytenr, u64 len);
3245int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
3246                          struct bio *bio, u32 *dst);
3247int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,
3248                              struct bio *bio, u64 logical_offset);
3249int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
3250                             struct btrfs_root *root,
3251                             u64 objectid, u64 pos,
3252                             u64 disk_offset, u64 disk_num_bytes,
3253                             u64 num_bytes, u64 offset, u64 ram_bytes,
3254                             u8 compression, u8 encryption, u16 other_encoding);
3255int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
3256                             struct btrfs_root *root,
3257                             struct btrfs_path *path, u64 objectid,
3258                             u64 bytenr, int mod);
3259int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
3260                           struct btrfs_root *root,
3261                           struct btrfs_ordered_sum *sums);
3262int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
3263                       struct bio *bio, u64 file_start, int contig);
3264struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
3265                                          struct btrfs_root *root,
3266                                          struct btrfs_path *path,
3267                                          u64 bytenr, int cow);
3268int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
3269                        struct btrfs_root *root, struct btrfs_path *path,
3270                        u64 isize);
3271int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
3272                             struct list_head *list, int search_commit);
3273/* inode.c */
3274struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
3275                                           size_t pg_offset, u64 start, u64 len,
3276                                           int create);
3277
3278/* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
3279#if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
3280#define ClearPageChecked ClearPageFsMisc
3281#define SetPageChecked SetPageFsMisc
3282#define PageChecked PageFsMisc
3283#endif
3284
3285/* This forces readahead on a given range of bytes in an inode */
3286static inline void btrfs_force_ra(struct address_space *mapping,
3287                                  struct file_ra_state *ra, struct file *file,
3288                                  pgoff_t offset, unsigned long req_size)
3289{
3290        page_cache_sync_readahead(mapping, ra, file, offset, req_size);
3291}
3292
3293struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
3294int btrfs_set_inode_index(struct inode *dir, u64 *index);
3295int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3296                       struct btrfs_root *root,
3297                       struct inode *dir, struct inode *inode,
3298                       const char *name, int name_len);
3299int btrfs_add_link(struct btrfs_trans_handle *trans,
3300                   struct inode *parent_inode, struct inode *inode,
3301                   const char *name, int name_len, int add_backref, u64 index);
3302int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3303                        struct btrfs_root *root,
3304                        struct inode *dir, u64 objectid,
3305                        const char *name, int name_len);
3306int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
3307                        int front);
3308int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
3309                               struct btrfs_root *root,
3310                               struct inode *inode, u64 new_size,
3311                               u32 min_type);
3312
3313int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
3314int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
3315                              struct extent_state **cached_state);
3316int btrfs_writepages(struct address_space *mapping,
3317                     struct writeback_control *wbc);
3318int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
3319                             struct btrfs_root *new_root, u64 new_dirid);
3320int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
3321                         size_t size, struct bio *bio, unsigned long bio_flags);
3322
3323int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
3324int btrfs_readpage(struct file *file, struct page *page);
3325void btrfs_evict_inode(struct inode *inode);
3326int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
3327int btrfs_dirty_inode(struct inode *inode);
3328struct inode *btrfs_alloc_inode(struct super_block *sb);
3329void btrfs_destroy_inode(struct inode *inode);
3330int btrfs_drop_inode(struct inode *inode);
3331int btrfs_init_cachep(void);
3332void btrfs_destroy_cachep(void);
3333long btrfs_ioctl_trans_end(struct file *file);
3334struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
3335                         struct btrfs_root *root, int *was_new);
3336struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
3337                                    size_t pg_offset, u64 start, u64 end,
3338                                    int create);
3339int btrfs_update_inode(struct btrfs_trans_handle *trans,
3340                              struct btrfs_root *root,
3341                              struct inode *inode);
3342int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3343                                struct btrfs_root *root, struct inode *inode);
3344int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
3345int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
3346int btrfs_orphan_cleanup(struct btrfs_root *root);
3347void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
3348                              struct btrfs_root *root);
3349int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
3350void btrfs_invalidate_inodes(struct btrfs_root *root);
3351void btrfs_add_delayed_iput(struct inode *inode);
3352void btrfs_run_delayed_iputs(struct btrfs_root *root);
3353int btrfs_prealloc_file_range(struct inode *inode, int mode,
3354                              u64 start, u64 num_bytes, u64 min_size,
3355                              loff_t actual_len, u64 *alloc_hint);
3356int btrfs_prealloc_file_range_trans(struct inode *inode,
3357                                    struct btrfs_trans_handle *trans, int mode,
3358                                    u64 start, u64 num_bytes, u64 min_size,
3359                                    loff_t actual_len, u64 *alloc_hint);
3360extern const struct dentry_operations btrfs_dentry_operations;
3361
3362/* ioctl.c */
3363long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
3364void btrfs_update_iflags(struct inode *inode);
3365void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
3366int btrfs_defrag_file(struct inode *inode, struct file *file,
3367                      struct btrfs_ioctl_defrag_range_args *range,
3368                      u64 newer_than, unsigned long max_pages);
3369void btrfs_get_block_group_info(struct list_head *groups_list,
3370                                struct btrfs_ioctl_space_info *space);
3371
3372/* file.c */
3373int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
3374                           struct inode *inode);
3375int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
3376int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
3377void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
3378                             int skip_pinned);
3379int btrfs_replace_extent_cache(struct inode *inode, struct extent_map *replace,
3380                               u64 start, u64 end, int skip_pinned,
3381                               int modified);
3382extern const struct file_operations btrfs_file_operations;
3383int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
3384                         struct btrfs_root *root, struct inode *inode,
3385                         struct btrfs_path *path, u64 start, u64 end,
3386                         u64 *drop_end, int drop_cache);
3387int btrfs_drop_extents(struct btrfs_trans_handle *trans,
3388                       struct btrfs_root *root, struct inode *inode, u64 start,
3389                       u64 end, int drop_cache);
3390int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
3391                              struct inode *inode, u64 start, u64 end);
3392int btrfs_release_file(struct inode *inode, struct file *file);
3393void btrfs_drop_pages(struct page **pages, size_t num_pages);
3394int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
3395                      struct page **pages, size_t num_pages,
3396                      loff_t pos, size_t write_bytes,
3397                      struct extent_state **cached);
3398
3399/* tree-defrag.c */
3400int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
3401                        struct btrfs_root *root, int cache_only);
3402
3403/* sysfs.c */
3404int btrfs_init_sysfs(void);
3405void btrfs_exit_sysfs(void);
3406
3407/* xattr.c */
3408ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
3409
3410/* super.c */
3411int btrfs_parse_options(struct btrfs_root *root, char *options);
3412int btrfs_sync_fs(struct super_block *sb, int wait);
3413
3414#ifdef CONFIG_PRINTK
3415__printf(2, 3)
3416void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...);
3417#else
3418static inline __printf(2, 3)
3419void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...)
3420{
3421}
3422#endif
3423
3424__printf(5, 6)
3425void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
3426                     unsigned int line, int errno, const char *fmt, ...);
3427
3428
3429void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
3430                               struct btrfs_root *root, const char *function,
3431                               unsigned int line, int errno);
3432
3433#define btrfs_set_fs_incompat(__fs_info, opt) \
3434        __btrfs_set_fs_incompat((__fs_info), BTRFS_FEATURE_INCOMPAT_##opt)
3435
3436static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
3437                                           u64 flag)
3438{
3439        struct btrfs_super_block *disk_super;
3440        u64 features;
3441
3442        disk_super = fs_info->super_copy;
3443        features = btrfs_super_incompat_flags(disk_super);
3444        if (!(features & flag)) {
3445                features |= flag;
3446                btrfs_set_super_incompat_flags(disk_super, features);
3447        }
3448}
3449
3450/*
3451 * Call btrfs_abort_transaction as early as possible when an error condition is
3452 * detected, that way the exact line number is reported.
3453 */
3454
3455#define btrfs_abort_transaction(trans, root, errno)             \
3456do {                                                            \
3457        __btrfs_abort_transaction(trans, root, __func__,        \
3458                                  __LINE__, errno);             \
3459} while (0)
3460
3461#define btrfs_std_error(fs_info, errno)                         \
3462do {                                                            \
3463        if ((errno))                                            \
3464                __btrfs_std_error((fs_info), __func__,          \
3465                                   __LINE__, (errno), NULL);    \
3466} while (0)
3467
3468#define btrfs_error(fs_info, errno, fmt, args...)               \
3469do {                                                            \
3470        __btrfs_std_error((fs_info), __func__, __LINE__,        \
3471                          (errno), fmt, ##args);                \
3472} while (0)
3473
3474__printf(5, 6)
3475void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
3476                   unsigned int line, int errno, const char *fmt, ...);
3477
3478#define btrfs_panic(fs_info, errno, fmt, args...)                       \
3479do {                                                                    \
3480        struct btrfs_fs_info *_i = (fs_info);                           \
3481        __btrfs_panic(_i, __func__, __LINE__, errno, fmt, ##args);      \
3482        BUG_ON(!(_i->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR));    \
3483} while (0)
3484
3485/* acl.c */
3486#ifdef CONFIG_BTRFS_FS_POSIX_ACL
3487struct posix_acl *btrfs_get_acl(struct inode *inode, int type);
3488int btrfs_init_acl(struct btrfs_trans_handle *trans,
3489                   struct inode *inode, struct inode *dir);
3490int btrfs_acl_chmod(struct inode *inode);
3491#else
3492#define btrfs_get_acl NULL
3493static inline int btrfs_init_acl(struct btrfs_trans_handle *trans,
3494                                 struct inode *inode, struct inode *dir)
3495{
3496        return 0;
3497}
3498static inline int btrfs_acl_chmod(struct inode *inode)
3499{
3500        return 0;
3501}
3502#endif
3503
3504/* relocation.c */
3505int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
3506int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
3507                          struct btrfs_root *root);
3508int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
3509                            struct btrfs_root *root);
3510int btrfs_recover_relocation(struct btrfs_root *root);
3511int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
3512void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
3513                           struct btrfs_root *root, struct extent_buffer *buf,
3514                           struct extent_buffer *cow);
3515void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
3516                              struct btrfs_pending_snapshot *pending,
3517                              u64 *bytes_to_reserve);
3518int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
3519                              struct btrfs_pending_snapshot *pending);
3520
3521/* scrub.c */
3522int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
3523                    struct btrfs_scrub_progress *progress, int readonly);
3524void btrfs_scrub_pause(struct btrfs_root *root);
3525void btrfs_scrub_pause_super(struct btrfs_root *root);
3526void btrfs_scrub_continue(struct btrfs_root *root);
3527void btrfs_scrub_continue_super(struct btrfs_root *root);
3528int __btrfs_scrub_cancel(struct btrfs_fs_info *info);
3529int btrfs_scrub_cancel(struct btrfs_root *root);
3530int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev);
3531int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid);
3532int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
3533                         struct btrfs_scrub_progress *progress);
3534
3535/* reada.c */
3536struct reada_control {
3537        struct btrfs_root       *root;          /* tree to prefetch */
3538        struct btrfs_key        key_start;
3539        struct btrfs_key        key_end;        /* exclusive */
3540        atomic_t                elems;
3541        struct kref             refcnt;
3542        wait_queue_head_t       wait;
3543};
3544struct reada_control *btrfs_reada_add(struct btrfs_root *root,
3545                              struct btrfs_key *start, struct btrfs_key *end);
3546int btrfs_reada_wait(void *handle);
3547void btrfs_reada_detach(void *handle);
3548int btree_readahead_hook(struct btrfs_root *root, struct extent_buffer *eb,
3549                         u64 start, int err);
3550
3551/* qgroup.c */
3552struct qgroup_update {
3553        struct list_head list;
3554        struct btrfs_delayed_ref_node *node;
3555        struct btrfs_delayed_extent_op *extent_op;
3556};
3557
3558int btrfs_quota_enable(struct btrfs_trans_handle *trans,
3559                       struct btrfs_fs_info *fs_info);
3560int btrfs_quota_disable(struct btrfs_trans_handle *trans,
3561                        struct btrfs_fs_info *fs_info);
3562int btrfs_quota_rescan(struct btrfs_fs_info *fs_info);
3563int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans,
3564                              struct btrfs_fs_info *fs_info, u64 src, u64 dst);
3565int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans,
3566                              struct btrfs_fs_info *fs_info, u64 src, u64 dst);
3567int btrfs_create_qgroup(struct btrfs_trans_handle *trans,
3568                        struct btrfs_fs_info *fs_info, u64 qgroupid,
3569                        char *name);
3570int btrfs_remove_qgroup(struct btrfs_trans_handle *trans,
3571                              struct btrfs_fs_info *fs_info, u64 qgroupid);
3572int btrfs_limit_qgroup(struct btrfs_trans_handle *trans,
3573                       struct btrfs_fs_info *fs_info, u64 qgroupid,
3574                       struct btrfs_qgroup_limit *limit);
3575int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info);
3576void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info);
3577struct btrfs_delayed_extent_op;
3578int btrfs_qgroup_record_ref(struct btrfs_trans_handle *trans,
3579                            struct btrfs_delayed_ref_node *node,
3580                            struct btrfs_delayed_extent_op *extent_op);
3581int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
3582                             struct btrfs_fs_info *fs_info,
3583                             struct btrfs_delayed_ref_node *node,
3584                             struct btrfs_delayed_extent_op *extent_op);
3585int btrfs_run_qgroups(struct btrfs_trans_handle *trans,
3586                      struct btrfs_fs_info *fs_info);
3587int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans,
3588                         struct btrfs_fs_info *fs_info, u64 srcid, u64 objectid,
3589                         struct btrfs_qgroup_inherit *inherit);
3590int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes);
3591void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes);
3592
3593void assert_qgroups_uptodate(struct btrfs_trans_handle *trans);
3594
3595static inline int is_fstree(u64 rootid)
3596{
3597        if (rootid == BTRFS_FS_TREE_OBJECTID ||
3598            (s64)rootid >= (s64)BTRFS_FIRST_FREE_OBJECTID)
3599                return 1;
3600        return 0;
3601}
3602#endif
3603
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.