Root/fs/btrfs/ctree.h

1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#ifndef __BTRFS_CTREE__
20#define __BTRFS_CTREE__
21
22#include <linux/version.h>
23#include <linux/mm.h>
24#include <linux/highmem.h>
25#include <linux/fs.h>
26#include <linux/completion.h>
27#include <linux/backing-dev.h>
28#include <linux/wait.h>
29#include <linux/slab.h>
30#include <asm/kmap_types.h>
31#include "extent_io.h"
32#include "extent_map.h"
33#include "async-thread.h"
34
35struct btrfs_trans_handle;
36struct btrfs_transaction;
37extern struct kmem_cache *btrfs_trans_handle_cachep;
38extern struct kmem_cache *btrfs_transaction_cachep;
39extern struct kmem_cache *btrfs_bit_radix_cachep;
40extern struct kmem_cache *btrfs_path_cachep;
41struct btrfs_ordered_sum;
42
43#define BTRFS_MAGIC "_BHRfS_M"
44
45#define BTRFS_MAX_LEVEL 8
46
47#define BTRFS_COMPAT_EXTENT_TREE_V0
48
49/*
50 * files bigger than this get some pre-flushing when they are added
51 * to the ordered operations list. That way we limit the total
52 * work done by the commit
53 */
54#define BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT (8 * 1024 * 1024)
55
56/* holds pointers to all of the tree roots */
57#define BTRFS_ROOT_TREE_OBJECTID 1ULL
58
59/* stores information about which extents are in use, and reference counts */
60#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
61
62/*
63 * chunk tree stores translations from logical -> physical block numbering
64 * the super block points to the chunk tree
65 */
66#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
67
68/*
69 * stores information about which areas of a given device are in use.
70 * one per device. The tree of tree roots points to the device tree
71 */
72#define BTRFS_DEV_TREE_OBJECTID 4ULL
73
74/* one per subvolume, storing files and directories */
75#define BTRFS_FS_TREE_OBJECTID 5ULL
76
77/* directory objectid inside the root tree */
78#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
79
80/* holds checksums of all the data extents */
81#define BTRFS_CSUM_TREE_OBJECTID 7ULL
82
83/* orhpan objectid for tracking unlinked/truncated files */
84#define BTRFS_ORPHAN_OBJECTID -5ULL
85
86/* does write ahead logging to speed up fsyncs */
87#define BTRFS_TREE_LOG_OBJECTID -6ULL
88#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
89
90/* for space balancing */
91#define BTRFS_TREE_RELOC_OBJECTID -8ULL
92#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
93
94/*
95 * extent checksums all have this objectid
96 * this allows them to share the logging tree
97 * for fsyncs
98 */
99#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
100
101/* dummy objectid represents multiple objectids */
102#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
103
104/*
105 * All files have objectids in this range.
106 */
107#define BTRFS_FIRST_FREE_OBJECTID 256ULL
108#define BTRFS_LAST_FREE_OBJECTID -256ULL
109#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
110
111
112/*
113 * the device items go into the chunk tree. The key is in the form
114 * [ 1 BTRFS_DEV_ITEM_KEY device_id ]
115 */
116#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
117
118#define BTRFS_BTREE_INODE_OBJECTID 1
119
120#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
121
122/*
123 * we can actually store much bigger names, but lets not confuse the rest
124 * of linux
125 */
126#define BTRFS_NAME_LEN 255
127
128/* 32 bytes in various csum fields */
129#define BTRFS_CSUM_SIZE 32
130
131/* csum types */
132#define BTRFS_CSUM_TYPE_CRC32 0
133
134static int btrfs_csum_sizes[] = { 4, 0 };
135
136/* four bytes for CRC32 */
137#define BTRFS_EMPTY_DIR_SIZE 0
138
139#define BTRFS_FT_UNKNOWN 0
140#define BTRFS_FT_REG_FILE 1
141#define BTRFS_FT_DIR 2
142#define BTRFS_FT_CHRDEV 3
143#define BTRFS_FT_BLKDEV 4
144#define BTRFS_FT_FIFO 5
145#define BTRFS_FT_SOCK 6
146#define BTRFS_FT_SYMLINK 7
147#define BTRFS_FT_XATTR 8
148#define BTRFS_FT_MAX 9
149
150/*
151 * The key defines the order in the tree, and so it also defines (optimal)
152 * block layout.
153 *
154 * objectid corresponds to the inode number.
155 *
156 * type tells us things about the object, and is a kind of stream selector.
157 * so for a given inode, keys with type of 1 might refer to the inode data,
158 * type of 2 may point to file data in the btree and type == 3 may point to
159 * extents.
160 *
161 * offset is the starting byte offset for this key in the stream.
162 *
163 * btrfs_disk_key is in disk byte order. struct btrfs_key is always
164 * in cpu native order. Otherwise they are identical and their sizes
165 * should be the same (ie both packed)
166 */
167struct btrfs_disk_key {
168    __le64 objectid;
169    u8 type;
170    __le64 offset;
171} __attribute__ ((__packed__));
172
173struct btrfs_key {
174    u64 objectid;
175    u8 type;
176    u64 offset;
177} __attribute__ ((__packed__));
178
179struct btrfs_mapping_tree {
180    struct extent_map_tree map_tree;
181};
182
183#define BTRFS_UUID_SIZE 16
184struct btrfs_dev_item {
185    /* the internal btrfs device id */
186    __le64 devid;
187
188    /* size of the device */
189    __le64 total_bytes;
190
191    /* bytes used */
192    __le64 bytes_used;
193
194    /* optimal io alignment for this device */
195    __le32 io_align;
196
197    /* optimal io width for this device */
198    __le32 io_width;
199
200    /* minimal io size for this device */
201    __le32 sector_size;
202
203    /* type and info about this device */
204    __le64 type;
205
206    /* expected generation for this device */
207    __le64 generation;
208
209    /*
210     * starting byte of this partition on the device,
211     * to allow for stripe alignment in the future
212     */
213    __le64 start_offset;
214
215    /* grouping information for allocation decisions */
216    __le32 dev_group;
217
218    /* seek speed 0-100 where 100 is fastest */
219    u8 seek_speed;
220
221    /* bandwidth 0-100 where 100 is fastest */
222    u8 bandwidth;
223
224    /* btrfs generated uuid for this device */
225    u8 uuid[BTRFS_UUID_SIZE];
226
227    /* uuid of FS who owns this device */
228    u8 fsid[BTRFS_UUID_SIZE];
229} __attribute__ ((__packed__));
230
231struct btrfs_stripe {
232    __le64 devid;
233    __le64 offset;
234    u8 dev_uuid[BTRFS_UUID_SIZE];
235} __attribute__ ((__packed__));
236
237struct btrfs_chunk {
238    /* size of this chunk in bytes */
239    __le64 length;
240
241    /* objectid of the root referencing this chunk */
242    __le64 owner;
243
244    __le64 stripe_len;
245    __le64 type;
246
247    /* optimal io alignment for this chunk */
248    __le32 io_align;
249
250    /* optimal io width for this chunk */
251    __le32 io_width;
252
253    /* minimal io size for this chunk */
254    __le32 sector_size;
255
256    /* 2^16 stripes is quite a lot, a second limit is the size of a single
257     * item in the btree
258     */
259    __le16 num_stripes;
260
261    /* sub stripes only matter for raid10 */
262    __le16 sub_stripes;
263    struct btrfs_stripe stripe;
264    /* additional stripes go here */
265} __attribute__ ((__packed__));
266
267static inline unsigned long btrfs_chunk_item_size(int num_stripes)
268{
269    BUG_ON(num_stripes == 0);
270    return sizeof(struct btrfs_chunk) +
271        sizeof(struct btrfs_stripe) * (num_stripes - 1);
272}
273
274#define BTRFS_FSID_SIZE 16
275#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
276#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
277#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
278#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
279
280#define BTRFS_BACKREF_REV_MAX 256
281#define BTRFS_BACKREF_REV_SHIFT 56
282#define BTRFS_BACKREF_REV_MASK (((u64)BTRFS_BACKREF_REV_MAX - 1) << \
283                     BTRFS_BACKREF_REV_SHIFT)
284
285#define BTRFS_OLD_BACKREF_REV 0
286#define BTRFS_MIXED_BACKREF_REV 1
287
288/*
289 * every tree block (leaf or node) starts with this header.
290 */
291struct btrfs_header {
292    /* these first four must match the super block */
293    u8 csum[BTRFS_CSUM_SIZE];
294    u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
295    __le64 bytenr; /* which block this node is supposed to live in */
296    __le64 flags;
297
298    /* allowed to be different from the super from here on down */
299    u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
300    __le64 generation;
301    __le64 owner;
302    __le32 nritems;
303    u8 level;
304} __attribute__ ((__packed__));
305
306#define BTRFS_NODEPTRS_PER_BLOCK(r) (((r)->nodesize - \
307                      sizeof(struct btrfs_header)) / \
308                     sizeof(struct btrfs_key_ptr))
309#define __BTRFS_LEAF_DATA_SIZE(bs) ((bs) - sizeof(struct btrfs_header))
310#define BTRFS_LEAF_DATA_SIZE(r) (__BTRFS_LEAF_DATA_SIZE(r->leafsize))
311#define BTRFS_MAX_INLINE_DATA_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
312                    sizeof(struct btrfs_item) - \
313                    sizeof(struct btrfs_file_extent_item))
314#define BTRFS_MAX_XATTR_SIZE(r) (BTRFS_LEAF_DATA_SIZE(r) - \
315                 sizeof(struct btrfs_item) -\
316                 sizeof(struct btrfs_dir_item))
317
318
319/*
320 * this is a very generous portion of the super block, giving us
321 * room to translate 14 chunks with 3 stripes each.
322 */
323#define BTRFS_SYSTEM_CHUNK_ARRAY_SIZE 2048
324#define BTRFS_LABEL_SIZE 256
325
326/*
327 * the super block basically lists the main trees of the FS
328 * it currently lacks any block count etc etc
329 */
330struct btrfs_super_block {
331    u8 csum[BTRFS_CSUM_SIZE];
332    /* the first 4 fields must match struct btrfs_header */
333    u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
334    __le64 bytenr; /* this block number */
335    __le64 flags;
336
337    /* allowed to be different from the btrfs_header from here own down */
338    __le64 magic;
339    __le64 generation;
340    __le64 root;
341    __le64 chunk_root;
342    __le64 log_root;
343
344    /* this will help find the new super based on the log root */
345    __le64 log_root_transid;
346    __le64 total_bytes;
347    __le64 bytes_used;
348    __le64 root_dir_objectid;
349    __le64 num_devices;
350    __le32 sectorsize;
351    __le32 nodesize;
352    __le32 leafsize;
353    __le32 stripesize;
354    __le32 sys_chunk_array_size;
355    __le64 chunk_root_generation;
356    __le64 compat_flags;
357    __le64 compat_ro_flags;
358    __le64 incompat_flags;
359    __le16 csum_type;
360    u8 root_level;
361    u8 chunk_root_level;
362    u8 log_root_level;
363    struct btrfs_dev_item dev_item;
364
365    char label[BTRFS_LABEL_SIZE];
366
367    /* future expansion */
368    __le64 reserved[32];
369    u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE];
370} __attribute__ ((__packed__));
371
372/*
373 * Compat flags that we support. If any incompat flags are set other than the
374 * ones specified below then we will fail to mount
375 */
376#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
377#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (2ULL << 0)
378
379#define BTRFS_FEATURE_COMPAT_SUPP 0ULL
380#define BTRFS_FEATURE_COMPAT_RO_SUPP 0ULL
381#define BTRFS_FEATURE_INCOMPAT_SUPP \
382    (BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF | \
383     BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL)
384
385/*
386 * A leaf is full of items. offset and size tell us where to find
387 * the item in the leaf (relative to the start of the data area)
388 */
389struct btrfs_item {
390    struct btrfs_disk_key key;
391    __le32 offset;
392    __le32 size;
393} __attribute__ ((__packed__));
394
395/*
396 * leaves have an item area and a data area:
397 * [item0, item1....itemN] [free space] [dataN...data1, data0]
398 *
399 * The data is separate from the items to get the keys closer together
400 * during searches.
401 */
402struct btrfs_leaf {
403    struct btrfs_header header;
404    struct btrfs_item items[];
405} __attribute__ ((__packed__));
406
407/*
408 * all non-leaf blocks are nodes, they hold only keys and pointers to
409 * other blocks
410 */
411struct btrfs_key_ptr {
412    struct btrfs_disk_key key;
413    __le64 blockptr;
414    __le64 generation;
415} __attribute__ ((__packed__));
416
417struct btrfs_node {
418    struct btrfs_header header;
419    struct btrfs_key_ptr ptrs[];
420} __attribute__ ((__packed__));
421
422/*
423 * btrfs_paths remember the path taken from the root down to the leaf.
424 * level 0 is always the leaf, and nodes[1...BTRFS_MAX_LEVEL] will point
425 * to any other levels that are present.
426 *
427 * The slots array records the index of the item or block pointer
428 * used while walking the tree.
429 */
430struct btrfs_path {
431    struct extent_buffer *nodes[BTRFS_MAX_LEVEL];
432    int slots[BTRFS_MAX_LEVEL];
433    /* if there is real range locking, this locks field will change */
434    int locks[BTRFS_MAX_LEVEL];
435    int reada;
436    /* keep some upper locks as we walk down */
437    int lowest_level;
438
439    /*
440     * set by btrfs_split_item, tells search_slot to keep all locks
441     * and to force calls to keep space in the nodes
442     */
443    unsigned int search_for_split:1;
444    unsigned int keep_locks:1;
445    unsigned int skip_locking:1;
446    unsigned int leave_spinning:1;
447    unsigned int search_commit_root:1;
448};
449
450/*
451 * items in the extent btree are used to record the objectid of the
452 * owner of the block and the number of references
453 */
454
455struct btrfs_extent_item {
456    __le64 refs;
457    __le64 generation;
458    __le64 flags;
459} __attribute__ ((__packed__));
460
461struct btrfs_extent_item_v0 {
462    __le32 refs;
463} __attribute__ ((__packed__));
464
465#define BTRFS_MAX_EXTENT_ITEM_SIZE(r) ((BTRFS_LEAF_DATA_SIZE(r) >> 4) - \
466                    sizeof(struct btrfs_item))
467
468#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
469#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
470
471/* following flags only apply to tree blocks */
472
473/* use full backrefs for extent pointers in the block */
474#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
475
476struct btrfs_tree_block_info {
477    struct btrfs_disk_key key;
478    u8 level;
479} __attribute__ ((__packed__));
480
481struct btrfs_extent_data_ref {
482    __le64 root;
483    __le64 objectid;
484    __le64 offset;
485    __le32 count;
486} __attribute__ ((__packed__));
487
488struct btrfs_shared_data_ref {
489    __le32 count;
490} __attribute__ ((__packed__));
491
492struct btrfs_extent_inline_ref {
493    u8 type;
494    __le64 offset;
495} __attribute__ ((__packed__));
496
497/* old style backrefs item */
498struct btrfs_extent_ref_v0 {
499    __le64 root;
500    __le64 generation;
501    __le64 objectid;
502    __le32 count;
503} __attribute__ ((__packed__));
504
505
506/* dev extents record free space on individual devices. The owner
507 * field points back to the chunk allocation mapping tree that allocated
508 * the extent. The chunk tree uuid field is a way to double check the owner
509 */
510struct btrfs_dev_extent {
511    __le64 chunk_tree;
512    __le64 chunk_objectid;
513    __le64 chunk_offset;
514    __le64 length;
515    u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
516} __attribute__ ((__packed__));
517
518struct btrfs_inode_ref {
519    __le64 index;
520    __le16 name_len;
521    /* name goes here */
522} __attribute__ ((__packed__));
523
524struct btrfs_timespec {
525    __le64 sec;
526    __le32 nsec;
527} __attribute__ ((__packed__));
528
529enum btrfs_compression_type {
530    BTRFS_COMPRESS_NONE = 0,
531    BTRFS_COMPRESS_ZLIB = 1,
532    BTRFS_COMPRESS_LAST = 2,
533};
534
535struct btrfs_inode_item {
536    /* nfs style generation number */
537    __le64 generation;
538    /* transid that last touched this inode */
539    __le64 transid;
540    __le64 size;
541    __le64 nbytes;
542    __le64 block_group;
543    __le32 nlink;
544    __le32 uid;
545    __le32 gid;
546    __le32 mode;
547    __le64 rdev;
548    __le64 flags;
549
550    /* modification sequence number for NFS */
551    __le64 sequence;
552
553    /*
554     * a little future expansion, for more than this we can
555     * just grow the inode item and version it
556     */
557    __le64 reserved[4];
558    struct btrfs_timespec atime;
559    struct btrfs_timespec ctime;
560    struct btrfs_timespec mtime;
561    struct btrfs_timespec otime;
562} __attribute__ ((__packed__));
563
564struct btrfs_dir_log_item {
565    __le64 end;
566} __attribute__ ((__packed__));
567
568struct btrfs_dir_item {
569    struct btrfs_disk_key location;
570    __le64 transid;
571    __le16 data_len;
572    __le16 name_len;
573    u8 type;
574} __attribute__ ((__packed__));
575
576struct btrfs_root_item {
577    struct btrfs_inode_item inode;
578    __le64 generation;
579    __le64 root_dirid;
580    __le64 bytenr;
581    __le64 byte_limit;
582    __le64 bytes_used;
583    __le64 last_snapshot;
584    __le64 flags;
585    __le32 refs;
586    struct btrfs_disk_key drop_progress;
587    u8 drop_level;
588    u8 level;
589} __attribute__ ((__packed__));
590
591/*
592 * this is used for both forward and backward root refs
593 */
594struct btrfs_root_ref {
595    __le64 dirid;
596    __le64 sequence;
597    __le16 name_len;
598} __attribute__ ((__packed__));
599
600#define BTRFS_FILE_EXTENT_INLINE 0
601#define BTRFS_FILE_EXTENT_REG 1
602#define BTRFS_FILE_EXTENT_PREALLOC 2
603
604struct btrfs_file_extent_item {
605    /*
606     * transaction id that created this extent
607     */
608    __le64 generation;
609    /*
610     * max number of bytes to hold this extent in ram
611     * when we split a compressed extent we can't know how big
612     * each of the resulting pieces will be. So, this is
613     * an upper limit on the size of the extent in ram instead of
614     * an exact limit.
615     */
616    __le64 ram_bytes;
617
618    /*
619     * 32 bits for the various ways we might encode the data,
620     * including compression and encryption. If any of these
621     * are set to something a given disk format doesn't understand
622     * it is treated like an incompat flag for reading and writing,
623     * but not for stat.
624     */
625    u8 compression;
626    u8 encryption;
627    __le16 other_encoding; /* spare for later use */
628
629    /* are we inline data or a real extent? */
630    u8 type;
631
632    /*
633     * disk space consumed by the extent, checksum blocks are included
634     * in these numbers
635     */
636    __le64 disk_bytenr;
637    __le64 disk_num_bytes;
638    /*
639     * the logical offset in file blocks (no csums)
640     * this extent record is for. This allows a file extent to point
641     * into the middle of an existing extent on disk, sharing it
642     * between two snapshots (useful if some bytes in the middle of the
643     * extent have changed
644     */
645    __le64 offset;
646    /*
647     * the logical number of file blocks (no csums included). This
648     * always reflects the size uncompressed and without encoding.
649     */
650    __le64 num_bytes;
651
652} __attribute__ ((__packed__));
653
654struct btrfs_csum_item {
655    u8 csum;
656} __attribute__ ((__packed__));
657
658/* different types of block groups (and chunks) */
659#define BTRFS_BLOCK_GROUP_DATA (1 << 0)
660#define BTRFS_BLOCK_GROUP_SYSTEM (1 << 1)
661#define BTRFS_BLOCK_GROUP_METADATA (1 << 2)
662#define BTRFS_BLOCK_GROUP_RAID0 (1 << 3)
663#define BTRFS_BLOCK_GROUP_RAID1 (1 << 4)
664#define BTRFS_BLOCK_GROUP_DUP (1 << 5)
665#define BTRFS_BLOCK_GROUP_RAID10 (1 << 6)
666
667struct btrfs_block_group_item {
668    __le64 used;
669    __le64 chunk_objectid;
670    __le64 flags;
671} __attribute__ ((__packed__));
672
673struct btrfs_space_info {
674    u64 flags;
675
676    u64 total_bytes; /* total bytes in the space */
677    u64 bytes_used; /* total bytes used on disk */
678    u64 bytes_pinned; /* total bytes pinned, will be freed when the
679                   transaction finishes */
680    u64 bytes_reserved; /* total bytes the allocator has reserved for
681                   current allocations */
682    u64 bytes_readonly; /* total bytes that are read only */
683    u64 bytes_super; /* total bytes reserved for the super blocks */
684    u64 bytes_root; /* the number of bytes needed to commit a
685                   transaction */
686    u64 bytes_may_use; /* number of bytes that may be used for
687                   delalloc/allocations */
688    u64 bytes_delalloc; /* number of bytes currently reserved for
689                   delayed allocation */
690
691    int full; /* indicates that we cannot allocate any more
692                   chunks for this space */
693    int force_alloc; /* set if we need to force a chunk alloc for
694                   this space */
695    int force_delalloc; /* make people start doing filemap_flush until
696                   we're under a threshold */
697
698    struct list_head list;
699
700    /* for controlling how we free up space for allocations */
701    wait_queue_head_t allocate_wait;
702    wait_queue_head_t flush_wait;
703    int allocating_chunk;
704    int flushing;
705
706    /* for block groups in our same type */
707    struct list_head block_groups;
708    spinlock_t lock;
709    struct rw_semaphore groups_sem;
710    atomic_t caching_threads;
711};
712
713/*
714 * free clusters are used to claim free space in relatively large chunks,
715 * allowing us to do less seeky writes. They are used for all metadata
716 * allocations and data allocations in ssd mode.
717 */
718struct btrfs_free_cluster {
719    spinlock_t lock;
720    spinlock_t refill_lock;
721    struct rb_root root;
722
723    /* largest extent in this cluster */
724    u64 max_size;
725
726    /* first extent starting offset */
727    u64 window_start;
728
729    /* if this cluster simply points at a bitmap in the block group */
730    bool points_to_bitmap;
731
732    struct btrfs_block_group_cache *block_group;
733    /*
734     * when a cluster is allocated from a block group, we put the
735     * cluster onto a list in the block group so that it can
736     * be freed before the block group is freed.
737     */
738    struct list_head block_group_list;
739};
740
741enum btrfs_caching_type {
742    BTRFS_CACHE_NO = 0,
743    BTRFS_CACHE_STARTED = 1,
744    BTRFS_CACHE_FINISHED = 2,
745};
746
747struct btrfs_caching_control {
748    struct list_head list;
749    struct mutex mutex;
750    wait_queue_head_t wait;
751    struct btrfs_block_group_cache *block_group;
752    u64 progress;
753    atomic_t count;
754};
755
756struct btrfs_block_group_cache {
757    struct btrfs_key key;
758    struct btrfs_block_group_item item;
759    struct btrfs_fs_info *fs_info;
760    spinlock_t lock;
761    u64 pinned;
762    u64 reserved;
763    u64 bytes_super;
764    u64 flags;
765    u64 sectorsize;
766    int extents_thresh;
767    int free_extents;
768    int total_bitmaps;
769    int ro;
770    int dirty;
771
772    /* cache tracking stuff */
773    int cached;
774    struct btrfs_caching_control *caching_ctl;
775    u64 last_byte_to_unpin;
776
777    struct btrfs_space_info *space_info;
778
779    /* free space cache stuff */
780    spinlock_t tree_lock;
781    struct rb_root free_space_offset;
782    u64 free_space;
783
784    /* block group cache stuff */
785    struct rb_node cache_node;
786
787    /* for block groups in the same raid type */
788    struct list_head list;
789
790    /* usage count */
791    atomic_t count;
792
793    /* List of struct btrfs_free_clusters for this block group.
794     * Today it will only have one thing on it, but that may change
795     */
796    struct list_head cluster_list;
797};
798
799struct reloc_control;
800struct btrfs_device;
801struct btrfs_fs_devices;
802struct btrfs_fs_info {
803    u8 fsid[BTRFS_FSID_SIZE];
804    u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
805    struct btrfs_root *extent_root;
806    struct btrfs_root *tree_root;
807    struct btrfs_root *chunk_root;
808    struct btrfs_root *dev_root;
809    struct btrfs_root *fs_root;
810    struct btrfs_root *csum_root;
811
812    /* the log root tree is a directory of all the other log roots */
813    struct btrfs_root *log_root_tree;
814
815    spinlock_t fs_roots_radix_lock;
816    struct radix_tree_root fs_roots_radix;
817
818    /* block group cache stuff */
819    spinlock_t block_group_cache_lock;
820    struct rb_root block_group_cache_tree;
821
822    struct extent_io_tree freed_extents[2];
823    struct extent_io_tree *pinned_extents;
824
825    /* logical->physical extent mapping */
826    struct btrfs_mapping_tree mapping_tree;
827
828    u64 generation;
829    u64 last_trans_committed;
830
831    /*
832     * this is updated to the current trans every time a full commit
833     * is required instead of the faster short fsync log commits
834     */
835    u64 last_trans_log_full_commit;
836    u64 open_ioctl_trans;
837    unsigned long mount_opt;
838    u64 max_inline;
839    u64 alloc_start;
840    struct btrfs_transaction *running_transaction;
841    wait_queue_head_t transaction_throttle;
842    wait_queue_head_t transaction_wait;
843    wait_queue_head_t async_submit_wait;
844
845    struct btrfs_super_block super_copy;
846    struct btrfs_super_block super_for_commit;
847    struct block_device *__bdev;
848    struct super_block *sb;
849    struct inode *btree_inode;
850    struct backing_dev_info bdi;
851    struct mutex trans_mutex;
852    struct mutex tree_log_mutex;
853    struct mutex transaction_kthread_mutex;
854    struct mutex cleaner_mutex;
855    struct mutex chunk_mutex;
856    struct mutex volume_mutex;
857    /*
858     * this protects the ordered operations list only while we are
859     * processing all of the entries on it. This way we make
860     * sure the commit code doesn't find the list temporarily empty
861     * because another function happens to be doing non-waiting preflush
862     * before jumping into the main commit.
863     */
864    struct mutex ordered_operations_mutex;
865    struct rw_semaphore extent_commit_sem;
866
867    struct rw_semaphore cleanup_work_sem;
868
869    struct rw_semaphore subvol_sem;
870    struct srcu_struct subvol_srcu;
871
872    struct list_head trans_list;
873    struct list_head hashers;
874    struct list_head dead_roots;
875    struct list_head caching_block_groups;
876
877    spinlock_t delayed_iput_lock;
878    struct list_head delayed_iputs;
879
880    atomic_t nr_async_submits;
881    atomic_t async_submit_draining;
882    atomic_t nr_async_bios;
883    atomic_t async_delalloc_pages;
884
885    /*
886     * this is used by the balancing code to wait for all the pending
887     * ordered extents
888     */
889    spinlock_t ordered_extent_lock;
890
891    /*
892     * all of the data=ordered extents pending writeback
893     * these can span multiple transactions and basically include
894     * every dirty data page that isn't from nodatacow
895     */
896    struct list_head ordered_extents;
897
898    /*
899     * all of the inodes that have delalloc bytes. It is possible for
900     * this list to be empty even when there is still dirty data=ordered
901     * extents waiting to finish IO.
902     */
903    struct list_head delalloc_inodes;
904
905    /*
906     * special rename and truncate targets that must be on disk before
907     * we're allowed to commit. This is basically the ext3 style
908     * data=ordered list.
909     */
910    struct list_head ordered_operations;
911
912    /*
913     * there is a pool of worker threads for checksumming during writes
914     * and a pool for checksumming after reads. This is because readers
915     * can run with FS locks held, and the writers may be waiting for
916     * those locks. We don't want ordering in the pending list to cause
917     * deadlocks, and so the two are serviced separately.
918     *
919     * A third pool does submit_bio to avoid deadlocking with the other
920     * two
921     */
922    struct btrfs_workers generic_worker;
923    struct btrfs_workers workers;
924    struct btrfs_workers delalloc_workers;
925    struct btrfs_workers endio_workers;
926    struct btrfs_workers endio_meta_workers;
927    struct btrfs_workers endio_meta_write_workers;
928    struct btrfs_workers endio_write_workers;
929    struct btrfs_workers submit_workers;
930    struct btrfs_workers enospc_workers;
931    /*
932     * fixup workers take dirty pages that didn't properly go through
933     * the cow mechanism and make them safe to write. It happens
934     * for the sys_munmap function call path
935     */
936    struct btrfs_workers fixup_workers;
937    struct task_struct *transaction_kthread;
938    struct task_struct *cleaner_kthread;
939    int thread_pool_size;
940
941    struct kobject super_kobj;
942    struct completion kobj_unregister;
943    int do_barriers;
944    int closing;
945    int log_root_recovering;
946
947    u64 total_pinned;
948
949    /* protected by the delalloc lock, used to keep from writing
950     * metadata until there is a nice batch
951     */
952    u64 dirty_metadata_bytes;
953    struct list_head dirty_cowonly_roots;
954
955    struct btrfs_fs_devices *fs_devices;
956
957    /*
958     * the space_info list is almost entirely read only. It only changes
959     * when we add a new raid type to the FS, and that happens
960     * very rarely. RCU is used to protect it.
961     */
962    struct list_head space_info;
963
964    struct reloc_control *reloc_ctl;
965
966    spinlock_t delalloc_lock;
967    spinlock_t new_trans_lock;
968    u64 delalloc_bytes;
969
970    /* data_alloc_cluster is only used in ssd mode */
971    struct btrfs_free_cluster data_alloc_cluster;
972
973    /* all metadata allocations go through this cluster */
974    struct btrfs_free_cluster meta_alloc_cluster;
975
976    spinlock_t ref_cache_lock;
977    u64 total_ref_cache_size;
978
979    u64 avail_data_alloc_bits;
980    u64 avail_metadata_alloc_bits;
981    u64 avail_system_alloc_bits;
982    u64 data_alloc_profile;
983    u64 metadata_alloc_profile;
984    u64 system_alloc_profile;
985
986    unsigned data_chunk_allocations;
987    unsigned metadata_ratio;
988
989    void *bdev_holder;
990};
991
992/*
993 * in ram representation of the tree. extent_root is used for all allocations
994 * and for the extent tree extent_root root.
995 */
996struct 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) \
1209u##bits btrfs_##name(struct extent_buffer *eb, type *s); \
1210void 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) \
1214static 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} \
1221static 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) \
1230static inline u##bits btrfs_##name(type *s) \
1231{ \
1232    return le##bits##_to_cpu(s->member); \
1233} \
1234static inline void btrfs_set_##name(type *s, u##bits val) \
1235{ \
1236    s->member = cpu_to_le##bits(val); \
1237}
1238
1239BTRFS_SETGET_FUNCS(device_type, struct btrfs_dev_item, type, 64);
1240BTRFS_SETGET_FUNCS(device_total_bytes, struct btrfs_dev_item, total_bytes, 64);
1241BTRFS_SETGET_FUNCS(device_bytes_used, struct btrfs_dev_item, bytes_used, 64);
1242BTRFS_SETGET_FUNCS(device_io_align, struct btrfs_dev_item, io_align, 32);
1243BTRFS_SETGET_FUNCS(device_io_width, struct btrfs_dev_item, io_width, 32);
1244BTRFS_SETGET_FUNCS(device_start_offset, struct btrfs_dev_item,
1245           start_offset, 64);
1246BTRFS_SETGET_FUNCS(device_sector_size, struct btrfs_dev_item, sector_size, 32);
1247BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
1248BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
1249BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
1250BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
1251BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
1252
1253BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
1254BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
1255             total_bytes, 64);
1256BTRFS_SETGET_STACK_FUNCS(stack_device_bytes_used, struct btrfs_dev_item,
1257             bytes_used, 64);
1258BTRFS_SETGET_STACK_FUNCS(stack_device_io_align, struct btrfs_dev_item,
1259             io_align, 32);
1260BTRFS_SETGET_STACK_FUNCS(stack_device_io_width, struct btrfs_dev_item,
1261             io_width, 32);
1262BTRFS_SETGET_STACK_FUNCS(stack_device_sector_size, struct btrfs_dev_item,
1263             sector_size, 32);
1264BTRFS_SETGET_STACK_FUNCS(stack_device_id, struct btrfs_dev_item, devid, 64);
1265BTRFS_SETGET_STACK_FUNCS(stack_device_group, struct btrfs_dev_item,
1266             dev_group, 32);
1267BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
1268             seek_speed, 8);
1269BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
1270             bandwidth, 8);
1271BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
1272             generation, 64);
1273
1274static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
1275{
1276    return (char *)d + offsetof(struct btrfs_dev_item, uuid);
1277}
1278
1279static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
1280{
1281    return (char *)d + offsetof(struct btrfs_dev_item, fsid);
1282}
1283
1284BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
1285BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
1286BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
1287BTRFS_SETGET_FUNCS(chunk_io_align, struct btrfs_chunk, io_align, 32);
1288BTRFS_SETGET_FUNCS(chunk_io_width, struct btrfs_chunk, io_width, 32);
1289BTRFS_SETGET_FUNCS(chunk_sector_size, struct btrfs_chunk, sector_size, 32);
1290BTRFS_SETGET_FUNCS(chunk_type, struct btrfs_chunk, type, 64);
1291BTRFS_SETGET_FUNCS(chunk_num_stripes, struct btrfs_chunk, num_stripes, 16);
1292BTRFS_SETGET_FUNCS(chunk_sub_stripes, struct btrfs_chunk, sub_stripes, 16);
1293BTRFS_SETGET_FUNCS(stripe_devid, struct btrfs_stripe, devid, 64);
1294BTRFS_SETGET_FUNCS(stripe_offset, struct btrfs_stripe, offset, 64);
1295
1296static inline char *btrfs_stripe_dev_uuid(struct btrfs_stripe *s)
1297{
1298    return (char *)s + offsetof(struct btrfs_stripe, dev_uuid);
1299}
1300
1301BTRFS_SETGET_STACK_FUNCS(stack_chunk_length, struct btrfs_chunk, length, 64);
1302BTRFS_SETGET_STACK_FUNCS(stack_chunk_owner, struct btrfs_chunk, owner, 64);
1303BTRFS_SETGET_STACK_FUNCS(stack_chunk_stripe_len, struct btrfs_chunk,
1304             stripe_len, 64);
1305BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_align, struct btrfs_chunk,
1306             io_align, 32);
1307BTRFS_SETGET_STACK_FUNCS(stack_chunk_io_width, struct btrfs_chunk,
1308             io_width, 32);
1309BTRFS_SETGET_STACK_FUNCS(stack_chunk_sector_size, struct btrfs_chunk,
1310             sector_size, 32);
1311BTRFS_SETGET_STACK_FUNCS(stack_chunk_type, struct btrfs_chunk, type, 64);
1312BTRFS_SETGET_STACK_FUNCS(stack_chunk_num_stripes, struct btrfs_chunk,
1313             num_stripes, 16);
1314BTRFS_SETGET_STACK_FUNCS(stack_chunk_sub_stripes, struct btrfs_chunk,
1315             sub_stripes, 16);
1316BTRFS_SETGET_STACK_FUNCS(stack_stripe_devid, struct btrfs_stripe, devid, 64);
1317BTRFS_SETGET_STACK_FUNCS(stack_stripe_offset, struct btrfs_stripe, offset, 64);
1318
1319static 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
1328static 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
1333static 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
1339static 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
1346static 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
1352static 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 */
1360BTRFS_SETGET_STACK_FUNCS(block_group_used, struct btrfs_block_group_item,
1361             used, 64);
1362BTRFS_SETGET_FUNCS(disk_block_group_used, struct btrfs_block_group_item,
1363             used, 64);
1364BTRFS_SETGET_STACK_FUNCS(block_group_chunk_objectid,
1365            struct btrfs_block_group_item, chunk_objectid, 64);
1366
1367BTRFS_SETGET_FUNCS(disk_block_group_chunk_objectid,
1368           struct btrfs_block_group_item, chunk_objectid, 64);
1369BTRFS_SETGET_FUNCS(disk_block_group_flags,
1370           struct btrfs_block_group_item, flags, 64);
1371BTRFS_SETGET_STACK_FUNCS(block_group_flags,
1372            struct btrfs_block_group_item, flags, 64);
1373
1374/* struct btrfs_inode_ref */
1375BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
1376BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
1377
1378/* struct btrfs_inode_item */
1379BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
1380BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
1381BTRFS_SETGET_FUNCS(inode_transid, struct btrfs_inode_item, transid, 64);
1382BTRFS_SETGET_FUNCS(inode_size, struct btrfs_inode_item, size, 64);
1383BTRFS_SETGET_FUNCS(inode_nbytes, struct btrfs_inode_item, nbytes, 64);
1384BTRFS_SETGET_FUNCS(inode_block_group, struct btrfs_inode_item, block_group, 64);
1385BTRFS_SETGET_FUNCS(inode_nlink, struct btrfs_inode_item, nlink, 32);
1386BTRFS_SETGET_FUNCS(inode_uid, struct btrfs_inode_item, uid, 32);
1387BTRFS_SETGET_FUNCS(inode_gid, struct btrfs_inode_item, gid, 32);
1388BTRFS_SETGET_FUNCS(inode_mode, struct btrfs_inode_item, mode, 32);
1389BTRFS_SETGET_FUNCS(inode_rdev, struct btrfs_inode_item, rdev, 64);
1390BTRFS_SETGET_FUNCS(inode_flags, struct btrfs_inode_item, flags, 64);
1391
1392static inline struct btrfs_timespec *
1393btrfs_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
1400static inline struct btrfs_timespec *
1401btrfs_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
1408static inline struct btrfs_timespec *
1409btrfs_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
1416static inline struct btrfs_timespec *
1417btrfs_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
1424BTRFS_SETGET_FUNCS(timespec_sec, struct btrfs_timespec, sec, 64);
1425BTRFS_SETGET_FUNCS(timespec_nsec, struct btrfs_timespec, nsec, 32);
1426
1427/* struct btrfs_dev_extent */
1428BTRFS_SETGET_FUNCS(dev_extent_chunk_tree, struct btrfs_dev_extent,
1429           chunk_tree, 64);
1430BTRFS_SETGET_FUNCS(dev_extent_chunk_objectid, struct btrfs_dev_extent,
1431           chunk_objectid, 64);
1432BTRFS_SETGET_FUNCS(dev_extent_chunk_offset, struct btrfs_dev_extent,
1433           chunk_offset, 64);
1434BTRFS_SETGET_FUNCS(dev_extent_length, struct btrfs_dev_extent, length, 64);
1435
1436static 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
1442BTRFS_SETGET_FUNCS(extent_refs, struct btrfs_extent_item, refs, 64);
1443BTRFS_SETGET_FUNCS(extent_generation, struct btrfs_extent_item,
1444           generation, 64);
1445BTRFS_SETGET_FUNCS(extent_flags, struct btrfs_extent_item, flags, 64);
1446
1447BTRFS_SETGET_FUNCS(extent_refs_v0, struct btrfs_extent_item_v0, refs, 32);
1448
1449
1450BTRFS_SETGET_FUNCS(tree_block_level, struct btrfs_tree_block_info, level, 8);
1451
1452static 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
1459static 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
1466BTRFS_SETGET_FUNCS(extent_data_ref_root, struct btrfs_extent_data_ref,
1467           root, 64);
1468BTRFS_SETGET_FUNCS(extent_data_ref_objectid, struct btrfs_extent_data_ref,
1469           objectid, 64);
1470BTRFS_SETGET_FUNCS(extent_data_ref_offset, struct btrfs_extent_data_ref,
1471           offset, 64);
1472BTRFS_SETGET_FUNCS(extent_data_ref_count, struct btrfs_extent_data_ref,
1473           count, 32);
1474
1475BTRFS_SETGET_FUNCS(shared_data_ref_count, struct btrfs_shared_data_ref,
1476           count, 32);
1477
1478BTRFS_SETGET_FUNCS(extent_inline_ref_type, struct btrfs_extent_inline_ref,
1479           type, 8);
1480BTRFS_SETGET_FUNCS(extent_inline_ref_offset, struct btrfs_extent_inline_ref,
1481           offset, 64);
1482
1483static 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
1498BTRFS_SETGET_FUNCS(ref_root_v0, struct btrfs_extent_ref_v0, root, 64);
1499BTRFS_SETGET_FUNCS(ref_generation_v0, struct btrfs_extent_ref_v0,
1500           generation, 64);
1501BTRFS_SETGET_FUNCS(ref_objectid_v0, struct btrfs_extent_ref_v0, objectid, 64);
1502BTRFS_SETGET_FUNCS(ref_count_v0, struct btrfs_extent_ref_v0, count, 32);
1503
1504/* struct btrfs_node */
1505BTRFS_SETGET_FUNCS(key_blockptr, struct btrfs_key_ptr, blockptr, 64);
1506BTRFS_SETGET_FUNCS(key_generation, struct btrfs_key_ptr, generation, 64);
1507
1508static 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
1516static 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
1525static 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
1533static 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
1542static 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
1548void btrfs_node_key(struct extent_buffer *eb,
1549            struct btrfs_disk_key *disk_key, int nr);
1550
1551static 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 */
1561BTRFS_SETGET_FUNCS(item_offset, struct btrfs_item, offset, 32);
1562BTRFS_SETGET_FUNCS(item_size, struct btrfs_item, size, 32);
1563
1564static 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
1570static 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
1576static 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
1582static 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
1587static 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
1592static 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
1597static 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
1604static 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
1611BTRFS_SETGET_FUNCS(dir_log_end, struct btrfs_dir_log_item, end, 64);
1612
1613/*
1614 * struct btrfs_root_ref
1615 */
1616BTRFS_SETGET_FUNCS(root_ref_dirid, struct btrfs_root_ref, dirid, 64);
1617BTRFS_SETGET_FUNCS(root_ref_sequence, struct btrfs_root_ref, sequence, 64);
1618BTRFS_SETGET_FUNCS(root_ref_name_len, struct btrfs_root_ref, name_len, 16);
1619
1620/* struct btrfs_dir_item */
1621BTRFS_SETGET_FUNCS(dir_data_len, struct btrfs_dir_item, data_len, 16);
1622BTRFS_SETGET_FUNCS(dir_type, struct btrfs_dir_item, type, 8);
1623BTRFS_SETGET_FUNCS(dir_name_len, struct btrfs_dir_item, name_len, 16);
1624BTRFS_SETGET_FUNCS(dir_transid, struct btrfs_dir_item, transid, 64);
1625
1626static 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
1633static 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 */
1641BTRFS_SETGET_STACK_FUNCS(disk_key_objectid, struct btrfs_disk_key,
1642             objectid, 64);
1643BTRFS_SETGET_STACK_FUNCS(disk_key_offset, struct btrfs_disk_key, offset, 64);
1644BTRFS_SETGET_STACK_FUNCS(disk_key_type, struct btrfs_disk_key, type, 8);
1645
1646static 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
1654static 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
1662static 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
1670static 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
1678static 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
1688static inline u8 btrfs_key_type(struct btrfs_key *key)
1689{
1690    return key->type;
1691}
1692
1693static inline void btrfs_set_key_type(struct btrfs_key *key, u8 val)
1694{
1695    key->type = val;
1696}
1697
1698/* struct btrfs_header */
1699BTRFS_SETGET_HEADER_FUNCS(header_bytenr, struct btrfs_header, bytenr, 64);
1700BTRFS_SETGET_HEADER_FUNCS(header_generation, struct btrfs_header,
1701              generation, 64);
1702BTRFS_SETGET_HEADER_FUNCS(header_owner, struct btrfs_header, owner, 64);
1703BTRFS_SETGET_HEADER_FUNCS(header_nritems, struct btrfs_header, nritems, 32);
1704BTRFS_SETGET_HEADER_FUNCS(header_flags, struct btrfs_header, flags, 64);
1705BTRFS_SETGET_HEADER_FUNCS(header_level, struct btrfs_header, level, 8);
1706
1707static inline int btrfs_header_flag(struct extent_buffer *eb, u64 flag)
1708{
1709    return (btrfs_header_flags(eb) & flag) == flag;
1710}
1711
1712static 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
1719static 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
1726static 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
1732static 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
1741static 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
1747static 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
1753static 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
1759static 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
1765static inline struct btrfs_node *btrfs_buffer_node(struct extent_buffer *eb)
1766{
1767    return NULL;
1768}
1769
1770static inline struct btrfs_leaf *btrfs_buffer_leaf(struct extent_buffer *eb)
1771{
1772    return NULL;
1773}
1774
1775static inline struct btrfs_header *btrfs_buffer_header(struct extent_buffer *eb)
1776{
1777    return NULL;
1778}
1779
1780static inline int btrfs_is_leaf(struct extent_buffer *eb)
1781{
1782    return btrfs_header_level(eb) == 0;
1783}
1784
1785/* struct btrfs_root_item */
1786BTRFS_SETGET_FUNCS(disk_root_generation, struct btrfs_root_item,
1787           generation, 64);
1788BTRFS_SETGET_FUNCS(disk_root_refs, struct btrfs_root_item, refs, 32);
1789BTRFS_SETGET_FUNCS(disk_root_bytenr, struct btrfs_root_item, bytenr, 64);
1790BTRFS_SETGET_FUNCS(disk_root_level, struct btrfs_root_item, level, 8);
1791
1792BTRFS_SETGET_STACK_FUNCS(root_generation, struct btrfs_root_item,
1793             generation, 64);
1794BTRFS_SETGET_STACK_FUNCS(root_bytenr, struct btrfs_root_item, bytenr, 64);
1795BTRFS_SETGET_STACK_FUNCS(root_level, struct btrfs_root_item, level, 8);
1796BTRFS_SETGET_STACK_FUNCS(root_dirid, struct btrfs_root_item, root_dirid, 64);
1797BTRFS_SETGET_STACK_FUNCS(root_refs, struct btrfs_root_item, refs, 32);
1798BTRFS_SETGET_STACK_FUNCS(root_flags, struct btrfs_root_item, flags, 64);
1799BTRFS_SETGET_STACK_FUNCS(root_used, struct btrfs_root_item, bytes_used, 64);
1800BTRFS_SETGET_STACK_FUNCS(root_limit, struct btrfs_root_item, byte_limit, 64);
1801BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
1802             last_snapshot, 64);
1803
1804/* struct btrfs_super_block */
1805
1806BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
1807BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
1808BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
1809             generation, 64);
1810BTRFS_SETGET_STACK_FUNCS(super_root, struct btrfs_super_block, root, 64);
1811BTRFS_SETGET_STACK_FUNCS(super_sys_array_size,
1812             struct btrfs_super_block, sys_chunk_array_size, 32);
1813BTRFS_SETGET_STACK_FUNCS(super_chunk_root_generation,
1814             struct btrfs_super_block, chunk_root_generation, 64);
1815BTRFS_SETGET_STACK_FUNCS(super_root_level, struct btrfs_super_block,
1816             root_level, 8);
1817BTRFS_SETGET_STACK_FUNCS(super_chunk_root, struct btrfs_super_block,
1818             chunk_root, 64);
1819BTRFS_SETGET_STACK_FUNCS(super_chunk_root_level, struct btrfs_super_block,
1820             chunk_root_level, 8);
1821BTRFS_SETGET_STACK_FUNCS(super_log_root, struct btrfs_super_block,
1822             log_root, 64);
1823BTRFS_SETGET_STACK_FUNCS(super_log_root_transid, struct btrfs_super_block,
1824             log_root_transid, 64);
1825BTRFS_SETGET_STACK_FUNCS(super_log_root_level, struct btrfs_super_block,
1826             log_root_level, 8);
1827BTRFS_SETGET_STACK_FUNCS(super_total_bytes, struct btrfs_super_block,
1828             total_bytes, 64);
1829BTRFS_SETGET_STACK_FUNCS(super_bytes_used, struct btrfs_super_block,
1830             bytes_used, 64);
1831BTRFS_SETGET_STACK_FUNCS(super_sectorsize, struct btrfs_super_block,
1832             sectorsize, 32);
1833BTRFS_SETGET_STACK_FUNCS(super_nodesize, struct btrfs_super_block,
1834             nodesize, 32);
1835BTRFS_SETGET_STACK_FUNCS(super_leafsize, struct btrfs_super_block,
1836             leafsize, 32);
1837BTRFS_SETGET_STACK_FUNCS(super_stripesize, struct btrfs_super_block,
1838             stripesize, 32);
1839BTRFS_SETGET_STACK_FUNCS(super_root_dir, struct btrfs_super_block,
1840             root_dir_objectid, 64);
1841BTRFS_SETGET_STACK_FUNCS(super_num_devices, struct btrfs_super_block,
1842             num_devices, 64);
1843BTRFS_SETGET_STACK_FUNCS(super_compat_flags, struct btrfs_super_block,
1844             compat_flags, 64);
1845BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
1846             compat_ro_flags, 64);
1847BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
1848             incompat_flags, 64);
1849BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
1850             csum_type, 16);
1851
1852static 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
1859static 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 */
1865BTRFS_SETGET_FUNCS(file_extent_type, struct btrfs_file_extent_item, type, 8);
1866
1867static inline unsigned long
1868btrfs_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
1875static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
1876{
1877    return offsetof(struct btrfs_file_extent_item, disk_bytenr) + datasize;
1878}
1879
1880BTRFS_SETGET_FUNCS(file_extent_disk_bytenr, struct btrfs_file_extent_item,
1881           disk_bytenr, 64);
1882BTRFS_SETGET_FUNCS(file_extent_generation, struct btrfs_file_extent_item,
1883           generation, 64);
1884BTRFS_SETGET_FUNCS(file_extent_disk_num_bytes, struct btrfs_file_extent_item,
1885           disk_num_bytes, 64);
1886BTRFS_SETGET_FUNCS(file_extent_offset, struct btrfs_file_extent_item,
1887          offset, 64);
1888BTRFS_SETGET_FUNCS(file_extent_num_bytes, struct btrfs_file_extent_item,
1889           num_bytes, 64);
1890BTRFS_SETGET_FUNCS(file_extent_ram_bytes, struct btrfs_file_extent_item,
1891           ram_bytes, 64);
1892BTRFS_SETGET_FUNCS(file_extent_compression, struct btrfs_file_extent_item,
1893           compression, 8);
1894BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
1895           encryption, 8);
1896BTRFS_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 */
1902static 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 */
1913static 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
1921static inline struct btrfs_root *btrfs_sb(struct super_block *sb)
1922{
1923    return sb->s_fs_info;
1924}
1925
1926static 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
1942static 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
1958static inline struct dentry *fdentry(struct file *file)
1959{
1960    return file->f_path.dentry;
1961}
1962
1963/* extent-tree.c */
1964void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
1965int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
1966               struct btrfs_root *root, unsigned long count);
1967int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);
1968int btrfs_pin_extent(struct btrfs_root *root,
1969             u64 bytenr, u64 num, int reserved);
1970int btrfs_drop_leaf_ref(struct btrfs_trans_handle *trans,
1971            struct btrfs_root *root, struct extent_buffer *leaf);
1972int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
1973              struct btrfs_root *root,
1974              u64 objectid, u64 offset, u64 bytenr);
1975int btrfs_copy_pinned(struct btrfs_root *root, struct extent_io_tree *copy);
1976struct btrfs_block_group_cache *btrfs_lookup_block_group(
1977                         struct btrfs_fs_info *info,
1978                         u64 bytenr);
1979void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
1980u64 btrfs_find_block_group(struct btrfs_root *root,
1981               u64 search_start, u64 search_hint, int owner);
1982struct 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);
1987int 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);
1991struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
1992                        struct btrfs_root *root,
1993                        u64 bytenr, u32 blocksize,
1994                        int level);
1995int 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);
1999int 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);
2003int 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);
2009int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2010          struct extent_buffer *buf, int full_backref);
2011int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2012          struct extent_buffer *buf, int full_backref);
2013int 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);
2017int 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
2022int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
2023int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
2024                struct btrfs_root *root);
2025int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
2026                   struct btrfs_root *root);
2027int 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
2032int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2033                    struct btrfs_root *root);
2034int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
2035int btrfs_free_block_groups(struct btrfs_fs_info *info);
2036int btrfs_read_block_groups(struct btrfs_root *root);
2037int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr);
2038int 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);
2042int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
2043                 struct btrfs_root *root, u64 group_start);
2044int btrfs_prepare_block_group_relocation(struct btrfs_root *root,
2045                struct btrfs_block_group_cache *group);
2046
2047u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
2048void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde);
2049void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
2050
2051int btrfs_reserve_metadata_space(struct btrfs_root *root, int num_items);
2052int btrfs_unreserve_metadata_space(struct btrfs_root *root, int num_items);
2053int btrfs_unreserve_metadata_for_delalloc(struct btrfs_root *root,
2054                      struct inode *inode, int num_items);
2055int btrfs_reserve_metadata_for_delalloc(struct btrfs_root *root,
2056                    struct inode *inode, int num_items);
2057int btrfs_check_data_free_space(struct btrfs_root *root, struct inode *inode,
2058                u64 bytes);
2059void btrfs_free_reserved_data_space(struct btrfs_root *root,
2060                    struct inode *inode, u64 bytes);
2061void btrfs_delalloc_reserve_space(struct btrfs_root *root, struct inode *inode,
2062                 u64 bytes);
2063void btrfs_delalloc_free_space(struct btrfs_root *root, struct inode *inode,
2064                  u64 bytes);
2065/* ctree.c */
2066int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
2067             int level, int *slot);
2068int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2);
2069int btrfs_previous_item(struct btrfs_root *root,
2070            struct btrfs_path *path, u64 min_objectid,
2071            int type);
2072int 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);
2075struct extent_buffer *btrfs_root_node(struct btrfs_root *root);
2076struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
2077int 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);
2080int 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);
2084int 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);
2088int 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);
2092int btrfs_block_can_be_shared(struct btrfs_root *root,
2093                  struct extent_buffer *buf);
2094int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root
2095              *root, struct btrfs_path *path, u32 data_size);
2096int 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);
2100int 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);
2105int btrfs_duplicate_item(struct btrfs_trans_handle *trans,
2106             struct btrfs_root *root,
2107             struct btrfs_path *path,
2108             struct btrfs_key *new_key);
2109int 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);
2112int 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);
2116void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p);
2117struct btrfs_path *btrfs_alloc_path(void);
2118void btrfs_free_path(struct btrfs_path *p);
2119void btrfs_set_path_blocking(struct btrfs_path *p);
2120void btrfs_unlock_up_safe(struct btrfs_path *p, int level);
2121
2122int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2123           struct btrfs_path *path, int slot, int nr);
2124static 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
2131int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
2132              *root, struct btrfs_key *key, void *data, u32 data_size);
2133int 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);
2138int 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
2143static 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
2152int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
2153int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
2154int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
2155int btrfs_drop_snapshot(struct btrfs_root *root, int update_ref);
2156int 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 */
2161int btrfs_find_root_ref(struct btrfs_root *tree_root,
2162            struct btrfs_path *path,
2163            u64 root_id, u64 ref_id);
2164int 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);
2168int 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);
2172int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2173           struct btrfs_key *key);
2174int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root
2175              *root, struct btrfs_key *key, struct btrfs_root_item
2176              *item);
2177int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
2178              *root, struct btrfs_key *key, struct btrfs_root_item
2179              *item);
2180int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct
2181             btrfs_root_item *item, struct btrfs_key *key);
2182int btrfs_search_root(struct btrfs_root *root, u64 search_start,
2183              u64 *found_objectid);
2184int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid);
2185int btrfs_find_orphan_roots(struct btrfs_root *tree_root);
2186int btrfs_set_root_node(struct btrfs_root_item *item,
2187            struct extent_buffer *node);
2188/* dir-item.c */
2189int 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);
2193struct 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);
2198struct btrfs_dir_item *
2199btrfs_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);
2204struct btrfs_dir_item *
2205btrfs_search_dir_index_item(struct btrfs_root *root,
2206                struct btrfs_path *path, u64 dirid,
2207                const char *name, int name_len);
2208struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
2209                  struct btrfs_path *path,
2210                  const char *name, int name_len);
2211int 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);
2215int 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);
2220struct 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 */
2227int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
2228                 struct btrfs_root *root, u64 offset);
2229int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
2230              struct btrfs_root *root, u64 offset);
2231int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);
2232
2233/* inode-map.c */
2234int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
2235                 struct btrfs_root *fs_root,
2236                 u64 dirid, u64 *objectid);
2237int btrfs_find_highest_inode(struct btrfs_root *fs_root, u64 *objectid);
2238
2239/* inode-item.c */
2240int 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);
2244int 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);
2248int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
2249                 struct btrfs_root *root,
2250                 struct btrfs_path *path, u64 objectid);
2251int 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 */
2256int btrfs_del_csums(struct btrfs_trans_handle *trans,
2257            struct btrfs_root *root, u64 bytenr, u64 len);
2258int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
2259              struct bio *bio, u32 *dst);
2260int 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);
2266int 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);
2270int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
2271               struct btrfs_root *root,
2272               struct btrfs_ordered_sum *sums);
2273int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
2274               struct bio *bio, u64 file_start, int contig);
2275int btrfs_csum_file_bytes(struct btrfs_root *root, struct inode *inode,
2276              u64 start, unsigned long len);
2277struct 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);
2281int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
2282            struct btrfs_root *root, struct btrfs_path *path,
2283            u64 isize);
2284int 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
2295struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);
2296int btrfs_set_inode_index(struct inode *dir, u64 *index);
2297int 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);
2301int 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);
2304int 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);
2308int 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
2313int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
2314int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
2315                  struct extent_state **cached_state);
2316int btrfs_writepages(struct address_space *mapping,
2317             struct writeback_control *wbc);
2318int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
2319                 struct btrfs_root *new_root,
2320                 u64 new_dirid, u64 alloc_hint);
2321int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
2322             size_t size, struct bio *bio, unsigned long bio_flags);
2323
2324unsigned long btrfs_force_ra(struct address_space *mapping,
2325                  struct file_ra_state *ra, struct file *file,
2326                  pgoff_t offset, pgoff_t last_index);
2327int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
2328int btrfs_readpage(struct file *file, struct page *page);
2329void btrfs_delete_inode(struct inode *inode);
2330void btrfs_put_inode(struct inode *inode);
2331int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc);
2332void btrfs_dirty_inode(struct inode *inode);
2333struct inode *btrfs_alloc_inode(struct super_block *sb);
2334void btrfs_destroy_inode(struct inode *inode);
2335void btrfs_drop_inode(struct inode *inode);
2336int btrfs_init_cachep(void);
2337void btrfs_destroy_cachep(void);
2338long btrfs_ioctl_trans_end(struct file *file);
2339struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
2340             struct btrfs_root *root, int *was_new);
2341int btrfs_commit_write(struct file *file, struct page *page,
2342               unsigned from, unsigned to);
2343struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
2344                    size_t page_offset, u64 start, u64 end,
2345                    int create);
2346int btrfs_update_inode(struct btrfs_trans_handle *trans,
2347                  struct btrfs_root *root,
2348                  struct inode *inode);
2349int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
2350int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
2351void btrfs_orphan_cleanup(struct btrfs_root *root);
2352int btrfs_cont_expand(struct inode *inode, loff_t size);
2353int btrfs_invalidate_inodes(struct btrfs_root *root);
2354void btrfs_add_delayed_iput(struct inode *inode);
2355void btrfs_run_delayed_iputs(struct btrfs_root *root);
2356extern const struct dentry_operations btrfs_dentry_operations;
2357
2358/* ioctl.c */
2359long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2360void btrfs_update_iflags(struct inode *inode);
2361void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
2362
2363/* file.c */
2364int btrfs_sync_file(struct file *file, struct dentry *dentry, int datasync);
2365int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
2366                int skip_pinned);
2367int btrfs_check_file(struct btrfs_root *root, struct inode *inode);
2368extern const struct file_operations btrfs_file_operations;
2369int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
2370               u64 start, u64 end, u64 *hint_byte, int drop_cache);
2371int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
2372                  struct inode *inode, u64 start, u64 end);
2373int btrfs_release_file(struct inode *inode, struct file *file);
2374
2375/* tree-defrag.c */
2376int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
2377            struct btrfs_root *root, int cache_only);
2378
2379/* sysfs.c */
2380int btrfs_init_sysfs(void);
2381void btrfs_exit_sysfs(void);
2382int btrfs_sysfs_add_super(struct btrfs_fs_info *fs);
2383int btrfs_sysfs_add_root(struct btrfs_root *root);
2384void btrfs_sysfs_del_root(struct btrfs_root *root);
2385void btrfs_sysfs_del_super(struct btrfs_fs_info *root);
2386
2387/* xattr.c */
2388ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
2389
2390/* super.c */
2391int btrfs_parse_options(struct btrfs_root *root, char *options);
2392int btrfs_sync_fs(struct super_block *sb, int wait);
2393
2394/* acl.c */
2395#ifdef CONFIG_BTRFS_FS_POSIX_ACL
2396int btrfs_check_acl(struct inode *inode, int mask);
2397#else
2398#define btrfs_check_acl NULL
2399#endif
2400int btrfs_init_acl(struct btrfs_trans_handle *trans,
2401           struct inode *inode, struct inode *dir);
2402int btrfs_acl_chmod(struct inode *inode);
2403
2404/* relocation.c */
2405int btrfs_relocate_block_group(struct btrfs_root *root, u64 group_start);
2406int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
2407              struct btrfs_root *root);
2408int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
2409                struct btrfs_root *root);
2410int btrfs_recover_relocation(struct btrfs_root *root);
2411int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
2412#endif
2413

Archive Download this file



interactive