fs/btrfs/ctree.h

   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/version.h>
  23 #include <linux/mm.h>
  24 #include <linux/highmem.h>
  25 #include <linux/fs.h>
  26 #include <linux/completion.h>
  27 #include <linux/backing-dev.h>
  28 #include <linux/wait.h>
  29 #include <linux/slab.h>
  30 #include <asm/kmap_types.h>
  31 #include "extent_io.h"
  32 #include "extent_map.h"
  33 #include "async-thread.h"
  34
  35 struct btrfs_trans_handle;
  36 struct btrfs_transaction;
  37 extern struct kmem_cache *btrfs_trans_handle_cachep;
  38 extern struct kmem_cache *btrfs_transaction_cachep;
  39 extern struct kmem_cache *btrfs_bit_radix_cachep;
  40 extern struct kmem_cache *btrfs_path_cachep;
  41 struct btrfs_ordered_sum;
  42
  43 #define BTRFS_MAGIC "_BHRfS_M"
  44
  45 #define BTRFS_MAX_LEVEL 8
  46
  47 #define BTRFS_COMPAT_EXTENT_TREE_V0
  48
  49 /*
  50  * files bigger than this get some pre-flushing when they are added
  51  * to the ordered operations list.  That way we limit the total
  52  * work done by the commit
  53  */
  54 #define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
  55
  56 /* holds pointers to all of the tree roots */
  57 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
  58
  59 /* stores information about which extents are in use, and reference counts */
  60 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
  61
  62 /*
  63  * chunk tree stores translations from logical -> physical block numbering
  64  * the super block points to the chunk tree
  65  */
  66 #define BTRFS_CHUNK_TREE_OBJECTID 3ULL
  67
  68 /*
  69  * stores information about which areas of a given device are in use.
  70  * one per device.  The tree of tree roots points to the device tree
  71  */
  72 #define BTRFS_DEV_TREE_OBJECTID 4ULL
  73
  74 /* one per subvolume, storing files and directories */
  75 #define BTRFS_FS_TREE_OBJECTID 5ULL
  76
  77 /* directory objectid inside the root tree */
  78 #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
  79
  80 /* holds checksums of all the data extents */
  81 #define BTRFS_CSUM_TREE_OBJECTID 7ULL
  82
  83 /* orhpan objectid for tracking unlinked/truncated files */
  84 #define BTRFS_ORPHAN_OBJECTID -5ULL
  85
  86 /* does write ahead logging to speed up fsyncs */
  87 #define BTRFS_TREE_LOG_OBJECTID -6ULL
  88 #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
  89
  90 /* for space balancing */
  91 #define BTRFS_TREE_RELOC_OBJECTID -8ULL
  92 #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
  93
  94 /*
  95  * extent checksums all have this objectid
  96  * this allows them to share the logging tree
  97  * for fsyncs
  98  */
  99 #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
 100
 101 /* dummy objectid represents multiple objectids */
 102 #define BTRFS_MULTIPLE_OBJECTIDS -255ULL
 103
 104 /*
 105  * All files have objectids in this range.
 106  */
 107 #define BTRFS_FIRST_FREE_OBJECTID 256ULL
 108 #define BTRFS_LAST_FREE_OBJECTID -256ULL
 109 #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
 110
 111
 112 /*
 113  * the device items go into the chunk tree.  The key is in the form
 114  * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
 115  */
 116 #define BTRFS_DEV_ITEMS_OBJECTID 1ULL
 117
 118 #define BTRFS_BTREE_INODE_OBJECTID 1
 119
 120 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
 121
 122 /*
 123  * we can actually store much bigger names, but lets not confuse the rest
 124  * of linux
 125  */
 126 #define BTRFS_NAME_LEN 255
 127
 128 /* 32 bytes in various csum fields */
 129 #define BTRFS_CSUM_SIZE 32
 130
 131 /* csum types */
 132 #define BTRFS_CSUM_TYPE_CRC32   0
 133
 134 static int btrfs_csum_sizes[] = { 4, 0 };
 135
 136 /* four bytes for CRC32 */
 137 #define BTRFS_EMPTY_DIR_SIZE 0
 138
 139 #define BTRFS_FT_UNKNOWN        0
 140 #define BTRFS_FT_REG_FILE       1
 141 #define BTRFS_FT_DIR            2
 142 #define BTRFS_FT_CHRDEV         3
 143 #define BTRFS_FT_BLKDEV         4
 144 #define BTRFS_FT_FIFO           5
 145 #define BTRFS_FT_SOCK           6
 146 #define BTRFS_FT_SYMLINK        7
 147 #define BTRFS_FT_XATTR          8
 148 #define BTRFS_FT_MAX            9
 149
 150 /*
 151  * The key defines the order in the tree, and so it also defines (optimal)
 152  * block layout.
 153  *
 154  * objectid corresponds to the inode number.
 155  *
 156  * type tells us things about the object, and is a kind of stream selector.
 157  * so for a given inode, keys with type of 1 might refer to the inode data,
 158  * type of 2 may point to file data in the btree and type == 3 may point to
 159  * extents.
 160  *
 161  * offset is the starting byte offset for this key in the stream.
 162  *
 163  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
 164  * in cpu native order.  Otherwise they are identical and their sizes
 165  * should be the same (ie both packed)
 166  */
 167 struct btrfs_disk_key {
 168         __le64 objectid;
 169         u8 type;
 170         __le64 offset;
 171 } __attribute__ ((__packed__));
 172
 173 struct btrfs_key {
 174         u64 objectid;
 175         u8 type;
 176         u64 offset;
 177 } __attribute__ ((__packed__));
 178
 179 struct btrfs_mapping_tree {
 180         struct extent_map_tree map_tree;
 181 };
 182
 183 #define BTRFS_UUID_SIZE 16
 184 struct btrfs_dev_item {
 185         /* the internal btrfs device id */
 186         __le64 devid;
 187
 188         /* size of the device */
 189         __le64 total_bytes;
 190
 191         /* bytes used */
 192         __le64 bytes_used;
 193
 194         /* optimal io alignment for this device */
 195         __le32 io_align;
 196
 197         /* optimal io width for this device */
 198         __le32 io_width;
 199
 200         /* minimal io size for this device */
 201         __le32 sector_size;
 202
 203         /* type and info about this device */
 204         __le64 type;
 205
 206         /* expected generation for this device */
 207         __le64 generation;
 208
 209         /*
 210          * starting byte of this partition on the device,
 211          * to allow for stripe alignment in the future
 212          */
 213         __le64 start_offset;
 214
 215         /* grouping information for allocation decisions */
 216         __le32 dev_group;
 217
 218         /* seek speed 0-100 where 100 is fastest */
 219         u8 seek_speed;
 220
 221         /* bandwidth 0-100 where 100 is fastest */
 222         u8 bandwidth;
 223
 224         /* btrfs generated uuid for this device */
 225         u8 uuid[BTRFS_UUID_SIZE];
 226
 227         /* uuid of FS who owns this device */
 228         u8 fsid[BTRFS_UUID_SIZE];
 229 } __attribute__ ((__packed__));
 230
 231 struct btrfs_stripe {
 232         __le64 devid;
 233         __le64 offset;
 234         u8 dev_uuid[BTRFS_UUID_SIZE];
 235 } __attribute__ ((__packed__));
 236
 237 struct btrfs_chunk {
 238         /* size of this chunk in bytes */
 239         __le64 length;
 240
 241         /* objectid of the root referencing this chunk */
 242         __le64 owner;
 243
 244         __le64 stripe_len;
 245         __le64 type;
 246
 247         /* optimal io alignment for this chunk */
 248         __le32 io_align;
 249
 250         /* optimal io width for this chunk */
 251         __le32 io_width;
 252
 253         /* minimal io size for this chunk */
 254         __le32 sector_size;
 255
 256         /* 2^16 stripes is quite a lot, a second limit is the size of a single
 257          * item in the btree
 258          */
 259         __le16 num_stripes;
 260
 261         /* sub stripes only matter for raid10 */
 262         __le16 sub_stripes;
 263         struct btrfs_stripe stripe;
 264         /* additional stripes go here */
 265 } __attribute__ ((__packed__));
 266
 267 static inline unsigned long btrfs_chunk_item_size(int num_stripes)
 268 {
 269         BUG_ON(num_stripes == 0);
 270         return sizeof(struct btrfs_chunk) +
 271                 sizeof(struct btrfs_stripe) * (num_stripes - 1);
 272 }
 273
 274 #define BTRFS_FSID_SIZE 16
 275 #define BTRFS_HEADER_FLAG_WRITTEN       (1ULL << 0)
 276 #define BTRFS_HEADER_FLAG_RELOC         (1ULL << 1)
 277 #define BTRFS_SUPER_FLAG_SEEDING        (1ULL << 32)
 278 #define BTRFS_SUPER_FLAG_METADUMP       (1ULL << 33)
 279
 280 #define BTRFS_BACKREF_REV_MAX           256
 281 #define BTRFS_BACKREF_REV_SHIFT         56
 282 #define BTRFS_BACKREF_REV_MASK          (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
 283                                          BTRFS_BACKREF_REV_SHIFT)
 284
 285 #define BTRFS_OLD_BACKREF_REV           0
 286 #define BTRFS_MIXED_BACKREF_REV         1
 287
 288 /*
 289  * every tree block (leaf or node) starts with this header.
 290  */
 291 struct btrfs_header {
 292         /* these first four must match the super block */
 293         u8 csum[BTRFS_CSUM_SIZE];
 294         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 295         __le64 bytenr; /* which block this node is supposed to live in */
 296         __le64 flags;
 297
 298         /* allowed to be different from the super from here on down */
 299         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 300         __le64 generation;
 301         __le64 owner;
 302         __le32 nritems;
 303         u8 level;
 304 } __attribute__ ((__packed__));
 305
 306 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
 307                                       sizeof(struct btrfs_header)) / \
 308                                      sizeof(struct btrfs_key_ptr))
 309 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 310 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
 311 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 312                                         sizeof(struct btrfs_item) - \
 313                                         sizeof(struct btrfs_file_extent_item))
 314 #define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 315                                  sizeof(struct btrfs_item) -\
 316                                  sizeof(struct btrfs_dir_item))
 317
 318
 319 /*
 320  * this is a very generous portion of the super block, giving us
 321  * room to translate 14 chunks with 3 stripes each.
 322  */
 323 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
 324 #define BTRFS_LABEL_SIZE 256
 325
 326 /*
 327  * the super block basically lists the main trees of the FS
 328  * it currently lacks any block count etc etc
 329  */
 330 struct btrfs_super_block {
 331         u8 csum[BTRFS_CSUM_SIZE];
 332         /* the first 4 fields must match struct btrfs_header */
 333         u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
 334         __le64 bytenr; /* this block number */
 335         __le64 flags;
 336
 337         /* allowed to be different from the btrfs_header from here own down */
 338         __le64 magic;
 339         __le64 generation;
 340         __le64 root;
 341         __le64 chunk_root;
 342         __le64 log_root;
 343
 344         /* this will help find the new super based on the log root */
 345         __le64 log_root_transid;
 346         __le64 total_bytes;
 347         __le64 bytes_used;
 348         __le64 root_dir_objectid;
 349         __le64 num_devices;
 350         __le32 sectorsize;
 351         __le32 nodesize;
 352         __le32 leafsize;
 353         __le32 stripesize;
 354         __le32 sys_chunk_array_size;
 355         __le64 chunk_root_generation;
 356         __le64 compat_flags;
 357         __le64 compat_ro_flags;
 358         __le64 incompat_flags;
 359         __le16 csum_type;
 360         u8 root_level;
 361         u8 chunk_root_level;
 362         u8 log_root_level;
 363         struct btrfs_dev_item dev_item;
 364
 365         char label[BTRFS_LABEL_SIZE];
 366
 367         /* future expansion */
 368         __le64 reserved[32];
 369         u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
 370 } __attribute__ ((__packed__));
 371
 372 /*
 373  * Compat flags that we support.  If any incompat flags are set other than the
 374  * ones specified below then we will fail to mount
 375  */
 376 #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF    (1ULL << 0)
 377 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL   (2ULL << 0)
 378
 379 #define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 380 #define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
 381 #define BTRFS_FEATURE_INCOMPAT_SUPP             \
 382         (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
 383          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)
 384
 385 /*
 386  * A leaf is full of items. offset and size tell us where to find
 387  * the item in the leaf (relative to the start of the data area)
 388  */
 389 struct btrfs_item {
 390         struct btrfs_disk_key key;
 391         __le32 offset;
 392         __le32 size;
 393 } __attribute__ ((__packed__));
 394
 395 /*
 396  * leaves have an item area and a data area:
 397  * [item0, item1....itemN] [free space] [dataN...data1, data0]
 398  *
 399  * The data is separate from the items to get the keys closer together
 400  * during searches.
 401  */
 402 struct btrfs_leaf {
 403         struct btrfs_header header;
 404         struct btrfs_item items[];
 405 } __attribute__ ((__packed__));
 406
 407 /*
 408  * all non-leaf blocks are nodes, they hold only keys and pointers to
 409  * other blocks
 410  */
 411 struct btrfs_key_ptr {
 412         struct btrfs_disk_key key;
 413         __le64 blockptr;
 414         __le64 generation;
 415 } __attribute__ ((__packed__));
 416
 417 struct btrfs_node {
 418         struct btrfs_header header;
 419         struct btrfs_key_ptr ptrs[];
 420 } __attribute__ ((__packed__));
 421
 422 /*
 423  * btrfs_paths remember the path taken from the root down to the leaf.
 424  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 425  * to any other levels that are present.
 426  *
 427  * The slots array records the index of the item or block pointer
 428  * used while walking the tree.
 429  */
 430 struct btrfs_path {
 431         struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
 432         int slots[BTRFS_MAX_LEVEL];
 433         /* if there is real range locking, this locks field will change */
 434         int locks[BTRFS_MAX_LEVEL];
 435         int reada;
 436         /* keep some upper locks as we walk down */
 437         int lowest_level;
 438
 439         /*
 440          * set by btrfs_split_item, tells search_slot to keep all locks
 441          * and to force calls to keep space in the nodes
 442          */
 443         unsigned int search_for_split:1;
 444         unsigned int keep_locks:1;
 445         unsigned int skip_locking:1;
 446         unsigned int leave_spinning:1;
 447         unsigned int search_commit_root:1;
 448 };
 449
 450 /*
 451  * items in the extent btree are used to record the objectid of the
 452  * owner of the block and the number of references
 453  */
 454
 455 struct btrfs_extent_item {
 456         __le64 refs;
 457         __le64 generation;
 458         __le64 flags;
 459 } __attribute__ ((__packed__));
 460
 461 struct btrfs_extent_item_v0 {
 462         __le32 refs;
 463 } __attribute__ ((__packed__));
 464
 465 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
 466                                         sizeof(struct btrfs_item))
 467
 468 #define BTRFS_EXTENT_FLAG_DATA          (1ULL << 0)
 469 #define BTRFS_EXTENT_FLAG_TREE_BLOCK    (1ULL << 1)
 470
 471 /* following flags only apply to tree blocks */
 472
 473 /* use full backrefs for extent pointers in the block */
 474 #define BTRFS_BLOCK_FLAG_FULL_BACKREF   (1ULL << 8)
 475
 476 struct btrfs_tree_block_info {
 477         struct btrfs_disk_key key;
 478         u8 level;
 479 } __attribute__ ((__packed__));
 480
 481 struct btrfs_extent_data_ref {
 482         __le64 root;
 483         __le64 objectid;
 484         __le64 offset;
 485         __le32 count;
 486 } __attribute__ ((__packed__));
 487
 488 struct btrfs_shared_data_ref {
 489         __le32 count;
 490 } __attribute__ ((__packed__));
 491
 492 struct btrfs_extent_inline_ref {
 493         u8 type;
 494         __le64 offset;
 495 } __attribute__ ((__packed__));
 496
 497 /* old style backrefs item */
 498 struct btrfs_extent_ref_v0 {
 499         __le64 root;
 500         __le64 generation;
 501         __le64 objectid;
 502         __le32 count;
 503 } __attribute__ ((__packed__));
 504
 505
 506 /* dev extents record free space on individual devices.  The owner
 507  * field points back to the chunk allocation mapping tree that allocated
 508  * the extent.  The chunk tree uuid field is a way to double check the owner
 509  */
 510 struct btrfs_dev_extent {
 511         __le64 chunk_tree;
 512         __le64 chunk_objectid;
 513         __le64 chunk_offset;
 514         __le64 length;
 515         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 516 } __attribute__ ((__packed__));
 517
 518 struct btrfs_inode_ref {
 519         __le64 index;
 520         __le16 name_len;
 521         /* name goes here */
 522 } __attribute__ ((__packed__));
 523
 524 struct btrfs_timespec {
 525         __le64 sec;
 526         __le32 nsec;
 527 } __attribute__ ((__packed__));
 528
 529 enum btrfs_compression_type {
 530         BTRFS_COMPRESS_NONE = 0,
 531         BTRFS_COMPRESS_ZLIB = 1,
 532         BTRFS_COMPRESS_LAST = 2,
 533 };
 534
 535 struct btrfs_inode_item {
 536         /* nfs style generation number */
 537         __le64 generation;
 538         /* transid that last touched this inode */
 539         __le64 transid;
 540         __le64 size;
 541         __le64 nbytes;
 542         __le64 block_group;
 543         __le32 nlink;
 544         __le32 uid;
 545         __le32 gid;
 546         __le32 mode;
 547         __le64 rdev;
 548         __le64 flags;
 549
 550         /* modification sequence number for NFS */
 551         __le64 sequence;
 552
 553         /*
 554          * a little future expansion, for more than this we can
 555          * just grow the inode item and version it
 556          */
 557         __le64 reserved[4];
 558         struct btrfs_timespec atime;
 559         struct btrfs_timespec ctime;
 560         struct btrfs_timespec mtime;
 561         struct btrfs_timespec otime;
 562 } __attribute__ ((__packed__));
 563
 564 struct btrfs_dir_log_item {
 565         __le64 end;
 566 } __attribute__ ((__packed__));
 567
 568 struct btrfs_dir_item {
 569         struct btrfs_disk_key location;
 570         __le64 transid;
 571         __le16 data_len;
 572         __le16 name_len;
 573         u8 type;
 574 } __attribute__ ((__packed__));
 575
 576 struct btrfs_root_item {
 577         struct btrfs_inode_item inode;
 578         __le64 generation;
 579         __le64 root_dirid;
 580         __le64 bytenr;
 581         __le64 byte_limit;
 582         __le64 bytes_used;
 583         __le64 last_snapshot;
 584         __le64 flags;
 585         __le32 refs;
 586         struct btrfs_disk_key drop_progress;
 587         u8 drop_level;
 588         u8 level;
 589 } __attribute__ ((__packed__));
 590
 591 /*
 592  * this is used for both forward and backward root refs
 593  */
 594 struct btrfs_root_ref {
 595         __le64 dirid;
 596         __le64 sequence;
 597         __le16 name_len;
 598 } __attribute__ ((__packed__));
 599
 600 #define BTRFS_FILE_EXTENT_INLINE 0
 601 #define BTRFS_FILE_EXTENT_REG 1
 602 #define BTRFS_FILE_EXTENT_PREALLOC 2
 603
 604 struct btrfs_file_extent_item {
 605         /*
 606          * transaction id that created this extent
 607          */
 608         __le64 generation;
 609         /*
 610          * max number of bytes to hold this extent in ram
 611          * when we split a compressed extent we can't know how big
 612          * each of the resulting pieces will be.  So, this is
 613          * an upper limit on the size of the extent in ram instead of
 614          * an exact limit.
 615          */
 616         __le64 ram_bytes;
 617
 618         /*
 619          * 32 bits for the various ways we might encode the data,
 620          * including compression and encryption.  If any of these
 621          * are set to something a given disk format doesn't understand
 622          * it is treated like an incompat flag for reading and writing,
 623          * but not for stat.
 624          */
 625         u8 compression;
 626         u8 encryption;
 627         __le16 other_encoding; /* spare for later use */
 628
 629         /* are we inline data or a real extent? */
 630         u8 type;
 631
 632         /*
 633          * disk space consumed by the extent, checksum blocks are included
 634          * in these numbers
 635          */
 636         __le64 disk_bytenr;
 637         __le64 disk_num_bytes;
 638         /*
 639          * the logical offset in file blocks (no csums)
 640          * this extent record is for.  This allows a file extent to point
 641          * into the middle of an existing extent on disk, sharing it
 642          * between two snapshots (useful if some bytes in the middle of the
 643          * extent have changed
 644          */
 645         __le64 offset;
 646         /*
 647          * the logical number of file blocks (no csums included).  This
 648          * always reflects the size uncompressed and without encoding.
 649          */
 650         __le64 num_bytes;
 651
 652 } __attribute__ ((__packed__));
 653
 654 struct btrfs_csum_item {
 655         u8 csum;
 656 } __attribute__ ((__packed__));
 657
 658 /* different types of block groups (and chunks) */
 659 #define BTRFS_BLOCK_GROUP_DATA     (1 << 0)
 660 #define BTRFS_BLOCK_GROUP_SYSTEM   (1 << 1)
 661 #define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
 662 #define BTRFS_BLOCK_GROUP_RAID0    (1 << 3)
 663 #define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)
 664 #define BTRFS_BLOCK_GROUP_DUP      (1 << 5)
 665 #define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)
 666
 667 struct btrfs_block_group_item {
 668         __le64 used;
 669         __le64 chunk_objectid;
 670         __le64 flags;
 671 } __attribute__ ((__packed__));
 672
 673 struct btrfs_space_info {
 674         u64 flags;
 675
 676         u64 total_bytes;        /* total bytes in the space */
 677         u64 bytes_used;         /* total bytes used on disk */
 678         u64 bytes_pinned;       /* total bytes pinned, will be freed when the
 679                                    transaction finishes */
 680         u64 bytes_reserved;     /* total bytes the allocator has reserved for
 681                                    current allocations */
 682         u64 bytes_readonly;     /* total bytes that are read only */
 683         u64 bytes_super;        /* total bytes reserved for the super blocks */
 684         u64 bytes_root;         /* the number of bytes needed to commit a
 685                                    transaction */
 686         u64 bytes_may_use;      /* number of bytes that may be used for
 687                                    delalloc/allocations */
 688         u64 bytes_delalloc;     /* number of bytes currently reserved for
 689                                    delayed allocation */
 690
 691         int full;               /* indicates that we cannot allocate any more
 692                                    chunks for this space */
 693         int force_alloc;        /* set if we need to force a chunk alloc for
 694                                    this space */
 695         int force_delalloc;     /* make people start doing filemap_flush until
 696                                    we're under a threshold */
 697
 698         struct list_head list;
 699
 700         /* for controlling how we free up space for allocations */
 701         wait_queue_head_t allocate_wait;
 702         wait_queue_head_t flush_wait;
 703         int allocating_chunk;
 704         int flushing;
 705
 706         /* for block groups in our same type */
 707         struct list_head block_groups;
 708         spinlock_t lock;
 709         struct rw_semaphore groups_sem;
 710         atomic_t caching_threads;
 711 };
 712
 713 /*
 714  * free clusters are used to claim free space in relatively large chunks,
 715  * allowing us to do less seeky writes.  They are used for all metadata
 716  * allocations and data allocations in ssd mode.
 717  */
 718 struct btrfs_free_cluster {
 719         spinlock_t lock;
 720         spinlock_t refill_lock;
 721         struct rb_root root;
 722
 723         /* largest extent in this cluster */
 724         u64 max_size;
 725
 726         /* first extent starting offset */
 727         u64 window_start;
 728
 729         /* if this cluster simply points at a bitmap in the block group */
 730         bool points_to_bitmap;
 731
 732         struct btrfs_block_group_cache *block_group;
 733         /*
 734          * when a cluster is allocated from a block group, we put the
 735          * cluster onto a list in the block group so that it can
 736          * be freed before the block group is freed.
 737          */
 738         struct list_head block_group_list;
 739 };
 740
 741 enum btrfs_caching_type {
 742         BTRFS_CACHE_NO          = 0,
 743         BTRFS_CACHE_STARTED     = 1,
 744         BTRFS_CACHE_FINISHED    = 2,
 745 };
 746
 747 struct btrfs_caching_control {
 748         struct list_head list;
 749         struct mutex mutex;
 750         wait_queue_head_t wait;
 751         struct btrfs_block_group_cache *block_group;
 752         u64 progress;
 753         atomic_t count;
 754 };
 755
 756 struct btrfs_block_group_cache {
 757         struct btrfs_key key;
 758         struct btrfs_block_group_item item;
 759         struct btrfs_fs_info *fs_info;
 760         spinlock_t lock;
 761         u64 pinned;
 762         u64 reserved;
 763         u64 bytes_super;
 764         u64 flags;
 765         u64 sectorsize;
 766         int extents_thresh;
 767         int free_extents;
 768         int total_bitmaps;
 769         int ro;
 770         int dirty;
 771
 772         /* cache tracking stuff */
 773         int cached;
 774         struct btrfs_caching_control *caching_ctl;
 775         u64 last_byte_to_unpin;
 776
 777         struct btrfs_space_info *space_info;
 778
 779         /* free space cache stuff */
 780         spinlock_t tree_lock;
 781         struct rb_root free_space_offset;
 782         u64 free_space;
 783
 784         /* block group cache stuff */
 785         struct rb_node cache_node;
 786
 787         /* for block groups in the same raid type */
 788         struct list_head list;
 789
 790         /* usage count */
 791         atomic_t count;
 792
 793         /* List of struct btrfs_free_clusters for this block group.
 794          * Today it will only have one thing on it, but that may change
 795          */
 796         struct list_head cluster_list;
 797 };
 798
 799 struct reloc_control;
 800 struct btrfs_device;
 801 struct btrfs_fs_devices;
 802 struct btrfs_fs_info {
 803         u8 fsid[BTRFS_FSID_SIZE];
 804         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
 805         struct btrfs_root *extent_root;
 806         struct btrfs_root *tree_root;
 807         struct btrfs_root *chunk_root;
 808         struct btrfs_root *dev_root;
 809         struct btrfs_root *fs_root;
 810         struct btrfs_root *csum_root;
 811
 812         /* the log root tree is a directory of all the other log roots */
 813         struct btrfs_root *log_root_tree;
 814
 815         spinlock_t fs_roots_radix_lock;
 816         struct radix_tree_root fs_roots_radix;
 817
 818         /* block group cache stuff */
 819         spinlock_t block_group_cache_lock;
 820         struct rb_root block_group_cache_tree;
 821
 822         struct extent_io_tree freed_extents[2];
 823         struct extent_io_tree *pinned_extents;
 824
 825         /* logical->physical extent mapping */
 826         struct btrfs_mapping_tree mapping_tree;
 827
 828         u64 generation;
 829         u64 last_trans_committed;
 830
 831         /*
 832          * this is updated to the current trans every time a full commit
 833          * is required instead of the faster short fsync log commits
 834          */
 835         u64 last_trans_log_full_commit;
 836         u64 open_ioctl_trans;
 837         unsigned long mount_opt;
 838         u64 max_inline;
 839         u64 alloc_start;
 840         struct btrfs_transaction *running_transaction;
 841         wait_queue_head_t transaction_throttle;
 842         wait_queue_head_t transaction_wait;
 843         wait_queue_head_t async_submit_wait;
 844
 845         struct btrfs_super_block super_copy;
 846         struct btrfs_super_block super_for_commit;
 847         struct block_device *__bdev;
 848         struct super_block *sb;
 849         struct inode *btree_inode;
 850         struct backing_dev_info bdi;
 851         struct mutex trans_mutex;
 852         struct mutex tree_log_mutex;
 853         struct mutex transaction_kthread_mutex;
 854         struct mutex cleaner_mutex;
 855         struct mutex chunk_mutex;
 856         struct mutex volume_mutex;
 857         /*
 858          * this protects the ordered operations list only while we are
 859          * processing all of the entries on it.  This way we make
 860          * sure the commit code doesn't find the list temporarily empty
 861          * because another function happens to be doing non-waiting preflush
 862          * before jumping into the main commit.
 863          */
 864         struct mutex ordered_operations_mutex;
 865         struct rw_semaphore extent_commit_sem;
 866
 867         struct rw_semaphore cleanup_work_sem;
 868
 869         struct rw_semaphore subvol_sem;
 870         struct srcu_struct subvol_srcu;
 871
 872         struct list_head trans_list;
 873         struct list_head hashers;
 874         struct list_head dead_roots;
 875         struct list_head caching_block_groups;
 876
 877         spinlock_t delayed_iput_lock;
 878         struct list_head delayed_iputs;
 879
 880         atomic_t nr_async_submits;
 881         atomic_t async_submit_draining;
 882         atomic_t nr_async_bios;
 883         atomic_t async_delalloc_pages;
 884
 885         /*
 886          * this is used by the balancing code to wait for all the pending
 887          * ordered extents
 888          */
 889         spinlock_t ordered_extent_lock;
 890
 891         /*
 892          * all of the data=ordered extents pending writeback
 893          * these can span multiple transactions and basically include
 894          * every dirty data page that isn't from nodatacow
 895          */
 896         struct list_head ordered_extents;
 897
 898         /*
 899          * all of the inodes that have delalloc bytes.  It is possible for
 900          * this list to be empty even when there is still dirty data=ordered
 901          * extents waiting to finish IO.
 902          */
 903         struct list_head delalloc_inodes;
 904
 905         /*
 906          * special rename and truncate targets that must be on disk before
 907          * we're allowed to commit.  This is basically the ext3 style
 908          * data=ordered list.
 909          */
 910         struct list_head ordered_operations;
 911
 912         /*
 913          * there is a pool of worker threads for checksumming during writes
 914          * and a pool for checksumming after reads.  This is because readers
 915          * can run with FS locks held, and the writers may be waiting for
 916          * those locks.  We don't want ordering in the pending list to cause
 917          * deadlocks, and so the two are serviced separately.
 918          *
 919          * A third pool does submit_bio to avoid deadlocking with the other
 920          * two
 921          */
 922         struct btrfs_workers generic_worker;
 923         struct btrfs_workers workers;
 924         struct btrfs_workers delalloc_workers;
 925         struct btrfs_workers endio_workers;
 926         struct btrfs_workers endio_meta_workers;
 927         struct btrfs_workers endio_meta_write_workers;
 928         struct btrfs_workers endio_write_workers;
 929         struct btrfs_workers submit_workers;
 930         struct btrfs_workers enospc_workers;
 931         /*
 932          * fixup workers take dirty pages that didn't properly go through
 933          * the cow mechanism and make them safe to write.  It happens
 934          * for the sys_munmap function call path
 935          */
 936         struct btrfs_workers fixup_workers;
 937         struct task_struct *transaction_kthread;
 938         struct task_struct *cleaner_kthread;
 939         int thread_pool_size;
 940
 941         struct kobject super_kobj;
 942         struct completion kobj_unregister;
 943         int do_barriers;
 944         int closing;
 945         int log_root_recovering;
 946
 947         u64 total_pinned;
 948
 949         /* protected by the delalloc lock, used to keep from writing
 950          * metadata until there is a nice batch
 951          */
 952         u64 dirty_metadata_bytes;
 953         struct list_head dirty_cowonly_roots;
 954
 955         struct btrfs_fs_devices *fs_devices;
 956
 957         /*
 958          * the space_info list is almost entirely read only.  It only changes
 959          * when we add a new raid type to the FS, and that happens
 960          * very rarely.  RCU is used to protect it.
 961          */
 962         struct list_head space_info;
 963
 964         struct reloc_control *reloc_ctl;
 965
 966         spinlock_t delalloc_lock;
 967         spinlock_t new_trans_lock;
 968         u64 delalloc_bytes;
 969
 970         /* data_alloc_cluster is only used in ssd mode */
 971         struct btrfs_free_cluster data_alloc_cluster;
 972
 973         /* all metadata allocations go through this cluster */
 974         struct btrfs_free_cluster meta_alloc_cluster;
 975
 976         spinlock_t ref_cache_lock;
 977         u64 total_ref_cache_size;
 978
 979         u64 avail_data_alloc_bits;
 980         u64 avail_metadata_alloc_bits;
 981         u64 avail_system_alloc_bits;
 982         u64 data_alloc_profile;
 983         u64 metadata_alloc_profile;
 984         u64 system_alloc_profile;
 985
 986         unsigned data_chunk_allocations;
 987         unsigned metadata_ratio;
 988
 989         void *bdev_holder;
 990 };
 991
 992 /*
 993  * in ram representation of the tree.  extent_root is used for all allocations
 994  * and for the extent tree extent_root root.
 995  */
 996 struct btrfs_root {
 997         struct extent_buffer *node;
 998
 999         /* the node lock is held while changing the node pointer */
1000         spinlock_t node_lock;
1001
1002         struct extent_buffer *commit_root;
1003         struct btrfs_root *log_root;
1004         struct btrfs_root *reloc_root;
1005
1006         struct btrfs_root_item root_item;
1007         struct btrfs_key root_key;
1008         struct btrfs_fs_info *fs_info;
1009         struct extent_io_tree dirty_log_pages;
1010
1011         struct kobject root_kobj;
1012         struct completion kobj_unregister;
1013         struct mutex objectid_mutex;
1014
1015         struct mutex log_mutex;
1016         wait_queue_head_t log_writer_wait;
1017         wait_queue_head_t log_commit_wait[2];
1018         atomic_t log_writers;
1019         atomic_t log_commit[2];
1020         unsigned long log_transid;
1021         unsigned long last_log_commit;
1022         unsigned long log_batch;
1023         pid_t log_start_pid;
1024         bool log_multiple_pids;
1025
1026         u64 objectid;
1027         u64 last_trans;
1028
1029         /* data allocations are done in sectorsize units */
1030         u32 sectorsize;
1031
1032         /* node allocations are done in nodesize units */
1033         u32 nodesize;
1034
1035         /* leaf allocations are done in leafsize units */
1036         u32 leafsize;
1037
1038         u32 stripesize;
1039
1040         u32 type;
1041
1042         u64 highest_objectid;
1043         int ref_cows;
1044         int track_dirty;
1045         int in_radix;
1046         int clean_orphans;
1047
1048         u64 defrag_trans_start;
1049         struct btrfs_key defrag_progress;
1050         struct btrfs_key defrag_max;
1051         int defrag_running;
1052         char *name;
1053         int in_sysfs;
1054
1055         /* the dirty list is only used by non-reference counted roots */
1056         struct list_head dirty_list;
1057
1058         struct list_head root_list;
1059
1060         spinlock_t list_lock;
1061         struct list_head orphan_list;
1062
1063         spinlock_t inode_lock;
1064         /* red-black tree that keeps track of in-memory inodes */
1065         struct rb_root inode_tree;
1066
1067         /*
1068          * right now this just gets used so that a root has its own devid
1069          * for stat.  It may be used for more later
1070          */
1071         struct super_block anon_super;
1072 };
1073
1074 /*
1075  * inode items have the data typically returned from stat and store other
1076  * info about object characteristics.  There is one for every file and dir in
1077  * the FS
1078  */
1079 #define BTRFS_INODE_ITEM_KEY            1
1080 #define BTRFS_INODE_REF_KEY             12
1081 #define BTRFS_XATTR_ITEM_KEY            24
1082 #define BTRFS_ORPHAN_ITEM_KEY           48
1083 /* reserve 2-15 close to the inode for later flexibility */
1084
1085 /*
1086  * dir items are the name -> inode pointers in a directory.  There is one
1087  * for every name in a directory.
1088  */
1089 #define BTRFS_DIR_LOG_ITEM_KEY  60
1090 #define BTRFS_DIR_LOG_INDEX_KEY 72
1091 #define BTRFS_DIR_ITEM_KEY      84
1092 #define BTRFS_DIR_INDEX_KEY     96
1093 /*
1094  * extent data is for file data
1095  */
1096 #define BTRFS_EXTENT_DATA_KEY   108
1097
1098 /*
1099  * extent csums are stored in a separate tree and hold csums for
1100  * an entire extent on disk.
1101  */
1102 #define BTRFS_EXTENT_CSUM_KEY   128
1103
1104 /*
1105  * root items point to tree roots.  They are typically in the root
1106  * tree used by the super block to find all the other trees
1107  */
1108 #define BTRFS_ROOT_ITEM_KEY     132
1109
1110 /*
1111  * root backrefs tie subvols and snapshots to the directory entries that
1112  * reference them
1113  */
1114 #define BTRFS_ROOT_BACKREF_KEY  144
1115
1116 /*
1117  * root refs make a fast index for listing all of the snapshots and
1118  * subvolumes referenced by a given root.  They point directly to the
1119  * directory item in the root that references the subvol
1120  */
1121 #define BTRFS_ROOT_REF_KEY      156
1122
1123 /*
1124  * extent items are in the extent map tree.  These record which blocks
1125  * are used, and how many references there are to each block
1126  */
1127 #define BTRFS_EXTENT_ITEM_KEY   168
1128
1129 #define BTRFS_TREE_BLOCK_REF_KEY        176
1130
1131 #define BTRFS_EXTENT_DATA_REF_KEY       178
1132
1133 #define BTRFS_EXTENT_REF_V0_KEY         180
1134
1135 #define BTRFS_SHARED_BLOCK_REF_KEY      182
1136
1137 #define BTRFS_SHARED_DATA_REF_KEY       184
1138
1139 /*
1140  * block groups give us hints into the extent allocation trees.  Which
1141  * blocks are free etc etc
1142  */
1143 #define BTRFS_BLOCK_GROUP_ITEM_KEY 192
1144
1145 #define BTRFS_DEV_EXTENT_KEY    204
1146 #define BTRFS_DEV_ITEM_KEY      216
1147 #define BTRFS_CHUNK_ITEM_KEY    228
1148
1149 /*
1150  * string items are for debugging.  They just store a short string of
1151  * data in the FS
1152  */
1153 #define BTRFS_STRING_ITEM_KEY   253
1154
1155 #define BTRFS_MOUNT_NODATASUM           (1 << 0)
1156 #define BTRFS_MOUNT_NODATACOW           (1 << 1)
1157 #define BTRFS_MOUNT_NOBARRIER           (1 << 2)
1158 #define BTRFS_MOUNT_SSD                 (1 << 3)
1159 #define BTRFS_MOUNT_DEGRADED            (1 << 4)
1160 #define BTRFS_MOUNT_COMPRESS            (1 << 5)
1161 #define BTRFS_MOUNT_NOTREELOG           (1 << 6)
1162 #define BTRFS_MOUNT_FLUSHONCOMMIT       (1 << 7)
1163 #define BTRFS_MOUNT_SSD_SPREAD          (1 << 8)
1164 #define BTRFS_MOUNT_NOSSD               (1 << 9)
1165 #define BTRFS_MOUNT_DISCARD             (1 << 10)
1166 #define BTRFS_MOUNT_FORCE_COMPRESS      (1 << 11)
1167
1168 #define btrfs_clear_opt(o, opt)         ((o) &= ~BTRFS_MOUNT_##opt)
1169 #define btrfs_set_opt(o, opt)           ((o) |= BTRFS_MOUNT_##opt)
1170 #define btrfs_test_opt(root, opt)       ((root)->fs_info->mount_opt & \
1171                                          BTRFS_MOUNT_##opt)
1172 /*
1173  * Inode flags
1174  */
1175 #define BTRFS_INODE_NODATASUM           (1 << 0)
1176 #define BTRFS_INODE_NODATACOW           (1 << 1)
1177 #define BTRFS_INODE_READONLY            (1 << 2)
1178 #define BTRFS_INODE_NOCOMPRESS          (1 << 3)
1179 #define BTRFS_INODE_PREALLOC            (1 << 4)
1180 #define BTRFS_INODE_SYNC                (1 << 5)
1181 #define BTRFS_INODE_IMMUTABLE           (1 << 6)
1182 #define BTRFS_INODE_APPEND              (1 << 7)
1183 #define BTRFS_INODE_NODUMP              (1 << 8)
1184 #define BTRFS_INODE_NOATIME             (1 << 9)
1185 #define BTRFS_INODE_DIRSYNC             (1 << 10)
1186
1187 /* some macros to generate set/get funcs for the struct fields.  This
1188  * assumes there is a lefoo_to_cpu for every type, so lets make a simple
1189  * one for u8:
1190  */
1191 #define le8_to_cpu(v) (v)
1192 #define cpu_to_le8(v) (v)
1193 #define __le8 u8
1194
1195 #define read_eb_member(eb, ptr, type, member, result) (                 \
1196         read_extent_buffer(eb, (char *)(result),                        \
1197                            ((unsigned long)(ptr)) +                     \
1198                             offsetof(type, member),                     \
1199                            sizeof(((type *)0)->member)))
1200
1201 #define write_eb_member(eb, ptr, type, member, result) (                \
1202         write_extent_buffer(eb, (char *)(result),                       \
1203                            ((unsigned long)(ptr)) +                     \
1204                             offsetof(type, member),                     \
1205                            sizeof(((type *)0)->member)))
1206
1207 #ifndef BTRFS_SETGET_FUNCS
1208 #define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
1209 u##bits btrfs_##name(struct extent_buffer *eb, type *s);                \
1210 void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
1211 #endif
1212
1213 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
1214 static inline u##bits btrfs_##name(struct extent_buffer *eb)            \
1215 {                                                                       \
1216         type *p = kmap_atomic(eb->first_page, KM_USER0);                \
1217         u##bits res = le##bits##_to_cpu(p->member);                     \
1218         kunmap_atomic(p, KM_USER0);                                     \
1219         return res;                                                     \
1220 }                                                                       \
1221 static inline void btrfs_set_##name(struct extent_buffer *eb,           \
1222                                     u##bits val)                        \
1223 {                                                                       \
1224         type *p = kmap_atomic(eb->first_page, KM_USER0);                \
1225         p->member = cpu_to_le##bits(val);                               \
1226         kunmap_atomic(p, KM_USER0);                                     \
1227 }
1228
1229 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
1230 static inline u##bits btrfs_##name(type *s)                             \
1231 {                                                                       \
1232         return le##bits##_to_cpu(s->member);                            \
1233 }                                                                       \
1234 static inline void btrfs_set_##name(type *s, u##bits val)               \
1235 {                                                                       \
1236         s->member = cpu_to_le##bits(val);                               \
1237 }
1238
1239 BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1240 BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
1241 BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1242 BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1243 BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1244 BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1245                    start_offset, 64);
1246 BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1247 BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1248 BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1249 BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1250 BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1251 BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1252
1253 BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1254 BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1255                          total_bytes, 64);
1256 BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1257                          bytes_used, 64);
1258 BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1259                          io_align, 32);
1260 BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1261                          io_width, 32);
1262 BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1263                          sector_size, 32);
1264 BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1265 BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1266                          dev_group, 32);
1267 BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1268                          seek_speed, 8);
1269 BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1270                          bandwidth, 8);
1271 BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1272                          generation, 64);
1273
1274 static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
1275 {
1276         return (char *)d + offsetof(struct btrfs_dev_item, uuid);
1277 }
1278
1279 static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
1280 {
1281         return (char *)d + offsetof(struct btrfs_dev_item, fsid);
1282 }
1283
1284 BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1285 BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1286 BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1287 BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1288 BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1289 BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1290 BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1291 BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1292 BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1293 BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1294 BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1295
1296 static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1297 {
1298         return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1299 }
1300
1301 BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1302 BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1303 BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1304                          stripe_len, 64);
1305 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1306                          io_align, 32);
1307 BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1308                          io_width, 32);
1309 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1310                          sector_size, 32);
1311 BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1312 BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1313                          num_stripes, 16);
1314 BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1315                          sub_stripes, 16);
1316 BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1317 BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1318
1319 static inline struct btrfs_stripe *btrfs_stripe_nr(struct btrfs_chunk *c,
1320                                                    int nr)
1321 {
1322         unsigned long offset = (unsigned long)c;
1323         offset += offsetof(struct btrfs_chunk, stripe);
1324         offset += nr * sizeof(struct btrfs_stripe);
1325         return (struct btrfs_stripe *)offset;
1326 }
1327
1328 static inline char *btrfs_stripe_dev_uuid_nr(struct btrfs_chunk *c, int nr)
1329 {
1330         return btrfs_stripe_dev_uuid(btrfs_stripe_nr(c, nr));
1331 }
1332
1333 static inline u64 btrfs_stripe_offset_nr(struct extent_buffer *eb,
1334                                          struct btrfs_chunk *c, int nr)
1335 {
1336         return btrfs_stripe_offset(eb, btrfs_stripe_nr(c, nr));
1337 }
1338
1339 static inline void btrfs_set_stripe_offset_nr(struct extent_buffer *eb,
1340                                              struct btrfs_chunk *c, int nr,
1341                                              u64 val)
1342 {
1343         btrfs_set_stripe_offset(eb, btrfs_stripe_nr(c, nr), val);
1344 }
1345
1346 static inline u64 btrfs_stripe_devid_nr(struct extent_buffer *eb,
1347                                          struct btrfs_chunk *c, int nr)
1348 {
1349         return btrfs_stripe_devid(eb, btrfs_stripe_nr(c, nr));
1350 }
1351
1352 static inline void btrfs_set_stripe_devid_nr(struct extent_buffer *eb,
1353                                              struct btrfs_chunk *c, int nr,
1354                                              u64 val)
1355 {
1356         btrfs_set_stripe_devid(eb, btrfs_stripe_nr(c, nr), val);
1357 }
1358
1359 /* struct btrfs_block_group_item */
1360 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1361                          used, 64);
1362 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1363                          used, 64);
1364 BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1365                         struct btrfs_block_group_item, chunk_objectid, 64);
1366
1367 BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
1368                    struct btrfs_block_group_item, chunk_objectid, 64);
1369 BTRFS_SETGET_FUNCS(disk_block_group_flags,
1370                    struct btrfs_block_group_item, flags, 64);
1371 BTRFS_SETGET_STACK_FUNCS(block_group_flags,
1372                         struct btrfs_block_group_item, flags, 64);
1373
1374 /* struct btrfs_inode_ref */
1375 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1376 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1377
1378 /* struct btrfs_inode_item */
1379 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1380 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1381 BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1382 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1383 BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1384 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1385 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1386 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1387 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1388 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1389 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1390 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1391
1392 static inline struct btrfs_timespec *
1393 btrfs_inode_atime(struct btrfs_inode_item *inode_item)
1394 {
1395         unsigned long ptr = (unsigned long)inode_item;
1396         ptr += offsetof(struct btrfs_inode_item, atime);
1397         return (struct btrfs_timespec *)ptr;
1398 }
1399
1400 static inline struct btrfs_timespec *
1401 btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
1402 {
1403         unsigned long ptr = (unsigned long)inode_item;
1404         ptr += offsetof(struct btrfs_inode_item, mtime);
1405         return (struct btrfs_timespec *)ptr;
1406 }
1407
1408 static inline struct btrfs_timespec *
1409 btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
1410 {
1411         unsigned long ptr = (unsigned long)inode_item;
1412         ptr += offsetof(struct btrfs_inode_item, ctime);
1413         return (struct btrfs_timespec *)ptr;
1414 }
1415
1416 static inline struct btrfs_timespec *
1417 btrfs_inode_otime(struct btrfs_inode_item *inode_item)
1418 {
1419         unsigned long ptr = (unsigned long)inode_item;
1420         ptr += offsetof(struct btrfs_inode_item, otime);
1421         return (struct btrfs_timespec *)ptr;
1422 }
1423
1424 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1425 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1426
1427 /* struct btrfs_dev_extent */
1428 BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1429                    chunk_tree, 64);
1430 BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1431                    chunk_objectid, 64);
1432 BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1433                    chunk_offset, 64);
1434 BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1435
1436 static inline u8 *btrfs_dev_extent_chunk_tree_uuid(struct btrfs_dev_extent *dev)
1437 {
1438         unsigned long ptr = offsetof(struct btrfs_dev_extent, chunk_tree_uuid);
1439         return (u8 *)((unsigned long)dev + ptr);
1440 }
1441
1442 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1443 BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1444                    generation, 64);
1445 BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1446
1447 BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1448
1449
1450 BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1451
1452 static inline void btrfs_tree_block_key(struct extent_buffer *eb,
1453                                         struct btrfs_tree_block_info *item,
1454                                         struct btrfs_disk_key *key)
1455 {
1456         read_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1457 }
1458
1459 static inline void btrfs_set_tree_block_key(struct extent_buffer *eb,
1460                                             struct btrfs_tree_block_info *item,
1461                                             struct btrfs_disk_key *key)
1462 {
1463         write_eb_member(eb, item, struct btrfs_tree_block_info, key, key);
1464 }
1465
1466 BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1467                    root, 64);
1468 BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1469                    objectid, 64);
1470 BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1471                    offset, 64);
1472 BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1473                    count, 32);
1474
1475 BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1476                    count, 32);
1477
1478 BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1479                    type, 8);
1480 BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1481                    offset, 64);
1482
1483 static inline u32 btrfs_extent_inline_ref_size(int type)
1484 {
1485         if (type == BTRFS_TREE_BLOCK_REF_KEY ||
1486             type == BTRFS_SHARED_BLOCK_REF_KEY)
1487                 return sizeof(struct btrfs_extent_inline_ref);
1488         if (type == BTRFS_SHARED_DATA_REF_KEY)
1489                 return sizeof(struct btrfs_shared_data_ref) +
1490                        sizeof(struct btrfs_extent_inline_ref);
1491         if (type == BTRFS_EXTENT_DATA_REF_KEY)
1492                 return sizeof(struct btrfs_extent_data_ref) +
1493                        offsetof(struct btrfs_extent_inline_ref, offset);
1494         BUG();
1495         return 0;
1496 }
1497
1498 BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1499 BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1500                    generation, 64);
1501 BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1502 BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
1503
1504 /* struct btrfs_node */
1505 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1506 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1507
1508 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
1509 {
1510         unsigned long ptr;
1511         ptr = offsetof(struct btrfs_node, ptrs) +
1512                 sizeof(struct btrfs_key_ptr) * nr;
1513         return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
1514 }
1515
1516 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
1517                                            int nr, u64 val)
1518 {
1519         unsigned long ptr;
1520         ptr = offsetof(struct btrfs_node, ptrs) +
1521                 sizeof(struct btrfs_key_ptr) * nr;
1522         btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
1523 }
1524
1525 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
1526 {
1527         unsigned long ptr;
1528         ptr = offsetof(struct btrfs_node, ptrs) +
1529                 sizeof(struct btrfs_key_ptr) * nr;
1530         return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
1531 }
1532
1533 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
1534                                                  int nr, u64 val)
1535 {
1536         unsigned long ptr;
1537         ptr = offsetof(struct btrfs_node, ptrs) +
1538                 sizeof(struct btrfs_key_ptr) * nr;
1539         btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
1540 }
1541
1542 static inline unsigned long btrfs_node_key_ptr_offset(int nr)
1543 {
1544         return offsetof(struct btrfs_node, ptrs) +
1545                 sizeof(struct btrfs_key_ptr) * nr;
1546 }
1547
1548 void btrfs_node_key(struct extent_buffer *eb,
1549                     struct btrfs_disk_key *disk_key, int nr);
1550
1551 static inline void btrfs_set_node_key(struct extent_buffer *eb,
1552                                       struct btrfs_disk_key *disk_key, int nr)
1553 {
1554         unsigned long ptr;
1555         ptr = btrfs_node_key_ptr_offset(nr);
1556         write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
1557                        struct btrfs_key_ptr, key, disk_key);
1558 }
1559
1560 /* struct btrfs_item */
1561 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1562 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1563
1564 static inline unsigned long btrfs_item_nr_offset(int nr)
1565 {
1566         return offsetof(struct btrfs_leaf, items) +
1567                 sizeof(struct btrfs_item) * nr;
1568 }
1569
1570 static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
1571                                                int nr)
1572 {
1573         return (struct btrfs_item *)btrfs_item_nr_offset(nr);
1574 }
1575
1576 static inline u32 btrfs_item_end(struct extent_buffer *eb,
1577                                  struct btrfs_item *item)
1578 {
1579         return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
1580 }
1581
1582 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
1583 {
1584         return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
1585 }
1586
1587 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
1588 {
1589         return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
1590 }
1591
1592 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
1593 {
1594         return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
1595 }
1596
1597 static inline void btrfs_item_key(struct extent_buffer *eb,
1598                            struct btrfs_disk_key *disk_key, int nr)
1599 {
1600         struct btrfs_item *item = btrfs_item_nr(eb, nr);
1601         read_eb_member(eb, item, struct btrfs_item, key, disk_key);
1602 }
1603
1604 static inline void btrfs_set_item_key(struct extent_buffer *eb,
1605                                struct btrfs_disk_key *disk_key, int nr)
1606 {
1607         struct btrfs_item *item = btrfs_item_nr(eb, nr);
1608         write_eb_member(eb, item, struct btrfs_item, key, disk_key);
1609 }
1610
1611 BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1612
1613 /*
1614  * struct btrfs_root_ref
1615  */
1616 BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
1617 BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
1618 BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
1619
1620 /* struct btrfs_dir_item */
1621 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
1622 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
1623 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
1624 BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
1625
1626 static inline void btrfs_dir_item_key(struct extent_buffer *eb,
1627                                       struct btrfs_dir_item *item,
1628                                       struct btrfs_disk_key *key)
1629 {
1630         read_eb_member(eb, item, struct btrfs_dir_item, location, key);
1631 }
1632
1633 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
1634                                           struct btrfs_dir_item *item,
1635                                           struct btrfs_disk_key *key)
1636 {
1637         write_eb_member(eb, item, struct btrfs_dir_item, location, key);
1638 }
1639
1640 /* struct btrfs_disk_key */
1641 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
1642                          objectid, 64);
1643 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
1644 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
1645
1646 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
1647                                          struct btrfs_disk_key *disk)
1648 {
1649         cpu->offset = le64_to_cpu(disk->offset);
1650         cpu->type = disk->type;
1651         cpu->objectid = le64_to_cpu(disk->objectid);
1652 }
1653
1654 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
1655                                          struct btrfs_key *cpu)
1656 {
1657         disk->offset = cpu_to_le64(cpu->offset);
1658         disk->type = cpu->type;
1659         disk->objectid = cpu_to_le64(cpu->objectid);
1660 }
1661
1662 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
1663                                   struct btrfs_key *key, int nr)
1664 {
1665         struct btrfs_disk_key disk_key;
1666         btrfs_node_key(eb, &disk_key, nr);
1667         btrfs_disk_key_to_cpu(key, &disk_key);
1668 }
1669
1670 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
1671                                   struct btrfs_key *key, int nr)
1672 {
1673         struct btrfs_disk_key disk_key;
1674         btrfs_item_key(eb, &disk_key, nr);
1675         btrfs_disk_key_to_cpu(key, &disk_key);
1676 }
1677
1678 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
1679                                       struct btrfs_dir_item *item,
1680                                       struct btrfs_key *key)
1681 {
1682         struct btrfs_disk_key disk_key;
1683         btrfs_dir_item_key(eb, item, &disk_key);
1684         btrfs_disk_key_to_cpu(key, &disk_key);
1685 }
1686
1687
1688 static inline u8 btrfs_key_type(struct btrfs_key *key)
1689 {
1690         return key->type;
1691 }
1692
1693 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
1694 {
1695         key->type = val;
1696 }
1697
1698 /* struct btrfs_header */
1699 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
1700 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
1701                           generation, 64);
1702 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
1703 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
1704 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
1705 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
1706
1707 static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
1708 {
1709         return (btrfs_header_flags(eb) & flag) == flag;
1710 }
1711
1712 static inline int btrfs_set_header_flag(struct extent_buffer *eb, u64 flag)
1713 {
1714         u64 flags = btrfs_header_flags(eb);
1715         btrfs_set_header_flags(eb, flags | flag);
1716         return (flags & flag) == flag;
1717 }
1718
1719 static inline int btrfs_clear_header_flag(struct extent_buffer *eb, u64 flag)
1720 {
1721         u64 flags = btrfs_header_flags(eb);
1722         btrfs_set_header_flags(eb, flags & ~flag);
1723         return (flags & flag) == flag;
1724 }
1725
1726 static inline int btrfs_header_backref_rev(struct extent_buffer *eb)
1727 {
1728         u64 flags = btrfs_header_flags(eb);
1729         return flags >> BTRFS_BACKREF_REV_SHIFT;
1730 }
1731
1732 static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
1733                                                 int rev)
1734 {
1735         u64 flags = btrfs_header_flags(eb);
1736         flags &= ~BTRFS_BACKREF_REV_MASK;
1737         flags |= (u64)rev << BTRFS_BACKREF_REV_SHIFT;
1738         btrfs_set_header_flags(eb, flags);
1739 }
1740
1741 static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
1742 {
1743         unsigned long ptr = offsetof(struct btrfs_header, fsid);
1744         return (u8 *)ptr;
1745 }
1746
1747 static inline u8 *btrfs_header_chunk_tree_uuid(struct extent_buffer *eb)
1748 {
1749         unsigned long ptr = offsetof(struct btrfs_header, chunk_tree_uuid);
1750         return (u8 *)ptr;
1751 }
1752
1753 static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)
1754 {
1755         unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
1756         return (u8 *)ptr;
1757 }
1758
1759 static inline u8 *btrfs_header_csum(struct extent_buffer *eb)
1760 {
1761         unsigned long ptr = offsetof(struct btrfs_header, csum);
1762         return (u8 *)ptr;
1763 }
1764
1765 static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
1766 {
1767         return NULL;
1768 }
1769
1770 static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
1771 {
1772         return NULL;
1773 }
1774
1775 static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
1776 {
1777         return NULL;
1778 }
1779
1780 static inline int btrfs_is_leaf(struct extent_buffer *eb)
1781 {
1782         return btrfs_header_level(eb) == 0;
1783 }
1784
1785 /* struct btrfs_root_item */
1786 BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
1787                    generation, 64);
1788 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
1789 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
1790 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
1791
1792 BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
1793                          generation, 64);
1794 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
1795 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
1796 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
1797 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
1798 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
1799 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
1800 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
1801 BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
1802                          last_snapshot, 64);
1803
1804 /* struct btrfs_super_block */
1805
1806 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
1807 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
1808 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
1809                          generation, 64);
1810 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
1811 BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
1812                          struct btrfs_super_block, sys_chunk_array_size, 32);
1813 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
1814                          struct btrfs_super_block, chunk_root_generation, 64);
1815 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
1816                          root_level, 8);
1817 BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
1818                          chunk_root, 64);
1819 BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
1820                          chunk_root_level, 8);
1821 BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
1822                          log_root, 64);
1823 BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
1824                          log_root_transid, 64);
1825 BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
1826                          log_root_level, 8);
1827 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
1828                          total_bytes, 64);
1829 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
1830                          bytes_used, 64);
1831 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
1832                          sectorsize, 32);
1833 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
1834                          nodesize, 32);
1835 BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
1836                          leafsize, 32);
1837 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
1838                          stripesize, 32);
1839 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
1840                          root_dir_objectid, 64);
1841 BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
1842                          num_devices, 64);
1843 BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
1844                          compat_flags, 64);
1845 BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
1846                          compat_ro_flags, 64);
1847 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
1848                          incompat_flags, 64);
1849 BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
1850                          csum_type, 16);
1851
1852 static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
1853 {
1854         int t = btrfs_super_csum_type(s);
1855         BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes));
1856         return btrfs_csum_sizes[t];
1857 }
1858
1859 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
1860 {
1861         return offsetof(struct btrfs_leaf, items);
1862 }
1863
1864 /* struct btrfs_file_extent_item */
1865 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
1866
1867 static inline unsigned long
1868 btrfs_file_extent_inline_start(struct btrfs_file_extent_item *e)
1869 {
1870         unsigned long offset = (unsigned long)e;
1871         offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
1872         return offset;
1873 }
1874
1875 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
1876 {
1877         return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
1878 }
1879
1880 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
1881                    disk_bytenr, 64);
1882 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
1883                    generation, 64);
1884 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
1885                    disk_num_bytes, 64);
1886 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
1887                   offset, 64);
1888 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
1889                    num_bytes, 64);
1890 BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
1891                    ram_bytes, 64);
1892 BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
1893                    compression, 8);
1894 BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
1895                    encryption, 8);
1896 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
1897                    other_encoding, 16);
1898
1899 /* this returns the number of file bytes represented by the inline item.
1900  * If an item is compressed, this is the uncompressed size
1901  */
1902 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
1903                                                struct btrfs_file_extent_item *e)
1904 {
1905         return btrfs_file_extent_ram_bytes(eb, e);
1906 }
1907
1908 /*
1909  * this returns the number of bytes used by the item on disk, minus the
1910  * size of any extent headers.  If a file is compressed on disk, this is
1911  * the compressed size
1912  */
1913 static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
1914                                                     struct btrfs_item *e)
1915 {
1916         unsigned long offset;
1917         offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
1918         return btrfs_item_size(eb, e) - offset;
1919 }
1920
1921 static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
1922 {
1923         return sb->s_fs_info;
1924 }
1925
1926 static inline int btrfs_set_root_name(struct btrfs_root *root,
1927                                       const char *name, int len)
1928 {
1929         /* if we already have a name just free it */
1930         kfree(root->name);
1931
1932         root->name = kmalloc(len+1, GFP_KERNEL);
1933         if (!root->name)
1934                 return -ENOMEM;
1935
1936         memcpy(root->name, name, len);
1937         root->name[len] = '\0';
1938
1939         return 0;
1940 }
1941
1942 static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
1943 {
1944         if (level == 0)
1945                 return root->leafsize;
1946         return root->nodesize;
1947 }
1948
1949 /* helper function to cast into the data area of the leaf. */
1950 #define btrfs_item_ptr(leaf, slot, type) \
1951         ((type *)(btrfs_leaf_data(leaf) + \
1952         btrfs_item_offset_nr(leaf, slot)))
1953
1954 #define btrfs_item_ptr_offset(leaf, slot) \
1955         ((unsigned long)(btrfs_leaf_data(leaf) + \
1956         btrfs_item_offset_nr(leaf, slot)))
1957
1958 static inline struct dentry *fdentry(struct file *file)
1959 {
1960         return file->f_path.dentry;
1961 }
1962
1963 /* extent-tree.c */
1964 void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
1965 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
1966                            struct btrfs_root *root, unsigned long count);
1967 int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
1968 int btrfs_pin_extent(struct btrfs_root *root,
1969                      u64 bytenr, u64 num, int reserved);
1970 int btrfs_drop_leaf_ref(struct btrfs_trans_handle *trans,
1971                         struct btrfs_root *root, struct extent_buffer *leaf);
1972 int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
1973                           struct btrfs_root *root,
1974                           u64 objectid, u64 offset, u64 bytenr);
1975 int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
1976 struct btrfs_block_group_cache *btrfs_lookup_block_group(
1977                                                  struct btrfs_fs_info *info,
1978                                                  u64 bytenr);
1979 void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
1980 u64 btrfs_find_block_group(struct btrfs_root *root,
1981                            u64 search_start, u64 search_hint, int owner);
1982 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
1983                                         struct btrfs_root *root, u32 blocksize,
1984                                         u64 parent, u64 root_objectid,
1985                                         struct btrfs_disk_key *key, int level,
1986                                         u64 hint, u64 empty_size);
1987 int btrfs_free_tree_block(struct btrfs_trans_handle *trans,
1988                           struct btrfs_root *root,
1989                           u64 bytenr, u32 blocksize,
1990                           u64 parent, u64 root_objectid, int level);
1991 struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
1992                                             struct btrfs_root *root,
1993                                             u64 bytenr, u32 blocksize,
1994                                             int level);
1995 int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
1996                                      struct btrfs_root *root,
1997                                      u64 root_objectid, u64 owner,
1998                                      u64 offset, struct btrfs_key *ins);
1999 int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
2000                                    struct btrfs_root *root,
2001                                    u64 root_objectid, u64 owner, u64 offset,
2002                                    struct btrfs_key *ins);
2003 int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
2004                                   struct btrfs_root *root,
2005                                   u64 num_bytes, u64 min_alloc_size,
2006                                   u64 empty_size, u64 hint_byte,
2007                                   u64 search_end, struct btrfs_key *ins,
2008                                   u64 data);
2009 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2010                   struct extent_buffer *buf, int full_backref);
2011 int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2012                   struct extent_buffer *buf, int full_backref);
2013 int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2014                                 struct btrfs_root *root,
2015                                 u64 bytenr, u64 num_bytes, u64 flags,
2016                                 int is_data);
2017 int btrfs_free_extent(struct btrfs_trans_handle *trans,
2018                       struct btrfs_root *root,
2019                       u64 bytenr, u64 num_bytes, u64 parent,
2020                       u64 root_objectid, u64 owner, u64 offset);
2021
2022 int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
2023 int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
2024                                 struct btrfs_root *root);
2025 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
2026                                struct btrfs_root *root);
2027 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
2028                          struct btrfs_root *root,
2029                          u64 bytenr, u64 num_bytes, u64 parent,
2030                          u64 root_objectid, u64 owner, u64 offset);
2031
2032 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2033                                     struct btrfs_root *root);
2034 int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
2035 int btrfs_free_block_groups(struct btrfs_fs_info *info);
2036 int btrfs_read_block_groups(struct btrfs_root *root);
2037 int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
2038 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
2039                            struct btrfs_root *root, u64 bytes_used,
2040                            u64 type, u64 chunk_objectid, u64 chunk_offset,
2041                            u64 size);
2042 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2043                              struct btrfs_root *root, u64 group_start);
2044 int btrfs_prepare_block_group_relocation(struct btrfs_root *root,
2045                                 struct btrfs_block_group_cache *group);
2046
2047 u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
2048 void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde);
2049 void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2050
2051 int btrfs_reserve_metadata_space(struct btrfs_root *root, int num_items);
2052 int btrfs_unreserve_metadata_space(struct btrfs_root *root, int num_items);
2053 int btrfs_unreserve_metadata_for_delalloc(struct btrfs_root *root,
2054                                           struct inode *inode, int num_items);
2055 int btrfs_reserve_metadata_for_delalloc(struct btrfs_root *root,
2056                                         struct inode *inode, int num_items);
2057 int btrfs_check_data_free_space(struct btrfs_root *root, struct inode *inode,
2058                                 u64 bytes);
2059 void btrfs_free_reserved_data_space(struct btrfs_root *root,
2060                                     struct inode *inode, u64 bytes);
2061 void btrfs_delalloc_reserve_space(struct btrfs_root *root, struct inode *inode,
2062                                  u64 bytes);
2063 void btrfs_delalloc_free_space(struct btrfs_root *root, struct inode *inode,
2064                               u64 bytes);
2065 /* ctree.c */
2066 int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
2067                      int level, int *slot);
2068 int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
2069 int btrfs_previous_item(struct btrfs_root *root,
2070                         struct btrfs_path *path, u64 min_objectid,
2071                         int type);
2072 int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,
2073                             struct btrfs_root *root, struct btrfs_path *path,
2074                             struct btrfs_key *new_key);
2075 struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2076 struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2077 int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
2078                         struct btrfs_key *key, int lowest_level,
2079                         int cache_only, u64 min_trans);
2080 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
2081                          struct btrfs_key *max_key,
2082                          struct btrfs_path *path, int cache_only,
2083                          u64 min_trans);
2084 int btrfs_cow_block(struct btrfs_trans_handle *trans,
2085                     struct btrfs_root *root, struct extent_buffer *buf,
2086                     struct extent_buffer *parent, int parent_slot,
2087                     struct extent_buffer **cow_ret);
2088 int btrfs_copy_root(struct btrfs_trans_handle *trans,
2089                       struct btrfs_root *root,
2090                       struct extent_buffer *buf,
2091                       struct extent_buffer **cow_ret, u64 new_root_objectid);
2092 int btrfs_block_can_be_shared(struct btrfs_root *root,
2093                               struct extent_buffer *buf);
2094 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
2095                       *root, struct btrfs_path *path, u32 data_size);
2096 int btrfs_truncate_item(struct btrfs_trans_handle *trans,
2097                         struct btrfs_root *root,
2098                         struct btrfs_path *path,
2099                         u32 new_size, int from_end);
2100 int btrfs_split_item(struct btrfs_trans_handle *trans,
2101                      struct btrfs_root *root,
2102                      struct btrfs_path *path,
2103                      struct btrfs_key *new_key,
2104                      unsigned long split_offset);
2105 int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2106                          struct btrfs_root *root,
2107                          struct btrfs_path *path,
2108                          struct btrfs_key *new_key);
2109 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
2110                       *root, struct btrfs_key *key, struct btrfs_path *p, int
2111                       ins_len, int cow);
2112 int btrfs_realloc_node(struct btrfs_trans_handle *trans,
2113                        struct btrfs_root *root, struct extent_buffer *parent,
2114                        int start_slot, int cache_only, u64 *last_ret,
2115                        struct btrfs_key *progress);
2116 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
2117 struct btrfs_path *btrfs_alloc_path(void);
2118 void btrfs_free_path(struct btrfs_path *p);
2119 void btrfs_set_path_blocking(struct btrfs_path *p);
2120 void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2121
2122 int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2123                    struct btrfs_path *path, int slot, int nr);
2124 static inline int btrfs_del_item(struct btrfs_trans_handle *trans,
2125                                  struct btrfs_root *root,
2126                                  struct btrfs_path *path)
2127 {
2128         return btrfs_del_items(trans, root, path, path->slots[0], 1);
2129 }
2130
2131 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
2132                       *root, struct btrfs_key *key, void *data, u32 data_size);
2133 int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
2134                             struct btrfs_root *root,
2135                             struct btrfs_path *path,
2136                             struct btrfs_key *cpu_key, u32 *data_size,
2137                             int nr);
2138 int btrfs_insert_empty_items(struct btrfs_trans_handle *trans,
2139                              struct btrfs_root *root,
2140                              struct btrfs_path *path,
2141                              struct btrfs_key *cpu_key, u32 *data_size, int nr);
2142
2143 static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
2144                                           struct btrfs_root *root,
2145                                           struct btrfs_path *path,
2146                                           struct btrfs_key *key,
2147                                           u32 data_size)
2148 {
2149         return btrfs_insert_empty_items(trans, root, path, key, &data_size, 1);
2150 }
2151
2152 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
2153 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
2154 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
2155 int btrfs_drop_snapshot(struct btrfs_root *root, int update_ref);
2156 int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
2157                         struct btrfs_root *root,
2158                         struct extent_buffer *node,
2159                         struct extent_buffer *parent);
2160 /* root-item.c */
2161 int btrfs_find_root_ref(struct btrfs_root *tree_root,
2162                         struct btrfs_path *path,
2163                         u64 root_id, u64 ref_id);
2164 int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
2165                        struct btrfs_root *tree_root,
2166                        u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
2167                        const char *name, int name_len);
2168 int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
2169                        struct btrfs_root *tree_root,
2170                        u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
2171                        const char *name, int name_len);
2172 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2173                    struct btrfs_key *key);
2174 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
2175                       *root, struct btrfs_key *key, struct btrfs_root_item
2176                       *item);
2177 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
2178                       *root, struct btrfs_key *key, struct btrfs_root_item
2179                       *item);
2180 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
2181                          btrfs_root_item *item, struct btrfs_key *key);
2182 int btrfs_search_root(struct btrfs_root *root, u64 search_start,
2183                       u64 *found_objectid);
2184 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
2185 int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
2186 int btrfs_set_root_node(struct btrfs_root_item *item,
2187                         struct extent_buffer *node);
2188 /* dir-item.c */
2189 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
2190                           struct btrfs_root *root, const char *name,
2191                           int name_len, u64 dir,
2192                           struct btrfs_key *location, u8 type, u64 index);
2193 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
2194                                              struct btrfs_root *root,
2195                                              struct btrfs_path *path, u64 dir,
2196                                              const char *name, int name_len,
2197                                              int mod);
2198 struct btrfs_dir_item *
2199 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
2200                             struct btrfs_root *root,
2201                             struct btrfs_path *path, u64 dir,
2202                             u64 objectid, const char *name, int name_len,
2203                             int mod);
2204 struct btrfs_dir_item *
2205 btrfs_search_dir_index_item(struct btrfs_root *root,
2206                             struct btrfs_path *path, u64 dirid,
2207                             const char *name, int name_len);
2208 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
2209                               struct btrfs_path *path,
2210                               const char *name, int name_len);
2211 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
2212                               struct btrfs_root *root,
2213                               struct btrfs_path *path,
2214                               struct btrfs_dir_item *di);
2215 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
2216                             struct btrfs_root *root,
2217                             struct btrfs_path *path, u64 objectid,
2218                             const char *name, u16 name_len,
2219                             const void *data, u16 data_len);
2220 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
2221                                           struct btrfs_root *root,
2222                                           struct btrfs_path *path, u64 dir,
2223                                           const char *name, u16 name_len,
2224                                           int mod);
2225
2226 /* orphan.c */
2227 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
2228                              struct btrfs_root *root, u64 offset);
2229 int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
2230                           struct btrfs_root *root, u64 offset);
2231 int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
2232
2233 /* inode-map.c */
2234 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
2235                              struct btrfs_root *fs_root,
2236                              u64 dirid, u64 *objectid);
2237 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
2238
2239 /* inode-item.c */
2240 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
2241                            struct btrfs_root *root,
2242                            const char *name, int name_len,
2243                            u64 inode_objectid, u64 ref_objectid, u64 index);
2244 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
2245                            struct btrfs_root *root,
2246                            const char *name, int name_len,
2247                            u64 inode_objectid, u64 ref_objectid, u64 *index);
2248 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
2249                              struct btrfs_root *root,
2250                              struct btrfs_path *path, u64 objectid);
2251 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
2252                        *root, struct btrfs_path *path,
2253                        struct btrfs_key *location, int mod);
2254
2255 /* file-item.c */
2256 int btrfs_del_csums(struct btrfs_trans_handle *trans,
2257                     struct btrfs_root *root, u64 bytenr, u64 len);
2258 int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
2259                           struct bio *bio, u32 *dst);
2260 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
2261                              struct btrfs_root *root,
2262                              u64 objectid, u64 pos,
2263                              u64 disk_offset, u64 disk_num_bytes,
2264                              u64 num_bytes, u64 offset, u64 ram_bytes,
2265                              u8 compression, u8 encryption, u16 other_encoding);
2266 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
2267                              struct btrfs_root *root,
2268                              struct btrfs_path *path, u64 objectid,
2269                              u64 bytenr, int mod);
2270 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
2271                            struct btrfs_root *root,
2272                            struct btrfs_ordered_sum *sums);
2273 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
2274                        struct bio *bio, u64 file_start, int contig);
2275 int btrfs_csum_file_bytes(struct btrfs_root *root, struct inode *inode,
2276                           u64 start, unsigned long len);
2277 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
2278                                           struct btrfs_root *root,
2279                                           struct btrfs_path *path,
2280                                           u64 bytenr, int cow);
2281 int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
2282                         struct btrfs_root *root, struct btrfs_path *path,
2283                         u64 isize);
2284 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start,
2285                              u64 end, struct list_head *list);
2286 /* inode.c */
2287
2288 /* RHEL and EL kernels have a patch that renames PG_checked to FsMisc */
2289 #if defined(ClearPageFsMisc) && !defined(ClearPageChecked)
2290 #define ClearPageChecked ClearPageFsMisc
2291 #define SetPageChecked SetPageFsMisc
2292 #define PageChecked PageFsMisc
2293 #endif
2294
2295 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
2296 int btrfs_set_inode_index(struct inode *dir, u64 *index);
2297 int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
2298                        struct btrfs_root *root,
2299                        struct inode *dir, struct inode *inode,
2300                        const char *name, int name_len);
2301 int btrfs_add_link(struct btrfs_trans_handle *trans,
2302                    struct inode *parent_inode, struct inode *inode,
2303                    const char *name, int name_len, int add_backref, u64 index);
2304 int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
2305                         struct btrfs_root *root,
2306                         struct inode *dir, u64 objectid,
2307                         const char *name, int name_len);
2308 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
2309                                struct btrfs_root *root,
2310                                struct inode *inode, u64 new_size,
2311                                u32 min_type);
2312
2313 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
2314 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
2315                               struct extent_state **cached_state);
2316 int btrfs_writepages(struct address_space *mapping,
2317                      struct writeback_control *wbc);
2318 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
2319                              struct btrfs_root *new_root,
2320                              u64 new_dirid, u64 alloc_hint);
2321 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
2322                          size_t size, struct bio *bio, unsigned long bio_flags);
2323
2324 unsigned long btrfs_force_ra(struct address_space *mapping,
2325                               struct file_ra_state *ra, struct file *file,
2326                               pgoff_t offset, pgoff_t last_index);
2327 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
2328 int btrfs_readpage(struct file *file, struct page *page);
2329 void btrfs_delete_inode(struct inode *inode);
2330 void btrfs_put_inode(struct inode *inode);
2331 int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
2332 void btrfs_dirty_inode(struct inode *inode);
2333 struct inode *btrfs_alloc_inode(struct super_block *sb);
2334 void btrfs_destroy_inode(struct inode *inode);
2335 void btrfs_drop_inode(struct inode *inode);
2336 int btrfs_init_cachep(void);
2337 void btrfs_destroy_cachep(void);
2338 long btrfs_ioctl_trans_end(struct file *file);
2339 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
2340                          struct btrfs_root *root, int *was_new);
2341 int btrfs_commit_write(struct file *file, struct page *page,
2342                        unsigned from, unsigned to);
2343 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
2344                                     size_t page_offset, u64 start, u64 end,
2345                                     int create);
2346 int btrfs_update_inode(struct btrfs_trans_handle *trans,
2347                               struct btrfs_root *root,
2348                               struct inode *inode);
2349 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
2350 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
2351 void btrfs_orphan_cleanup(struct btrfs_root *root);
2352 int btrfs_cont_expand(struct inode *inode, loff_t size);
2353 int btrfs_invalidate_inodes(struct btrfs_root *root);
2354 void btrfs_add_delayed_iput(struct inode *inode);
2355 void btrfs_run_delayed_iputs(struct btrfs_root *root);
2356 extern const struct dentry_operations btrfs_dentry_operations;
2357
2358 /* ioctl.c */
2359 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2360 void btrfs_update_iflags(struct inode *inode);
2361 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
2362
2363 /* file.c */
2364 int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync);
2365 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
2366                             int skip_pinned);
2367 int btrfs_check_file(struct btrfs_root *root, struct inode *inode);
2368 extern const struct file_operations btrfs_file_operations;
2369 int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
2370                        u64 start, u64 end, u64 *hint_byte, int drop_cache);
2371 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
2372                               struct inode *inode, u64 start, u64 end);
2373 int btrfs_release_file(struct inode *inode, struct file *file);
2374
2375 /* tree-defrag.c */
2376 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
2377                         struct btrfs_root *root, int cache_only);
2378
2379 /* sysfs.c */
2380 int btrfs_init_sysfs(void);
2381 void btrfs_exit_sysfs(void);
2382 int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
2383 int btrfs_sysfs_add_root(struct btrfs_root *root);
2384 void btrfs_sysfs_del_root(struct btrfs_root *root);
2385 void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
2386
2387 /* xattr.c */
2388 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
2389
2390 /* super.c */
2391 int btrfs_parse_options(struct btrfs_root *root, char *options);
2392 int btrfs_sync_fs(struct super_block *sb, int wait);
2393
2394 /* acl.c */
2395 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
2396 int btrfs_check_acl(struct inode *inode, int mask);
2397 #else
2398 #define btrfs_check_acl NULL
2399 #endif
2400 int btrfs_init_acl(struct btrfs_trans_handle *trans,
2401                    struct inode *inode, struct inode *dir);
2402 int btrfs_acl_chmod(struct inode *inode);
2403
2404 /* relocation.c */
2405 int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
2406 int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
2407                           struct btrfs_root *root);
2408 int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
2409                             struct btrfs_root *root);
2410 int btrfs_recover_relocation(struct btrfs_root *root);
2411 int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
2412 #endif