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