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__
  20 #define __BTRFS__
  21
  22 #include <linux/mm.h>
  23 #include <linux/highmem.h>
  24 #include <linux/fs.h>
  25 #include <linux/workqueue.h>
  26 #include <linux/completion.h>
  27 #include <asm/kmap_types.h>
  28 #include "bit-radix.h"
  29 #include "extent_map.h"
  30
  31 struct btrfs_trans_handle;
  32 struct btrfs_transaction;
  33 extern struct kmem_cache *btrfs_trans_handle_cachep;
  34 extern struct kmem_cache *btrfs_transaction_cachep;
  35 extern struct kmem_cache *btrfs_bit_radix_cachep;
  36 extern struct kmem_cache *btrfs_path_cachep;
  37
  38 #define BTRFS_MAGIC "_B2RfS_M"
  39
  40 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
  41 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
  42 #define BTRFS_FS_TREE_OBJECTID 3ULL
  43 #define BTRFS_ROOT_TREE_DIR_OBJECTID 4ULL
  44 #define BTRFS_FIRST_FREE_OBJECTID 5ULL
  45
  46 /*
  47  * we can actually store much bigger names, but lets not confuse the rest
  48  * of linux
  49  */
  50 #define BTRFS_NAME_LEN 255
  51
  52 /* 32 bytes in various csum fields */
  53 #define BTRFS_CSUM_SIZE 32
  54 /* four bytes for CRC32 */
  55 #define BTRFS_CRC32_SIZE 4
  56 #define BTRFS_EMPTY_DIR_SIZE 6
  57
  58 #define BTRFS_FT_UNKNOWN        0
  59 #define BTRFS_FT_REG_FILE       1
  60 #define BTRFS_FT_DIR            2
  61 #define BTRFS_FT_CHRDEV         3
  62 #define BTRFS_FT_BLKDEV         4
  63 #define BTRFS_FT_FIFO           5
  64 #define BTRFS_FT_SOCK           6
  65 #define BTRFS_FT_SYMLINK        7
  66 #define BTRFS_FT_XATTR          8
  67 #define BTRFS_FT_MAX            9
  68
  69 /*
  70  * the key defines the order in the tree, and so it also defines (optimal)
  71  * block layout.  objectid corresonds to the inode number.  The flags
  72  * tells us things about the object, and is a kind of stream selector.
  73  * so for a given inode, keys with flags of 1 might refer to the inode
  74  * data, flags of 2 may point to file data in the btree and flags == 3
  75  * may point to extents.
  76  *
  77  * offset is the starting byte offset for this key in the stream.
  78  *
  79  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
  80  * in cpu native order.  Otherwise they are identical and their sizes
  81  * should be the same (ie both packed)
  82  */
  83 struct btrfs_disk_key {
  84         __le64 objectid;
  85         u8 type;
  86         __le64 offset;
  87 } __attribute__ ((__packed__));
  88
  89 struct btrfs_key {
  90         u64 objectid;
  91         u8 type;
  92         u64 offset;
  93 } __attribute__ ((__packed__));
  94
  95 #define BTRFS_FSID_SIZE 16
  96 /*
  97  * every tree block (leaf or node) starts with this header.
  98  */
  99 struct btrfs_header {
 100         u8 csum[BTRFS_CSUM_SIZE];
 101         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
 102         __le64 bytenr; /* which block this node is supposed to live in */
 103         __le64 generation;
 104         __le64 owner;
 105         __le32 nritems;
 106         __le16 flags;
 107         u8 level;
 108 } __attribute__ ((__packed__));
 109
 110 #define BTRFS_MAX_LEVEL 8
 111 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
 112                                 sizeof(struct btrfs_header)) / \
 113                                 sizeof(struct btrfs_key_ptr))
 114 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
 115 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
 116 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
 117                                         sizeof(struct btrfs_item) - \
 118                                         sizeof(struct btrfs_file_extent_item))
 119
 120 /*
 121  * the super block basically lists the main trees of the FS
 122  * it currently lacks any block count etc etc
 123  */
 124 struct btrfs_super_block {
 125         u8 csum[BTRFS_CSUM_SIZE];
 126         /* the first 3 fields must match struct btrfs_header */
 127         u8 fsid[16];    /* FS specific uuid */
 128         __le64 bytenr; /* this block number */
 129         __le64 magic;
 130         __le64 generation;
 131         __le64 root;
 132         __le64 total_bytes;
 133         __le64 bytes_used;
 134         __le64 root_dir_objectid;
 135         __le32 sectorsize;
 136         __le32 nodesize;
 137         __le32 leafsize;
 138         __le32 stripesize;
 139         u8 root_level;
 140 } __attribute__ ((__packed__));
 141
 142 /*
 143  * A leaf is full of items. offset and size tell us where to find
 144  * the item in the leaf (relative to the start of the data area)
 145  */
 146 struct btrfs_item {
 147         struct btrfs_disk_key key;
 148         __le32 offset;
 149         __le32 size;
 150 } __attribute__ ((__packed__));
 151
 152 /*
 153  * leaves have an item area and a data area:
 154  * [item0, item1....itemN] [free space] [dataN...data1, data0]
 155  *
 156  * The data is separate from the items to get the keys closer together
 157  * during searches.
 158  */
 159 struct btrfs_leaf {
 160         struct btrfs_header header;
 161         struct btrfs_item items[];
 162 } __attribute__ ((__packed__));
 163
 164 /*
 165  * all non-leaf blocks are nodes, they hold only keys and pointers to
 166  * other blocks
 167  */
 168 struct btrfs_key_ptr {
 169         struct btrfs_disk_key key;
 170         __le64 blockptr;
 171         __le64 generation;
 172 } __attribute__ ((__packed__));
 173
 174 struct btrfs_node {
 175         struct btrfs_header header;
 176         struct btrfs_key_ptr ptrs[];
 177 } __attribute__ ((__packed__));
 178
 179 /*
 180  * btrfs_paths remember the path taken from the root down to the leaf.
 181  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
 182  * to any other levels that are present.
 183  *
 184  * The slots array records the index of the item or block pointer
 185  * used while walking the tree.
 186  */
 187 struct btrfs_path {
 188         struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
 189         int slots[BTRFS_MAX_LEVEL];
 190         int reada;
 191         int lowest_level;
 192 };
 193
 194 /*
 195  * items in the extent btree are used to record the objectid of the
 196  * owner of the block and the number of references
 197  */
 198 struct btrfs_extent_item {
 199         __le32 refs;
 200 } __attribute__ ((__packed__));
 201
 202 struct btrfs_extent_ref {
 203         __le64 root;
 204         __le64 generation;
 205         __le64 objectid;
 206         __le64 offset;
 207 } __attribute__ ((__packed__));
 208
 209 struct btrfs_inode_timespec {
 210         __le64 sec;
 211         __le32 nsec;
 212 } __attribute__ ((__packed__));
 213
 214 /*
 215  * there is no padding here on purpose.  If you want to extent the inode,
 216  * make a new item type
 217  */
 218 struct btrfs_inode_item {
 219         __le64 generation;
 220         __le64 size;
 221         __le64 nblocks;
 222         __le64 block_group;
 223         __le32 nlink;
 224         __le32 uid;
 225         __le32 gid;
 226         __le32 mode;
 227         __le32 rdev;
 228         __le16 flags;
 229         __le16 compat_flags;
 230         struct btrfs_inode_timespec atime;
 231         struct btrfs_inode_timespec ctime;
 232         struct btrfs_inode_timespec mtime;
 233         struct btrfs_inode_timespec otime;
 234 } __attribute__ ((__packed__));
 235
 236 struct btrfs_dir_item {
 237         struct btrfs_disk_key location;
 238         __le16 data_len;
 239         __le16 name_len;
 240         u8 type;
 241 } __attribute__ ((__packed__));
 242
 243 struct btrfs_root_item {
 244         struct btrfs_inode_item inode;
 245         __le64 root_dirid;
 246         __le64 bytenr;
 247         __le64 byte_limit;
 248         __le64 bytes_used;
 249         __le32 flags;
 250         __le32 refs;
 251         struct btrfs_disk_key drop_progress;
 252         u8 drop_level;
 253         u8 level;
 254 } __attribute__ ((__packed__));
 255
 256 #define BTRFS_FILE_EXTENT_REG 0
 257 #define BTRFS_FILE_EXTENT_INLINE 1
 258
 259 struct btrfs_file_extent_item {
 260         __le64 generation;
 261         u8 type;
 262         /*
 263          * disk space consumed by the extent, checksum blocks are included
 264          * in these numbers
 265          */
 266         __le64 disk_bytenr;
 267         __le64 disk_num_bytes;
 268         /*
 269          * the logical offset in file blocks (no csums)
 270          * this extent record is for.  This allows a file extent to point
 271          * into the middle of an existing extent on disk, sharing it
 272          * between two snapshots (useful if some bytes in the middle of the
 273          * extent have changed
 274          */
 275         __le64 offset;
 276         /*
 277          * the logical number of file blocks (no csums included)
 278          */
 279         __le64 num_bytes;
 280 } __attribute__ ((__packed__));
 281
 282 struct btrfs_csum_item {
 283         u8 csum;
 284 } __attribute__ ((__packed__));
 285
 286 /* tag for the radix tree of block groups in ram */
 287 #define BTRFS_BLOCK_GROUP_SIZE (256 * 1024 * 1024)
 288
 289
 290 #define BTRFS_BLOCK_GROUP_DATA 1
 291 #define BTRFS_BLOCK_GROUP_MIXED 2
 292
 293 struct btrfs_block_group_item {
 294         __le64 used;
 295         u8 flags;
 296 } __attribute__ ((__packed__));
 297
 298 struct btrfs_block_group_cache {
 299         struct btrfs_key key;
 300         struct btrfs_block_group_item item;
 301         int data;
 302         int cached;
 303         u64 pinned;
 304 };
 305 struct btrfs_fs_info {
 306         u8 fsid[BTRFS_FSID_SIZE];
 307         struct btrfs_root *extent_root;
 308         struct btrfs_root *tree_root;
 309         struct radix_tree_root fs_roots_radix;
 310
 311         struct extent_map_tree free_space_cache;
 312         struct extent_map_tree block_group_cache;
 313         struct extent_map_tree pinned_extents;
 314         struct extent_map_tree pending_del;
 315         struct extent_map_tree extent_ins;
 316
 317         u64 generation;
 318         u64 last_trans_committed;
 319         struct btrfs_transaction *running_transaction;
 320         struct btrfs_super_block super_copy;
 321         struct extent_buffer *sb_buffer;
 322         struct super_block *sb;
 323         struct inode *btree_inode;
 324         spinlock_t hash_lock;
 325         struct mutex trans_mutex;
 326         struct mutex fs_mutex;
 327         struct list_head trans_list;
 328         struct list_head hashers;
 329         struct list_head dead_roots;
 330         struct delayed_work trans_work;
 331         struct kobject super_kobj;
 332         struct completion kobj_unregister;
 333         int do_barriers;
 334         int closing;
 335
 336         u64 total_pinned;
 337 };
 338 /*
 339  * in ram representation of the tree.  extent_root is used for all allocations
 340  * and for the extent tree extent_root root.
 341  */
 342 struct btrfs_root {
 343         struct extent_buffer *node;
 344         struct extent_buffer *commit_root;
 345         struct btrfs_root_item root_item;
 346         struct btrfs_key root_key;
 347         struct btrfs_fs_info *fs_info;
 348         struct inode *inode;
 349         struct kobject root_kobj;
 350         struct completion kobj_unregister;
 351         struct rw_semaphore snap_sem;
 352         u64 objectid;
 353         u64 last_trans;
 354
 355         /* data allocations are done in sectorsize units */
 356         u32 sectorsize;
 357
 358         /* node allocations are done in nodesize units */
 359         u32 nodesize;
 360
 361         /* leaf allocations are done in leafsize units */
 362         u32 leafsize;
 363
 364         u32 stripesize;
 365
 366         u32 type;
 367         u64 highest_inode;
 368         u64 last_inode_alloc;
 369         int ref_cows;
 370         struct btrfs_key defrag_progress;
 371         int defrag_running;
 372         int defrag_level;
 373         char *name;
 374 };
 375
 376 /*
 377  * inode items have the data typically returned from stat and store other
 378  * info about object characteristics.  There is one for every file and dir in
 379  * the FS
 380  */
 381 #define BTRFS_INODE_ITEM_KEY            1
 382 #define BTRFS_XATTR_ITEM_KEY            2
 383 /* reserve 2-15 close to the inode for later flexibility */
 384
 385 /*
 386  * dir items are the name -> inode pointers in a directory.  There is one
 387  * for every name in a directory.
 388  */
 389 #define BTRFS_DIR_ITEM_KEY      16
 390 #define BTRFS_DIR_INDEX_KEY     17
 391 /*
 392  * extent data is for file data
 393  */
 394 #define BTRFS_EXTENT_DATA_KEY   18
 395 /*
 396  * csum items have the checksums for data in the extents
 397  */
 398 #define BTRFS_CSUM_ITEM_KEY     19
 399
 400 /* reserve 20-31 for other file stuff */
 401
 402 /*
 403  * root items point to tree roots.  There are typically in the root
 404  * tree used by the super block to find all the other trees
 405  */
 406 #define BTRFS_ROOT_ITEM_KEY     32
 407 /*
 408  * extent items are in the extent map tree.  These record which blocks
 409  * are used, and how many references there are to each block
 410  */
 411 #define BTRFS_EXTENT_ITEM_KEY   33
 412 #define BTRFS_EXTENT_REF_KEY    34
 413
 414 /*
 415  * block groups give us hints into the extent allocation trees.  Which
 416  * blocks are free etc etc
 417  */
 418 #define BTRFS_BLOCK_GROUP_ITEM_KEY 50
 419
 420 /*
 421  * string items are for debugging.  They just store a short string of
 422  * data in the FS
 423  */
 424 #define BTRFS_STRING_ITEM_KEY   253
 425
 426 /* some macros to generate set/get funcs for the struct fields.  This
 427  * assumes there is a lefoo_to_cpu for every type, so lets make a simple
 428  * one for u8:
 429  */
 430 #define le8_to_cpu(v) (v)
 431 #define cpu_to_le8(v) (v)
 432 #define __le8 u8
 433
 434 #define read_eb_member(eb, ptr, type, member, result) (                 \
 435         read_extent_buffer(eb, (char *)(result),                        \
 436                            ((unsigned long)(ptr)) +                     \
 437                             offsetof(type, member),                     \
 438                            sizeof(((type *)0)->member)))
 439
 440 #define write_eb_member(eb, ptr, type, member, result) (                \
 441         write_extent_buffer(eb, (char *)(result),                       \
 442                            ((unsigned long)(ptr)) +                     \
 443                             offsetof(type, member),                     \
 444                            sizeof(((type *)0)->member)))
 445
 446 #ifndef BTRFS_SETGET_FUNCS
 447 #define BTRFS_SETGET_FUNCS(name, type, member, bits)                    \
 448 u##bits btrfs_##name(struct extent_buffer *eb, type *s);                \
 449 void btrfs_set_##name(struct extent_buffer *eb, type *s, u##bits val);
 450 #endif
 451
 452 #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits)             \
 453 static inline u##bits btrfs_##name(struct extent_buffer *eb)            \
 454 {                                                                       \
 455         char *kaddr = kmap_atomic(eb->first_page, KM_USER0);            \
 456         unsigned long offset = offsetof(type, member);                  \
 457         u##bits res;                                                    \
 458         __le##bits *tmp = (__le##bits *)(kaddr + offset);               \
 459         res = le##bits##_to_cpu(*tmp);                                  \
 460         kunmap_atomic(kaddr, KM_USER0);                                 \
 461         return res;                                                     \
 462 }                                                                       \
 463 static inline void btrfs_set_##name(struct extent_buffer *eb,           \
 464                                     u##bits val)                        \
 465 {                                                                       \
 466         char *kaddr = kmap_atomic(eb->first_page, KM_USER0);            \
 467         unsigned long offset = offsetof(type, member);                  \
 468         __le##bits *tmp = (__le##bits *)(kaddr + offset);               \
 469         *tmp = cpu_to_le##bits(val);                                    \
 470         kunmap_atomic(kaddr, KM_USER0);                                 \
 471 }
 472
 473 #define BTRFS_SETGET_STACK_FUNCS(name, type, member, bits)              \
 474 static inline u##bits btrfs_##name(type *s)                             \
 475 {                                                                       \
 476         return le##bits##_to_cpu(s->member);                            \
 477 }                                                                       \
 478 static inline void btrfs_set_##name(type *s, u##bits val)               \
 479 {                                                                       \
 480         s->member = cpu_to_le##bits(val);                               \
 481 }
 482
 483 /* struct btrfs_block_group_item */
 484 BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
 485                          used, 64);
 486 BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
 487                          used, 64);
 488
 489 /* struct btrfs_inode_item */
 490 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
 491 BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
 492 BTRFS_SETGET_FUNCS(inode_nblocks, struct btrfs_inode_item, nblocks, 64);
 493 BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
 494 BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
 495 BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
 496 BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
 497 BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
 498 BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 32);
 499 BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 16);
 500 BTRFS_SETGET_FUNCS(inode_compat_flags, struct btrfs_inode_item,
 501                    compat_flags, 16);
 502
 503 static inline struct btrfs_inode_timespec *
 504 btrfs_inode_atime(struct btrfs_inode_item *inode_item)
 505 {
 506         unsigned long ptr = (unsigned long)inode_item;
 507         ptr += offsetof(struct btrfs_inode_item, atime);
 508         return (struct btrfs_inode_timespec *)ptr;
 509 }
 510
 511 static inline struct btrfs_inode_timespec *
 512 btrfs_inode_mtime(struct btrfs_inode_item *inode_item)
 513 {
 514         unsigned long ptr = (unsigned long)inode_item;
 515         ptr += offsetof(struct btrfs_inode_item, mtime);
 516         return (struct btrfs_inode_timespec *)ptr;
 517 }
 518
 519 static inline struct btrfs_inode_timespec *
 520 btrfs_inode_ctime(struct btrfs_inode_item *inode_item)
 521 {
 522         unsigned long ptr = (unsigned long)inode_item;
 523         ptr += offsetof(struct btrfs_inode_item, ctime);
 524         return (struct btrfs_inode_timespec *)ptr;
 525 }
 526
 527 static inline struct btrfs_inode_timespec *
 528 btrfs_inode_otime(struct btrfs_inode_item *inode_item)
 529 {
 530         unsigned long ptr = (unsigned long)inode_item;
 531         ptr += offsetof(struct btrfs_inode_item, otime);
 532         return (struct btrfs_inode_timespec *)ptr;
 533 }
 534
 535 BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_inode_timespec, sec, 64);
 536 BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_inode_timespec, nsec, 32);
 537
 538 /* struct btrfs_extent_item */
 539 BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 32);
 540
 541 /* struct btrfs_extent_ref */
 542 BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);
 543 BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64);
 544 BTRFS_SETGET_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64);
 545 BTRFS_SETGET_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64);
 546
 547 BTRFS_SETGET_STACK_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);
 548 BTRFS_SETGET_STACK_FUNCS(ref_generation, struct btrfs_extent_ref,
 549                          generation, 64);
 550 BTRFS_SETGET_STACK_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64);
 551 BTRFS_SETGET_STACK_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64);
 552
 553 BTRFS_SETGET_STACK_FUNCS(stack_extent_refs, struct btrfs_extent_item,
 554                          refs, 32);
 555
 556 /* struct btrfs_node */
 557 BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
 558 BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
 559
 560 static inline u64 btrfs_node_blockptr(struct extent_buffer *eb, int nr)
 561 {
 562         unsigned long ptr;
 563         ptr = offsetof(struct btrfs_node, ptrs) +
 564                 sizeof(struct btrfs_key_ptr) * nr;
 565         return btrfs_key_blockptr(eb, (struct btrfs_key_ptr *)ptr);
 566 }
 567
 568 static inline void btrfs_set_node_blockptr(struct extent_buffer *eb,
 569                                            int nr, u64 val)
 570 {
 571         unsigned long ptr;
 572         ptr = offsetof(struct btrfs_node, ptrs) +
 573                 sizeof(struct btrfs_key_ptr) * nr;
 574         btrfs_set_key_blockptr(eb, (struct btrfs_key_ptr *)ptr, val);
 575 }
 576
 577 static inline u64 btrfs_node_ptr_generation(struct extent_buffer *eb, int nr)
 578 {
 579         unsigned long ptr;
 580         ptr = offsetof(struct btrfs_node, ptrs) +
 581                 sizeof(struct btrfs_key_ptr) * nr;
 582         return btrfs_key_generation(eb, (struct btrfs_key_ptr *)ptr);
 583 }
 584
 585 static inline void btrfs_set_node_ptr_generation(struct extent_buffer *eb,
 586                                                  int nr, u64 val)
 587 {
 588         unsigned long ptr;
 589         ptr = offsetof(struct btrfs_node, ptrs) +
 590                 sizeof(struct btrfs_key_ptr) * nr;
 591         btrfs_set_key_generation(eb, (struct btrfs_key_ptr *)ptr, val);
 592 }
 593
 594 static inline unsigned long btrfs_node_key_ptr_offset(int nr)
 595 {
 596         return offsetof(struct btrfs_node, ptrs) +
 597                 sizeof(struct btrfs_key_ptr) * nr;
 598 }
 599
 600 void btrfs_node_key(struct extent_buffer *eb,
 601                     struct btrfs_disk_key *disk_key, int nr);
 602
 603 static inline void btrfs_set_node_key(struct extent_buffer *eb,
 604                                       struct btrfs_disk_key *disk_key, int nr)
 605 {
 606         unsigned long ptr;
 607         ptr = btrfs_node_key_ptr_offset(nr);
 608         write_eb_member(eb, (struct btrfs_key_ptr *)ptr,
 609                        struct btrfs_key_ptr, key, disk_key);
 610 }
 611
 612 /* struct btrfs_item */
 613 BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
 614 BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
 615
 616 static inline unsigned long btrfs_item_nr_offset(int nr)
 617 {
 618         return offsetof(struct btrfs_leaf, items) +
 619                 sizeof(struct btrfs_item) * nr;
 620 }
 621
 622 static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
 623                                                int nr)
 624 {
 625         return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 626 }
 627
 628 static inline u32 btrfs_item_end(struct extent_buffer *eb,
 629                                  struct btrfs_item *item)
 630 {
 631         return btrfs_item_offset(eb, item) + btrfs_item_size(eb, item);
 632 }
 633
 634 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
 635 {
 636         return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
 637 }
 638
 639 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
 640 {
 641         return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
 642 }
 643
 644 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
 645 {
 646         return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
 647 }
 648
 649 static inline void btrfs_item_key(struct extent_buffer *eb,
 650                            struct btrfs_disk_key *disk_key, int nr)
 651 {
 652         struct btrfs_item *item = btrfs_item_nr(eb, nr);
 653         read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 654 }
 655
 656 static inline void btrfs_set_item_key(struct extent_buffer *eb,
 657                                struct btrfs_disk_key *disk_key, int nr)
 658 {
 659         struct btrfs_item *item = btrfs_item_nr(eb, nr);
 660         write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 661 }
 662
 663 /* struct btrfs_dir_item */
 664 BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
 665 BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
 666 BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
 667
 668 static inline void btrfs_dir_item_key(struct extent_buffer *eb,
 669                                       struct btrfs_dir_item *item,
 670                                       struct btrfs_disk_key *key)
 671 {
 672         read_eb_member(eb, item, struct btrfs_dir_item, location, key);
 673 }
 674
 675 static inline void btrfs_set_dir_item_key(struct extent_buffer *eb,
 676                                           struct btrfs_dir_item *item,
 677                                           struct btrfs_disk_key *key)
 678 {
 679         write_eb_member(eb, item, struct btrfs_dir_item, location, key);
 680 }
 681
 682 /* struct btrfs_disk_key */
 683 BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
 684                          objectid, 64);
 685 BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
 686 BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
 687
 688 static inline void btrfs_disk_key_to_cpu(struct btrfs_key *cpu,
 689                                          struct btrfs_disk_key *disk)
 690 {
 691         cpu->offset = le64_to_cpu(disk->offset);
 692         cpu->type = disk->type;
 693         cpu->objectid = le64_to_cpu(disk->objectid);
 694 }
 695
 696 static inline void btrfs_cpu_key_to_disk(struct btrfs_disk_key *disk,
 697                                          struct btrfs_key *cpu)
 698 {
 699         disk->offset = cpu_to_le64(cpu->offset);
 700         disk->type = cpu->type;
 701         disk->objectid = cpu_to_le64(cpu->objectid);
 702 }
 703
 704 static inline void btrfs_node_key_to_cpu(struct extent_buffer *eb,
 705                                   struct btrfs_key *key, int nr)
 706 {
 707         struct btrfs_disk_key disk_key;
 708         btrfs_node_key(eb, &disk_key, nr);
 709         btrfs_disk_key_to_cpu(key, &disk_key);
 710 }
 711
 712 static inline void btrfs_item_key_to_cpu(struct extent_buffer *eb,
 713                                   struct btrfs_key *key, int nr)
 714 {
 715         struct btrfs_disk_key disk_key;
 716         btrfs_item_key(eb, &disk_key, nr);
 717         btrfs_disk_key_to_cpu(key, &disk_key);
 718 }
 719
 720 static inline void btrfs_dir_item_key_to_cpu(struct extent_buffer *eb,
 721                                       struct btrfs_dir_item *item,
 722                                       struct btrfs_key *key)
 723 {
 724         struct btrfs_disk_key disk_key;
 725         btrfs_dir_item_key(eb, item, &disk_key);
 726         btrfs_disk_key_to_cpu(key, &disk_key);
 727 }
 728
 729
 730 static inline u8 btrfs_key_type(struct btrfs_key *key)
 731 {
 732         return key->type;
 733 }
 734
 735 static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
 736 {
 737         key->type = val;
 738 }
 739
 740 /* struct btrfs_header */
 741 BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
 742 BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
 743                           generation, 64);
 744 BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
 745 BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
 746 BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 16);
 747 BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
 748
 749 static inline u8 *btrfs_header_fsid(struct extent_buffer *eb)
 750 {
 751         unsigned long ptr = offsetof(struct btrfs_header, fsid);
 752         return (u8 *)ptr;
 753 }
 754
 755 static inline u8 *btrfs_super_fsid(struct extent_buffer *eb)
 756 {
 757         unsigned long ptr = offsetof(struct btrfs_super_block, fsid);
 758         return (u8 *)ptr;
 759 }
 760
 761 static inline u8 *btrfs_header_csum(struct extent_buffer *eb)
 762 {
 763         unsigned long ptr = offsetof(struct btrfs_header, csum);
 764         return (u8 *)ptr;
 765 }
 766
 767 static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
 768 {
 769         return NULL;
 770 }
 771
 772 static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
 773 {
 774         return NULL;
 775 }
 776
 777 static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
 778 {
 779         return NULL;
 780 }
 781
 782 static inline int btrfs_is_leaf(struct extent_buffer *eb)
 783 {
 784         return (btrfs_header_level(eb) == 0);
 785 }
 786
 787 /* struct btrfs_root_item */
 788 BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
 789 BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
 790 BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
 791
 792 BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
 793 BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
 794 BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
 795 BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
 796 BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 32);
 797 BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
 798 BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
 799
 800 /* struct btrfs_super_block */
 801 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
 802 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
 803                          generation, 64);
 804 BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
 805 BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
 806                          root_level, 8);
 807 BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
 808                          total_bytes, 64);
 809 BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
 810                          bytes_used, 64);
 811 BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
 812                          sectorsize, 32);
 813 BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
 814                          nodesize, 32);
 815 BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
 816                          leafsize, 32);
 817 BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
 818                          stripesize, 32);
 819 BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
 820                          root_dir_objectid, 64);
 821
 822 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
 823 {
 824         return offsetof(struct btrfs_leaf, items);
 825 }
 826
 827 /* struct btrfs_file_extent_item */
 828 BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
 829
 830 static inline unsigned long btrfs_file_extent_inline_start(struct
 831                                                    btrfs_file_extent_item *e)
 832 {
 833         unsigned long offset = (unsigned long)e;
 834         offset += offsetof(struct btrfs_file_extent_item, disk_bytenr);
 835         return offset;
 836 }
 837
 838 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
 839 {
 840         return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
 841 }
 842
 843 static inline u32 btrfs_file_extent_inline_len(struct extent_buffer *eb,
 844                                                struct btrfs_item *e)
 845 {
 846         unsigned long offset;
 847         offset = offsetof(struct btrfs_file_extent_item, disk_bytenr);
 848         return btrfs_item_size(eb, e) - offset;
 849 }
 850
 851 BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
 852                    disk_bytenr, 64);
 853 BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
 854                    generation, 64);
 855 BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
 856                    disk_num_bytes, 64);
 857 BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
 858                   offset, 64);
 859 BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
 860                    num_bytes, 64);
 861
 862 static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
 863 {
 864         return sb->s_fs_info;
 865 }
 866
 867 static inline int btrfs_set_root_name(struct btrfs_root *root,
 868                                       const char *name, int len)
 869 {
 870         /* if we already have a name just free it */
 871         if (root->name)
 872                 kfree(root->name);
 873
 874         root->name = kmalloc(len+1, GFP_KERNEL);
 875         if (!root->name)
 876                 return -ENOMEM;
 877
 878         memcpy(root->name, name, len);
 879         root->name[len] ='\0';
 880
 881         return 0;
 882 }
 883
 884 static inline u32 btrfs_level_size(struct btrfs_root *root, int level) {
 885         if (level == 0)
 886                 return root->leafsize;
 887         return root->nodesize;
 888 }
 889
 890 /* helper function to cast into the data area of the leaf. */
 891 #define btrfs_item_ptr(leaf, slot, type) \
 892         ((type *)(btrfs_leaf_data(leaf) + \
 893         btrfs_item_offset_nr(leaf, slot)))
 894
 895 #define btrfs_item_ptr_offset(leaf, slot) \
 896         ((unsigned long)(btrfs_leaf_data(leaf) + \
 897         btrfs_item_offset_nr(leaf, slot)))
 898
 899 /* mount option defines and helpers */
 900 #define BTRFS_MOUNT_SUBVOL              0x000001
 901 #define btrfs_clear_opt(o, opt)         o &= ~BTRFS_MOUNT_##opt
 902 #define btrfs_set_opt(o, opt)           o |= BTRFS_MOUNT_##opt
 903 #define btrfs_test_opt(sb, opt)         (BTRFS_SB(sb)->s_mount_opt & \
 904                                          BTRFS_MOUNT_##opt)
 905 /* extent-tree.c */
 906 int btrfs_extent_post_op(struct btrfs_trans_handle *trans,
 907                          struct btrfs_root *root);
 908 int btrfs_copy_pinned(struct btrfs_root *root, struct extent_map_tree *copy);
 909 struct btrfs_block_group_cache *btrfs_lookup_block_group(struct
 910                                                          btrfs_fs_info *info,
 911                                                          u64 bytenr);
 912 struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root,
 913                                                  struct btrfs_block_group_cache
 914                                                  *hint, u64 search_start,
 915                                                  int data, int owner);
 916 int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,
 917                        struct btrfs_root *root);
 918 struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
 919                                             struct btrfs_root *root, u32 size,
 920                                             u64 hint, u64 empty_size);
 921 int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
 922                        struct btrfs_root *root, u64 owner,
 923                        u64 num_bytes, u64 empty_size, u64 search_start,
 924                        u64 search_end, struct btrfs_key *ins, int data);
 925 int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 926                   struct extent_buffer *buf);
 927 int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
 928                       *root, u64 bytenr, u64 num_bytes, int pin);
 929 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
 930                                struct btrfs_root *root,
 931                                struct extent_map_tree *unpin);
 932 int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
 933                                 struct btrfs_root *root,
 934                                 u64 bytenr, u64 num_bytes);
 935 int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
 936                                     struct btrfs_root *root);
 937 int btrfs_free_block_groups(struct btrfs_fs_info *info);
 938 int btrfs_read_block_groups(struct btrfs_root *root);
 939 /* ctree.c */
 940 int btrfs_cow_block(struct btrfs_trans_handle *trans,
 941                     struct btrfs_root *root, struct extent_buffer *buf,
 942                     struct extent_buffer *parent, int parent_slot,
 943                     struct extent_buffer **cow_ret);
 944 int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
 945                       *root, struct btrfs_path *path, u32 data_size);
 946 int btrfs_truncate_item(struct btrfs_trans_handle *trans,
 947                         struct btrfs_root *root,
 948                         struct btrfs_path *path,
 949                         u32 new_size, int from_end);
 950 int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
 951                       *root, struct btrfs_key *key, struct btrfs_path *p, int
 952                       ins_len, int cow);
 953 int btrfs_realloc_node(struct btrfs_trans_handle *trans,
 954                        struct btrfs_root *root, struct extent_buffer *parent,
 955                        int start_slot, int cache_only, u64 *last_ret,
 956                        struct btrfs_key *progress);
 957 void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
 958 struct btrfs_path *btrfs_alloc_path(void);
 959 void btrfs_free_path(struct btrfs_path *p);
 960 void btrfs_init_path(struct btrfs_path *p);
 961 int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 962                    struct btrfs_path *path);
 963 int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
 964                       *root, struct btrfs_key *key, void *data, u32 data_size);
 965 int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root
 966                             *root, struct btrfs_path *path, struct btrfs_key
 967                             *cpu_key, u32 data_size);
 968 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
 969 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
 970 int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root
 971                         *root);
 972 /* root-item.c */
 973 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 974                    struct btrfs_key *key);
 975 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
 976                       *root, struct btrfs_key *key, struct btrfs_root_item
 977                       *item);
 978 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
 979                       *root, struct btrfs_key *key, struct btrfs_root_item
 980                       *item);
 981 int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
 982                          btrfs_root_item *item, struct btrfs_key *key);
 983 int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid,
 984                           struct btrfs_root *latest_root);
 985 /* dir-item.c */
 986 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
 987                           *root, const char *name, int name_len, u64 dir,
 988                           struct btrfs_key *location, u8 type);
 989 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
 990                                              struct btrfs_root *root,
 991                                              struct btrfs_path *path, u64 dir,
 992                                              const char *name, int name_len,
 993                                              int mod);
 994 struct btrfs_dir_item *
 995 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
 996                             struct btrfs_root *root,
 997                             struct btrfs_path *path, u64 dir,
 998                             u64 objectid, const char *name, int name_len,
 999                             int mod);
1000 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
1001                               struct btrfs_path *path,
1002                               const char *name, int name_len);
1003 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
1004                               struct btrfs_root *root,
1005                               struct btrfs_path *path,
1006                               struct btrfs_dir_item *di);
1007 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
1008                             struct btrfs_root *root, const char *name,
1009                             u16 name_len, const void *data, u16 data_len,
1010                             u64 dir);
1011 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
1012                                           struct btrfs_root *root,
1013                                           struct btrfs_path *path, u64 dir,
1014                                           const char *name, u16 name_len,
1015                                           int mod);
1016 /* inode-map.c */
1017 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
1018                              struct btrfs_root *fs_root,
1019                              u64 dirid, u64 *objectid);
1020 int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
1021
1022 /* inode-item.c */
1023 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
1024                              struct btrfs_root *root,
1025                              struct btrfs_path *path, u64 objectid);
1026 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
1027                        *root, struct btrfs_path *path,
1028                        struct btrfs_key *location, int mod);
1029
1030 /* file-item.c */
1031 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
1032                                struct btrfs_root *root,
1033                                u64 objectid, u64 pos, u64 offset,
1034                                u64 disk_num_bytes,
1035                                u64 num_bytes);
1036 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
1037                              struct btrfs_root *root,
1038                              struct btrfs_path *path, u64 objectid,
1039                              u64 bytenr, int mod);
1040 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
1041                           struct btrfs_root *root,
1042                           struct inode *inode,
1043                           u64 objectid, u64 offset,
1044                           char *data, size_t len);
1045 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
1046                                           struct btrfs_root *root,
1047                                           struct btrfs_path *path,
1048                                           u64 objectid, u64 offset,
1049                                           int cow);
1050 int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
1051                         struct btrfs_root *root, struct btrfs_path *path,
1052                         u64 isize);
1053 /* inode.c */
1054 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct page *page);
1055 int btrfs_readpage(struct file *file, struct page *page);
1056 void btrfs_delete_inode(struct inode *inode);
1057 void btrfs_read_locked_inode(struct inode *inode);
1058 int btrfs_write_inode(struct inode *inode, int wait);
1059 void btrfs_dirty_inode(struct inode *inode);
1060 struct inode *btrfs_alloc_inode(struct super_block *sb);
1061 void btrfs_destroy_inode(struct inode *inode);
1062 int btrfs_init_cachep(void);
1063 void btrfs_destroy_cachep(void);
1064 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1065 struct inode *btrfs_iget_locked(struct super_block *s, u64 objectid,
1066                                 struct btrfs_root *root);
1067 int btrfs_commit_write(struct file *file, struct page *page,
1068                        unsigned from, unsigned to);
1069 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
1070                                     size_t page_offset, u64 start, u64 end,
1071                                     int create);
1072 int btrfs_update_inode(struct btrfs_trans_handle *trans,
1073                               struct btrfs_root *root,
1074                               struct inode *inode);
1075 /* file.c */
1076 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end);
1077 extern struct file_operations btrfs_file_operations;
1078 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
1079                        struct btrfs_root *root, struct inode *inode,
1080                        u64 start, u64 end, u64 inline_limit, u64 *hint_block);
1081 /* tree-defrag.c */
1082 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
1083                         struct btrfs_root *root, int cache_only);
1084
1085 /* sysfs.c */
1086 int btrfs_init_sysfs(void);
1087 void btrfs_exit_sysfs(void);
1088 int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
1089 int btrfs_sysfs_add_root(struct btrfs_root *root);
1090 void btrfs_sysfs_del_root(struct btrfs_root *root);
1091 void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
1092
1093 /* xattr.c */
1094 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
1095 int btrfs_delete_xattrs(struct btrfs_trans_handle *trans,
1096                         struct btrfs_root *root, struct inode *inode);
1097 #endif