Btrfs: add new defrag-range ioctl.
[linux-2.6.git] / 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 <asm/kmap_types.h>
30 #include "extent_io.h"
31 #include "extent_map.h"
32 #include "async-thread.h"
33
34 struct btrfs_trans_handle;
35 struct btrfs_transaction;
36 extern struct kmem_cache *btrfs_trans_handle_cachep;
37 extern struct kmem_cache *btrfs_transaction_cachep;
38 extern struct kmem_cache *btrfs_bit_radix_cachep;
39 extern struct kmem_cache *btrfs_path_cachep;
40 struct btrfs_ordered_sum;
41
42 #define BTRFS_MAGIC "_BHRfS_M"
43
44 #define BTRFS_MAX_LEVEL 8
45
46 #define BTRFS_COMPAT_EXTENT_TREE_V0
47
48 /*
49  * files bigger than this get some pre-flushing when they are added
50  * to the ordered operations list.  That way we limit the total
51  * work done by the commit
52  */
53 #define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
54
55 /* holds pointers to all of the tree roots */
56 #define BTRFS_ROOT_TREE_OBJECTID 1ULL
57
58 /* stores information about which extents are in use, and reference counts */
59 #define BTRFS_EXTENT_TREE_OBJECTID 2ULL
60
61 /*
62  * chunk tree stores translations from logical -> physical block numbering
63  * the super block points to the chunk tree
64  */
65 #define BTRFS_CHUNK_TREE_OBJECTID 3ULL
66
67 /*
68  * stores information about which areas of a given device are in use.
69  * one per device.  The tree of tree roots points to the device tree
70  */
71 #define BTRFS_DEV_TREE_OBJECTID 4ULL
72
73 /* one per subvolume, storing files and directories */
74 #define BTRFS_FS_TREE_OBJECTID 5ULL
75
76 /* directory objectid inside the root tree */
77 #define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
78
79 /* holds checksums of all the data extents */
80 #define BTRFS_CSUM_TREE_OBJECTID 7ULL
81
82 /* orhpan objectid for tracking unlinked/truncated files */
83 #define BTRFS_ORPHAN_OBJECTID -5ULL
84
85 /* does write ahead logging to speed up fsyncs */
86 #define BTRFS_TREE_LOG_OBJECTID -6ULL
87 #define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
88
89 /* for space balancing */
90 #define BTRFS_TREE_RELOC_OBJECTID -8ULL
91 #define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
92
93 /*
94  * extent checksums all have this objectid
95  * this allows them to share the logging tree
96  * for fsyncs
97  */
98 #define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
99
100 /* dummy objectid represents multiple objectids */
101 #define BTRFS_MULTIPLE_OBJECTIDS -255ULL
102
103 /*
104  * All files have objectids in this range.
105  */
106 #define BTRFS_FIRST_FREE_OBJECTID 256ULL
107 #define BTRFS_LAST_FREE_OBJECTID -256ULL
108 #define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
109
110
111 /*
112  * the device items go into the chunk tree.  The key is in the form
113  * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
114  */
115 #define BTRFS_DEV_ITEMS_OBJECTID 1ULL
116
117 #define BTRFS_BTREE_INODE_OBJECTID 1
118
119 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
120
121 /*
122  * we can actually store much bigger names, but lets not confuse the rest
123  * of linux
124  */
125 #define BTRFS_NAME_LEN 255
126
127 /* 32 bytes in various csum fields */
128 #define BTRFS_CSUM_SIZE 32
129
130 /* csum types */
131 #define BTRFS_CSUM_TYPE_CRC32   0
132
133 static int btrfs_csum_sizes[] = { 4, 0 };
134
135 /* four bytes for CRC32 */
136 #define BTRFS_EMPTY_DIR_SIZE 0
137
138 #define BTRFS_FT_UNKNOWN        0
139 #define BTRFS_FT_REG_FILE       1
140 #define BTRFS_FT_DIR            2
141 #define BTRFS_FT_CHRDEV         3
142 #define BTRFS_FT_BLKDEV         4
143 #define BTRFS_FT_FIFO           5
144 #define BTRFS_FT_SOCK           6
145 #define BTRFS_FT_SYMLINK        7
146 #define BTRFS_FT_XATTR          8
147 #define BTRFS_FT_MAX            9
148
149 /*
150  * The key defines the order in the tree, and so it also defines (optimal)
151  * block layout.
152  *
153  * objectid corresponds to the inode number.
154  *
155  * type tells us things about the object, and is a kind of stream selector.
156  * so for a given inode, keys with type of 1 might refer to the inode data,
157  * type of 2 may point to file data in the btree and type == 3 may point to
158  * extents.
159  *
160  * offset is the starting byte offset for this key in the stream.
161  *
162  * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
163  * in cpu native order.  Otherwise they are identical and their sizes
164  * should be the same (ie both packed)
165  */
166 struct btrfs_disk_key {
167         __le64 objectid;
168         u8 type;
169         __le64 offset;
170 } __attribute__ ((__packed__));
171
172 struct btrfs_key {
173         u64 objectid;
174         u8 type;
175         u64 offset;
176 } __attribute__ ((__packed__));
177
178 struct btrfs_mapping_tree {
179         struct extent_map_tree map_tree;
180 };
181
182 #define BTRFS_UUID_SIZE 16
183 struct btrfs_dev_item {
184         /* the internal btrfs device id */
185         __le64 devid;
186
187         /* size of the device */
188         __le64 total_bytes;
189
190         /* bytes used */
191         __le64 bytes_used;
192
193         /* optimal io alignment for this device */
194         __le32 io_align;
195
196         /* optimal io width for this device */
197         __le32 io_width;
198
199         /* minimal io size for this device */
200         __le32 sector_size;
201
202         /* type and info about this device */
203         __le64 type;
204
205         /* expected generation for this device */
206         __le64 generation;
207
208         /*
209          * starting byte of this partition on the device,
210          * to allow for stripe alignment in the future
211          */
212         __le64 start_offset;
213
214         /* grouping information for allocation decisions */
215         __le32 dev_group;
216
217         /* seek speed 0-100 where 100 is fastest */
218         u8 seek_speed;
219
220         /* bandwidth 0-100 where 100 is fastest */
221         u8 bandwidth;
222
223         /* btrfs generated uuid for this device */
224         u8 uuid[BTRFS_UUID_SIZE];
225
226         /* uuid of FS who owns this device */
227         u8 fsid[BTRFS_UUID_SIZE];
228 } __attribute__ ((__packed__));
229
230 struct btrfs_stripe {
231         __le64 devid;
232         __le64 offset;
233         u8 dev_uuid[BTRFS_UUID_SIZE];
234 } __attribute__ ((__packed__));
235
236 struct btrfs_chunk {
237         /* size of this chunk in bytes */
238         __le64 length;
239
240         /* objectid of the root referencing this chunk */
241         __le64 owner;
242
243         __le64 stripe_len;
244         __le64 type;
245
246         /* optimal io alignment for this chunk */
247         __le32 io_align;
248
249         /* optimal io width for this chunk */
250         __le32 io_width;
251
252         /* minimal io size for this chunk */
253         __le32 sector_size;
254
255         /* 2^16 stripes is quite a lot, a second limit is the size of a single
256          * item in the btree
257          */
258         __le16 num_stripes;
259
260         /* sub stripes only matter for raid10 */
261         __le16 sub_stripes;
262         struct btrfs_stripe stripe;
263         /* additional stripes go here */
264 } __attribute__ ((__packed__));
265
266 static inline unsigned long btrfs_chunk_item_size(int num_stripes)
267 {
268         BUG_ON(num_stripes == 0);
269         return sizeof(struct btrfs_chunk) +
270                 sizeof(struct btrfs_stripe) * (num_stripes - 1);
271 }
272
273 #define BTRFS_FSID_SIZE 16
274 #define BTRFS_HEADER_FLAG_WRITTEN       (1ULL << 0)
275 #define BTRFS_HEADER_FLAG_RELOC         (1ULL << 1)
276 #define BTRFS_SUPER_FLAG_SEEDING        (1ULL << 32)
277 #define BTRFS_SUPER_FLAG_METADUMP       (1ULL << 33)
278
279 #define BTRFS_BACKREF_REV_MAX           256
280 #define BTRFS_BACKREF_REV_SHIFT         56
281 #define BTRFS_BACKREF_REV_MASK          (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
282                                          BTRFS_BACKREF_REV_SHIFT)
283
284 #define BTRFS_OLD_BACKREF_REV           0
285 #define BTRFS_MIXED_BACKREF_REV         1
286
287 /*
288  * every tree block (leaf or node) starts with this header.
289  */
290 struct btrfs_header {
291         /* these first four must match the super block */
292         u8 csum[BTRFS_CSUM_SIZE];
293         u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
294         __le64 bytenr; /* which block this node is supposed to live in */
295         __le64 flags;
296
297         /* allowed to be different from the super from here on down */
298         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
299         __le64 generation;
300         __le64 owner;
301         __le32 nritems;
302         u8 level;
303 } __attribute__ ((__packed__));
304
305 #define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
306                                       sizeof(struct btrfs_header)) / \
307                                      sizeof(struct btrfs_key_ptr))
308 #define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
309 #define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
310 #define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
311                                         sizeof(struct btrfs_item) - \
312                                         sizeof(struct btrfs_file_extent_item))
313 #define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
314                                  sizeof(struct btrfs_item) -\
315                                  sizeof(struct btrfs_dir_item))
316
317
318 /*
319  * this is a very generous portion of the super block, giving us
320  * room to translate 14 chunks with 3 stripes each.
321  */
322 #define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
323 #define BTRFS_LABEL_SIZE 256
324
325 /*
326  * the super block basically lists the main trees of the FS
327  * it currently lacks any block count etc etc
328  */
329 struct btrfs_super_block {
330         u8 csum[BTRFS_CSUM_SIZE];
331         /* the first 4 fields must match struct btrfs_header */
332         u8 fsid[BTRFS_FSID_SIZE];    /* FS specific uuid */
333         __le64 bytenr; /* this block number */
334         __le64 flags;
335
336         /* allowed to be different from the btrfs_header from here own down */
337         __le64 magic;
338         __le64 generation;
339         __le64 root;
340         __le64 chunk_root;
341         __le64 log_root;
342
343         /* this will help find the new super based on the log root */
344         __le64 log_root_transid;
345         __le64 total_bytes;
346         __le64 bytes_used;
347         __le64 root_dir_objectid;
348         __le64 num_devices;
349         __le32 sectorsize;
350         __le32 nodesize;
351         __le32 leafsize;
352         __le32 stripesize;
353         __le32 sys_chunk_array_size;
354         __le64 chunk_root_generation;
355         __le64 compat_flags;
356         __le64 compat_ro_flags;
357         __le64 incompat_flags;
358         __le16 csum_type;
359         u8 root_level;
360         u8 chunk_root_level;
361         u8 log_root_level;
362         struct btrfs_dev_item dev_item;
363
364         char label[BTRFS_LABEL_SIZE];
365
366         /* future expansion */
367         __le64 reserved[32];
368         u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
369 } __attribute__ ((__packed__));
370
371 /*
372  * Compat flags that we support.  If any incompat flags are set other than the
373  * ones specified below then we will fail to mount
374  */
375 #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF    (1ULL << 0)
376 #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL   (2ULL << 0)
377
378 #define BTRFS_FEATURE_COMPAT_SUPP               0ULL
379 #define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
380 #define BTRFS_FEATURE_INCOMPAT_SUPP             \
381         (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
382          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)
383
384 /*
385  * A leaf is full of items. offset and size tell us where to find
386  * the item in the leaf (relative to the start of the data area)
387  */
388 struct btrfs_item {
389         struct btrfs_disk_key key;
390         __le32 offset;
391         __le32 size;
392 } __attribute__ ((__packed__));
393
394 /*
395  * leaves have an item area and a data area:
396  * [item0, item1....itemN] [free space] [dataN...data1, data0]
397  *
398  * The data is separate from the items to get the keys closer together
399  * during searches.
400  */
401 struct btrfs_leaf {
402         struct btrfs_header header;
403         struct btrfs_item items[];
404 } __attribute__ ((__packed__));
405
406 /*
407  * all non-leaf blocks are nodes, they hold only keys and pointers to
408  * other blocks
409  */
410 struct btrfs_key_ptr {
411         struct btrfs_disk_key key;
412         __le64 blockptr;
413         __le64 generation;
414 } __attribute__ ((__packed__));
415
416 struct btrfs_node {
417         struct btrfs_header header;
418         struct btrfs_key_ptr ptrs[];
419 } __attribute__ ((__packed__));
420
421 /*
422  * btrfs_paths remember the path taken from the root down to the leaf.
423  * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
424  * to any other levels that are present.
425  *
426  * The slots array records the index of the item or block pointer
427  * used while walking the tree.
428  */
429 struct btrfs_path {
430         struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
431         int slots[BTRFS_MAX_LEVEL];
432         /* if there is real range locking, this locks field will change */
433         int locks[BTRFS_MAX_LEVEL];
434         int reada;
435         /* keep some upper locks as we walk down */
436         int lowest_level;
437
438         /*
439          * set by btrfs_split_item, tells search_slot to keep all locks
440          * and to force calls to keep space in the nodes
441          */
442         unsigned int search_for_split:1;
443         unsigned int keep_locks:1;
444         unsigned int skip_locking:1;
445         unsigned int leave_spinning:1;
446         unsigned int search_commit_root:1;
447 };
448
449 /*
450  * items in the extent btree are used to record the objectid of the
451  * owner of the block and the number of references
452  */
453
454 struct btrfs_extent_item {
455         __le64 refs;
456         __le64 generation;
457         __le64 flags;
458 } __attribute__ ((__packed__));
459
460 struct btrfs_extent_item_v0 {
461         __le32 refs;
462 } __attribute__ ((__packed__));
463
464 #define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
465                                         sizeof(struct btrfs_item))
466
467 #define BTRFS_EXTENT_FLAG_DATA          (1ULL << 0)
468 #define BTRFS_EXTENT_FLAG_TREE_BLOCK    (1ULL << 1)
469
470 /* following flags only apply to tree blocks */
471
472 /* use full backrefs for extent pointers in the block */
473 #define BTRFS_BLOCK_FLAG_FULL_BACKREF   (1ULL << 8)
474
475 struct btrfs_tree_block_info {
476         struct btrfs_disk_key key;
477         u8 level;
478 } __attribute__ ((__packed__));
479
480 struct btrfs_extent_data_ref {
481         __le64 root;
482         __le64 objectid;
483         __le64 offset;
484         __le32 count;
485 } __attribute__ ((__packed__));
486
487 struct btrfs_shared_data_ref {
488         __le32 count;
489 } __attribute__ ((__packed__));
490
491 struct btrfs_extent_inline_ref {
492         u8 type;
493         __le64 offset;
494 } __attribute__ ((__packed__));
495
496 /* old style backrefs item */
497 struct btrfs_extent_ref_v0 {
498         __le64 root;
499         __le64 generation;
500         __le64 objectid;
501         __le32 count;
502 } __attribute__ ((__packed__));
503
504
505 /* dev extents record free space on individual devices.  The owner
506  * field points back to the chunk allocation mapping tree that allocated
507  * the extent.  The chunk tree uuid field is a way to double check the owner
508  */
509 struct btrfs_dev_extent {
510         __le64 chunk_tree;
511         __le64 chunk_objectid;
512         __le64 chunk_offset;
513         __le64 length;
514         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
515 } __attribute__ ((__packed__));
516
517 struct btrfs_inode_ref {
518         __le64 index;
519         __le16 name_len;
520         /* name goes here */
521 } __attribute__ ((__packed__));
522
523 struct btrfs_timespec {
524         __le64 sec;
525         __le32 nsec;
526 } __attribute__ ((__packed__));
527
528 enum btrfs_compression_type {
529         BTRFS_COMPRESS_NONE = 0,
530         BTRFS_COMPRESS_ZLIB = 1,
531         BTRFS_COMPRESS_LAST = 2,
532 };
533
534 struct btrfs_inode_item {
535         /* nfs style generation number */
536         __le64 generation;
537         /* transid that last touched this inode */
538         __le64 transid;
539         __le64 size;
540         __le64 nbytes;
541         __le64 block_group;
542         __le32 nlink;
543         __le32 uid;
544         __le32 gid;
545         __le32 mode;
546         __le64 rdev;
547         __le64 flags;
548
549         /* modification sequence number for NFS */
550         __le64 sequence;
551
552         /*
553          * a little future expansion, for more than this we can
554          * just grow the inode item and version it
555          */
556         __le64 reserved[4];
557         struct btrfs_timespec atime;
558         struct btrfs_timespec ctime;
559         struct btrfs_timespec mtime;
560         struct btrfs_timespec otime;
561 } __attribute__ ((__packed__));
562
563 struct btrfs_dir_log_item {
564         __le64 end;
565 } __attribute__ ((__packed__));
566
567 struct btrfs_dir_item {
568         struct btrfs_disk_key location;
569         __le64 transid;
570         __le16 data_len;
571         __le16 name_len;
572         u8 type;
573 } __attribute__ ((__packed__));
574
575 struct btrfs_root_item {
576         struct btrfs_inode_item inode;
577         __le64 generation;
578         __le64 root_dirid;
579         __le64 bytenr;
580         __le64 byte_limit;
581         __le64 bytes_used;
582         __le64 last_snapshot;
583         __le64 flags;
584         __le32 refs;
585         struct btrfs_disk_key drop_progress;
586         u8 drop_level;
587         u8 level;
588 } __attribute__ ((__packed__));
589
590 /*
591  * this is used for both forward and backward root refs
592  */
593 struct btrfs_root_ref {
594         __le64 dirid;
595         __le64 sequence;
596         __le16 name_len;
597 } __attribute__ ((__packed__));
598
599 #define BTRFS_FILE_EXTENT_INLINE 0
600 #define BTRFS_FILE_EXTENT_REG 1
601 #define BTRFS_FILE_EXTENT_PREALLOC 2
602
603 struct btrfs_file_extent_item {
604         /*
605          * transaction id that created this extent
606          */
607         __le64 generation;
608         /*
609          * max number of bytes to hold this extent in ram
610          * when we split a compressed extent we can't know how big
611          * each of the resulting pieces will be.  So, this is
612          * an upper limit on the size of the extent in ram instead of
613          * an exact limit.
614          */
615         __le64 ram_bytes;
616
617         /*
618          * 32 bits for the various ways we might encode the data,
619          * including compression and encryption.  If any of these
620          * are set to something a given disk format doesn't understand
621          * it is treated like an incompat flag for reading and writing,
622          * but not for stat.
623          */
624         u8 compression;
625         u8 encryption;
626         __le16 other_encoding; /* spare for later use */
627
628         /* are we inline data or a real extent? */
629         u8 type;
630
631         /*
632          * disk space consumed by the extent, checksum blocks are included
633          * in these numbers
634          */
635         __le64 disk_bytenr;
636         __le64 disk_num_bytes;
637         /*
638          * the logical offset in file blocks (no csums)
639          * this extent record is for.  This allows a file extent to point
640          * into the middle of an existing extent on disk, sharing it
641          * between two snapshots (useful if some bytes in the middle of the
642          * extent have changed
643          */
644         __le64 offset;
645         /*
646          * the logical number of file blocks (no csums included).  This
647          * always reflects the size uncompressed and without encoding.
648          */
649         __le64 num_bytes;
650
651 } __attribute__ ((__packed__));
652
653 struct btrfs_csum_item {
654         u8 csum;
655 } __attribute__ ((__packed__));
656
657 /* different types of block groups (and chunks) */
658 #define BTRFS_BLOCK_GROUP_DATA     (1 << 0)
659 #define BTRFS_BLOCK_GROUP_SYSTEM   (1 << 1)
660 #define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
661 #define BTRFS_BLOCK_GROUP_RAID0    (1 << 3)
662 #define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)
663 #define BTRFS_BLOCK_GROUP_DUP      (1 << 5)
664 #define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)
665
666 struct btrfs_block_group_item {
667         __le64 used;
668         __le64 chunk_objectid;
669         __le64 flags;
670 } __attribute__ ((__packed__));
671
672 struct btrfs_space_info {
673         u64 flags;
674
675         u64 total_bytes;        /* total bytes in the space */
676         u64 bytes_used;         /* total bytes used on disk */
677         u64 bytes_pinned;       /* total bytes pinned, will be freed when the
678                                    transaction finishes */
679         u64 bytes_reserved;     /* total bytes the allocator has reserved for
680                                    current allocations */
681         u64 bytes_readonly;     /* total bytes that are read only */
682         u64 bytes_super;        /* total bytes reserved for the super blocks */
683         u64 bytes_root;         /* the number of bytes needed to commit a
684                                    transaction */
685         u64 bytes_may_use;      /* number of bytes that may be used for
686                                    delalloc/allocations */
687         u64 bytes_delalloc;     /* number of bytes currently reserved for
688                                    delayed allocation */
689
690         int full;               /* indicates that we cannot allocate any more
691                                    chunks for this space */
692         int force_alloc;        /* set if we need to force a chunk alloc for
693                                    this space */
694         int force_delalloc;     /* make people start doing filemap_flush until
695                                    we're under a threshold */
696
697         struct list_head list;
698
699         /* for controlling how we free up space for allocations */
700         wait_queue_head_t allocate_wait;
701         wait_queue_head_t flush_wait;
702         int allocating_chunk;
703         int flushing;
704
705         /* for block groups in our same type */
706         struct list_head block_groups;
707         spinlock_t lock;
708         struct rw_semaphore groups_sem;
709         atomic_t caching_threads;
710 };
711
712 /*
713  * free clusters are used to claim free space in relatively large chunks,
714  * allowing us to do less seeky writes.  They are used for all metadata
715  * allocations and data allocations in ssd mode.
716  */
717 struct btrfs_free_cluster {
718         spinlock_t lock;
719         spinlock_t refill_lock;
720         struct rb_root root;
721
722         /* largest extent in this cluster */
723         u64 max_size;
724
725         /* first extent starting offset */
726         u64 window_start;
727
728         /* if this cluster simply points at a bitmap in the block group */
729         bool points_to_bitmap;
730
731         struct btrfs_block_group_cache *block_group;
732         /*
733          * when a cluster is allocated from a block group, we put the
734          * cluster onto a list in the block group so that it can
735          * be freed before the block group is freed.
736          */
737         struct list_head block_group_list;
738 };
739
740 enum btrfs_caching_type {
741         BTRFS_CACHE_NO          = 0,
742         BTRFS_CACHE_STARTED     = 1,
743         BTRFS_CACHE_FINISHED    = 2,
744 };
745
746 struct btrfs_caching_control {
747         struct list_head list;
748         struct mutex mutex;
749         wait_queue_head_t wait;
750         struct btrfs_block_group_cache *block_group;
751         u64 progress;
752         atomic_t count;
753 };
754
755 struct btrfs_block_group_cache {
756         struct btrfs_key key;
757         struct btrfs_block_group_item item;
758         struct btrfs_fs_info *fs_info;
759         spinlock_t lock;
760         u64 pinned;
761         u64 reserved;
762         u64 bytes_super;
763         u64 flags;
764         u64 sectorsize;
765         int extents_thresh;
766         int free_extents;
767         int total_bitmaps;
768         int ro;
769         int dirty;
770
771         /* cache tracking stuff */
772         int cached;
773         struct btrfs_caching_control *caching_ctl;
774         u64 last_byte_to_unpin;
775
776         struct btrfs_space_info *space_info;
777
778         /* free space cache stuff */
779         spinlock_t tree_lock;
780         struct rb_root free_space_offset;
781         u64 free_space;
782
783         /* block group cache stuff */
784         struct rb_node cache_node;
785
786         /* for block groups in the same raid type */
787         struct list_head list;
788
789         /* usage count */
790         atomic_t count;
791
792         /* List of struct btrfs_free_clusters for this block group.
793          * Today it will only have one thing on it, but that may change
794          */
795         struct list_head cluster_list;
796 };
797
798 struct reloc_control;
799 struct btrfs_device;
800 struct btrfs_fs_devices;
801 struct btrfs_fs_info {
802         u8 fsid[BTRFS_FSID_SIZE];
803         u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
804         struct btrfs_root *extent_root;
805         struct btrfs_root *tree_root;
806         struct btrfs_root *chunk_root;
807         struct btrfs_root *dev_root;
808         struct btrfs_root *fs_root;
809         struct btrfs_root *csum_root;
810
811         /* the log root tree is a directory of all the other log roots */
812         struct btrfs_root *log_root_tree;
813
814         spinlock_t fs_roots_radix_lock;
815         struct radix_tree_root fs_roots_radix;
816
817         /* block group cache stuff */
818         spinlock_t block_group_cache_lock;
819         struct rb_root block_group_cache_tree;
820
821         struct extent_io_tree freed_extents[2];
822         struct extent_io_tree *pinned_extents;
823
824         /* logical->physical extent mapping */
825         struct btrfs_mapping_tree mapping_tree;
826
827         u64 generation;
828         u64 last_trans_committed;
829
830         /*
831          * this is updated to the current trans every time a full commit
832          * is required instead of the faster short fsync log commits
833          */
834         u64 last_trans_log_full_commit;
835         u64 open_ioctl_trans;
836         unsigned long mount_opt;
837         u64 max_extent;
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 int btrfs_writepages(struct address_space *mapping,
2316                      struct writeback_control *wbc);
2317 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
2318                              struct btrfs_root *new_root,
2319                              u64 new_dirid, u64 alloc_hint);
2320 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
2321                          size_t size, struct bio *bio, unsigned long bio_flags);
2322
2323 unsigned long btrfs_force_ra(struct address_space *mapping,
2324                               struct file_ra_state *ra, struct file *file,
2325                               pgoff_t offset, pgoff_t last_index);
2326 int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
2327 int btrfs_readpage(struct file *file, struct page *page);
2328 void btrfs_delete_inode(struct inode *inode);
2329 void btrfs_put_inode(struct inode *inode);
2330 int btrfs_write_inode(struct inode *inode, int wait);
2331 void btrfs_dirty_inode(struct inode *inode);
2332 struct inode *btrfs_alloc_inode(struct super_block *sb);
2333 void btrfs_destroy_inode(struct inode *inode);
2334 void btrfs_drop_inode(struct inode *inode);
2335 int btrfs_init_cachep(void);
2336 void btrfs_destroy_cachep(void);
2337 long btrfs_ioctl_trans_end(struct file *file);
2338 struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
2339                          struct btrfs_root *root, int *was_new);
2340 int btrfs_commit_write(struct file *file, struct page *page,
2341                        unsigned from, unsigned to);
2342 struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
2343                                     size_t page_offset, u64 start, u64 end,
2344                                     int create);
2345 int btrfs_update_inode(struct btrfs_trans_handle *trans,
2346                               struct btrfs_root *root,
2347                               struct inode *inode);
2348 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
2349 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
2350 void btrfs_orphan_cleanup(struct btrfs_root *root);
2351 int btrfs_cont_expand(struct inode *inode, loff_t size);
2352 int btrfs_invalidate_inodes(struct btrfs_root *root);
2353 void btrfs_add_delayed_iput(struct inode *inode);
2354 void btrfs_run_delayed_iputs(struct btrfs_root *root);
2355 extern const struct dentry_operations btrfs_dentry_operations;
2356
2357 /* ioctl.c */
2358 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2359 void btrfs_update_iflags(struct inode *inode);
2360 void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
2361
2362 /* file.c */
2363 int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync);
2364 int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
2365                             int skip_pinned);
2366 int btrfs_check_file(struct btrfs_root *root, struct inode *inode);
2367 extern const struct file_operations btrfs_file_operations;
2368 int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
2369                        u64 start, u64 end, u64 *hint_byte, int drop_cache);
2370 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
2371                               struct inode *inode, u64 start, u64 end);
2372 int btrfs_release_file(struct inode *inode, struct file *file);
2373
2374 /* tree-defrag.c */
2375 int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
2376                         struct btrfs_root *root, int cache_only);
2377
2378 /* sysfs.c */
2379 int btrfs_init_sysfs(void);
2380 void btrfs_exit_sysfs(void);
2381 int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
2382 int btrfs_sysfs_add_root(struct btrfs_root *root);
2383 void btrfs_sysfs_del_root(struct btrfs_root *root);
2384 void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
2385
2386 /* xattr.c */
2387 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
2388
2389 /* super.c */
2390 u64 btrfs_parse_size(char *str);
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