git.oblomov.eu Git - linux-2.6/blob - fs/btrfs/ctree.h

   1 #ifndef __BTRFS__
   2 #define __BTRFS__
   3
   4 #include <linux/fs.h>
   5 #include <linux/buffer_head.h>
   6 #include <linux/kobject.h>
   7 #include "bit-radix.h"
   8
   9 struct btrfs_trans_handle;
  10 struct btrfs_transaction;
  11 extern struct kmem_cache *btrfs_path_cachep;
  12
  13 #define BTRFS_MAGIC "_BtRfS_M"
  14
  15 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
  16 #define BTRFS_DEV_TREE_OBJECTID 2ULL
  17 #define BTRFS_EXTENT_TREE_OBJECTID 3ULL
  18 #define BTRFS_FS_TREE_OBJECTID 4ULL
  19 #define BTRFS_ROOT_TREE_DIR_OBJECTID 5ULL
  20 #define BTRFS_FIRST_FREE_OBJECTID 6ULL
  21
  22 /*
  23  * we can actually store much bigger names, but lets not confuse the rest
  24  * of linux
  25  */
  26 #define BTRFS_NAME_LEN 255
  27
  28 /* 32 bytes in various csum fields */
  29 #define BTRFS_CSUM_SIZE 32
  30
  31 /*
  32  * the key defines the order in the tree, and so it also defines (optimal)
  33  * block layout.  objectid corresonds to the inode number.  The flags
  34  * tells us things about the object, and is a kind of stream selector.
  35  * so for a given inode, keys with flags of 1 might refer to the inode
  36  * data, flags of 2 may point to file data in the btree and flags == 3
  37  * may point to extents.
  38  *
  39  * offset is the starting byte offset for this key in the stream.
  40  *
  41  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
  42  * in cpu native order.  Otherwise they are identical and their sizes
  43  * should be the same (ie both packed)
  44  */
  45 struct btrfs_disk_key {
  46         __le64 objectid;
  47         __le32 flags;
  48         __le64 offset;
  49 } __attribute__ ((__packed__));
  50
  51 struct btrfs_key {
  52         u64 objectid;
  53         u32 flags;
  54         u64 offset;
  55 } __attribute__ ((__packed__));
  56
  57 /*
  58  * every tree block (leaf or node) starts with this header.
  59  */
  60 struct btrfs_header {
  61         u8 csum[BTRFS_CSUM_SIZE];
  62         u8 fsid[16]; /* FS specific uuid */
  63         __le64 blocknr; /* which block this node is supposed to live in */
  64         __le64 generation;
  65         __le64 owner;
  66         __le16 nritems;
  67         __le16 flags;
  68         u8 level;
  69 } __attribute__ ((__packed__));
  70
  71 #define BTRFS_MAX_LEVEL 8
  72 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->blocksize - \
  73                                 sizeof(struct btrfs_header)) / \
  74                                (sizeof(struct btrfs_disk_key) + sizeof(u64)))
  75 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
  76 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->blocksize))
  77 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
  78                                         sizeof(struct btrfs_item) - \
  79                                         sizeof(struct btrfs_file_extent_item))
  80
  81 struct buffer_head;
  82 /*
  83  * the super block basically lists the main trees of the FS
  84  * it currently lacks any block count etc etc
  85  */
  86 struct btrfs_super_block {
  87         u8 csum[BTRFS_CSUM_SIZE];
  88         /* the first 3 fields must match struct btrfs_header */
  89         u8 fsid[16];    /* FS specific uuid */
  90         __le64 blocknr; /* this block number */
  91         __le64 magic;
  92         __le32 blocksize;
  93         __le64 generation;
  94         __le64 root;
  95         __le64 total_blocks;
  96         __le64 blocks_used;
  97         __le64 root_dir_objectid;
  98         __le64 last_device_id;
  99         /* fields below here vary with the underlying disk */
 100         __le64 device_block_start;
 101         __le64 device_num_blocks;
 102         __le64 device_root;
 103         __le64 device_id;
 104 } __attribute__ ((__packed__));
 105
 106 /*
 107  * A leaf is full of items. offset and size tell us where to find
 108  * the item in the leaf (relative to the start of the data area)
 109  */
 110 struct btrfs_item {
 111         struct btrfs_disk_key key;
 112         __le32 offset;
 113         __le16 size;
 114 } __attribute__ ((__packed__));
 115
 116 /*
 117  * leaves have an item area and a data area:
 118  * [item0, item1....itemN] [free space] [dataN...data1, data0]
 119  *
 120  * The data is separate from the items to get the keys closer together
 121  * during searches.
 122  */
 123 struct btrfs_leaf {
 124         struct btrfs_header header;
 125         struct btrfs_item items[];
 126 } __attribute__ ((__packed__));
 127
 128 /*
 129  * all non-leaf blocks are nodes, they hold only keys and pointers to
 130  * other blocks
 131  */
 132 struct btrfs_key_ptr {
 133         struct btrfs_disk_key key;
 134         __le64 blockptr;
 135 } __attribute__ ((__packed__));
 136
 137 struct btrfs_node {
 138         struct btrfs_header header;
 139         struct btrfs_key_ptr ptrs[];
 140 } __attribute__ ((__packed__));
 141
 142 /*
 143  * btrfs_paths remember the path taken from the root down to the leaf.
 144  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 145  * to any other levels that are present.
 146  *
 147  * The slots array records the index of the item or block pointer
 148  * used while walking the tree.
 149  */
 150 struct btrfs_path {
 151         struct buffer_head *nodes[BTRFS_MAX_LEVEL];
 152         int slots[BTRFS_MAX_LEVEL];
 153 };
 154
 155 /*
 156  * items in the extent btree are used to record the objectid of the
 157  * owner of the block and the number of references
 158  */
 159 struct btrfs_extent_item {
 160         __le32 refs;
 161         __le64 owner;
 162 } __attribute__ ((__packed__));
 163
 164 struct btrfs_inode_timespec {
 165         __le64 sec;
 166         __le32 nsec;
 167 } __attribute__ ((__packed__));
 168
 169 /*
 170  * there is no padding here on purpose.  If you want to extent the inode,
 171  * make a new item type
 172  */
 173 struct btrfs_inode_item {
 174         __le64 generation;
 175         __le64 size;
 176         __le64 nblocks;
 177         __le32 nlink;
 178         __le32 uid;
 179         __le32 gid;
 180         __le32 mode;
 181         __le32 rdev;
 182         __le16 flags;
 183         __le16 compat_flags;
 184         struct btrfs_inode_timespec atime;
 185         struct btrfs_inode_timespec ctime;
 186         struct btrfs_inode_timespec mtime;
 187         struct btrfs_inode_timespec otime;
 188 } __attribute__ ((__packed__));
 189
 190 struct btrfs_dir_item {
 191         struct btrfs_disk_key location;
 192         __le16 flags;
 193         __le16 name_len;
 194         u8 type;
 195 } __attribute__ ((__packed__));
 196
 197 struct btrfs_root_item {
 198         struct btrfs_inode_item inode;
 199         __le64 root_dirid;
 200         __le64 blocknr;
 201         __le32 flags;
 202         __le64 block_limit;
 203         __le64 blocks_used;
 204         __le32 refs;
 205 } __attribute__ ((__packed__));
 206
 207 #define BTRFS_FILE_EXTENT_REG 0
 208 #define BTRFS_FILE_EXTENT_INLINE 1
 209
 210 struct btrfs_file_extent_item {
 211         __le64 generation;
 212         u8 type;
 213         /*
 214          * disk space consumed by the extent, checksum blocks are included
 215          * in these numbers
 216          */
 217         __le64 disk_blocknr;
 218         __le64 disk_num_blocks;
 219         /*
 220          * the logical offset in file blocks (no csums)
 221          * this extent record is for.  This allows a file extent to point
 222          * into the middle of an existing extent on disk, sharing it
 223          * between two snapshots (useful if some bytes in the middle of the
 224          * extent have changed
 225          */
 226         __le64 offset;
 227         /*
 228          * the logical number of file blocks (no csums included)
 229          */
 230         __le64 num_blocks;
 231 } __attribute__ ((__packed__));
 232
 233 struct btrfs_csum_item {
 234         u8 csum[BTRFS_CSUM_SIZE];
 235 } __attribute__ ((__packed__));
 236
 237 struct btrfs_device_item {
 238         __le16 pathlen;
 239         __le64 device_id;
 240 } __attribute__ ((__packed__));
 241
 242 /* tag for the radix tree of block groups in ram */
 243 #define BTRFS_BLOCK_GROUP_DIRTY 0
 244 #define BTRFS_BLOCK_GROUP_HINTS 8
 245 #define BTRFS_BLOCK_GROUP_SIZE (256 * 1024 * 1024)
 246 struct btrfs_block_group_item {
 247         __le64 used;
 248 } __attribute__ ((__packed__));
 249
 250 struct btrfs_block_group_cache {
 251         struct btrfs_key key;
 252         struct btrfs_block_group_item item;
 253         u64 first_free;
 254         u64 last_alloc;
 255 };
 256
 257 struct crypto_hash;
 258 struct btrfs_fs_info {
 259         struct btrfs_root *extent_root;
 260         struct btrfs_root *tree_root;
 261         struct btrfs_root *dev_root;
 262         struct btrfs_block_group_cache *block_group_cache;
 263         struct radix_tree_root fs_roots_radix;
 264         struct radix_tree_root pending_del_radix;
 265         struct radix_tree_root pinned_radix;
 266         struct radix_tree_root dev_radix;
 267         struct radix_tree_root block_group_radix;
 268
 269         u64 extent_tree_insert[BTRFS_MAX_LEVEL * 3];
 270         int extent_tree_insert_nr;
 271         u64 extent_tree_prealloc[BTRFS_MAX_LEVEL * 3];
 272         int extent_tree_prealloc_nr;
 273
 274         u64 generation;
 275         struct btrfs_transaction *running_transaction;
 276         struct btrfs_super_block *disk_super;
 277         struct buffer_head *sb_buffer;
 278         struct super_block *sb;
 279         struct inode *btree_inode;
 280         struct mutex trans_mutex;
 281         struct mutex fs_mutex;
 282         struct list_head trans_list;
 283         struct crypto_hash *hash_tfm;
 284         spinlock_t hash_lock;
 285         int do_barriers;
 286         struct kobject kobj;
 287 };
 288
 289 /*
 290  * in ram representation of the tree.  extent_root is used for all allocations
 291  * and for the extent tree extent_root root.
 292  */
 293 struct btrfs_root {
 294         struct buffer_head *node;
 295         struct buffer_head *commit_root;
 296         struct btrfs_root_item root_item;
 297         struct btrfs_key root_key;
 298         struct btrfs_fs_info *fs_info;
 299         struct inode *inode;
 300         u64 objectid;
 301         u64 last_trans;
 302         u32 blocksize;
 303         int ref_cows;
 304         u32 type;
 305         u64 highest_inode;
 306         u64 last_inode_alloc;
 307 };
 308
 309 /* the lower bits in the key flags defines the item type */
 310 #define BTRFS_KEY_TYPE_MAX      256
 311 #define BTRFS_KEY_TYPE_SHIFT    24
 312 #define BTRFS_KEY_TYPE_MASK     (((u32)BTRFS_KEY_TYPE_MAX - 1) << \
 313                                   BTRFS_KEY_TYPE_SHIFT)
 314
 315 /*
 316  * inode items have the data typically returned from stat and store other
 317  * info about object characteristics.  There is one for every file and dir in
 318  * the FS
 319  */
 320 #define BTRFS_INODE_ITEM_KEY            1
 321
 322 /* reserve 2-15 close to the inode for later flexibility */
 323
 324 /*
 325  * dir items are the name -> inode pointers in a directory.  There is one
 326  * for every name in a directory.
 327  */
 328 #define BTRFS_DIR_ITEM_KEY      16
 329 #define BTRFS_DIR_INDEX_KEY     17
 330 /*
 331  * extent data is for file data
 332  */
 333 #define BTRFS_EXTENT_DATA_KEY   18
 334 /*
 335  * csum items have the checksums for data in the extents
 336  */
 337 #define BTRFS_CSUM_ITEM_KEY     19
 338
 339 /* reserve 20-31 for other file stuff */
 340
 341 /*
 342  * root items point to tree roots.  There are typically in the root
 343  * tree used by the super block to find all the other trees
 344  */
 345 #define BTRFS_ROOT_ITEM_KEY     32
 346 /*
 347  * extent items are in the extent map tree.  These record which blocks
 348  * are used, and how many references there are to each block
 349  */
 350 #define BTRFS_EXTENT_ITEM_KEY   33
 351
 352 /*
 353  * block groups give us hints into the extent allocation trees.  Which
 354  * blocks are free etc etc
 355  */
 356 #define BTRFS_BLOCK_GROUP_ITEM_KEY 34
 357
 358 /*
 359  * dev items list the devices that make up the FS
 360  */
 361 #define BTRFS_DEV_ITEM_KEY      35
 362
 363 /*
 364  * string items are for debugging.  They just store a short string of
 365  * data in the FS
 366  */
 367 #define BTRFS_STRING_ITEM_KEY   253
 368
 369
 370 static inline u64 btrfs_block_group_used(struct btrfs_block_group_item *bi)
 371 {
 372         return le64_to_cpu(bi->used);
 373 }
 374
 375 static inline void btrfs_set_block_group_used(struct
 376                                                    btrfs_block_group_item *bi,
 377                                                    u64 val)
 378 {
 379         bi->used = cpu_to_le64(val);
 380 }
 381
 382 static inline u64 btrfs_inode_generation(struct btrfs_inode_item *i)
 383 {
 384         return le64_to_cpu(i->generation);
 385 }
 386
 387 static inline void btrfs_set_inode_generation(struct btrfs_inode_item *i,
 388                                               u64 val)
 389 {
 390         i->generation = cpu_to_le64(val);
 391 }
 392
 393 static inline u64 btrfs_inode_size(struct btrfs_inode_item *i)
 394 {
 395         return le64_to_cpu(i->size);
 396 }
 397
 398 static inline void btrfs_set_inode_size(struct btrfs_inode_item *i, u64 val)
 399 {
 400         i->size = cpu_to_le64(val);
 401 }
 402
 403 static inline u64 btrfs_inode_nblocks(struct btrfs_inode_item *i)
 404 {
 405         return le64_to_cpu(i->nblocks);
 406 }
 407
 408 static inline void btrfs_set_inode_nblocks(struct btrfs_inode_item *i, u64 val)
 409 {
 410         i->nblocks = cpu_to_le64(val);
 411 }
 412
 413 static inline u32 btrfs_inode_nlink(struct btrfs_inode_item *i)
 414 {
 415         return le32_to_cpu(i->nlink);
 416 }
 417
 418 static inline void btrfs_set_inode_nlink(struct btrfs_inode_item *i, u32 val)
 419 {
 420         i->nlink = cpu_to_le32(val);
 421 }
 422
 423 static inline u32 btrfs_inode_uid(struct btrfs_inode_item *i)
 424 {
 425         return le32_to_cpu(i->uid);
 426 }
 427
 428 static inline void btrfs_set_inode_uid(struct btrfs_inode_item *i, u32 val)
 429 {
 430         i->uid = cpu_to_le32(val);
 431 }
 432
 433 static inline u32 btrfs_inode_gid(struct btrfs_inode_item *i)
 434 {
 435         return le32_to_cpu(i->gid);
 436 }
 437
 438 static inline void btrfs_set_inode_gid(struct btrfs_inode_item *i, u32 val)
 439 {
 440         i->gid = cpu_to_le32(val);
 441 }
 442
 443 static inline u32 btrfs_inode_mode(struct btrfs_inode_item *i)
 444 {
 445         return le32_to_cpu(i->mode);
 446 }
 447
 448 static inline void btrfs_set_inode_mode(struct btrfs_inode_item *i, u32 val)
 449 {
 450         i->mode = cpu_to_le32(val);
 451 }
 452
 453 static inline u32 btrfs_inode_rdev(struct btrfs_inode_item *i)
 454 {
 455         return le32_to_cpu(i->rdev);
 456 }
 457
 458 static inline void btrfs_set_inode_rdev(struct btrfs_inode_item *i, u32 val)
 459 {
 460         i->rdev = cpu_to_le32(val);
 461 }
 462
 463 static inline u16 btrfs_inode_flags(struct btrfs_inode_item *i)
 464 {
 465         return le16_to_cpu(i->flags);
 466 }
 467
 468 static inline void btrfs_set_inode_flags(struct btrfs_inode_item *i, u16 val)
 469 {
 470         i->flags = cpu_to_le16(val);
 471 }
 472
 473 static inline u16 btrfs_inode_compat_flags(struct btrfs_inode_item *i)
 474 {
 475         return le16_to_cpu(i->compat_flags);
 476 }
 477
 478 static inline void btrfs_set_inode_compat_flags(struct btrfs_inode_item *i,
 479                                                 u16 val)
 480 {
 481         i->compat_flags = cpu_to_le16(val);
 482 }
 483
 484 static inline u64 btrfs_timespec_sec(struct btrfs_inode_timespec *ts)
 485 {
 486         return le64_to_cpu(ts->sec);
 487 }
 488
 489 static inline void btrfs_set_timespec_sec(struct btrfs_inode_timespec *ts,
 490                                           u64 val)
 491 {
 492         ts->sec = cpu_to_le64(val);
 493 }
 494
 495 static inline u32 btrfs_timespec_nsec(struct btrfs_inode_timespec *ts)
 496 {
 497         return le32_to_cpu(ts->nsec);
 498 }
 499
 500 static inline void btrfs_set_timespec_nsec(struct btrfs_inode_timespec *ts,
 501                                           u32 val)
 502 {
 503         ts->nsec = cpu_to_le32(val);
 504 }
 505
 506 static inline u32 btrfs_extent_refs(struct btrfs_extent_item *ei)
 507 {
 508         return le32_to_cpu(ei->refs);
 509 }
 510
 511 static inline void btrfs_set_extent_refs(struct btrfs_extent_item *ei, u32 val)
 512 {
 513         ei->refs = cpu_to_le32(val);
 514 }
 515
 516 static inline u64 btrfs_extent_owner(struct btrfs_extent_item *ei)
 517 {
 518         return le64_to_cpu(ei->owner);
 519 }
 520
 521 static inline void btrfs_set_extent_owner(struct btrfs_extent_item *ei, u64 val)
 522 {
 523         ei->owner = cpu_to_le64(val);
 524 }
 525
 526 static inline u64 btrfs_node_blockptr(struct btrfs_node *n, int nr)
 527 {
 528         return le64_to_cpu(n->ptrs[nr].blockptr);
 529 }
 530
 531
 532 static inline void btrfs_set_node_blockptr(struct btrfs_node *n, int nr,
 533                                            u64 val)
 534 {
 535         n->ptrs[nr].blockptr = cpu_to_le64(val);
 536 }
 537
 538 static inline u32 btrfs_item_offset(struct btrfs_item *item)
 539 {
 540         return le32_to_cpu(item->offset);
 541 }
 542
 543 static inline void btrfs_set_item_offset(struct btrfs_item *item, u32 val)
 544 {
 545         item->offset = cpu_to_le32(val);
 546 }
 547
 548 static inline u32 btrfs_item_end(struct btrfs_item *item)
 549 {
 550         return le32_to_cpu(item->offset) + le16_to_cpu(item->size);
 551 }
 552
 553 static inline u16 btrfs_item_size(struct btrfs_item *item)
 554 {
 555         return le16_to_cpu(item->size);
 556 }
 557
 558 static inline void btrfs_set_item_size(struct btrfs_item *item, u16 val)
 559 {
 560         item->size = cpu_to_le16(val);
 561 }
 562
 563 static inline u16 btrfs_dir_flags(struct btrfs_dir_item *d)
 564 {
 565         return le16_to_cpu(d->flags);
 566 }
 567
 568 static inline void btrfs_set_dir_flags(struct btrfs_dir_item *d, u16 val)
 569 {
 570         d->flags = cpu_to_le16(val);
 571 }
 572
 573 static inline u8 btrfs_dir_type(struct btrfs_dir_item *d)
 574 {
 575         return d->type;
 576 }
 577
 578 static inline void btrfs_set_dir_type(struct btrfs_dir_item *d, u8 val)
 579 {
 580         d->type = val;
 581 }
 582
 583 static inline u16 btrfs_dir_name_len(struct btrfs_dir_item *d)
 584 {
 585         return le16_to_cpu(d->name_len);
 586 }
 587
 588 static inline void btrfs_set_dir_name_len(struct btrfs_dir_item *d, u16 val)
 589 {
 590         d->name_len = cpu_to_le16(val);
 591 }
 592
 593 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 594                                          struct btrfs_disk_key *disk)
 595 {
 596         cpu->offset = le64_to_cpu(disk->offset);
 597         cpu->flags = le32_to_cpu(disk->flags);
 598         cpu->objectid = le64_to_cpu(disk->objectid);
 599 }
 600
 601 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
 602                                          struct btrfs_key *cpu)
 603 {
 604         disk->offset = cpu_to_le64(cpu->offset);
 605         disk->flags = cpu_to_le32(cpu->flags);
 606         disk->objectid = cpu_to_le64(cpu->objectid);
 607 }
 608
 609 static inline u64 btrfs_disk_key_objectid(struct btrfs_disk_key *disk)
 610 {
 611         return le64_to_cpu(disk->objectid);
 612 }
 613
 614 static inline void btrfs_set_disk_key_objectid(struct btrfs_disk_key *disk,
 615                                                u64 val)
 616 {
 617         disk->objectid = cpu_to_le64(val);
 618 }
 619
 620 static inline u64 btrfs_disk_key_offset(struct btrfs_disk_key *disk)
 621 {
 622         return le64_to_cpu(disk->offset);
 623 }
 624
 625 static inline void btrfs_set_disk_key_offset(struct btrfs_disk_key *disk,
 626                                              u64 val)
 627 {
 628         disk->offset = cpu_to_le64(val);
 629 }
 630
 631 static inline u32 btrfs_disk_key_flags(struct btrfs_disk_key *disk)
 632 {
 633         return le32_to_cpu(disk->flags);
 634 }
 635
 636 static inline void btrfs_set_disk_key_flags(struct btrfs_disk_key *disk,
 637                                             u32 val)
 638 {
 639         disk->flags = cpu_to_le32(val);
 640 }
 641
 642 static inline u32 btrfs_disk_key_type(struct btrfs_disk_key *key)
 643 {
 644         return le32_to_cpu(key->flags) >> BTRFS_KEY_TYPE_SHIFT;
 645 }
 646
 647 static inline void btrfs_set_disk_key_type(struct btrfs_disk_key *key,
 648                                                u32 val)
 649 {
 650         u32 flags = btrfs_disk_key_flags(key);
 651         BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
 652         val = val << BTRFS_KEY_TYPE_SHIFT;
 653         flags = (flags & ~BTRFS_KEY_TYPE_MASK) | val;
 654         btrfs_set_disk_key_flags(key, flags);
 655 }
 656
 657 static inline u32 btrfs_key_type(struct btrfs_key *key)
 658 {
 659         return key->flags >> BTRFS_KEY_TYPE_SHIFT;
 660 }
 661
 662 static inline void btrfs_set_key_type(struct btrfs_key *key, u32 val)
 663 {
 664         BUG_ON(val >= BTRFS_KEY_TYPE_MAX);
 665         val = val << BTRFS_KEY_TYPE_SHIFT;
 666         key->flags = (key->flags & ~(BTRFS_KEY_TYPE_MASK)) | val;
 667 }
 668
 669 static inline u64 btrfs_header_blocknr(struct btrfs_header *h)
 670 {
 671         return le64_to_cpu(h->blocknr);
 672 }
 673
 674 static inline void btrfs_set_header_blocknr(struct btrfs_header *h, u64 blocknr)
 675 {
 676         h->blocknr = cpu_to_le64(blocknr);
 677 }
 678
 679 static inline u64 btrfs_header_generation(struct btrfs_header *h)
 680 {
 681         return le64_to_cpu(h->generation);
 682 }
 683
 684 static inline void btrfs_set_header_generation(struct btrfs_header *h,
 685                                                u64 val)
 686 {
 687         h->generation = cpu_to_le64(val);
 688 }
 689
 690 static inline u64 btrfs_header_owner(struct btrfs_header *h)
 691 {
 692         return le64_to_cpu(h->owner);
 693 }
 694
 695 static inline void btrfs_set_header_owner(struct btrfs_header *h,
 696                                                u64 val)
 697 {
 698         h->owner = cpu_to_le64(val);
 699 }
 700
 701 static inline u16 btrfs_header_nritems(struct btrfs_header *h)
 702 {
 703         return le16_to_cpu(h->nritems);
 704 }
 705
 706 static inline void btrfs_set_header_nritems(struct btrfs_header *h, u16 val)
 707 {
 708         h->nritems = cpu_to_le16(val);
 709 }
 710
 711 static inline u16 btrfs_header_flags(struct btrfs_header *h)
 712 {
 713         return le16_to_cpu(h->flags);
 714 }
 715
 716 static inline void btrfs_set_header_flags(struct btrfs_header *h, u16 val)
 717 {
 718         h->flags = cpu_to_le16(val);
 719 }
 720
 721 static inline int btrfs_header_level(struct btrfs_header *h)
 722 {
 723         return h->level;
 724 }
 725
 726 static inline void btrfs_set_header_level(struct btrfs_header *h, int level)
 727 {
 728         BUG_ON(level > BTRFS_MAX_LEVEL);
 729         h->level = level;
 730 }
 731
 732 static inline int btrfs_is_leaf(struct btrfs_node *n)
 733 {
 734         return (btrfs_header_level(&n->header) == 0);
 735 }
 736
 737 static inline u64 btrfs_root_blocknr(struct btrfs_root_item *item)
 738 {
 739         return le64_to_cpu(item->blocknr);
 740 }
 741
 742 static inline void btrfs_set_root_blocknr(struct btrfs_root_item *item, u64 val)
 743 {
 744         item->blocknr = cpu_to_le64(val);
 745 }
 746
 747 static inline u64 btrfs_root_dirid(struct btrfs_root_item *item)
 748 {
 749         return le64_to_cpu(item->root_dirid);
 750 }
 751
 752 static inline void btrfs_set_root_dirid(struct btrfs_root_item *item, u64 val)
 753 {
 754         item->root_dirid = cpu_to_le64(val);
 755 }
 756
 757 static inline u32 btrfs_root_refs(struct btrfs_root_item *item)
 758 {
 759         return le32_to_cpu(item->refs);
 760 }
 761
 762 static inline void btrfs_set_root_refs(struct btrfs_root_item *item, u32 val)
 763 {
 764         item->refs = cpu_to_le32(val);
 765 }
 766
 767 static inline u64 btrfs_super_blocknr(struct btrfs_super_block *s)
 768 {
 769         return le64_to_cpu(s->blocknr);
 770 }
 771
 772 static inline void btrfs_set_super_blocknr(struct btrfs_super_block *s, u64 val)
 773 {
 774         s->blocknr = cpu_to_le64(val);
 775 }
 776
 777 static inline u64 btrfs_super_generation(struct btrfs_super_block *s)
 778 {
 779         return le64_to_cpu(s->generation);
 780 }
 781
 782 static inline void btrfs_set_super_generation(struct btrfs_super_block *s,
 783                                               u64 val)
 784 {
 785         s->generation = cpu_to_le64(val);
 786 }
 787
 788 static inline u64 btrfs_super_root(struct btrfs_super_block *s)
 789 {
 790         return le64_to_cpu(s->root);
 791 }
 792
 793 static inline void btrfs_set_super_root(struct btrfs_super_block *s, u64 val)
 794 {
 795         s->root = cpu_to_le64(val);
 796 }
 797
 798 static inline u64 btrfs_super_total_blocks(struct btrfs_super_block *s)
 799 {
 800         return le64_to_cpu(s->total_blocks);
 801 }
 802
 803 static inline void btrfs_set_super_total_blocks(struct btrfs_super_block *s,
 804                                                 u64 val)
 805 {
 806         s->total_blocks = cpu_to_le64(val);
 807 }
 808
 809 static inline u64 btrfs_super_blocks_used(struct btrfs_super_block *s)
 810 {
 811         return le64_to_cpu(s->blocks_used);
 812 }
 813
 814 static inline void btrfs_set_super_blocks_used(struct btrfs_super_block *s,
 815                                                 u64 val)
 816 {
 817         s->blocks_used = cpu_to_le64(val);
 818 }
 819
 820 static inline u32 btrfs_super_blocksize(struct btrfs_super_block *s)
 821 {
 822         return le32_to_cpu(s->blocksize);
 823 }
 824
 825 static inline void btrfs_set_super_blocksize(struct btrfs_super_block *s,
 826                                                 u32 val)
 827 {
 828         s->blocksize = cpu_to_le32(val);
 829 }
 830
 831 static inline u64 btrfs_super_root_dir(struct btrfs_super_block *s)
 832 {
 833         return le64_to_cpu(s->root_dir_objectid);
 834 }
 835
 836 static inline void btrfs_set_super_root_dir(struct btrfs_super_block *s, u64
 837                                             val)
 838 {
 839         s->root_dir_objectid = cpu_to_le64(val);
 840 }
 841
 842 static inline u64 btrfs_super_last_device_id(struct btrfs_super_block *s)
 843 {
 844         return le64_to_cpu(s->last_device_id);
 845 }
 846
 847 static inline void btrfs_set_super_last_device_id(struct btrfs_super_block *s,
 848                                                   u64 val)
 849 {
 850         s->last_device_id = cpu_to_le64(val);
 851 }
 852
 853 static inline u64 btrfs_super_device_id(struct btrfs_super_block *s)
 854 {
 855         return le64_to_cpu(s->device_id);
 856 }
 857
 858 static inline void btrfs_set_super_device_id(struct btrfs_super_block *s,
 859                                                   u64 val)
 860 {
 861         s->device_id = cpu_to_le64(val);
 862 }
 863
 864 static inline u64 btrfs_super_device_block_start(struct btrfs_super_block *s)
 865 {
 866         return le64_to_cpu(s->device_block_start);
 867 }
 868
 869 static inline void btrfs_set_super_device_block_start(struct btrfs_super_block
 870                                                       *s, u64 val)
 871 {
 872         s->device_block_start = cpu_to_le64(val);
 873 }
 874
 875 static inline u64 btrfs_super_device_num_blocks(struct btrfs_super_block *s)
 876 {
 877         return le64_to_cpu(s->device_num_blocks);
 878 }
 879
 880 static inline void btrfs_set_super_device_num_blocks(struct btrfs_super_block
 881                                                      *s, u64 val)
 882 {
 883         s->device_num_blocks = cpu_to_le64(val);
 884 }
 885
 886 static inline u64 btrfs_super_device_root(struct btrfs_super_block *s)
 887 {
 888         return le64_to_cpu(s->device_root);
 889 }
 890
 891 static inline void btrfs_set_super_device_root(struct btrfs_super_block
 892                                                       *s, u64 val)
 893 {
 894         s->device_root = cpu_to_le64(val);
 895 }
 896
 897
 898 static inline u8 *btrfs_leaf_data(struct btrfs_leaf *l)
 899 {
 900         return (u8 *)l->items;
 901 }
 902
 903 static inline int btrfs_file_extent_type(struct btrfs_file_extent_item *e)
 904 {
 905         return e->type;
 906 }
 907 static inline void btrfs_set_file_extent_type(struct btrfs_file_extent_item *e,
 908                                               u8 val)
 909 {
 910         e->type = val;
 911 }
 912
 913 static inline char *btrfs_file_extent_inline_start(struct
 914                                                    btrfs_file_extent_item *e)
 915 {
 916         return (char *)(&e->disk_blocknr);
 917 }
 918
 919 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
 920 {
 921         return (unsigned long)(&((struct
 922                   btrfs_file_extent_item *)NULL)->disk_blocknr) + datasize;
 923 }
 924
 925 static inline u32 btrfs_file_extent_inline_len(struct btrfs_item *e)
 926 {
 927         struct btrfs_file_extent_item *fe = NULL;
 928         return btrfs_item_size(e) - (unsigned long)(&fe->disk_blocknr);
 929 }
 930
 931 static inline u64 btrfs_file_extent_disk_blocknr(struct btrfs_file_extent_item
 932                                                  *e)
 933 {
 934         return le64_to_cpu(e->disk_blocknr);
 935 }
 936
 937 static inline void btrfs_set_file_extent_disk_blocknr(struct
 938                                                       btrfs_file_extent_item
 939                                                       *e, u64 val)
 940 {
 941         e->disk_blocknr = cpu_to_le64(val);
 942 }
 943
 944 static inline u64 btrfs_file_extent_generation(struct btrfs_file_extent_item *e)
 945 {
 946         return le64_to_cpu(e->generation);
 947 }
 948
 949 static inline void btrfs_set_file_extent_generation(struct
 950                                                     btrfs_file_extent_item *e,
 951                                                     u64 val)
 952 {
 953         e->generation = cpu_to_le64(val);
 954 }
 955
 956 static inline u64 btrfs_file_extent_disk_num_blocks(struct
 957                                                     btrfs_file_extent_item *e)
 958 {
 959         return le64_to_cpu(e->disk_num_blocks);
 960 }
 961
 962 static inline void btrfs_set_file_extent_disk_num_blocks(struct
 963                                                          btrfs_file_extent_item
 964                                                          *e, u64 val)
 965 {
 966         e->disk_num_blocks = cpu_to_le64(val);
 967 }
 968
 969 static inline u64 btrfs_file_extent_offset(struct btrfs_file_extent_item *e)
 970 {
 971         return le64_to_cpu(e->offset);
 972 }
 973
 974 static inline void btrfs_set_file_extent_offset(struct btrfs_file_extent_item
 975                                                 *e, u64 val)
 976 {
 977         e->offset = cpu_to_le64(val);
 978 }
 979
 980 static inline u64 btrfs_file_extent_num_blocks(struct btrfs_file_extent_item
 981                                                *e)
 982 {
 983         return le64_to_cpu(e->num_blocks);
 984 }
 985
 986 static inline void btrfs_set_file_extent_num_blocks(struct
 987                                                     btrfs_file_extent_item *e,
 988                                                     u64 val)
 989 {
 990         e->num_blocks = cpu_to_le64(val);
 991 }
 992
 993 static inline u16 btrfs_device_pathlen(struct btrfs_device_item *d)
 994 {
 995         return le16_to_cpu(d->pathlen);
 996 }
 997
 998 static inline void btrfs_set_device_pathlen(struct btrfs_device_item *d,
 999                                                 u16 val)
1000 {
1001         d->pathlen = cpu_to_le16(val);
1002 }
1003
1004 static inline u64 btrfs_device_id(struct btrfs_device_item *d)
1005 {
1006         return le64_to_cpu(d->device_id);
1007 }
1008
1009 static inline void btrfs_set_device_id(struct btrfs_device_item *d,
1010                                                 u64 val)
1011 {
1012         d->device_id = cpu_to_le64(val);
1013 }
1014
1015 static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
1016 {
1017         return sb->s_fs_info;
1018 }
1019
1020 static inline void btrfs_check_bounds(void *vptr, size_t len,
1021                                      void *vcontainer, size_t container_len)
1022 {
1023         char *ptr = vptr;
1024         char *container = vcontainer;
1025         WARN_ON(ptr < container);
1026         WARN_ON(ptr + len > container + container_len);
1027 }
1028
1029 static inline void btrfs_memcpy(struct btrfs_root *root,
1030                                 void *dst_block,
1031                                 void *dst, const void *src, size_t nr)
1032 {
1033         btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
1034         memcpy(dst, src, nr);
1035 }
1036
1037 static inline void btrfs_memmove(struct btrfs_root *root,
1038                                 void *dst_block,
1039                                 void *dst, void *src, size_t nr)
1040 {
1041         btrfs_check_bounds(dst, nr, dst_block, root->fs_info->sb->s_blocksize);
1042         memmove(dst, src, nr);
1043 }
1044
1045 static inline void btrfs_mark_buffer_dirty(struct buffer_head *bh)
1046 {
1047         WARN_ON(!atomic_read(&bh->b_count));
1048         mark_buffer_dirty(bh);
1049 }
1050
1051 /* helper function to cast into the data area of the leaf. */
1052 #define btrfs_item_ptr(leaf, slot, type) \
1053         ((type *)(btrfs_leaf_data(leaf) + \
1054         btrfs_item_offset((leaf)->items + (slot))))
1055
1056 /* extent-tree.c */
1057 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
1058                        struct btrfs_root *root);
1059 struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
1060                                             struct btrfs_root *root);
1061 int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
1062                        struct btrfs_root *root, u64 owner,
1063                        u64 num_blocks, u64 search_start,
1064                        u64 search_end, struct btrfs_key *ins);
1065 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1066                   struct buffer_head *buf);
1067 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
1068                       *root, u64 blocknr, u64 num_blocks, int pin);
1069 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, struct
1070                                btrfs_root *root);
1071 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1072                                 struct btrfs_root *root,
1073                                 u64 blocknr, u64 num_blocks);
1074 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
1075                                     struct btrfs_root *root);
1076 int btrfs_free_block_groups(struct btrfs_fs_info *info);
1077 int btrfs_read_block_groups(struct btrfs_root *root);
1078 /* ctree.c */
1079 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
1080                       *root, struct btrfs_path *path, u32 data_size);
1081 int btrfs_truncate_item(struct btrfs_trans_handle *trans,
1082                         struct btrfs_root *root,
1083                         struct btrfs_path *path,
1084                         u32 new_size);
1085 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
1086                       *root, struct btrfs_key *key, struct btrfs_path *p, int
1087                       ins_len, int cow);
1088 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
1089 struct btrfs_path *btrfs_alloc_path(void);
1090 void btrfs_free_path(struct btrfs_path *p);
1091 void btrfs_init_path(struct btrfs_path *p);
1092 int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1093                    struct btrfs_path *path);
1094 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
1095                       *root, struct btrfs_key *key, void *data, u32 data_size);
1096 int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
1097                             *root, struct btrfs_path *path, struct btrfs_key
1098                             *cpu_key, u32 data_size);
1099 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
1100 int btrfs_leaf_free_space(struct btrfs_root *root, struct btrfs_leaf *leaf);
1101 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
1102                         *root, struct buffer_head *snap);
1103 /* root-item.c */
1104 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1105                    struct btrfs_key *key);
1106 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
1107                       *root, struct btrfs_key *key, struct btrfs_root_item
1108                       *item);
1109 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
1110                       *root, struct btrfs_key *key, struct btrfs_root_item
1111                       *item);
1112 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
1113                          btrfs_root_item *item, struct btrfs_key *key);
1114 /* dir-item.c */
1115 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
1116                           *root, const char *name, int name_len, u64 dir,
1117                           struct btrfs_key *location, u8 type);
1118 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
1119                                              struct btrfs_root *root,
1120                                              struct btrfs_path *path, u64 dir,
1121                                              const char *name, int name_len,
1122                                              int mod);
1123 struct btrfs_dir_item *
1124 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
1125                             struct btrfs_root *root,
1126                             struct btrfs_path *path, u64 dir,
1127                             u64 objectid, const char *name, int name_len,
1128                             int mod);
1129 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
1130                               struct btrfs_path *path,
1131                               const char *name, int name_len);
1132 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
1133                               struct btrfs_root *root,
1134                               struct btrfs_path *path,
1135                               struct btrfs_dir_item *di);
1136 /* inode-map.c */
1137 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
1138                              struct btrfs_root *fs_root,
1139                              u64 dirid, u64 *objectid);
1140 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
1141
1142 /* inode-item.c */
1143 int btrfs_insert_inode(struct btrfs_trans_handle *trans, struct btrfs_root
1144                        *root, u64 objectid, struct btrfs_inode_item
1145                        *inode_item);
1146 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
1147                        *root, struct btrfs_path *path,
1148                        struct btrfs_key *location, int mod);
1149
1150 /* file-item.c */
1151 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
1152                                struct btrfs_root *root,
1153                                u64 objectid, u64 pos, u64 offset,
1154                                u64 num_blocks);
1155 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
1156                              struct btrfs_root *root,
1157                              struct btrfs_path *path, u64 objectid,
1158                              u64 blocknr, int mod);
1159 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
1160                           struct btrfs_root *root,
1161                           u64 objectid, u64 offset,
1162                           char *data, size_t len);
1163 int btrfs_csum_verify_file_block(struct btrfs_root *root,
1164                                  u64 objectid, u64 offset,
1165                                  char *data, size_t len);
1166 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
1167                                           struct btrfs_root *root,
1168                                           struct btrfs_path *path,
1169                                           u64 objectid, u64 offset,
1170                                           int cow);
1171 /* super.c */
1172 extern struct subsystem btrfs_subsys;
1173
1174 #endif